-
Welcome to your static Space!
-
You can modify this app directly by editing index.html in the Files and versions tab.
-
- Also don't forget to check the
- Spaces documentation .
+
+
+
+
+
Reachy Mini Conversation App
+
+
+
+
+
+
+
+
+
+
+
-
+
+
+
🎤
+
Natural voice chat
+
Talk freely and get fast, high-quality replies powered by realtime models.
+
+
+
🎥
+
Vision-aware replies
+
Ask the camera tool to see what’s in front, track a face, or keep attention on whoever is speaking.
+
+
+
💃
+
Expressive motion
+
Queue dances, play recorded emotions while Reachy listens and talks.
+
+
+
🧠
+
Personalities on demand
+
Switch conversation styles through profiles and decide which tools (dance, camera, tracking) each persona can use.
+
+
+
🌐
+
Ready for your setup
+
Works with wired or wireless Reachy Mini, and can run vision locally or through the default cloud model.
+
+
+
+
+
+
+
+
How it feels
+
From hello to helpful in seconds
+
+ 👋 Say “Hey Reachy” and start chatting—no extra setup in the moment.
+ 👀 Ask what it sees; it can peek through the camera or keep focus on your face.
+ 🎭 Trigger emotions or dance breaks to keep the conversation lively.
+ 📝 Follow along with live transcripts in the web UI or run audio-only from the console.
+
+
+
+
Where it shines
+
Great for demos, teaching, and playful exploration
+
+ Show off how Reachy Mini listens, responds, and moves in sync. Whether you’re guiding a class, hosting a booth, or experimenting at home, the app keeps the robot expressive without juggling scripts or joystick controls.
+
+
+ Live conversation
+ Face tracking
+ Camera tool
+ Dance library
+ Profiles & tools
+
+
+
+
+
+
+
+
+
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000000000000000000000000000000000000..ad073540899f3f2a079815dc7bd9edfd525934c9
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,79 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "peachy"
+version = "0.1.0"
+description = "Peachy — on-robot conversational assistant for Reachy Mini"
+readme = "README.md"
+license = { file = "LICENSE" }
+requires-python = ">=3.12"
+dependencies = [
+ "huggingface-hub>=1.17.0",
+ "httpx>=0.28.1",
+ "python-dotenv",
+ "openai==2.28.0",
+ "reachy_mini_dances_library",
+ "reachy_mini_toolbox",
+ "reachy-mini==1.9.0",
+ "mcp>=1.27.1",
+ "numpy",
+ "scipy",
+]
+keywords = ["reachy-mini-app"]
+
+[project.scripts]
+peachy = "peachy.main:main"
+
+[project.entry-points."reachy_mini_apps"]
+peachy = "peachy.main:Peachy"
+
+[dependency-groups]
+dev = [
+ "build",
+ "certifi",
+ "pytest",
+ "pytest-asyncio",
+ "pytest-timeout",
+ "ruff==0.12.0",
+ "mypy==1.18.2",
+]
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+include-package-data = false
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+peachy = [
+ "static/*",
+ "static/**/*",
+ ".env.example",
+ "profiles/**/*.txt",
+]
+
+[tool.setuptools.exclude-package-data]
+"*" = ["**/__pycache__/*", "**/*.pyc"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+asyncio_mode = "auto"
+addopts = "-m 'not live_openai'"
+markers = [
+ "live_openai: opt-in paid OpenAI Realtime smoke; never CI",
+]
+
+[tool.ruff]
+line-length = 119
+exclude = [".venv", "dist", "build", "**/__pycache__", "*.egg-info", ".mypy_cache", ".pytest_cache"]
+
+[tool.mypy]
+python_version = "3.12"
+files = ["src/"]
+ignore_missing_imports = true
+strict = true
+show_error_codes = true
+warn_unused_ignores = true
diff --git a/src/peachy/.env.example b/src/peachy/.env.example
new file mode 100644
index 0000000000000000000000000000000000000000..946e51b6dbcba58c2bc89c6f17f76a57bc13ca67
--- /dev/null
+++ b/src/peachy/.env.example
@@ -0,0 +1,36 @@
+# Optional realtime input transcription language.
+# Defaults to "en". Set to a backend-supported code such as "zh" for Chinese.
+# REALTIME_TRANSCRIPTION_LANGUAGE="en"
+
+PEACHY_REALTIME_PROVIDER=openai
+OPENAI_API_KEY=
+OPENAI_REALTIME_MODEL=gpt-realtime
+
+# Hugging Face connection mode: "deployed" or "local".
+# Deployed mode uses the built-in Hugging Face server.
+# Defaults to "deployed" when unset.
+# HF_REALTIME_CONNECTION_MODE="deployed"
+
+# Direct Hugging Face realtime endpoint for local/LAN backends.
+# Accepts either the base URL (`ws://127.0.0.1:8765/v1`) or the full realtime URL
+# (`ws://127.0.0.1:8765/v1/realtime`). Used when HF_REALTIME_CONNECTION_MODE=local.
+# HF_REALTIME_WS_URL="ws://127.0.0.1:8765/v1/realtime"
+
+# Hugging Face token for accessing datasets/models
+HF_TOKEN=
+
+# Optional built-in profile selector. Use a folder name from profiles/.
+# If unset, the app uses the default profile unless startup settings were saved from the UI.
+# REACHY_MINI_CUSTOM_PROFILE=mars_rover
+
+# Optional external profile/tool directories
+# REACHY_MINI_EXTERNAL_PROFILES_DIRECTORY=external_content/external_profiles
+# REACHY_MINI_EXTERNAL_TOOLS_DIRECTORY=external_content/external_tools
+
+# Optional: discover and auto-load all tools found in REACHY_MINI_EXTERNAL_TOOLS_DIRECTORY,
+# even if they are not listed in the selected profile's tools.txt.
+# This is convenient for downloaded tools used with built-in/default profiles.
+# AUTOLOAD_EXTERNAL_TOOLS=1
+
+# Minutes of inactivity before Reachy goes to sleep and the app stops. Default 1440 (one day), 0 disables.
+# REACHY_MINI_APP_TIMEOUT_MINUTES=1440
diff --git a/src/peachy/__init__.py b/src/peachy/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e334df1df4868f72b8c26b7e2d9f671f4add762
--- /dev/null
+++ b/src/peachy/__init__.py
@@ -0,0 +1,2 @@
+"""Nothing (for ruff)."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
diff --git a/src/peachy/app_lifecycle.py b/src/peachy/app_lifecycle.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6a6ad767031f1b730512941e2ceb9c1e79da077
--- /dev/null
+++ b/src/peachy/app_lifecycle.py
@@ -0,0 +1,85 @@
+"""Helpers for app startup and shutdown lifecycle behavior."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+import asyncio
+import logging
+import urllib.error
+import urllib.request
+
+import numpy as np
+import numpy.typing as npt
+
+from reachy_mini import ReachyMini
+from reachy_mini.reachy_mini import SLEEP_HEAD_POSE
+from reachy_mini.utils.interpolation import distance_between_poses
+from peachy.tools.core_tools import ToolDependencies
+from peachy.tools.go_to_sleep import GoToSleep
+
+
+_STOP_CURRENT_APP_PATH = "/api/apps/stop-current-app"
+_STOP_CURRENT_APP_TIMEOUT_S = 2.0
+_SLEEP_HEAD_TRANSLATION_TOLERANCE_M = 0.05
+_SLEEP_HEAD_ROTATION_TOLERANCE_RAD = 0.35
+
+
+def request_stop_current_app(robot: ReachyMini, logger: logging.Logger) -> bool:
+ """Request the Reachy Mini daemon to stop the current app."""
+ stop_current_app_url = f"http://{robot.client.host}:{robot.client.port}{_STOP_CURRENT_APP_PATH}"
+ request = urllib.request.Request(stop_current_app_url, method="POST")
+ try:
+ with urllib.request.urlopen(request, timeout=_STOP_CURRENT_APP_TIMEOUT_S) as response:
+ response.read()
+ except urllib.error.URLError as e:
+ logger.error("Failed to request current app stop via %s: %s", stop_current_app_url, e)
+ return False
+
+ logger.info("Requested current app stop via %s", stop_current_app_url)
+ return True
+
+
+def _is_sleep_head_pose(head_pose: npt.ArrayLike) -> bool:
+ try:
+ current_head_pose: npt.NDArray[np.float64] = np.asarray(head_pose, dtype=np.float64)
+ except (TypeError, ValueError):
+ return False
+
+ if current_head_pose.shape != (4, 4):
+ return False
+
+ pose_distances = distance_between_poses(current_head_pose, SLEEP_HEAD_POSE)
+ translation_distance = float(pose_distances[0])
+ rotation_angle = float(pose_distances[1])
+ return (
+ translation_distance <= _SLEEP_HEAD_TRANSLATION_TOLERANCE_M
+ and rotation_angle <= _SLEEP_HEAD_ROTATION_TOLERANCE_RAD
+ )
+
+
+def wake_up_if_sleeping(robot: ReachyMini, logger: logging.Logger) -> bool:
+ """Run the SDK wake-up movement when Reachy starts from the sleep pose."""
+ try:
+ head_pose = robot.get_current_head_pose()
+ except Exception as e:
+ logger.warning("Could not read robot pose before startup wake-up check: %s", e)
+ return False
+
+ if not _is_sleep_head_pose(head_pose):
+ return False
+
+ logger.info("Robot is in sleep pose; running wake-up movement.")
+ try:
+ robot.wake_up()
+ except Exception as e:
+ logger.error("Failed to run wake-up movement: %s", e)
+ return False
+ return True
+
+
+def run_go_to_sleep_tool(deps: ToolDependencies, logger: logging.Logger) -> dict[str, object]:
+ """Run the shared go_to_sleep tool from synchronous shutdown paths."""
+ try:
+ return asyncio.run(GoToSleep()(deps))
+ except Exception as e:
+ logger.error("Failed to run go_to_sleep tool during shutdown: %s", e)
+ return {"error": f"go_to_sleep failed: {type(e).__name__}: {e}"}
diff --git a/src/peachy/audio/__init__.py b/src/peachy/audio/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..215891716d270d9e3b7d27463ca296ec7cc1a7e7
--- /dev/null
+++ b/src/peachy/audio/__init__.py
@@ -0,0 +1 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
diff --git a/src/peachy/audio/resampling.py b/src/peachy/audio/resampling.py
new file mode 100644
index 0000000000000000000000000000000000000000..b8e8a472055e064af70a189374d88784e2c79ad8
--- /dev/null
+++ b/src/peachy/audio/resampling.py
@@ -0,0 +1,55 @@
+"""Provider-neutral mono normalization and audio sample-rate conversion."""
+
+from __future__ import annotations
+
+from typing import cast
+
+import numpy as np
+from numpy.typing import NDArray
+from scipy.signal import resample
+
+from peachy.streaming import AudioArray, audio_to_float32
+
+
+def audio_to_mono(audio: AudioArray) -> AudioArray:
+ """Return a contiguous mono array while preserving dtype."""
+ if audio.ndim == 1:
+ return cast(AudioArray, np.ascontiguousarray(audio))
+ if audio.ndim != 2:
+ raise ValueError("Audio must be one- or two-dimensional")
+ if audio.size == 0:
+ return cast(AudioArray, np.empty(0, dtype=audio.dtype))
+ channels_last = audio.T if audio.shape[1] > audio.shape[0] else audio
+ mono = channels_last[:, 0]
+ return cast(AudioArray, np.ascontiguousarray(mono))
+
+
+def resample_audio(
+ audio: AudioArray,
+ source_rate: int,
+ target_rate: int,
+) -> NDArray[np.float32]:
+ """Return contiguous mono float32 audio at `target_rate`."""
+ if source_rate <= 0 or target_rate <= 0:
+ raise ValueError("Audio sample rates must be positive")
+ mono = audio_to_float32(audio_to_mono(audio))
+ if mono.size == 0:
+ return np.ascontiguousarray(mono, dtype=np.float32)
+ if source_rate == target_rate:
+ return np.ascontiguousarray(mono, dtype=np.float32)
+ target_samples = round(mono.shape[0] * target_rate / source_rate)
+ if target_samples == 0:
+ return np.empty(0, dtype=np.float32)
+ converted = resample(mono, target_samples)
+ return np.ascontiguousarray(converted, dtype=np.float32)
+
+
+def pcm16_at_rate(
+ audio: AudioArray,
+ source_rate: int,
+ target_rate: int,
+) -> NDArray[np.int16]:
+ """Return clipped, contiguous mono signed PCM16 at `target_rate`."""
+ converted = resample_audio(audio, source_rate, target_rate)
+ clipped = np.clip(converted, -1.0, 1.0)
+ return np.ascontiguousarray(clipped * 32767.0, dtype=np.int16)
diff --git a/src/peachy/audio/startup_config.py b/src/peachy/audio/startup_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..a656cd80ab4636d2e77640bd429465a9b88d19c6
--- /dev/null
+++ b/src/peachy/audio/startup_config.py
@@ -0,0 +1,66 @@
+"""Startup configuration for the Reachy Mini audio processor."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import logging
+from collections.abc import Sequence
+
+
+AudioControlValue = float | int
+AudioStartupParameter = tuple[str, tuple[AudioControlValue, ...]]
+WRITE_SETTLE_SECONDS = 0.1
+
+AUDIO_STARTUP_CONFIG: tuple[AudioStartupParameter, ...] = (
+ ("PP_AGCMAXGAIN", (10.0,)),
+ ("PP_MIN_NS", (0.8,)),
+ ("PP_MIN_NN", (0.8,)),
+ ("PP_GAMMA_E", (0.5,)),
+ ("PP_GAMMA_ETAIL", (0.5,)),
+ ("PP_NLATTENONOFF", (0,)),
+ ("PP_MGSCALE", (4.0, 1.0, 1.0)),
+)
+
+
+def apply_audio_startup_config(
+ robot: object,
+ *,
+ logger: logging.Logger | None = None,
+ verify: bool = True,
+ write_settle_seconds: float = WRITE_SETTLE_SECONDS,
+) -> bool:
+ """Apply the tuned XVF3800 audio configuration for the conversation app."""
+ log = logger or logging.getLogger(__name__)
+ audio = getattr(getattr(robot, "media", None), "audio", None)
+
+ if audio is None:
+ log.warning("Skipping Reachy audio startup config: robot media audio is unavailable.")
+ return False
+
+ apply_audio_config = getattr(audio, "apply_audio_config", None)
+ if not callable(apply_audio_config):
+ log.warning("Skipping Reachy audio startup config: SDK audio config API is unavailable.")
+ return False
+
+ try:
+ applied = bool(
+ apply_audio_config(
+ AUDIO_STARTUP_CONFIG,
+ verify=verify,
+ write_settle_seconds=write_settle_seconds,
+ )
+ )
+ except Exception as exc:
+ log.warning("Skipping Reachy audio startup config: SDK audio config failed: %s", exc)
+ return False
+
+ if applied:
+ log.info("Applied Reachy audio startup config: %s", _format_config(AUDIO_STARTUP_CONFIG))
+ else:
+ log.warning("Reachy audio startup config was not applied.")
+
+ return applied
+
+
+def _format_config(config: Sequence[AudioStartupParameter]) -> str:
+ return ", ".join(f"{name}={' '.join(str(value) for value in values)}" for name, values in config)
diff --git a/src/peachy/config.py b/src/peachy/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..5227a4b9ccaf2dc04cf7a897dac0a6764f4216c1
--- /dev/null
+++ b/src/peachy/config.py
@@ -0,0 +1,489 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import os
+import sys
+import logging
+from pathlib import Path
+from dataclasses import dataclass
+from urllib.parse import urlsplit, parse_qsl, urlunsplit
+from importlib.resources import files
+
+from dotenv import find_dotenv, load_dotenv
+from peachy.state import resolve_state_root
+
+
+# Locked profile: set to a profile name (e.g., "astronomer") to lock the app
+# to that profile and disable all profile switching. Leave as None for normal behavior.
+LOCKED_PROFILE: str | None = None
+PROJECT_ROOT = Path(__file__).parents[2].resolve()
+
+
+def _is_source_checkout_root(root: Path) -> bool:
+ """Return whether the given root looks like this project's source checkout."""
+ return (root / "pyproject.toml").is_file() and (root / "src" / "peachy").is_dir()
+
+
+def _packaged_profiles_directory() -> Path | None:
+ """Return Peachy's wheel-owned built-in profiles directory."""
+ try:
+ return Path(str(files("peachy").joinpath("profiles")))
+ except Exception:
+ return None
+
+
+def _resolve_default_profiles_directory() -> Path:
+ """Resolve built-in profiles from source checkout or installed package data."""
+ source_profiles = PROJECT_ROOT / "src" / "peachy" / "profiles"
+ if _is_source_checkout_root(PROJECT_ROOT) and source_profiles.is_dir():
+ return source_profiles
+
+ packaged_profiles = _packaged_profiles_directory()
+ if packaged_profiles is not None and packaged_profiles.is_dir():
+ return packaged_profiles
+
+ return source_profiles
+
+
+DEFAULT_PROFILES_DIRECTORY = _resolve_default_profiles_directory()
+
+# UI-created profiles live under a writable instance dir
+USER_PERSONALITIES_DIRNAME = "user_personalities"
+
+# Qwen3-TTS CustomVoice speaker catalog from the deployed Hugging Face backend.
+HF_AVAILABLE_VOICES: list[str] = [
+ "Aiden",
+ "Ryan",
+ "Dylan",
+ "Eric",
+ "Ono_Anna",
+ "Serena",
+ "Sohee",
+ "Uncle_Fu",
+ "Vivian",
+]
+
+HF_BACKEND = "huggingface"
+HF_REALTIME_CONNECTION_MODE_ENV = "HF_REALTIME_CONNECTION_MODE"
+HF_REALTIME_WS_URL_ENV = "HF_REALTIME_WS_URL"
+REALTIME_TRANSCRIPTION_LANGUAGE_ENV = "REALTIME_TRANSCRIPTION_LANGUAGE"
+HF_LOCAL_CONNECTION_MODE = "local"
+HF_DEPLOYED_CONNECTION_MODE = "deployed"
+HF_REALTIME_SESSION_PROXY_URL = "https://pollen-robotics-reachy-mini-realtime-url.hf.space/session"
+
+
+@dataclass(frozen=True)
+class HFBackendDefaults:
+ """Defaults for the Hugging Face realtime backend."""
+
+ connection_mode: str = HF_DEPLOYED_CONNECTION_MODE
+ # App-managed Hugging Face Space proxy. The Space forwards to the current
+ # session allocator, so allocator changes do not require app releases.
+ # Users who need a custom target should use HF_REALTIME_CONNECTION_MODE=local
+ # with HF_REALTIME_WS_URL.
+ session_url: str = HF_REALTIME_SESSION_PROXY_URL
+ voice: str = "Aiden"
+ direct_port: int = 8765
+
+
+HF_DEFAULTS = HFBackendDefaults()
+
+logger = logging.getLogger(__name__)
+
+# Removed backend selectors kept in stale robot .env files: warn but ignore them.
+_OBSOLETE_BACKEND_ENV_NAMES = ("BACKEND_PROVIDER", "MODEL_NAME")
+
+
+def _warn_on_obsolete_backend_env() -> None:
+ """Warn when removed multi-backend selectors are still set; Hugging Face is the only backend."""
+ present = [name for name in _OBSOLETE_BACKEND_ENV_NAMES if (os.getenv(name) or "").strip()]
+ if present:
+ logger.warning(
+ "Ignoring obsolete backend environment variable(s): %s. This app now uses the Hugging Face backend only.",
+ ", ".join(present),
+ )
+
+
+def _env_flag(name: str, default: bool = False) -> bool:
+ """Parse a boolean environment flag.
+
+ Accepted truthy values: 1, true, yes, on
+ Accepted falsy values: 0, false, no, off
+ """
+ raw = os.getenv(name)
+ if raw is None:
+ return default
+
+ value = raw.strip().lower()
+ if value in {"1", "true", "yes", "on"}:
+ return True
+ if value in {"0", "false", "no", "off"}:
+ return False
+
+ logger.warning("Invalid boolean value for %s=%r, using default=%s", name, raw, default)
+ return default
+
+
+APP_TIMEOUT_MINUTES_ENV = "REACHY_MINI_APP_TIMEOUT_MINUTES"
+DEFAULT_APP_TIMEOUT_MINUTES = 1440.0
+
+
+def resolve_app_timeout_minutes() -> float | None:
+ """Read the app inactivity timeout (minutes) from the environment; None means disabled."""
+ raw_value = os.getenv(APP_TIMEOUT_MINUTES_ENV, "").strip()
+ if not raw_value:
+ return DEFAULT_APP_TIMEOUT_MINUTES
+ try:
+ timeout_minutes = float(raw_value)
+ except ValueError:
+ logger.warning("Ignoring invalid %s=%r; using default.", APP_TIMEOUT_MINUTES_ENV, raw_value)
+ return DEFAULT_APP_TIMEOUT_MINUTES
+ return timeout_minutes if timeout_minutes > 0 else None
+
+
+def _normalize_hf_connection_mode(value: str | None) -> str | None:
+ """Normalize the Hugging Face connection mode, if explicitly configured."""
+ candidate = (value or "").strip().lower()
+ if not candidate:
+ return None
+
+ if candidate not in {HF_LOCAL_CONNECTION_MODE, HF_DEPLOYED_CONNECTION_MODE}:
+ logger.warning(
+ "Invalid %s=%r. Expected local or deployed.",
+ HF_REALTIME_CONNECTION_MODE_ENV,
+ value,
+ )
+ return None
+ return candidate
+
+
+def _normalize_transcription_language(value: str | None) -> str:
+ """Return the configured realtime transcription language."""
+ candidate = (value or "").strip()
+ return candidate or "en"
+
+
+@dataclass(frozen=True)
+class HFConnectionSelection:
+ """Resolved Hugging Face connection mode and target availability."""
+
+ mode: str
+ has_target: bool
+ session_url: str | None = None
+ direct_ws_url: str | None = None
+
+
+@dataclass(frozen=True)
+class HFRealtimeURLParts:
+ """Parsed Hugging Face realtime URL components used by UI and client setup."""
+
+ base_url: str
+ websocket_base_url: str
+ connect_query: dict[str, str]
+ host: str | None
+ port: int | None
+ has_realtime_path: bool
+
+
+def parse_hf_realtime_url(realtime_url: str) -> HFRealtimeURLParts:
+ """Parse a Hugging Face realtime URL into OpenAI-compatible client endpoints."""
+ parsed = urlsplit(realtime_url)
+ scheme = parsed.scheme.lower()
+ if scheme not in {"ws", "wss", "http", "https"}:
+ raise ValueError(
+ "Expected Hugging Face realtime URL to start with ws://, wss://, http://, or https://, "
+ f"got: {realtime_url}"
+ )
+
+ path = parsed.path.rstrip("/")
+ has_realtime_path = path.endswith("/realtime")
+ if has_realtime_path:
+ base_path = path[: -len("/realtime")]
+ else:
+ base_path = path
+
+ connect_query = {key: value for key, value in parse_qsl(parsed.query, keep_blank_values=True) if key != "model"}
+ http_scheme = "https" if scheme in {"wss", "https"} else "http"
+ websocket_scheme = "wss" if scheme in {"wss", "https"} else "ws"
+ base_url = urlunsplit((http_scheme, parsed.netloc, base_path, "", ""))
+ websocket_base_url = urlunsplit((websocket_scheme, parsed.netloc, base_path, "", ""))
+ return HFRealtimeURLParts(
+ base_url=base_url,
+ websocket_base_url=websocket_base_url,
+ connect_query=connect_query,
+ host=parsed.hostname,
+ port=parsed.port or HF_DEFAULTS.direct_port,
+ has_realtime_path=has_realtime_path,
+ )
+
+
+def parse_hf_direct_target(ws_url: str | None) -> tuple[str | None, int | None]:
+ """Extract host and port from a direct Hugging Face realtime URL."""
+ if not ws_url:
+ return None, None
+ try:
+ parsed = parse_hf_realtime_url(ws_url)
+ return parsed.host, parsed.port
+ except Exception:
+ return None, None
+
+
+def build_hf_direct_ws_url(host: str, port: int) -> str:
+ """Build the direct Hugging Face realtime websocket URL used by the app."""
+ return f"ws://{host}:{port}/v1/realtime"
+
+
+def _collect_profile_names(profiles_root: Path) -> set[str]:
+ """Return profile folder names from a profiles root directory."""
+ if not profiles_root.exists() or not profiles_root.is_dir():
+ return set()
+ return {p.name for p in profiles_root.iterdir() if p.is_dir()}
+
+
+def _collect_tool_module_names(tools_root: Path) -> set[str]:
+ """Return tool module names from a tools directory."""
+ if not tools_root.exists() or not tools_root.is_dir():
+ return set()
+ ignored = {"__init__", "core_tools"}
+ return {p.stem for p in tools_root.glob("*.py") if p.is_file() and p.stem not in ignored}
+
+
+def _raise_on_name_collisions(
+ *,
+ label: str,
+ external_root: Path,
+ internal_root: Path,
+ external_names: set[str],
+ internal_names: set[str],
+) -> None:
+ """Raise with a clear message when external/internal names collide."""
+ collisions = sorted(external_names & internal_names)
+ if not collisions:
+ return
+
+ raise RuntimeError(
+ f"Config.__init__(): Ambiguous {label} names found in both external and built-in libraries: {collisions}. "
+ f"External {label} root: {external_root}. Built-in {label} root: {internal_root}. "
+ f"Please rename the conflicting external {label}(s) to continue."
+ )
+
+
+# Validate LOCKED_PROFILE at startup
+if LOCKED_PROFILE is not None:
+ _profiles_dir = DEFAULT_PROFILES_DIRECTORY
+ _profile_path = _profiles_dir / LOCKED_PROFILE
+ _instructions_file = _profile_path / "instructions.txt"
+ if not _profile_path.is_dir():
+ logger.critical("LOCKED_PROFILE %r does not exist in %s", LOCKED_PROFILE, _profiles_dir)
+ sys.exit(1)
+ if not _instructions_file.is_file():
+ logger.critical("LOCKED_PROFILE %r has no instructions.txt", LOCKED_PROFILE)
+ sys.exit(1)
+
+_skip_dotenv = _env_flag("REACHY_MINI_SKIP_DOTENV", default=False)
+
+if _skip_dotenv:
+ logger.info("Skipping .env loading because REACHY_MINI_SKIP_DOTENV is set")
+else:
+ # Locate .env file (search upward from current working directory)
+ dotenv_path = find_dotenv(usecwd=True)
+
+ if dotenv_path:
+ # Load .env and override environment variables
+ load_dotenv(dotenv_path=dotenv_path, override=True)
+ logger.info(f"Configuration loaded from {dotenv_path}")
+ else:
+ logger.warning("No .env file found, using environment variables")
+
+_warn_on_obsolete_backend_env()
+
+
+class Config:
+ """Configuration class for the conversation app."""
+
+ HF_REALTIME_CONNECTION_MODE = (
+ _normalize_hf_connection_mode(os.getenv(HF_REALTIME_CONNECTION_MODE_ENV)) or HF_DEFAULTS.connection_mode
+ )
+ # Deliberately ignore HF_REALTIME_SESSION_URL from the environment; the app-managed proxy is HF_DEFAULTS.session_url.
+ HF_REALTIME_SESSION_URL = HF_DEFAULTS.session_url
+ HF_REALTIME_WS_URL = os.getenv(HF_REALTIME_WS_URL_ENV)
+ REALTIME_TRANSCRIPTION_LANGUAGE = _normalize_transcription_language(os.getenv(REALTIME_TRANSCRIPTION_LANGUAGE_ENV))
+ HF_TOKEN = os.getenv("HF_TOKEN") # Optional, falls back to hf auth login if not set
+
+ logger.debug(
+ "HF mode: %s, HF session URL set: %s, HF direct URL set: %s",
+ HF_REALTIME_CONNECTION_MODE,
+ bool(HF_REALTIME_SESSION_URL and HF_REALTIME_SESSION_URL.strip()),
+ bool(HF_REALTIME_WS_URL and HF_REALTIME_WS_URL.strip()),
+ )
+
+ # Filesystem root containing profile directories, not a Python import path.
+ _profiles_directory_env = os.getenv("REACHY_MINI_EXTERNAL_PROFILES_DIRECTORY")
+ PROFILES_DIRECTORY = Path(_profiles_directory_env) if _profiles_directory_env else DEFAULT_PROFILES_DIRECTORY
+ INSTANCE_PATH: Path | None = None # set at startup; writable home for UI-created profiles
+ _tools_directory_env = os.getenv("REACHY_MINI_EXTERNAL_TOOLS_DIRECTORY")
+ TOOLS_DIRECTORY = Path(_tools_directory_env) if _tools_directory_env else None
+ AUTOLOAD_EXTERNAL_TOOLS = _env_flag("AUTOLOAD_EXTERNAL_TOOLS", default=False)
+ REACHY_MINI_CUSTOM_PROFILE = LOCKED_PROFILE or os.getenv("REACHY_MINI_CUSTOM_PROFILE")
+
+ logger.debug(f"Custom Profile: {REACHY_MINI_CUSTOM_PROFILE}")
+
+ def __init__(self) -> None:
+ """Initialize the configuration."""
+ if self.REACHY_MINI_CUSTOM_PROFILE and self.PROFILES_DIRECTORY != DEFAULT_PROFILES_DIRECTORY:
+ selected_profile_path = self.PROFILES_DIRECTORY / self.REACHY_MINI_CUSTOM_PROFILE
+ if not selected_profile_path.is_dir():
+ available_profiles = sorted(_collect_profile_names(self.PROFILES_DIRECTORY))
+ raise RuntimeError(
+ "Config.__init__(): Selected profile "
+ f"'{self.REACHY_MINI_CUSTOM_PROFILE}' was not found in external profiles root "
+ f"{self.PROFILES_DIRECTORY}. "
+ f"Available external profiles: {available_profiles}. "
+ "Either set 'REACHY_MINI_CUSTOM_PROFILE' to one of the available external profiles "
+ "or unset 'REACHY_MINI_EXTERNAL_PROFILES_DIRECTORY' to use built-in profiles."
+ )
+
+ if self.PROFILES_DIRECTORY != DEFAULT_PROFILES_DIRECTORY:
+ external_profiles = _collect_profile_names(self.PROFILES_DIRECTORY)
+ internal_profiles = _collect_profile_names(DEFAULT_PROFILES_DIRECTORY)
+ _raise_on_name_collisions(
+ label="profile",
+ external_root=self.PROFILES_DIRECTORY,
+ internal_root=DEFAULT_PROFILES_DIRECTORY,
+ external_names=external_profiles,
+ internal_names=internal_profiles,
+ )
+
+ if self.TOOLS_DIRECTORY is not None:
+ builtin_tools_root = Path(__file__).parent / "tools"
+ external_tools = _collect_tool_module_names(self.TOOLS_DIRECTORY)
+ internal_tools = _collect_tool_module_names(builtin_tools_root)
+ _raise_on_name_collisions(
+ label="tool",
+ external_root=self.TOOLS_DIRECTORY,
+ internal_root=builtin_tools_root,
+ external_names=external_tools,
+ internal_names=internal_tools,
+ )
+
+ if self.PROFILES_DIRECTORY != DEFAULT_PROFILES_DIRECTORY:
+ logger.warning(
+ "Environment variable 'REACHY_MINI_EXTERNAL_PROFILES_DIRECTORY' is set. "
+ "Profiles (instructions.txt, ...) will be loaded from %s.",
+ self.PROFILES_DIRECTORY,
+ )
+ else:
+ logger.info(
+ "'REACHY_MINI_EXTERNAL_PROFILES_DIRECTORY' is not set. Using built-in profiles from %s.",
+ DEFAULT_PROFILES_DIRECTORY,
+ )
+
+ if self.TOOLS_DIRECTORY is not None:
+ logger.warning(
+ "Environment variable 'REACHY_MINI_EXTERNAL_TOOLS_DIRECTORY' is set. "
+ "External tools will be loaded from %s.",
+ self.TOOLS_DIRECTORY,
+ )
+ else:
+ logger.info("'REACHY_MINI_EXTERNAL_TOOLS_DIRECTORY' is not set. Using built-in shared tools only.")
+
+ def user_personalities_root(self) -> Path:
+ """Writable root for UI-created profiles."""
+ base = self.INSTANCE_PATH if self.INSTANCE_PATH is not None else resolve_state_root()
+ return Path(base) / USER_PERSONALITIES_DIRNAME
+
+ def resolve_profile_dir(self, profile: str) -> Path:
+ """On-disk directory for a profile selection."""
+ head, _, tail = profile.partition("/")
+ if head == USER_PERSONALITIES_DIRNAME and tail:
+ return self.user_personalities_root() / tail
+ return self.PROFILES_DIRECTORY / profile
+
+
+config = Config()
+
+
+def refresh_runtime_config_from_env() -> None:
+ """Refresh mutable runtime config fields from the current environment."""
+ _warn_on_obsolete_backend_env()
+ config.HF_REALTIME_CONNECTION_MODE = (
+ _normalize_hf_connection_mode(os.getenv(HF_REALTIME_CONNECTION_MODE_ENV)) or HF_DEFAULTS.connection_mode
+ )
+ # Deliberately ignore HF_REALTIME_SESSION_URL from the environment; the app-managed proxy is HF_DEFAULTS.session_url.
+ config.HF_REALTIME_SESSION_URL = HF_DEFAULTS.session_url
+ config.HF_REALTIME_WS_URL = os.getenv(HF_REALTIME_WS_URL_ENV)
+ config.REALTIME_TRANSCRIPTION_LANGUAGE = _normalize_transcription_language(
+ os.getenv(REALTIME_TRANSCRIPTION_LANGUAGE_ENV)
+ )
+ config.HF_TOKEN = os.getenv("HF_TOKEN")
+ config.REACHY_MINI_CUSTOM_PROFILE = LOCKED_PROFILE or os.getenv("REACHY_MINI_CUSTOM_PROFILE")
+
+
+def get_available_voices() -> list[str]:
+ """Return the curated Hugging Face voice list."""
+ return list(HF_AVAILABLE_VOICES)
+
+
+def get_default_voice() -> str:
+ """Return the default Hugging Face voice."""
+ return HF_DEFAULTS.voice
+
+
+def get_hf_session_url() -> str | None:
+ """Return the built-in Hugging Face session proxy URL, if any."""
+ value = (getattr(config, "HF_REALTIME_SESSION_URL", None) or "").strip()
+ return value or None
+
+
+def get_hf_direct_ws_url() -> str | None:
+ """Return the configured direct Hugging Face realtime URL, if any."""
+ value = (getattr(config, "HF_REALTIME_WS_URL", None) or "").strip()
+ return value or None
+
+
+def get_hf_connection_selection() -> HFConnectionSelection:
+ """Resolve the selected Hugging Face connection mode and whether it is usable."""
+ session_url = get_hf_session_url()
+ direct_ws_url = get_hf_direct_ws_url()
+ mode = _normalize_hf_connection_mode(getattr(config, "HF_REALTIME_CONNECTION_MODE", None))
+ if mode is None:
+ raise RuntimeError(f"{HF_REALTIME_CONNECTION_MODE_ENV} must be set to local or deployed.")
+
+ target = direct_ws_url if mode == HF_LOCAL_CONNECTION_MODE else session_url
+
+ return HFConnectionSelection(
+ mode=mode,
+ has_target=bool(target),
+ session_url=session_url,
+ direct_ws_url=direct_ws_url,
+ )
+
+
+def has_hf_realtime_target() -> bool:
+ """Return whether Hugging Face has a target for the selected mode."""
+ return get_hf_connection_selection().has_target
+
+
+def set_instance_path(instance_path: str | Path | None) -> None:
+ """Record the app instance dir so UI-created profiles persist outside package data."""
+ config.INSTANCE_PATH = Path(instance_path) if instance_path else None
+
+
+def set_custom_profile(profile: str | None) -> None:
+ """Update the selected custom profile at runtime and expose it via env.
+
+ This ensures modules that read `config` and code that inspects the
+ environment see a consistent value.
+ """
+ if LOCKED_PROFILE is not None:
+ return
+ try:
+ config.REACHY_MINI_CUSTOM_PROFILE = profile
+ except Exception as e:
+ logger.warning("Failed to update config profile: %s", e)
+ try:
+ if profile:
+ os.environ["REACHY_MINI_CUSTOM_PROFILE"] = profile
+ else:
+ # Remove to reflect default
+ os.environ.pop("REACHY_MINI_CUSTOM_PROFILE", None)
+ except Exception as e:
+ logger.warning("Failed to sync profile to environment: %s", e)
diff --git a/src/peachy/console.py b/src/peachy/console.py
new file mode 100644
index 0000000000000000000000000000000000000000..60cabe2e25d9f899092ce32c09a6afaf60eaa387
--- /dev/null
+++ b/src/peachy/console.py
@@ -0,0 +1,1005 @@
+"""Bidirectional local audio stream with optional web settings UI.
+
+If the selected backend is missing its required API key, a settings page is
+served via the Reachy Mini Apps settings server so users can configure it.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+import os
+import time
+import asyncio
+import logging
+import tempfile
+import threading
+from typing import List, Optional
+from pathlib import Path
+from collections.abc import Callable, AsyncGenerator
+
+from reachy_mini import ReachyMini
+from reachy_mini.media.media_manager import MediaBackend
+from peachy.config import (
+ LOCKED_PROFILE,
+ HF_REALTIME_WS_URL_ENV,
+ HF_LOCAL_CONNECTION_MODE,
+ HF_DEPLOYED_CONNECTION_MODE,
+ HF_REALTIME_CONNECTION_MODE_ENV,
+ config,
+ get_default_voice,
+ get_hf_session_url,
+ build_hf_direct_ws_url,
+ parse_hf_direct_target,
+ get_hf_connection_selection,
+ refresh_runtime_config_from_env,
+)
+from peachy.streaming import AdditionalOutputs
+from peachy.audio.resampling import resample_audio
+from peachy.startup_settings import read_startup_settings, write_startup_settings
+from peachy.tools.core_tools import initialize_tools
+from peachy.personality_routes import mount_personality_routes
+from peachy.audio.startup_config import apply_audio_startup_config
+from peachy.conversation_handler import ConversationHandler
+from peachy.providers import (
+ OPENAI_DEFAULT_MODEL,
+ OPENAI_MODEL_ENV,
+ OPENAI_PROVIDER,
+ PROVIDER_ENV,
+ ProviderDefinition,
+ available_provider_names,
+ get_provider_definition,
+ redact_configured_credentials,
+ redact_secrets,
+ resolve_provider_name,
+)
+
+
+try:
+ # FastAPI is provided by the Reachy Mini Apps runtime
+ from fastapi import FastAPI, Request, Response
+ from pydantic import BaseModel
+ from fastapi.responses import FileResponse, JSONResponse, StreamingResponse
+ from starlette.staticfiles import StaticFiles
+except Exception: # pragma: no cover - only loaded when settings_app is used
+ FastAPI = object # type: ignore
+ FileResponse = object # type: ignore
+ JSONResponse = object # type: ignore
+ StreamingResponse = object # type: ignore
+ StaticFiles = object # type: ignore
+ BaseModel = object # type: ignore
+ Request = object # type: ignore
+
+logger = logging.getLogger(__name__)
+
+_SSE_KEEPALIVE_INTERVAL_SECONDS = 15.0 # below typical 60s proxy idle timeout
+SETTINGS_API_PREFIX = "/api/v1"
+
+
+def _detach_framework_root_routes(app: "FastAPI") -> None:
+ """Strip framework routes that would shadow the settings UI."""
+ routes = getattr(app, "router", None)
+ routes = getattr(routes, "routes", None) if routes else getattr(app, "routes", None)
+ if routes is None:
+ return
+ survivors = []
+ for route in routes:
+ path = getattr(route, "path", None)
+ is_catch_all = isinstance(path, str) and path.startswith("/{") and path.endswith(":path}")
+ if path in ("/", "/static") or is_catch_all:
+ logger.debug("detaching framework-provided route %r (%s)", path, type(route).__name__)
+ continue
+ survivors.append(route)
+ routes[:] = survivors
+
+
+class ConversationEventBus:
+ """Thread-safe fan-out bus that delivers conversation activity events to SSE subscribers."""
+
+ MAX_QUEUE_SIZE = 64
+
+ def __init__(self) -> None:
+ """Initialize the bus."""
+ # Each entry is (loop, queue); loop captured at subscribe() time for cross-thread delivery.
+ self._subscribers: list[tuple[asyncio.AbstractEventLoop, "asyncio.Queue[str]"]] = []
+ self._lock = threading.Lock()
+
+ def subscribe(self) -> tuple["asyncio.Queue[str]", Callable[[], None]]:
+ """Return a per-subscriber queue and its unsubscribe callback. Must be called from a coroutine."""
+ loop = asyncio.get_running_loop()
+ queue: "asyncio.Queue[str]" = asyncio.Queue(maxsize=self.MAX_QUEUE_SIZE)
+ entry = (loop, queue)
+ with self._lock:
+ self._subscribers.append(entry)
+
+ def unsubscribe() -> None:
+ with self._lock:
+ try:
+ self._subscribers.remove(entry)
+ except ValueError:
+ pass
+
+ return queue, unsubscribe
+
+ def publish(self, event: str) -> None:
+ """Broadcast to all subscribers via call_soon_threadsafe. Drops events for full or closed queues."""
+ with self._lock:
+ snapshot = list(self._subscribers)
+ for loop, queue in snapshot:
+ try:
+ loop.call_soon_threadsafe(self._enqueue_safely, queue, event)
+ except RuntimeError:
+ pass # loop closed; subscriber will clean itself up on disconnect
+
+ @staticmethod
+ def _enqueue_safely(queue: "asyncio.Queue[str]", event: str) -> None:
+ try:
+ queue.put_nowait(event)
+ except asyncio.QueueFull:
+ logger.debug("conversation event dropped (subscriber queue full): %s", event)
+
+
+async def _conversation_events_stream(
+ bus: ConversationEventBus,
+ request: "Request",
+) -> "AsyncGenerator[str, None]":
+ """Yield SSE lines for one subscriber; emits keep-alive comments during idle periods."""
+ queue, unsubscribe = bus.subscribe()
+ try:
+ yield "retry: 2000\n\n"
+ yield "event: ready\ndata: connected\n\n"
+
+ while True:
+ if await request.is_disconnected():
+ return
+ try:
+ event = await asyncio.wait_for(queue.get(), timeout=_SSE_KEEPALIVE_INTERVAL_SECONDS)
+ except asyncio.TimeoutError:
+ yield ": keep-alive\n\n"
+ continue
+ yield f"event: activity\ndata: {event}\n\n"
+ finally:
+ unsubscribe()
+
+
+LOCAL_PLAYER_BACKEND = (
+ getattr(MediaBackend, "LOCAL", None)
+ or getattr(MediaBackend, "GSTREAMER", None)
+ or getattr(MediaBackend, "DEFAULT", None)
+)
+
+HandlerFactory = Callable[[Optional[str]], ConversationHandler]
+ProviderResolver = Callable[[], ProviderDefinition]
+
+LEGACY_STARTUP_ENV_NAMES = (
+ "REACHY_MINI_CUSTOM_PROFILE",
+ "REACHY_MINI_VOICE_OVERRIDE",
+)
+BACKEND_RETRY_DELAY_SECONDS = 5.0
+
+
+class LocalStream:
+ """LocalStream using Reachy Mini's recorder/player."""
+
+ def __init__(
+ self,
+ handler: ConversationHandler,
+ robot: ReachyMini,
+ *,
+ settings_app: Optional[FastAPI] = None,
+ instance_path: Optional[str] = None,
+ handler_factory: HandlerFactory | None = None,
+ provider_resolver: ProviderResolver = get_provider_definition,
+ startup_voice: Optional[str] = None,
+ ):
+ """Initialize the stream with a realtime handler and pipelines.
+
+ - ``settings_app``: the Reachy Mini Apps FastAPI to attach settings endpoints.
+ - ``instance_path``: directory where per-instance ``.env`` should be stored.
+ - ``handler_factory``: builds a fresh handler for the currently selected backend.
+ - ``provider_resolver``: returns the current provider definition and readiness.
+ """
+ self._robot = robot
+ self._stop_event = asyncio.Event()
+ self._restart_requested = asyncio.Event()
+ self._tasks: List[asyncio.Task[None]] = []
+ self._handler_factory = handler_factory
+ self._provider_resolver = provider_resolver
+ self._voice_override = startup_voice
+ self._settings_app: Optional[FastAPI] = settings_app
+ self._instance_path: Optional[str] = instance_path
+ self._settings_initialized = False
+ self._asyncio_loop = None
+ self._mic_muted = False # mic starts live; the UI toggles it via the settings API
+ self._backend_connection_state = "not_started"
+ self._backend_error: str | None = None
+ self._backend_retry_delay = BACKEND_RETRY_DELAY_SECONDS
+ # One bus for the stream's lifetime: the conversation events route
+ # closes over it, so handler rebuilds must keep publishing into it.
+ self._event_bus = ConversationEventBus()
+ self._install_handler(handler)
+
+ def _install_handler(self, handler: ConversationHandler) -> None:
+ """Set the active handler and wire LocalStream-owned helpers into it."""
+ self.handler = handler
+ self.handler._clear_queue = self.clear_audio_queue
+ self._attach_event_bus_to_handler()
+
+ def _attach_event_bus_to_handler(self) -> None:
+ """Wire the event bus as the handler's activity observer, if supported."""
+ setter = getattr(self.handler, "set_activity_observer", None)
+ if callable(setter):
+ setter(self._event_bus.publish)
+
+ def seconds_since_activity(self) -> float:
+ """Seconds since the live handler last saw conversation activity."""
+ return time.monotonic() - self.handler.last_activity_time
+
+ def _read_env_lines(self, env_path: Path) -> list[str]:
+ """Load env file contents or a template as a list of lines."""
+ inst = env_path.parent
+ try:
+ if env_path.exists():
+ try:
+ return env_path.read_text(encoding="utf-8").splitlines()
+ except Exception:
+ return []
+ template_text = None
+ ex = inst / ".env.example"
+ if ex.exists():
+ try:
+ template_text = ex.read_text(encoding="utf-8")
+ except Exception:
+ template_text = None
+ if template_text is None:
+ try:
+ cwd_example = Path.cwd() / ".env.example"
+ if cwd_example.exists():
+ template_text = cwd_example.read_text(encoding="utf-8")
+ except Exception:
+ template_text = None
+ if template_text is None:
+ packaged = Path(__file__).parent / ".env.example"
+ if packaged.exists():
+ try:
+ template_text = packaged.read_text(encoding="utf-8")
+ except Exception:
+ template_text = None
+ return template_text.splitlines() if template_text else []
+ except Exception:
+ return []
+
+ def _backend_connected(self) -> bool:
+ """Return whether the active handler currently has a realtime connection."""
+ try:
+ handler_state = vars(self.handler)
+ except TypeError:
+ handler_state = {}
+ return handler_state.get("connection") is not None
+
+ def _can_rebuild_handler(self) -> bool:
+ """Return whether LocalStream can construct handlers for backend changes."""
+ return self._handler_factory is not None
+
+ def _build_handler_for_current_backend(self) -> ConversationHandler:
+ """Create and install a fresh handler for the current runtime backend config."""
+ if self._handler_factory is None:
+ return self.handler
+ handler = self._handler_factory(self._voice_override)
+ self._install_handler(handler)
+ return handler
+
+ async def _shutdown_active_handler(self) -> None:
+ """Best-effort shutdown for the currently active handler."""
+ try:
+ await self.handler.shutdown()
+ except asyncio.CancelledError:
+ raise
+ except Exception as e:
+ logger.debug(
+ "Active handler shutdown ignored during restart: %s",
+ redact_configured_credentials(e),
+ )
+
+ def _mark_restart_requested(self, reason: str) -> None:
+ """Request a backend restart from a synchronous route handler."""
+ logger.info("Backend restart requested: %s", reason)
+ self._set_backend_connection_state("connecting")
+ loop = self._asyncio_loop
+ if loop is not None and loop.is_running():
+ asyncio.run_coroutine_threadsafe(self.request_backend_restart(reason), loop)
+ return
+ self._restart_requested.set()
+
+ async def request_backend_restart(self, reason: str) -> None:
+ """Ask the startup loop to rebuild the backend and stop the current handler."""
+ self._set_backend_connection_state("connecting")
+ self._restart_requested.set()
+ self.clear_audio_queue()
+ await self._shutdown_active_handler()
+
+ async def _sleep_or_restart_requested(self, delay: float) -> None:
+ """Sleep for a retry interval, waking early if a restart is requested."""
+ if self._restart_requested.is_set():
+ return
+ try:
+ await asyncio.wait_for(self._restart_requested.wait(), timeout=delay)
+ except asyncio.TimeoutError:
+ pass
+
+ async def _wait_for_restart_or_stop(self) -> None:
+ """Wait until configuration/manual restart or app shutdown."""
+ while not self._stop_event.is_set() and not self._restart_requested.is_set():
+ await asyncio.sleep(0.1)
+
+ @staticmethod
+ def _format_backend_error(error: BaseException | str) -> str:
+ """Return a compact user-facing backend error string."""
+ if isinstance(error, str):
+ return redact_secrets(error)
+ message = str(error).strip()
+ rendered = f"{type(error).__name__}: {message}" if message else type(error).__name__
+ return redact_secrets(rendered)
+
+ def _set_backend_connection_state(self, state: str, error: BaseException | str | None = None) -> None:
+ """Update backend connection status exposed through the settings UI."""
+ self._backend_connection_state = state
+ if error is not None:
+ self._backend_error = self._format_backend_error(error)
+ elif state != "disconnected":
+ self._backend_error = None
+
+ def _backend_connection_status(self) -> dict[str, object]:
+ """Return the backend connection state exposed in the settings API."""
+ connected = self._backend_connected()
+ state = "connected" if connected else self._backend_connection_state
+ return {
+ "backend_connected": connected,
+ "backend_connection_state": state,
+ "backend_error": None if connected else self._backend_error,
+ }
+
+ @staticmethod
+ def _apply_runtime_env_values(
+ updates: dict[str, str],
+ removals: tuple[str, ...] = (),
+ ) -> None:
+ """Apply runtime environment updates, rolling back on refresh failure."""
+ affected_names = set(updates).union(removals)
+ previous_values = {name: os.environ.get(name) for name in affected_names}
+ try:
+ for env_name in removals:
+ os.environ.pop(env_name, None)
+ for env_name, value in updates.items():
+ os.environ[env_name] = value
+ refresh_runtime_config_from_env()
+ except Exception:
+ for env_name, previous in previous_values.items():
+ if previous is None:
+ os.environ.pop(env_name, None)
+ else:
+ os.environ[env_name] = previous
+ try:
+ refresh_runtime_config_from_env()
+ except Exception:
+ pass
+ raise
+
+ @staticmethod
+ def _write_env_file_atomically(env_path: Path, text: str) -> None:
+ """Securely replace an env file without exposing a partial credential write."""
+ file_descriptor, temporary_name = tempfile.mkstemp(
+ prefix=f".{env_path.name}.",
+ suffix=".tmp",
+ dir=env_path.parent,
+ )
+ os.close(file_descriptor)
+ temporary_path = Path(temporary_name)
+ try:
+ temporary_path.write_text(text, encoding="utf-8")
+ temporary_path.chmod(0o600)
+ temporary_path.replace(env_path)
+ finally:
+ temporary_path.unlink(missing_ok=True)
+
+ def _persist_env_values(
+ self,
+ updates: dict[str, str],
+ *,
+ removals: tuple[str, ...] = (),
+ ) -> None:
+ """Persist environment updates/removals transactionally, then refresh runtime config."""
+ normalized_updates = {name: (value or "").strip() for name, value in updates.items()}
+ normalized_updates = {name: value for name, value in normalized_updates.items() if value}
+ normalized_removals = tuple(
+ sorted(
+ {
+ name.strip()
+ for name in removals
+ if name and name.strip() and name.strip() not in normalized_updates
+ }
+ )
+ )
+ if not normalized_updates and not normalized_removals:
+ return
+
+ if not self._instance_path:
+ self._apply_runtime_env_values(normalized_updates, normalized_removals)
+ return
+
+ inst = Path(self._instance_path)
+ env_path = inst / ".env"
+ original_exists = env_path.exists()
+ original_text = env_path.read_text(encoding="utf-8") if original_exists else None
+ lines = original_text.splitlines() if original_text is not None else self._read_env_lines(env_path)
+ lines = [
+ line
+ for line in lines
+ if not any(line.strip().startswith(f"{env_name}=") for env_name in normalized_removals)
+ ]
+ for env_name, value in normalized_updates.items():
+ replaced = False
+ for i, line in enumerate(lines):
+ if line.strip().startswith(f"{env_name}="):
+ lines[i] = f"{env_name}={value}"
+ replaced = True
+ break
+ if not replaced:
+ lines.append(f"{env_name}={value}")
+ final_text = "\n".join(lines) + "\n"
+
+ self._write_env_file_atomically(env_path, final_text)
+ try:
+ self._apply_runtime_env_values(normalized_updates, normalized_removals)
+ except Exception:
+ try:
+ if original_exists and original_text is not None:
+ self._write_env_file_atomically(env_path, original_text)
+ else:
+ env_path.unlink(missing_ok=True)
+ except Exception:
+ logger.error("Failed to roll back provider configuration file after runtime update failure")
+ raise
+ changed_names = sorted((*normalized_updates, *normalized_removals))
+ logger.info("Persisted %s to %s", ", ".join(changed_names), env_path)
+
+ def _remove_persisted_env_values(self, env_names: tuple[str, ...]) -> None:
+ """Remove keys from the instance `.env` without mutating the current runtime."""
+ normalized_names = tuple(sorted({name.strip() for name in env_names if name and name.strip()}))
+ if not normalized_names or not self._instance_path:
+ return
+
+ env_path = Path(self._instance_path) / ".env"
+ if not env_path.exists():
+ return
+
+ try:
+ lines = env_path.read_text(encoding="utf-8").splitlines()
+ filtered_lines = [
+ line
+ for line in lines
+ if not any(line.strip().startswith(f"{env_name}=") for env_name in normalized_names)
+ ]
+ if filtered_lines == lines:
+ return
+
+ final_text = "\n".join(filtered_lines)
+ if final_text:
+ final_text += "\n"
+ env_path.write_text(final_text, encoding="utf-8")
+ env_path.chmod(0o600)
+ logger.info("Removed %s from %s", ", ".join(normalized_names), env_path)
+ except Exception as e:
+ logger.warning("Failed to remove %s: %s", ", ".join(normalized_names), e)
+
+ def _persist_hf_direct_connection(self, host: str, port: int) -> None:
+ """Persist a direct Hugging Face websocket target."""
+ self._persist_env_values(
+ {
+ HF_REALTIME_CONNECTION_MODE_ENV: HF_LOCAL_CONNECTION_MODE,
+ HF_REALTIME_WS_URL_ENV: build_hf_direct_ws_url(host, port),
+ }
+ )
+
+ def _persist_hf_allocator_connection(self) -> None:
+ """Persist the deployed Hugging Face allocator mode."""
+ self._persist_env_values(
+ {HF_REALTIME_CONNECTION_MODE_ENV: HF_DEPLOYED_CONNECTION_MODE},
+ removals=("HF_REALTIME_SESSION_URL",),
+ )
+
+ def _persist_personality(self, profile: Optional[str], voice_override: Optional[str] = None) -> None:
+ """Persist startup profile and voice in instance-local UI settings."""
+ if LOCKED_PROFILE is not None:
+ return
+ selection = (profile or "").strip() or None
+ normalized_voice_override = (voice_override or "").strip() or None
+ try:
+ from peachy.config import set_custom_profile
+
+ set_custom_profile(selection)
+ except Exception:
+ pass
+
+ if not self._instance_path:
+ return
+ try:
+ write_startup_settings(
+ self._instance_path,
+ profile=selection,
+ voice=normalized_voice_override,
+ )
+ self._remove_persisted_env_values(LEGACY_STARTUP_ENV_NAMES)
+ logger.info("Persisted startup personality settings to %s", Path(self._instance_path))
+ except Exception as e:
+ logger.warning("Failed to persist startup personality settings: %s", e)
+
+ def _read_persisted_personality(self) -> Optional[str]:
+ """Read the saved startup personality from instance-local UI settings."""
+ return read_startup_settings(self._instance_path).profile
+
+ async def apply_personality(self, profile: Optional[str]) -> str:
+ """Apply a personality by updating config and restarting the active backend."""
+ try:
+ from peachy.config import set_custom_profile
+ from peachy.prompts import get_session_voice, get_session_instructions
+
+ previous_profile = getattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ set_custom_profile(profile)
+ try:
+ get_session_instructions()
+ get_session_voice(default=get_default_voice())
+ except Exception:
+ set_custom_profile(previous_profile)
+ raise
+ except Exception as e:
+ safe_error = redact_secrets(e)
+ logger.error("Error applying personality '%s': %s", profile, safe_error)
+ return f"Failed to apply personality: {safe_error}"
+
+ # Rebuild the tool registry
+ initialize_tools(force=True)
+ await self.request_backend_restart("personality_changed")
+ return "Applied personality and restarting backend."
+
+ async def get_available_voices(self) -> list[str]:
+ """Return voices exposed by the active provider handler."""
+ try:
+ return list(await self.handler.get_available_voices())
+ except asyncio.CancelledError:
+ raise
+ except Exception as e:
+ logger.error("Failed to read voices from active provider: %s", redact_configured_credentials(e))
+ return []
+
+ def get_current_voice(self) -> str:
+ """Return the active provider handler's current voice."""
+ try:
+ handler_voice = self.handler.get_current_voice()
+ if isinstance(handler_voice, str):
+ return handler_voice
+ except Exception as e:
+ logger.error("Failed to read current voice from active provider: %s", redact_configured_credentials(e))
+
+ # Preserve the pre-provider fallback for incomplete test/external handlers.
+ if self._voice_override:
+ return self._voice_override
+ try:
+ from peachy.prompts import get_session_voice
+
+ return get_session_voice(default=get_default_voice())
+ except Exception:
+ return get_default_voice()
+
+ async def change_voice(self, voice: str) -> str:
+ """Change the voice through the active handler without rebuilding the backend."""
+ try:
+ status = await self.handler.change_voice(voice)
+ except asyncio.CancelledError:
+ raise
+ except Exception as e:
+ safe_error = redact_configured_credentials(e)
+ logger.error("Error changing voice to %r: %s", voice, safe_error)
+ return f"Failed to change voice: {safe_error}"
+
+ try:
+ current_voice = self.handler.get_current_voice()
+ if isinstance(current_voice, str) and current_voice.strip():
+ self._voice_override = current_voice
+ except Exception as e:
+ logger.debug(
+ "Could not sync LocalStream voice override after voice change: %s",
+ redact_configured_credentials(e),
+ )
+ if self._voice_override:
+ self._persist_voice_override(self._voice_override)
+ return status
+
+ def _persist_voice_override(self, voice: str) -> None:
+ """Persist the chosen voice as the startup voice, keeping the startup profile."""
+ if not self._instance_path:
+ return
+ try:
+ existing = read_startup_settings(self._instance_path)
+ write_startup_settings(self._instance_path, profile=existing.profile, voice=voice)
+ except Exception as e:
+ logger.warning("Failed to persist startup voice: %s", e)
+
+ def _init_settings_ui_if_needed(self) -> None:
+ """Attach minimal settings UI to the settings app.
+
+ Always mounts the UI when a settings_app is provided so that users
+ see a confirmation message even if the API key is already configured.
+ """
+ if self._settings_initialized:
+ return
+ if self._settings_app is None:
+ return
+ settings_app = self._settings_app
+
+ static_dir = Path(__file__).parent / "static"
+ index_file = static_dir / "index.html"
+ logger.info("Serving settings UI from %s", static_dir)
+
+ # Framework pre-registers GET / and /static; strip them so our routes aren't shadowed.
+ _detach_framework_root_routes(settings_app)
+
+ if hasattr(settings_app, "mount"):
+ try:
+ settings_app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+ except Exception:
+ pass
+
+ class BackendPayload(BaseModel):
+ provider: Optional[str] = None
+ openai_api_key: Optional[str] = None
+ openai_model: Optional[str] = None
+ hf_mode: Optional[str] = None
+ hf_host: Optional[str] = None
+ hf_port: Optional[int] = None
+
+ def _status_payload() -> dict[str, object]:
+ definition = self._provider_resolver()
+ readiness = definition.readiness()
+ backend_connection = self._backend_connection_status()
+ payload = {
+ "provider": definition.name,
+ "available_providers": list(available_provider_names()),
+ "provider_state": readiness.state,
+ "provider_message": readiness.message,
+ "can_proceed": readiness.state == "ready",
+ "requires_restart": not self._can_rebuild_handler(),
+ **definition.redacted_status(),
+ **backend_connection,
+ }
+ return {
+ name: redact_secrets(value) if isinstance(value, str) else value
+ for name, value in payload.items()
+ }
+
+ # GET / -> index.html
+ @settings_app.get("/")
+ def _root() -> FileResponse:
+ return FileResponse(str(index_file))
+
+ # GET /favicon.ico -> optional, avoid noisy 404s on some browsers
+ @settings_app.get("/favicon.ico")
+ def _favicon() -> Response:
+ return Response(status_code=204)
+
+ @settings_app.get(f"{SETTINGS_API_PREFIX}/status")
+ def _status() -> JSONResponse:
+ return JSONResponse(_status_payload())
+
+ @settings_app.post(f"{SETTINGS_API_PREFIX}/reconnect")
+ def _reconnect() -> JSONResponse:
+ self._mark_restart_requested("manual_reconnect")
+ return JSONResponse({"ok": True, "message": "Reconnecting selected provider."})
+
+ event_bus = self._event_bus
+
+ @settings_app.get(f"{SETTINGS_API_PREFIX}/conversation_events")
+ async def _conversation_events(request: Request) -> StreamingResponse:
+ return StreamingResponse(
+ _conversation_events_stream(event_bus, request),
+ media_type="text/event-stream",
+ headers={
+ "Cache-Control": "no-cache",
+ "X-Accel-Buffering": "no", # disable proxy buffering (e.g. nginx)
+ "Connection": "keep-alive",
+ },
+ )
+
+ class MicPayload(BaseModel):
+ muted: bool
+
+ @settings_app.get(f"{SETTINGS_API_PREFIX}/mic")
+ def _mic_state() -> JSONResponse:
+ return JSONResponse({"muted": self._mic_muted})
+
+ @settings_app.post(f"{SETTINGS_API_PREFIX}/mic")
+ def _set_mic(payload: MicPayload) -> JSONResponse:
+ self._mic_muted = bool(payload.muted)
+ logger.info("Microphone %s via web UI", "muted" if self._mic_muted else "unmuted")
+ return JSONResponse({"muted": self._mic_muted})
+
+ @settings_app.post(f"{SETTINGS_API_PREFIX}/backend_config")
+ def _set_backend(payload: BackendPayload) -> JSONResponse:
+ selected = resolve_provider_name(payload.provider)
+ if selected not in available_provider_names():
+ return JSONResponse({"ok": False, "error": "invalid_provider"}, status_code=400)
+
+ updates = {PROVIDER_ENV: selected}
+ removals: tuple[str, ...] = ()
+ if selected == OPENAI_PROVIDER:
+ supplied_key = (payload.openai_api_key or "").strip()
+ existing_key = (os.getenv("OPENAI_API_KEY") or "").strip()
+ if not supplied_key and not existing_key:
+ return JSONResponse({"ok": False, "error": "empty_key"}, status_code=400)
+ if supplied_key:
+ updates["OPENAI_API_KEY"] = supplied_key
+ model = (payload.openai_model or os.getenv(OPENAI_MODEL_ENV) or OPENAI_DEFAULT_MODEL).strip()
+ updates[OPENAI_MODEL_ENV] = model or OPENAI_DEFAULT_MODEL
+ else:
+ hf_selection = get_hf_connection_selection()
+ hf_mode = (payload.hf_mode or hf_selection.mode).strip().lower()
+ if hf_mode == HF_LOCAL_CONNECTION_MODE:
+ existing_host, existing_port = parse_hf_direct_target(hf_selection.direct_ws_url)
+ host = (payload.hf_host or "").strip() or existing_host or ""
+ if not host:
+ return JSONResponse({"ok": False, "error": "empty_hf_host"}, status_code=400)
+ if "://" in host or "/" in host or "?" in host or "#" in host:
+ return JSONResponse({"ok": False, "error": "invalid_hf_host"}, status_code=400)
+
+ port = payload.hf_port if payload.hf_port is not None else existing_port or 8765
+ if port < 1 or port > 65535:
+ return JSONResponse({"ok": False, "error": "invalid_hf_port"}, status_code=400)
+
+ updates[HF_REALTIME_CONNECTION_MODE_ENV] = HF_LOCAL_CONNECTION_MODE
+ updates[HF_REALTIME_WS_URL_ENV] = build_hf_direct_ws_url(host, port)
+ elif hf_mode == HF_DEPLOYED_CONNECTION_MODE:
+ if not bool(get_hf_session_url()):
+ return JSONResponse({"ok": False, "error": "missing_hf_session_url"}, status_code=400)
+ updates[HF_REALTIME_CONNECTION_MODE_ENV] = HF_DEPLOYED_CONNECTION_MODE
+ removals = ("HF_REALTIME_SESSION_URL",)
+ else:
+ return JSONResponse({"ok": False, "error": "invalid_hf_mode"}, status_code=400)
+
+ try:
+ self._persist_env_values(updates, removals=removals)
+ except Exception as e:
+ logger.warning("Failed to persist provider configuration (%s)", type(e).__name__)
+ return JSONResponse({"ok": False, "error": "persistence_failed"}, status_code=500)
+ if self._can_rebuild_handler():
+ self._mark_restart_requested("provider_config_changed")
+ message = "Connection saved. Reconnecting backend."
+ else:
+ message = "Connection saved. Restart Reachy Mini Conversation from the desktop app to apply it."
+ return JSONResponse(
+ {
+ "ok": True,
+ "message": message,
+ **_status_payload(),
+ }
+ )
+
+ try:
+ mount_personality_routes(
+ self._settings_app,
+ self.handler,
+ lambda: self._asyncio_loop,
+ persist_personality=self._persist_personality,
+ get_persisted_personality=self._read_persisted_personality,
+ apply_personality=self.apply_personality,
+ get_voices=self.get_available_voices,
+ get_current_voice=self.get_current_voice,
+ change_voice=self.change_voice,
+ api_prefix=SETTINGS_API_PREFIX,
+ )
+ except Exception:
+ logger.exception("Failed to mount personality routes; the personality UI will be unavailable")
+
+ self._settings_initialized = True
+
+ async def _run_handler_startup_loop(self) -> None:
+ """Start the realtime handler and keep settings UI alive after backend failures."""
+ while not self._stop_event.is_set():
+ definition = self._provider_resolver()
+ readiness = definition.readiness()
+ if readiness.state != "ready":
+ self._set_backend_connection_state(readiness.state, readiness.message)
+ await self._wait_for_restart_or_stop()
+ if self._stop_event.is_set():
+ return
+
+ if self._restart_requested.is_set():
+ await self._shutdown_active_handler()
+ self._restart_requested.clear()
+ if not self._can_rebuild_handler():
+ self._set_backend_connection_state("restart_required")
+ await self._wait_for_restart_or_stop()
+ continue
+ try:
+ self._build_handler_for_current_backend()
+ except Exception as exc:
+ self._set_backend_connection_state("configuration_error", exc)
+ await self._wait_for_restart_or_stop()
+ continue
+ definition = self._provider_resolver()
+ readiness = definition.readiness()
+ if readiness.state != "ready":
+ continue
+
+ self._set_backend_connection_state("connecting")
+ try:
+ await self.handler.start_up()
+ except asyncio.CancelledError:
+ raise
+ except Exception as exc:
+ self._set_backend_connection_state("disconnected", exc)
+ logger.warning("Provider activation stopped: %s", redact_secrets(exc))
+ else:
+ if self._stop_event.is_set():
+ return
+ self._set_backend_connection_state("disconnected")
+
+ if definition.auto_reconnect:
+ await self._sleep_or_restart_requested(self._backend_retry_delay)
+ else:
+ await self._wait_for_restart_or_stop()
+
+ def launch(self) -> None:
+ """Start the recorder/player and run the async processing loops.
+
+ If the selected backend is missing its required key, expose a tiny
+ settings UI via the Reachy Mini settings server to collect it before
+ starting streams.
+ """
+ self._stop_event.clear()
+
+ # Try to load an existing instance .env first (covers subsequent runs)
+ if self._instance_path:
+ try:
+ from dotenv import load_dotenv
+
+ env_path = Path(self._instance_path) / ".env"
+ if env_path.exists():
+ load_dotenv(dotenv_path=str(env_path), override=True)
+ refresh_runtime_config_from_env()
+ except Exception:
+ pass # Instance .env loading is optional; continue with defaults
+
+ # Always expose settings UI if a settings app is available
+ # (do this AFTER loading the instance .env so status endpoint sees the right value)
+ self._init_settings_ui_if_needed()
+
+ # Media starts even while the provider waits for configuration so the UI stays responsive.
+ self._robot.media.start_recording()
+ self._robot.media.start_playing()
+
+ async def runner() -> None:
+ # Capture loop for cross-thread personality actions
+ loop = asyncio.get_running_loop()
+ self._asyncio_loop = loop # type: ignore[assignment]
+ # Connect the backend first so it overlaps the warmup and audio config below.
+ handler_task = asyncio.create_task(self._run_handler_startup_loop(), name="realtime-handler")
+ self._tasks = [handler_task]
+ await asyncio.sleep(1) # give the pipelines time to start
+ await asyncio.to_thread(apply_audio_startup_config, self._robot, logger=logger)
+ self._tasks += [
+ asyncio.create_task(self.record_loop(), name="stream-record-loop"),
+ asyncio.create_task(self.play_loop(), name="stream-play-loop"),
+ ]
+ try:
+ await asyncio.gather(*self._tasks)
+ except asyncio.CancelledError:
+ logger.info("Tasks cancelled during shutdown")
+ finally:
+ # Ensure handler connection is closed
+ await self._shutdown_active_handler()
+
+ asyncio.run(runner())
+
+ def close(self) -> None:
+ """Stop the stream and underlying media pipelines.
+
+ This method:
+ - Stops audio recording and playback first
+ - Sets the stop event to signal async loops to terminate
+ - Cancels all pending async tasks (openai-handler, record-loop, play-loop)
+ """
+ logger.info("Stopping LocalStream...")
+
+ # Stop media pipelines FIRST before cancelling async tasks
+ # This ensures clean shutdown before PortAudio cleanup
+ try:
+ self._robot.media.stop_recording()
+ except Exception as e:
+ logger.debug(f"Error stopping recording (may already be stopped): {e}")
+
+ try:
+ self._robot.media.stop_playing()
+ except Exception as e:
+ logger.debug(f"Error stopping playback (may already be stopped): {e}")
+
+ # close() runs on watcher threads, loop-owned state must change on the loop.
+ loop = self._asyncio_loop
+ if loop is None or not loop.is_running():
+ self._stop_event.set()
+ return
+ loop.call_soon_threadsafe(self._stop_event.set)
+ for task in self._tasks:
+ if not task.done():
+ loop.call_soon_threadsafe(task.cancel)
+
+ def clear_audio_queue(self) -> None:
+ """Flush queued playback audio immediately on user barge-in.
+
+ Calls the SDK's ``clear_player()`` — now a first-class flush on both
+ the local GStreamer and WebRTC backends (the WebRTC one also tells the
+ daemon to drop audio already queued for the speaker). Falls back to the
+ deprecated ``clear_output_buffer()`` only for older SDKs.
+ """
+ logger.info("User intervention: flushing player queue")
+ audio = getattr(self._robot.media, "audio", None)
+ if audio is not None:
+ if hasattr(audio, "clear_player") and callable(audio.clear_player):
+ audio.clear_player()
+ elif hasattr(audio, "clear_output_buffer") and callable(audio.clear_output_buffer):
+ # Older SDK without clear_player(); best-effort.
+ audio.clear_output_buffer()
+ # Drain the handler's pending output in place — do NOT replace the
+ # queue object, since emit() may be awaiting it (wait_for_item).
+ self._drain_output_queue()
+
+ def _drain_output_queue(self) -> None:
+ """Empty the handler's output queue in place without replacing it."""
+ queue = getattr(self.handler, "output_queue", None)
+ if queue is None:
+ return
+ while not queue.empty():
+ try:
+ queue.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ async def record_loop(self) -> None:
+ """Read mic frames from the recorder and forward them to the handler."""
+ input_sample_rate = self._robot.media.get_input_audio_samplerate()
+ logger.debug(f"Audio recording started at {input_sample_rate} Hz")
+
+ while not self._stop_event.is_set():
+ audio_frame = self._robot.media.get_audio_sample()
+ if audio_frame is not None and not self._mic_muted:
+ await self.handler.receive((input_sample_rate, audio_frame))
+ await asyncio.sleep(0) # avoid busy loop
+
+ async def play_loop(self) -> None:
+ """Fetch outputs from the handler: log text and play audio frames."""
+ while not self._stop_event.is_set():
+ handler = self.handler
+ try:
+ handler_output = await asyncio.wait_for(handler.emit(), timeout=0.5)
+ except asyncio.TimeoutError:
+ continue
+
+ if isinstance(handler_output, AdditionalOutputs):
+ for msg in handler_output.args:
+ content = msg.get("content", "")
+ if isinstance(content, str):
+ logger.info(
+ "role=%s content=%s",
+ msg.get("role"),
+ content if len(content) < 500 else content[:500] + "…",
+ )
+
+ elif isinstance(handler_output, tuple):
+ source_rate, audio_data = handler_output
+ if audio_data.size == 0:
+ continue
+ output_rate = self._robot.media.get_output_audio_samplerate()
+ audio_frame = resample_audio(audio_data, source_rate, output_rate)
+ self._robot.media.push_audio_sample(audio_frame)
+
+ else:
+ logger.debug("Ignoring output type=%s", type(handler_output).__name__)
+
+ await asyncio.sleep(0) # yield to event loop
diff --git a/src/peachy/conversation_handler.py b/src/peachy/conversation_handler.py
new file mode 100644
index 0000000000000000000000000000000000000000..d56a0529c06f722bad0a0bf9d272aff4db2d4261
--- /dev/null
+++ b/src/peachy/conversation_handler.py
@@ -0,0 +1,133 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+from __future__ import annotations
+import time
+import asyncio
+import logging
+from abc import ABC, abstractmethod
+from typing import ClassVar, TypeAlias
+from collections.abc import Callable
+
+from peachy.streaming import AdditionalOutputs, AsyncStreamHandler, AudioArray, wait_for_item
+from peachy.idle_policy import start_idle_tool_call
+from peachy.tools.core_tools import ToolDependencies, get_tool_specs
+from peachy.tools.background_tool_manager import BackgroundToolManager
+
+
+logger = logging.getLogger(__name__)
+
+
+AudioFrame: TypeAlias = tuple[int, AudioArray]
+HandlerOutput: TypeAlias = AudioFrame | AdditionalOutputs | None
+QueueItem: TypeAlias = AudioFrame | AdditionalOutputs
+
+
+class ConversationHandler(AsyncStreamHandler, ABC):
+ """Shared app handler contract and idle behavior for realtime conversation backends."""
+
+ IDLE_BEHAVIOR_THRESHOLD_S: ClassVar[float] = 180.0
+
+ deps: ToolDependencies
+ tool_manager: BackgroundToolManager
+ output_queue: asyncio.Queue[QueueItem]
+ last_activity_time: float
+ last_idle_behavior_time: float
+ _activity_observer: Callable[[str], None] | None = None
+
+ def __init__(self) -> None:
+ """Initialize the stream handler and shared idle/activity tracking."""
+ super().__init__()
+ self.last_activity_time = time.monotonic()
+ self.last_idle_behavior_time = self.last_activity_time
+
+ def set_activity_observer(self, observer: Callable[[str], None] | None) -> None:
+ """Attach or detach an activity observer. Pass None to clear."""
+ self._activity_observer = observer
+
+ def _mark_activity(self, reason: str) -> None:
+ """Record non-idle conversation activity for the idle timer."""
+ self.last_activity_time = time.monotonic()
+ logger.debug("last activity time updated to %s (%s)", self.last_activity_time, reason)
+ if self._activity_observer is not None:
+ try:
+ self._activity_observer(reason)
+ except Exception:
+ logger.debug("activity observer raised (ignored)", exc_info=True)
+
+ def _idle_behavior_ready(self) -> bool:
+ """Return whether idle behavior may run now. Backends can add guards."""
+ return True
+
+ async def emit(self) -> HandlerOutput:
+ """Emit the next queued output, triggering local idle behavior when due."""
+ now = time.monotonic()
+ idle_duration = now - self.last_activity_time
+ idle_behavior_duration = now - self.last_idle_behavior_time
+ if (
+ idle_duration > self.IDLE_BEHAVIOR_THRESHOLD_S
+ and idle_behavior_duration > self.IDLE_BEHAVIOR_THRESHOLD_S
+ and self._idle_behavior_ready()
+ and self.deps.movement_manager.is_idle()
+ ):
+ try:
+ await self.send_idle_signal(idle_duration)
+ except Exception as e:
+ logger.warning("Idle tool skipped (connection closed?): %s", e)
+ return None
+ self.last_idle_behavior_time = now
+ handler_output = await wait_for_item(self.output_queue)
+ return handler_output
+
+ async def send_idle_signal(self, idle_duration: float) -> None:
+ """Run a locally selected idle tool without sending an idle turn to the model."""
+ if not self._is_connected():
+ logger.debug("No active session; cannot run idle tool")
+ return
+
+ available_tool_names = {spec["name"] for spec in get_tool_specs()}
+ await start_idle_tool_call(
+ deps=self.deps,
+ tool_manager=self.tool_manager,
+ output_queue=self.output_queue,
+ available_tool_names=available_tool_names,
+ idle_duration=idle_duration,
+ )
+
+ @abstractmethod
+ def _is_connected(self) -> bool:
+ """Return whether the backend session/connection is currently open."""
+ ...
+
+ @abstractmethod
+ async def start_up(self) -> None:
+ """Start the realtime handler."""
+ ...
+
+ @abstractmethod
+ async def shutdown(self) -> None:
+ """Shut down the realtime handler."""
+ ...
+
+ @abstractmethod
+ async def receive(self, frame: AudioFrame) -> None:
+ """Receive an input audio frame."""
+ ...
+
+ @abstractmethod
+ async def apply_personality(self, profile: str | None) -> str:
+ """Apply a personality profile."""
+ ...
+
+ @abstractmethod
+ async def get_available_voices(self) -> list[str]:
+ """Return voices available for the active backend."""
+ ...
+
+ @abstractmethod
+ def get_current_voice(self) -> str:
+ """Return the current voice."""
+ ...
+
+ @abstractmethod
+ async def change_voice(self, voice: str) -> str:
+ """Change the current voice."""
+ ...
diff --git a/src/peachy/dance_emotion_moves.py b/src/peachy/dance_emotion_moves.py
new file mode 100644
index 0000000000000000000000000000000000000000..0641c4b7aadcd7f9b54602a4be327f2f27866548
--- /dev/null
+++ b/src/peachy/dance_emotion_moves.py
@@ -0,0 +1,156 @@
+"""Dance and emotion moves for the movement queue system.
+
+This module implements dance moves and emotions as Move objects that can be queued
+and executed sequentially by the MovementManager.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import logging
+from typing import Tuple
+
+import numpy as np
+from numpy.typing import NDArray
+
+from reachy_mini.motion.move import Move
+from reachy_mini.motion.recorded_move import RecordedMoves
+from reachy_mini_dances_library.dance_move import DanceMove
+
+
+logger = logging.getLogger(__name__)
+
+
+class DanceQueueMove(Move): # type: ignore
+ """Wrapper for dance moves to work with the movement queue system."""
+
+ def __init__(self, move_name: str):
+ """Initialize a DanceQueueMove."""
+ self.dance_move = DanceMove(move_name)
+ self.move_name = move_name
+
+ @property
+ def duration(self) -> float:
+ """Duration property required by official Move interface."""
+ return float(self.dance_move.duration)
+
+ def evaluate(self, t: float) -> tuple[NDArray[np.float64] | None, NDArray[np.float64] | None, float | None]:
+ """Evaluate dance move at time t."""
+ try:
+ # Get the pose from the dance move
+ head_pose, antennas, body_yaw = self.dance_move.evaluate(t)
+
+ # Convert to numpy array if antennas is tuple and return in official Move format
+ if isinstance(antennas, tuple):
+ antennas = np.array([antennas[0], antennas[1]])
+
+ return (head_pose, antennas, body_yaw)
+
+ except Exception as e:
+ logger.error(f"Error evaluating dance move '{self.move_name}' at t={t}: {e}")
+ # Return neutral pose on error
+ from reachy_mini.utils import create_head_pose
+
+ neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ return (neutral_head_pose, np.array([0.0, 0.0], dtype=np.float64), 0.0)
+
+
+class EmotionQueueMove(Move): # type: ignore
+ """Wrapper for emotion moves to work with the movement queue system."""
+
+ def __init__(self, emotion_name: str, recorded_moves: RecordedMoves):
+ """Initialize an EmotionQueueMove."""
+ self.emotion_move = recorded_moves.get(emotion_name)
+ self.emotion_name = emotion_name
+
+ @property
+ def duration(self) -> float:
+ """Duration property required by official Move interface."""
+ return float(self.emotion_move.duration)
+
+ def evaluate(self, t: float) -> tuple[NDArray[np.float64] | None, NDArray[np.float64] | None, float | None]:
+ """Evaluate emotion move at time t."""
+ try:
+ # Get the pose from the emotion move
+ head_pose, antennas, body_yaw = self.emotion_move.evaluate(t)
+
+ # Convert to numpy array if antennas is tuple and return in official Move format
+ if isinstance(antennas, tuple):
+ antennas = np.array([antennas[0], antennas[1]])
+
+ return (head_pose, antennas, body_yaw)
+
+ except Exception as e:
+ logger.error(f"Error evaluating emotion '{self.emotion_name}' at t={t}: {e}")
+ # Return neutral pose on error
+ from reachy_mini.utils import create_head_pose
+
+ neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ return (neutral_head_pose, np.array([0.0, 0.0], dtype=np.float64), 0.0)
+
+
+class GotoQueueMove(Move): # type: ignore
+ """Wrapper for goto moves to work with the movement queue system."""
+
+ def __init__(
+ self,
+ target_head_pose: NDArray[np.float32],
+ start_head_pose: NDArray[np.float32] | None = None,
+ target_antennas: Tuple[float, float] = (0, 0),
+ start_antennas: Tuple[float, float] | None = None,
+ target_body_yaw: float = 0,
+ start_body_yaw: float | None = None,
+ duration: float = 1.0,
+ ):
+ """Initialize a GotoQueueMove."""
+ self._duration = duration
+ self.target_head_pose = target_head_pose
+ self.start_head_pose = start_head_pose
+ self.target_antennas = target_antennas
+ self.start_antennas = start_antennas or (0, 0)
+ self.target_body_yaw = target_body_yaw
+ self.start_body_yaw = start_body_yaw or 0
+
+ @property
+ def duration(self) -> float:
+ """Duration property required by official Move interface."""
+ return self._duration
+
+ def evaluate(self, t: float) -> tuple[NDArray[np.float64] | None, NDArray[np.float64] | None, float | None]:
+ """Evaluate goto move at time t using linear interpolation."""
+ try:
+ from reachy_mini.utils import create_head_pose
+ from reachy_mini.utils.interpolation import linear_pose_interpolation
+
+ # Clamp t to [0, 1] for interpolation
+ t_clamped = max(0, min(1, t / self.duration))
+
+ # Use start pose if available, otherwise neutral
+ if self.start_head_pose is not None:
+ start_pose = self.start_head_pose
+ else:
+ start_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+
+ # Interpolate head pose
+ head_pose = linear_pose_interpolation(start_pose, self.target_head_pose, t_clamped)
+
+ # Interpolate antennas - return as numpy array
+ antennas = np.array(
+ [
+ self.start_antennas[0] + (self.target_antennas[0] - self.start_antennas[0]) * t_clamped,
+ self.start_antennas[1] + (self.target_antennas[1] - self.start_antennas[1]) * t_clamped,
+ ],
+ dtype=np.float64,
+ )
+
+ # Interpolate body yaw
+ body_yaw = self.start_body_yaw + (self.target_body_yaw - self.start_body_yaw) * t_clamped
+
+ return (head_pose, antennas, body_yaw)
+
+ except Exception as e:
+ logger.error(f"Error evaluating goto move at t={t}: {e}")
+ # Return target pose on error - convert to float64
+ target_head_pose_f64 = self.target_head_pose.astype(np.float64)
+ target_antennas_array = np.array([self.target_antennas[0], self.target_antennas[1]], dtype=np.float64)
+ return (target_head_pose_f64, target_antennas_array, self.target_body_yaw)
diff --git a/src/peachy/huggingface_realtime.py b/src/peachy/huggingface_realtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fee7081dffafbf3af6c9573a5094a60ace4e9bc
--- /dev/null
+++ b/src/peachy/huggingface_realtime.py
@@ -0,0 +1,1133 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import json
+import time
+import uuid
+import base64
+import random
+import asyncio
+import logging
+from typing import Any, Final, Optional
+from urllib.parse import urlsplit, urlunsplit
+
+import httpx
+import numpy as np
+from openai import AsyncOpenAI
+from pydantic import Field, BaseModel
+from typing_extensions import Literal, TypedDict
+from openai.types.realtime import (
+ AudioTranscriptionParam,
+ RealtimeAudioConfigParam,
+ RealtimeToolsConfigParam,
+ RealtimeFunctionToolParam,
+ RealtimeAudioConfigInputParam,
+ RealtimeAudioConfigOutputParam,
+ RealtimeSessionCreateRequestParam,
+)
+from websockets.exceptions import ConnectionClosedError
+from openai.resources.realtime.realtime import AsyncRealtimeConnection
+from openai.types.realtime.realtime_audio_input_turn_detection_param import ServerVad
+
+from peachy.tools import core_tools
+from peachy.config import (
+ HF_LOCAL_CONNECTION_MODE,
+ config,
+ get_default_voice,
+ get_available_voices,
+ get_hf_direct_ws_url,
+ parse_hf_realtime_url,
+ get_hf_connection_selection,
+)
+from peachy.prompts import (
+ get_session_voice,
+ get_session_instructions,
+ get_session_greeting_prompt,
+)
+from peachy.streaming import AdditionalOutputs, audio_to_int16
+from peachy.tools.core_tools import (
+ ToolSpec,
+ ToolDependencies,
+ get_tool_specs,
+)
+from peachy.conversation_handler import AudioFrame, QueueItem, ConversationHandler
+from peachy.providers import redact_secrets
+from peachy.tools.background_tool_manager import (
+ ToolCallRoutine,
+ ToolNotification,
+ BackgroundToolManager,
+)
+
+
+logger = logging.getLogger(__name__)
+
+_RESPONSE_DONE_TIMEOUT: Final[float] = 30.0
+_RESPONSE_REJECTION_RETRY_DELAY: Final[float] = 0.5
+
+
+def _safe_endpoint_for_log(endpoint: str) -> str:
+ """Render an endpoint without userinfo, query parameters, or fragments."""
+ parsed = urlsplit(endpoint)
+ host = parsed.hostname or ""
+ if ":" in host and not host.startswith("["):
+ host = f"[{host}]"
+ netloc = f"{host}:{parsed.port}" if parsed.port is not None else host
+ return urlunsplit((parsed.scheme, netloc, parsed.path, "", ""))
+
+
+class InputTranscriptChunksByItem(BaseModel):
+ """Current item_id and its accumulated deltas. Only one item at a time."""
+
+ item_id: str | None = None
+ deltas: list[str] = Field(default_factory=list)
+
+
+def to_realtime_tools_config(tool_specs: list[ToolSpec]) -> RealtimeToolsConfigParam:
+ """Convert app tool specs to the OpenAI-compatible realtime session shape."""
+ realtime_tools: RealtimeToolsConfigParam = []
+ for spec in tool_specs:
+ realtime_tools.append(
+ RealtimeFunctionToolParam(
+ type="function",
+ name=spec["name"],
+ description=spec["description"],
+ parameters=spec["parameters"],
+ )
+ )
+ return realtime_tools
+
+
+class HFNativeRateAudioPCM(TypedDict):
+ """Hugging Face extension for native-rate PCM audio."""
+
+ type: Literal["audio/pcm"]
+ rate: None
+
+
+def _native_rate_audio_pcm() -> HFNativeRateAudioPCM:
+ """Return the Hugging Face native-rate PCM config."""
+ return {"type": "audio/pcm", "rate": None}
+
+
+def _build_openai_compatible_client_from_realtime_url(
+ realtime_url: str,
+ bearer_token: str | None,
+) -> tuple[AsyncOpenAI, dict[str, str]]:
+ """Build an OpenAI-compatible realtime client from a direct websocket/base URL."""
+ parsed = parse_hf_realtime_url(realtime_url)
+ client = AsyncOpenAI(
+ api_key=bearer_token or "DUMMY",
+ base_url=parsed.base_url,
+ websocket_base_url=parsed.websocket_base_url,
+ )
+ return client, parsed.connect_query
+
+
+class HuggingFaceRealtimeHandler(ConversationHandler):
+ """Realtime stream handler for the Hugging Face OpenAI-compatible endpoint."""
+
+ SAMPLE_RATE = 16000
+
+ def __init__(
+ self,
+ deps: ToolDependencies,
+ instance_path: Optional[str] = None,
+ startup_voice: Optional[str] = None,
+ ):
+ """Initialize the handler."""
+ super().__init__()
+
+ self.deps = deps
+
+ self.client: AsyncOpenAI
+ self.connection: AsyncRealtimeConnection | None = None
+ self.output_queue: asyncio.Queue[QueueItem] = asyncio.Queue()
+
+ self.instance_path = instance_path
+ self._voice_override: str | None = self._normalize_startup_voice(startup_voice)
+ self._realtime_connect_query: dict[str, str] = {}
+
+ # Debouncing for partial transcripts
+ self.partial_transcript_task: asyncio.Task[None] | None = None
+ self.partial_debounce_delay = 0.5 # seconds
+ self.input_transcript_chunks_by_item = InputTranscriptChunksByItem()
+
+ # Internal lifecycle flags
+ self._connected_event: asyncio.Event = asyncio.Event()
+
+ # Background tool manager
+ self.tool_manager = BackgroundToolManager()
+
+ # Response-in-progress guard: the Realtime API only allows one active
+ # response per conversation at a time. A dedicated worker task
+ # (_response_sender_loop) dequeues and sends one request at a time
+ self._pending_responses: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+ self._response_done_event: asyncio.Event = asyncio.Event()
+ self._response_done_event.set()
+ self._response_started_or_rejected_event: asyncio.Event = asyncio.Event()
+ self._last_response_rejected: bool = False
+ self._turn_user_done_at: float | None = None
+ self._turn_response_created_at: float | None = None
+ self._turn_first_audio_at: float | None = None
+ self._startup_greeting_sent = False
+ self._in_flight_tool_calls: set[str] = set()
+ self._tool_batch_needs_response = False
+ self._restart_tasks: set[asyncio.Task[None]] = set()
+ self._restart_lock = asyncio.Lock()
+ self._shutdown_started = False
+
+ @staticmethod
+ def _sanitize_tool_result_for_model(tool_name: str, tool_result: dict[str, Any]) -> dict[str, Any]:
+ """Remove bulky transport-only fields before echoing tool output back to the model."""
+ if tool_name == "camera" and "b64_im" in tool_result:
+ sanitized = dict(tool_result)
+ sanitized.pop("b64_im", None)
+ sanitized["image_attached"] = True
+ return sanitized
+ return tool_result
+
+ def _normalize_startup_voice(self, voice: str | None) -> str | None:
+ """Return a valid persisted startup voice, or None."""
+ return self._resolve_backend_voice(voice, source="persisted startup voice")
+
+ def _restart_task_done(self, task: asyncio.Task[None]) -> None:
+ """Retrieve and sanitize background restart failures."""
+ self._restart_tasks.discard(task)
+ if task.cancelled():
+ return
+ try:
+ task.result()
+ except Exception as exc:
+ logger.warning("Realtime session restart failed: %s", redact_secrets(exc))
+
+ async def _cancel_restart_tasks(self) -> None:
+ """Cancel and retrieve retained restart tasks during handler shutdown."""
+ restart_tasks = tuple(self._restart_tasks)
+ for task in restart_tasks:
+ task.cancel()
+ if restart_tasks:
+ await asyncio.gather(*restart_tasks, return_exceptions=True)
+ self._restart_tasks.clear()
+
+ async def _wait_for_response_done_before_tool_result(self) -> bool:
+ """Return whether the function-call response finished before sending tool output."""
+ if self._response_done_event.is_set():
+ return True
+
+ try:
+ await asyncio.wait_for(
+ self._response_done_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ return True
+ except asyncio.TimeoutError:
+ return False
+
+ def _resolve_backend_voice(
+ self,
+ voice: str | None,
+ *,
+ source: str,
+ fallback: str | None = None,
+ ) -> str | None:
+ """Return a backend-supported voice, optionally falling back when unsupported."""
+ available_voices = get_available_voices()
+ voice_value = (voice or "").strip()
+ if not voice_value:
+ return fallback
+
+ voice_by_lowercase = {candidate.lower(): candidate for candidate in available_voices}
+ normalized_voice = voice_by_lowercase.get(voice_value.lower())
+ if normalized_voice is not None:
+ return normalized_voice
+
+ if voice:
+ logger.warning(
+ "Ignoring unsupported %s %r; expected one of %s",
+ source,
+ voice,
+ available_voices,
+ )
+ return fallback
+
+ def _get_session_config(self, tool_specs: list[ToolSpec]) -> RealtimeSessionCreateRequestParam:
+ """Return the Hugging Face OpenAI-compatible session config."""
+ return RealtimeSessionCreateRequestParam(
+ type="realtime",
+ instructions=get_session_instructions(self.instance_path),
+ audio=RealtimeAudioConfigParam(
+ input=RealtimeAudioConfigInputParam(
+ # The OpenAI SDK type only includes 24 kHz PCM, but the HF
+ # compatible server uses rate=None for native 16 kHz mode.
+ format=_native_rate_audio_pcm(), # type: ignore[typeddict-item]
+ transcription=AudioTranscriptionParam(
+ model="gpt-4o-transcribe",
+ language=config.REALTIME_TRANSCRIPTION_LANGUAGE,
+ ),
+ turn_detection=ServerVad(type="server_vad", interrupt_response=True),
+ ),
+ output=RealtimeAudioConfigOutputParam(
+ format=_native_rate_audio_pcm(), # type: ignore[typeddict-item]
+ voice=self.get_current_voice(),
+ ),
+ ),
+ tools=to_realtime_tools_config(tool_specs),
+ tool_choice="auto",
+ )
+
+ def _is_connected(self) -> bool:
+ """Return whether the realtime connection is open."""
+ return self.connection is not None
+
+ def _idle_behavior_ready(self) -> bool:
+ """Hold idle behavior while a model response is still active."""
+ return self._response_done_event.is_set()
+
+ async def _cancel_partial_transcript_task(self) -> None:
+ if self.partial_transcript_task and not self.partial_transcript_task.done():
+ self.partial_transcript_task.cancel()
+ try:
+ await self.partial_transcript_task
+ except asyncio.CancelledError:
+ pass
+
+ async def change_voice(self, voice: str) -> str:
+ """Change only the voice, updating the active session when possible."""
+ default_voice = get_default_voice()
+ resolved_voice = (
+ self._resolve_backend_voice(voice, source="requested voice", fallback=default_voice) or default_voice
+ )
+ self._voice_override = resolved_voice
+ if self.connection is not None:
+ try:
+ await self.connection.session.update(
+ session=RealtimeSessionCreateRequestParam(
+ type="realtime",
+ audio=RealtimeAudioConfigParam(
+ output=RealtimeAudioConfigOutputParam(
+ voice=resolved_voice,
+ ),
+ ),
+ ),
+ )
+ return f"Voice changed to {resolved_voice}."
+ except Exception as e:
+ logger.warning("Failed to update live session for voice change: %s", redact_secrets(e))
+ return "Voice change failed. Will take effect on next connection."
+ return "Voice changed. Will take effect on next connection."
+
+ def get_current_voice(self) -> str:
+ """Return the voice currently selected for this handler."""
+ default_voice = get_default_voice()
+ voice = self._voice_override or get_session_voice(default=default_voice)
+ return self._resolve_backend_voice(voice, source="session voice", fallback=default_voice) or default_voice
+
+ async def apply_personality(self, profile: str | None) -> str:
+ """Apply a new personality (profile) at runtime if possible.
+
+ - Updates the global config's selected profile for subsequent calls.
+ - If a realtime connection is active, sends a session.update with the
+ freshly resolved instructions so the change takes effect immediately.
+
+ Returns a short status message for UI feedback.
+ """
+ try:
+ # Update the in-process config value and env
+ from peachy.config import config as _config
+ from peachy.config import set_custom_profile
+
+ set_custom_profile(profile)
+ logger.info(
+ "Set custom profile to %r (config=%r)", profile, getattr(_config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ )
+
+ try:
+ instructions = get_session_instructions(self.instance_path)
+ voice = self.get_current_voice()
+ except Exception as e:
+ safe_error = redact_secrets(e)
+ logger.error("Failed to resolve personality content: %s", safe_error)
+ return f"Failed to apply personality: {safe_error}"
+
+ # Rebuild the tool registry
+ core_tools.initialize_tools(force=True)
+
+ # Attempt a live update first, then force a full restart to ensure it sticks
+ if self.connection is not None:
+ try:
+ await self.connection.session.update(
+ session=RealtimeSessionCreateRequestParam(
+ type="realtime",
+ instructions=instructions,
+ audio=RealtimeAudioConfigParam(
+ output=RealtimeAudioConfigOutputParam(
+ voice=voice,
+ ),
+ ),
+ ),
+ )
+ logger.info("Applied personality via live update: %s", profile or "built-in default")
+ except Exception as e:
+ logger.warning("Live update failed; will restart session: %s", redact_secrets(e))
+
+ # Force a real restart to guarantee the new instructions/voice
+ try:
+ await self._restart_session()
+ return "Applied personality and restarted realtime session."
+ except Exception as e:
+ logger.warning("Failed to restart session after apply: %s", redact_secrets(e))
+ return "Applied personality. Will take effect on next connection."
+ else:
+ logger.info(
+ "Applied personality recorded: %s (no live connection; will apply on next session)",
+ profile or "built-in default",
+ )
+ return "Applied personality. Will take effect on next connection."
+ except Exception as e:
+ safe_error = redact_secrets(e)
+ logger.error("Error applying personality '%s': %s", profile, safe_error)
+ return f"Failed to apply personality: {safe_error}"
+
+ async def _emit_debounced_partial(self, transcript: str, item_id: str, sequence_counter: int) -> None:
+ """Emit partial transcript after debounce delay."""
+ try:
+ await asyncio.sleep(self.partial_debounce_delay)
+
+ input_transcript = self.input_transcript_chunks_by_item
+ if input_transcript.item_id == item_id and len(input_transcript.deltas) - 1 == sequence_counter:
+ await self.output_queue.put(AdditionalOutputs({"role": "user_partial", "content": transcript}))
+ logger.debug(f"Debounced partial emitted: {transcript}")
+ except asyncio.CancelledError:
+ logger.debug("Debounced partial cancelled")
+ raise
+
+ def _record_partial_transcript_delta(
+ self,
+ input_transcript: InputTranscriptChunksByItem,
+ item_id: str,
+ delta: str,
+ ) -> None:
+ """Record a Hugging Face partial transcript snapshot."""
+ input_transcript.item_id = item_id
+ input_transcript.deltas = [delta]
+
+ async def start_up(self) -> None:
+ """Start the handler with minimal retries on unexpected websocket closure."""
+ self.client = await self._build_realtime_client()
+
+ max_attempts = 3
+ for attempt in range(1, max_attempts + 1):
+ try:
+ await self._run_realtime_session()
+ # Normal exit from the session, stop retrying
+ return
+ except ConnectionClosedError as e:
+ # Abrupt close (e.g., "no close frame received or sent") → retry
+ logger.warning(
+ "Realtime websocket closed unexpectedly (attempt %d/%d): %s",
+ attempt,
+ max_attempts,
+ redact_secrets(e),
+ )
+ if attempt < max_attempts:
+ self.client = await self._build_realtime_client()
+ # exponential backoff with jitter
+ base_delay = 2 ** (attempt - 1) # 1s, 2s, 4s, 8s, etc.
+ jitter = random.uniform(0, 0.5)
+ delay = base_delay + jitter
+ logger.info("Retrying in %.1f seconds...", delay)
+ await asyncio.sleep(delay)
+ continue
+ raise
+ finally:
+ # never keep a stale reference
+ self.connection = None
+ try:
+ self._connected_event.clear()
+ except Exception:
+ pass
+
+ async def _restart_session(self) -> None:
+ """Force-close the current session and start a fresh one in background.
+
+ Does not block the caller while the new session is establishing.
+ """
+ try:
+ async with self._restart_lock:
+ if self._shutdown_started:
+ return
+
+ if self.connection is not None:
+ try:
+ await self.connection.close()
+ except Exception:
+ pass
+ finally:
+ self.connection = None
+
+ # Ensure we have a client (start_up must have run once)
+ if getattr(self, "client", None) is None:
+ logger.warning("Cannot restart: realtime client not initialized yet.")
+ return
+
+ # Build before registering the session task, then re-check the
+ # shutdown gate because client construction may have suspended.
+ try:
+ self._connected_event.clear()
+ except Exception:
+ pass
+ client = await self._build_realtime_client()
+ if self._shutdown_started:
+ return
+ self.client = client
+ restart_task = asyncio.create_task(
+ self._run_realtime_session(),
+ name="realtime-session-restart",
+ )
+ self._restart_tasks.add(restart_task)
+ restart_task.add_done_callback(self._restart_task_done)
+ try:
+ await asyncio.wait_for(self._connected_event.wait(), timeout=5.0)
+ if not self._shutdown_started:
+ logger.info("Realtime session restarted and connected.")
+ except asyncio.TimeoutError:
+ if not self._shutdown_started:
+ logger.warning("Realtime session restart timed out; continuing in background.")
+ except asyncio.CancelledError:
+ raise
+ except Exception as e:
+ logger.warning("_restart_session failed: %s", redact_secrets(e))
+
+ async def _safe_response_create(self, **kwargs: Any) -> None:
+ """Enqueue a response.create() kwargs for the sender worker _response_sender_loop().
+
+ This method never blocks the caller.
+ """
+ await self._pending_responses.put(kwargs)
+
+ async def _send_startup_greeting_prompt(self) -> None:
+ """Prompt the model to open the conversation once the session is ready."""
+ if self._startup_greeting_sent or not self.connection:
+ return
+
+ greeting_prompt = get_session_greeting_prompt().strip()
+ if not greeting_prompt:
+ self._startup_greeting_sent = True
+ return
+
+ try:
+ await self.connection.conversation.item.create(
+ item={
+ "type": "message",
+ "role": "user",
+ "content": [
+ {
+ "type": "input_text",
+ "text": greeting_prompt,
+ },
+ ],
+ },
+ )
+ self._startup_greeting_sent = True
+ self._mark_activity("startup_greeting_prompt")
+ await self._safe_response_create()
+ logger.info("Queued startup greeting prompt")
+ except Exception as e:
+ logger.warning("Failed to queue startup greeting prompt: %s", redact_secrets(e))
+
+ async def _response_sender_loop(self) -> None:
+ """Dedicated worker that sends ``response.create()`` calls serially.
+
+ This logic was designed to comply with the response.create() docstring specification for event ordering:
+ https://github.com/openai/openai-python/blob/3e0c05b84a2056870abf3bd6a5e7849020209cc3/src/openai/resources/realtime/realtime.py#L649C1-L651C30
+
+ For each queued request the worker:
+ 1. Waits until no response is active (_response_done_event).
+ 2. Sends response.create().
+ 3. Waits until the receiver observes response.created or a rejection.
+ 4. Waits for the response cycle to complete (response.done).
+ 5. If the server rejected with active_response, retries from step 1.
+ """
+ while self.connection:
+ try:
+ kwargs = await self._pending_responses.get()
+ except asyncio.CancelledError:
+ return
+
+ # Parallel tool calls enqueue duplicate empty requests; coalesce to one.
+ while not kwargs and not self._pending_responses.empty():
+ try:
+ self._pending_responses.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ sent = False
+ max_retries = 5
+ attempts = 0
+ while not sent and self.connection and attempts < max_retries:
+ try:
+ await asyncio.wait_for(
+ self._response_done_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ except asyncio.TimeoutError:
+ logger.debug("Timed out waiting for previous response to finish; forcing ahead")
+ self._response_done_event.set()
+
+ if not self.connection:
+ break
+
+ self._last_response_rejected = False
+ self._response_started_or_rejected_event.clear()
+ try:
+ await self.connection.response.create(**kwargs)
+ except Exception as e:
+ logger.debug("_response_sender_loop: send failed: %s", redact_secrets(e))
+ self._response_done_event.set()
+ break
+
+ try:
+ await asyncio.wait_for(
+ self._response_started_or_rejected_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ except asyncio.TimeoutError:
+ logger.debug("Timed out waiting for response.created or response rejection")
+
+ # Check if the receiver loop observed an asynchronous rejection.
+ if self._last_response_rejected:
+ attempts += 1
+ if attempts >= max_retries:
+ logger.debug("response.create rejected %d times; giving up", attempts)
+ break
+ logger.debug("response.create was rejected; retrying (%d/%d)", attempts, max_retries)
+ await asyncio.sleep(_RESPONSE_REJECTION_RETRY_DELAY)
+ continue
+
+ try:
+ await asyncio.wait_for(
+ self._response_done_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ except asyncio.TimeoutError:
+ logger.debug("Timed out waiting for response.done; assuming response completed")
+ self._response_done_event.set()
+ break
+
+ sent = True
+
+ async def _handle_tool_result(self, completed_tool: ToolNotification) -> None:
+ """Process the result of a tool call."""
+ if completed_tool.error is not None:
+ logger.error(
+ "Tool '%s' (id=%s) failed with error: %s",
+ completed_tool.tool_name,
+ completed_tool.id,
+ completed_tool.error,
+ )
+ tool_result = {"error": completed_tool.error}
+ tool_result_for_model = tool_result
+ elif completed_tool.result is not None:
+ tool_result = completed_tool.result
+ tool_result_for_model = (
+ self._sanitize_tool_result_for_model(completed_tool.tool_name, tool_result)
+ if isinstance(tool_result, dict)
+ else tool_result
+ )
+ logger.info(
+ "Tool '%s' (id=%s) executed successfully.",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ logger.debug("Tool '%s' model-visible result: %s", completed_tool.tool_name, tool_result_for_model)
+ else:
+ logger.warning(
+ "Tool '%s' (id=%s) returned no result and no error", completed_tool.tool_name, completed_tool.id
+ )
+ tool_result = {"error": "No result returned from tool execution"}
+ tool_result_for_model = tool_result
+
+ # Connection may have closed while tool was running
+ if not self.connection:
+ logger.warning(
+ "Connection closed during tool '%s' (id=%s) execution; cannot send result back",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ return
+
+ try:
+ send_result_to_model = not completed_tool.is_idle_tool_call
+ if send_result_to_model:
+ self._mark_activity("tool_result_ready")
+ model_result_submitted = False
+ if send_result_to_model and isinstance(completed_tool.id, str):
+ if not await self._wait_for_response_done_before_tool_result():
+ send_result_to_model = False
+ if not send_result_to_model:
+ logger.warning(
+ "Dropping realtime model result for tool '%s' (id=%s) because response.done was not observed",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ elif not self.connection:
+ logger.warning(
+ "Connection closed before sending tool '%s' (id=%s) result back",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ return
+ else:
+ await self.connection.conversation.item.create(
+ item={
+ "type": "function_call_output",
+ "call_id": completed_tool.id,
+ "output": json.dumps(tool_result_for_model),
+ },
+ )
+ model_result_submitted = True
+
+ await self.output_queue.put(
+ AdditionalOutputs(
+ {
+ "role": "assistant",
+ "content": json.dumps(tool_result_for_model),
+ },
+ ),
+ )
+
+ if model_result_submitted and completed_tool.tool_name == "camera" and "b64_im" in tool_result:
+ # use raw base64, don't json.dumps (which adds quotes)
+ b64_im = tool_result["b64_im"]
+ if not isinstance(b64_im, str):
+ logger.warning("Unexpected type for b64_im: %s", type(b64_im))
+ b64_im = str(b64_im)
+ image_width = tool_result.get("image_width")
+ image_height = tool_result.get("image_height")
+ jpeg_bytes_value = tool_result.get("jpeg_bytes")
+ jpeg_bytes = jpeg_bytes_value if isinstance(jpeg_bytes_value, int) else (len(b64_im) * 3) // 4
+ await self.connection.conversation.item.create(
+ item={
+ "type": "message",
+ "role": "user",
+ "content": [
+ {
+ "type": "input_image",
+ "image_url": f"data:image/jpeg;base64,{b64_im}",
+ },
+ ],
+ },
+ )
+ if isinstance(image_width, int) and isinstance(image_height, int):
+ logger.info(
+ "Added camera image to conversation frame=%sx%s jpeg_bytes=%s",
+ image_width,
+ image_height,
+ jpeg_bytes,
+ )
+ else:
+ logger.info(
+ "Added camera image to conversation jpeg_bytes=%s",
+ jpeg_bytes,
+ )
+
+ if isinstance(completed_tool.id, str):
+ self._in_flight_tool_calls.discard(completed_tool.id)
+
+ tool = core_tools.ALL_TOOLS.get(completed_tool.tool_name)
+ # Always surface errors, skip the spoken follow-up for tools that opt out.
+ if model_result_submitted and (completed_tool.error is not None or tool is None or tool.needs_response):
+ self._tool_batch_needs_response = True
+
+ # Parallel tool calls in one turn: respond once every result is in, not per tool.
+ if self._tool_batch_needs_response and not self._in_flight_tool_calls:
+ self._tool_batch_needs_response = False
+ await self._safe_response_create()
+
+ except ConnectionClosedError:
+ logger.warning("Connection closed while sending tool result")
+ self.connection = None
+ self._response_done_event.set()
+
+ async def _run_realtime_session(self) -> None:
+ """Establish and manage a single realtime session."""
+ tool_specs = get_tool_specs()
+ logger.info(
+ "Tools to be used in conversation: %s",
+ [tool["name"] for tool in tool_specs],
+ )
+ connect_kwargs: dict[str, Any] = {}
+ if self._realtime_connect_query:
+ connect_kwargs["extra_query"] = self._realtime_connect_query
+ async with self.client.realtime.connect(**connect_kwargs) as conn:
+ try:
+ session_config = self._get_session_config(tool_specs)
+ await conn.session.update(session=session_config)
+ logger.info(
+ "Realtime session initialized with profile=%r voice=%r",
+ getattr(config, "REACHY_MINI_CUSTOM_PROFILE", None),
+ self.get_current_voice(),
+ )
+ except Exception as exc:
+ logger.error(
+ "Realtime session.update failed; aborting startup: %s",
+ redact_secrets(exc),
+ )
+ raise
+
+ logger.info("Realtime session updated successfully")
+
+ # Reset the partial-transcript accumulator for each new session
+ self.input_transcript_chunks_by_item = InputTranscriptChunksByItem()
+
+ # Manage events received from the realtime server.
+ self.connection = conn
+ try:
+ self._connected_event.set()
+ except Exception:
+ pass
+
+ response_sender_task: asyncio.Task[None] | None = None
+ try:
+ # Start the background tool manager
+ self.tool_manager.start_up(tool_callbacks=[self._handle_tool_result])
+
+ # Start the response sender worker
+ response_sender_task = asyncio.create_task(self._response_sender_loop(), name="response-sender")
+ await self._send_startup_greeting_prompt()
+
+ async for event in self.connection:
+ logger.debug("Realtime event: %s", event.type)
+ if event.type == "input_audio_buffer.speech_started":
+ self._mark_activity("user_speech_started")
+ self._turn_user_done_at = None
+ self._turn_response_created_at = None
+ self._turn_first_audio_at = None
+ if self._clear_queue:
+ self._clear_queue()
+ self.deps.movement_manager.set_listening(True)
+ logger.debug("User speech started")
+
+ if event.type == "input_audio_buffer.speech_stopped":
+ self._mark_activity("user_speech_stopped")
+ self.deps.movement_manager.set_listening(False)
+ logger.debug("User speech stopped - server will auto-commit with VAD")
+
+ if event.type == "response.output_audio.done":
+ self.deps.movement_manager.set_speaking(False)
+ logger.debug("response completed")
+
+ if event.type == "response.output_text.delta":
+ logger.debug("response text delta")
+
+ if event.type == "response.output_text.done":
+ logger.debug("response text done: %s", event.text)
+
+ if event.type == "response.created":
+ self._mark_activity("response_created")
+ self.deps.movement_manager.set_speaking(True)
+ self._response_done_event.clear()
+ self._response_started_or_rejected_event.set()
+ if self._turn_user_done_at is not None and self._turn_response_created_at is None:
+ self._turn_response_created_at = time.perf_counter()
+ delta_ms = (self._turn_response_created_at - self._turn_user_done_at) * 1000
+ logger.info("Turn latency: response.created %.0f ms after user transcript", delta_ms)
+ logger.debug("Response created (active)")
+
+ if event.type == "response.done":
+ # Doesn't mean the audio is done playing
+ # Resume tracking for responses that emit no audio (text-only / tool-only).
+ self.deps.movement_manager.set_speaking(False)
+ self._response_done_event.set()
+ self._response_started_or_rejected_event.set()
+ logger.debug("Response done")
+
+ if event.type == "conversation.item.input_audio_transcription.delta":
+ self._mark_activity("user_transcription_delta")
+ logger.debug(f"User partial transcript: {event.delta}")
+
+ item_id = event.item_id
+ delta = event.delta or ""
+
+ input_transcript = self.input_transcript_chunks_by_item
+ self._record_partial_transcript_delta(input_transcript, item_id, delta)
+
+ current_partial = "".join(input_transcript.deltas)
+ sequence_counter = len(input_transcript.deltas) - 1
+
+ await self._cancel_partial_transcript_task()
+
+ # Start new debounce timer with the last delta
+ self.partial_transcript_task = asyncio.create_task(
+ self._emit_debounced_partial(current_partial, item_id, sequence_counter)
+ )
+
+ # Handle completed transcription (user finished speaking)
+ if event.type == "conversation.item.input_audio_transcription.completed":
+ self._mark_activity("user_transcription_completed")
+ raw_transcript = event.transcript or ""
+ transcript = raw_transcript.strip()
+ logger.debug("User transcript: %s", raw_transcript)
+ self.deps.movement_manager.set_listening(False)
+
+ await self._cancel_partial_transcript_task()
+
+ if not transcript:
+ logger.debug("Ignoring empty user transcript")
+ continue
+
+ self._turn_user_done_at = time.perf_counter()
+ self._turn_response_created_at = None
+ self._turn_first_audio_at = None
+ self._in_flight_tool_calls.clear()
+ self._tool_batch_needs_response = False
+
+ await self.output_queue.put(AdditionalOutputs({"role": "user", "content": transcript}))
+
+ # Handle assistant transcription
+ if event.type == "response.output_audio_transcript.done":
+ self._mark_activity("assistant_transcript_done")
+ logger.debug(f"Assistant transcript: {event.transcript}")
+ await self.output_queue.put(
+ AdditionalOutputs({"role": "assistant", "content": event.transcript})
+ )
+
+ # Handle audio delta
+ if event.type == "response.output_audio.delta":
+ decoded_pcm_bytes = base64.b64decode(event.delta)
+ decoded_pcm = np.frombuffer(decoded_pcm_bytes, dtype=np.int16).reshape(1, -1)
+ self._mark_activity("assistant_audio_delta")
+ if self._turn_user_done_at is not None and self._turn_first_audio_at is None:
+ self._turn_first_audio_at = time.perf_counter()
+ delta_ms = (self._turn_first_audio_at - self._turn_user_done_at) * 1000
+ logger.info("Turn latency: first audio delta %.0f ms after user transcript", delta_ms)
+ await self.output_queue.put(
+ (
+ self.SAMPLE_RATE,
+ decoded_pcm,
+ ),
+ )
+ # ---- tool-calling plumbing ----
+ if event.type == "response.function_call_arguments.done":
+ self._mark_activity("tool_call_received")
+ tool_name = getattr(event, "name", None)
+ args_json_str = getattr(event, "arguments", None)
+ call_id: str = str(getattr(event, "call_id", uuid.uuid4()))
+
+ logger.info(
+ "Tool call received — tool_name=%r, call_id=%s, args=%s",
+ tool_name,
+ call_id,
+ args_json_str,
+ )
+
+ if not isinstance(tool_name, str) or not isinstance(args_json_str, str):
+ logger.error(
+ "Invalid tool call: tool_name=%s (type=%s), args=%s (type=%s), call_id=%s",
+ tool_name,
+ type(tool_name).__name__,
+ args_json_str,
+ type(args_json_str).__name__,
+ call_id,
+ )
+ continue
+
+ self._in_flight_tool_calls.add(call_id)
+ background_tool = await self.tool_manager.start_tool(
+ call_id=call_id,
+ tool_call_routine=ToolCallRoutine(
+ tool_name=tool_name,
+ args_json_str=args_json_str,
+ deps=self.deps,
+ ),
+ is_idle_tool_call=False,
+ )
+
+ await self.output_queue.put(
+ AdditionalOutputs(
+ {
+ "role": "assistant",
+ "content": f"🛠️ Used tool {tool_name} with args {args_json_str}. The tool is now running. Tool ID: {background_tool.tool_id}",
+ },
+ ),
+ )
+ logger.info(
+ "Started background tool: %s (id=%s, call_id=%s)",
+ tool_name,
+ background_tool.tool_id,
+ call_id,
+ )
+
+ # server error
+ if event.type == "error":
+ err = getattr(event, "error", None)
+ msg = getattr(err, "message", str(err) if err else "unknown error")
+ code = getattr(err, "code", "") or getattr(err, "type", "")
+
+ if code == "conversation_already_has_active_response":
+ # response.create was rejected. The sender worker
+ # is waiting on _response_done_event; when the active
+ # response finishes it will wake up and see this flag.
+ self._last_response_rejected = True
+ self._response_started_or_rejected_event.set()
+ logger.debug("response.create rejected; worker will retry after active response finishes")
+ else:
+ self._response_started_or_rejected_event.set()
+ logger.error(
+ "Realtime error [%s]: %s (raw=%s)",
+ code,
+ redact_secrets(msg),
+ redact_secrets(err),
+ )
+
+ if code == "input_audio_buffer_commit_empty":
+ self.deps.movement_manager.set_listening(False)
+
+ # Only show user-facing errors, not internal state errors.
+ if code not in (
+ "input_audio_buffer_commit_empty",
+ "conversation_already_has_active_response",
+ ):
+ await self.output_queue.put(
+ AdditionalOutputs(
+ {
+ "role": "assistant",
+ "content": f"[error] {redact_secrets(msg)}",
+ }
+ )
+ )
+ finally:
+ # Stop the response sender worker.
+ if response_sender_task is not None:
+ response_sender_task.cancel()
+ try:
+ await response_sender_task
+ except asyncio.CancelledError:
+ pass
+
+ # Stop background tool manager tasks (listener + cleanup) in all paths.
+ await self.tool_manager.shutdown()
+
+ # Microphone receive
+ async def receive(self, frame: AudioFrame) -> None:
+ """Receive audio frame from the microphone and send it to the realtime server.
+
+ Handles both mono and stereo audio formats, converting to the expected
+ mono format for the realtime API.
+
+ Args:
+ frame: A tuple containing (sample_rate, audio_data).
+
+ """
+ if not self.connection:
+ return
+
+ _, audio_frame = frame
+ if audio_frame.size == 0:
+ return
+
+ # Reshape if needed
+ if audio_frame.ndim == 2:
+ # channels-last convention
+ if audio_frame.shape[1] > audio_frame.shape[0]:
+ audio_frame = audio_frame.T
+ # Multiple channels -> Mono channel
+ if audio_frame.shape[1] > 1:
+ audio_frame = audio_frame[:, 0]
+
+ # Cast if needed
+ audio_frame = audio_to_int16(audio_frame)
+
+ # Send to the realtime input buffer (guard against races during reconnect).
+ try:
+ audio_message = base64.b64encode(audio_frame.tobytes()).decode("utf-8")
+ await self.connection.input_audio_buffer.append(audio=audio_message)
+ except Exception as e:
+ logger.debug("Dropping audio frame: connection not ready (%s)", redact_secrets(e))
+ return
+
+ async def shutdown(self) -> None:
+ """Shutdown the handler."""
+ self._shutdown_started = True
+ self._connected_event.set()
+
+ # Wait for any restart still constructing its client to observe the
+ # shutdown gate before taking the complete registered-task snapshot.
+ async with self._restart_lock:
+ pass
+
+ # Unblock the response sender worker so it can exit
+ self._response_done_event.set()
+
+ await self._cancel_restart_tasks()
+
+ # Stop background tool manager tasks (listener + cleanup)
+ await self.tool_manager.shutdown()
+
+ await self._cancel_partial_transcript_task()
+
+ if self.connection:
+ try:
+ await self.connection.close()
+ except ConnectionClosedError as e:
+ logger.debug("Connection already closed during shutdown: %s", redact_secrets(e))
+ except Exception as e:
+ logger.debug("connection.close() ignored: %s", redact_secrets(e))
+ finally:
+ self.connection = None
+
+ # Clear any remaining items in the output queue
+ while not self.output_queue.empty():
+ try:
+ self.output_queue.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ async def get_available_voices(self) -> list[str]:
+ """Return the available Hugging Face voices."""
+ return get_available_voices()
+
+ async def _build_realtime_client(self) -> AsyncOpenAI:
+ """Build the Hugging Face OpenAI-compatible realtime client."""
+ bearer_token = (config.HF_TOKEN or "").strip()
+ connection_selection = get_hf_connection_selection()
+ direct_realtime_url = get_hf_direct_ws_url()
+ if connection_selection.mode == HF_LOCAL_CONNECTION_MODE:
+ if not direct_realtime_url:
+ raise RuntimeError("HF_REALTIME_WS_URL must be set when HF_REALTIME_CONNECTION_MODE=local")
+ client, connect_query = _build_openai_compatible_client_from_realtime_url(
+ direct_realtime_url,
+ bearer_token,
+ )
+ self._realtime_connect_query = connect_query
+ logger.info(
+ "Using direct Hugging Face realtime endpoint %s",
+ redact_secrets(_safe_endpoint_for_log(direct_realtime_url)),
+ )
+ return client
+
+ session_url = connection_selection.session_url
+ if not session_url:
+ raise RuntimeError("Built-in Hugging Face session proxy URL is unavailable")
+ if direct_realtime_url:
+ logger.info("HF_REALTIME_CONNECTION_MODE=deployed; ignoring HF_REALTIME_WS_URL.")
+
+ allocator_headers = {"Authorization": f"Bearer {bearer_token}"} if bearer_token else None
+ async with httpx.AsyncClient(timeout=10.0) as http_client:
+ response = await http_client.post(session_url, headers=allocator_headers)
+ response.raise_for_status()
+ payload = response.json()
+
+ connect_url = payload.get("connect_url")
+ if not isinstance(connect_url, str) or not connect_url:
+ raise RuntimeError(f"Session allocator response did not contain a valid connect_url: {payload!r}")
+
+ parsed_connect_url = parse_hf_realtime_url(connect_url)
+ if not parsed_connect_url.has_realtime_path:
+ raise ValueError(f"Expected realtime connect URL ending with /realtime, got: {connect_url}")
+
+ logger.info("Allocated realtime session %s", payload.get("session_id") or "
")
+ client, connect_query = _build_openai_compatible_client_from_realtime_url(
+ connect_url,
+ bearer_token,
+ )
+ self._realtime_connect_query = connect_query
+ return client
diff --git a/src/peachy/idle_policy.py b/src/peachy/idle_policy.py
new file mode 100644
index 0000000000000000000000000000000000000000..cede9cc28a64e73fc9eda641490be9e2ccf1d4f7
--- /dev/null
+++ b/src/peachy/idle_policy.py
@@ -0,0 +1,140 @@
+"""Local idle tool selection and dispatch.
+
+Default idle weights among active, registered tools:
+- IdleDoNothing: 60%
+- Dance: 16%
+- PlayEmotion: 16%
+- MoveHead: 8%
+
+Profiles or sessions can disable tools. When one or more idle tools are unavailable, selection is renormalized across the
+remaining active candidates.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import json
+import uuid
+import random
+import asyncio
+import logging
+from typing import Any, Final
+from dataclasses import dataclass
+from collections.abc import Mapping, Callable, Iterable
+
+from peachy.tools import core_tools
+from peachy.streaming import AdditionalOutputs
+from peachy.tools.dance import Dance
+from peachy.tools.move_head import MoveHead
+from peachy.tools.play_emotion import PlayEmotion
+from peachy.tools.idle_do_nothing import IdleDoNothing
+from peachy.tools.background_tool_manager import (
+ BackgroundTool,
+ ToolCallRoutine,
+ BackgroundToolManager,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class IdleToolCandidate:
+ """Weighted idle tool candidate and argument factory."""
+
+ tool_type: type[core_tools.Tool]
+ weight: float
+ args_factory: Callable[[], dict[str, Any]]
+
+
+def _no_args() -> dict[str, Any]:
+ return {}
+
+
+def _idle_do_nothing_args() -> dict[str, Any]:
+ return {"reason": "random idle policy selected stillness"}
+
+
+def _move_head_args() -> dict[str, Any]:
+ return {"direction": random.choice(tuple(MoveHead.DELTAS))}
+
+
+_IDLE_TOOL_CANDIDATES: Final[tuple[IdleToolCandidate, ...]] = (
+ IdleToolCandidate(IdleDoNothing, 0.60, _idle_do_nothing_args),
+ IdleToolCandidate(Dance, 0.16, _no_args),
+ IdleToolCandidate(PlayEmotion, 0.16, _no_args),
+ IdleToolCandidate(MoveHead, 0.08, _move_head_args),
+)
+
+
+def choose_idle_tool_call(
+ available_tool_names: Iterable[str],
+ *,
+ tool_registry: Mapping[str, core_tools.Tool] | None = None,
+) -> tuple[str, dict[str, Any]] | None:
+ """Choose a weighted idle tool call from the tools available to the session."""
+ available = set(available_tool_names)
+ registry = core_tools.ALL_TOOLS if tool_registry is None else tool_registry
+ candidates = [
+ (tool.name, candidate)
+ for candidate in _IDLE_TOOL_CANDIDATES
+ for tool in registry.values()
+ if tool.name in available and isinstance(tool, candidate.tool_type)
+ ]
+ if not candidates:
+ return None
+
+ selected_name, selected_candidate = random.choices(
+ candidates,
+ weights=[candidate.weight for _, candidate in candidates],
+ k=1,
+ )[0]
+ return selected_name, selected_candidate.args_factory()
+
+
+async def start_idle_tool_call(
+ *,
+ deps: core_tools.ToolDependencies,
+ tool_manager: BackgroundToolManager,
+ output_queue: asyncio.Queue[Any],
+ available_tool_names: Iterable[str],
+ idle_duration: float,
+) -> BackgroundTool | None:
+ """Start a locally selected idle tool and publish the console notification."""
+ selected_tool = choose_idle_tool_call(available_tool_names)
+ if selected_tool is None:
+ logger.warning("No idle tools are available; idle action skipped")
+ return None
+
+ tool_name, arguments = selected_tool
+ args_json_str = json.dumps(arguments)
+ call_id = f"idle-{uuid.uuid4()}"
+ background_tool = await tool_manager.start_tool(
+ call_id=call_id,
+ tool_call_routine=ToolCallRoutine(
+ tool_name=tool_name,
+ args_json_str=args_json_str,
+ deps=deps,
+ ),
+ is_idle_tool_call=True,
+ )
+ await output_queue.put(
+ AdditionalOutputs(
+ {
+ "role": "assistant",
+ "content": (
+ f"🛠️ Idle tool {tool_name} with args {args_json_str}. "
+ f"The tool is now running. Tool ID: {background_tool.tool_id}"
+ ),
+ },
+ ),
+ )
+ logger.info(
+ "Started local idle tool after %.1fs idle: %s (id=%s, call_id=%s, args=%s)",
+ idle_duration,
+ tool_name,
+ background_tool.tool_id,
+ call_id,
+ args_json_str,
+ )
+ return background_tool
diff --git a/src/peachy/main.py b/src/peachy/main.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7acedc4d19dbc32da0c3ab1c5f652c38d9a2be0
--- /dev/null
+++ b/src/peachy/main.py
@@ -0,0 +1,372 @@
+"""Entrypoint for the Reachy Mini conversation app."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import sys
+import time
+import asyncio
+import logging
+import argparse
+import threading
+from typing import TYPE_CHECKING, Any, Optional
+from pathlib import Path
+from collections.abc import Callable, Awaitable
+
+from fastapi import FastAPI, Request, Response
+
+from reachy_mini import ReachyMini, ReachyMiniApp
+from peachy import app_lifecycle
+from peachy.state import resolve_state_root
+from peachy.utils import (
+ parse_args,
+ setup_logger,
+ log_connection_troubleshooting,
+)
+
+
+if TYPE_CHECKING:
+ from peachy.console import LocalStream
+ from peachy.conversation_handler import ConversationHandler
+ from peachy.providers import ProviderDefinition
+ from peachy.tools.core_tools import ToolDependencies
+
+
+def _build_selected_handler(
+ deps: "ToolDependencies",
+ instance_path: str | None,
+ startup_voice: str | None,
+) -> tuple["ProviderDefinition", "ConversationHandler"]:
+ """Build the handler selected by the explicit provider registry."""
+ from peachy.providers import get_provider_definition
+
+ definition = get_provider_definition()
+ return definition, definition.build_handler(deps, instance_path, startup_voice)
+
+
+def _start_inactivity_timeout_thread(
+ timeout_minutes: float,
+ stream_manager: LocalStream,
+ logger: logging.Logger,
+ app_stop_event: threading.Event | None,
+ go_to_sleep: Callable[[], dict[str, Any]] | None = None,
+) -> threading.Thread:
+ """Start a daemon that puts the app to sleep after inactivity."""
+ timeout_seconds = timeout_minutes * 60.0
+
+ def poll_inactivity_timeout() -> None:
+ logger.info("App inactivity timeout enabled: %.1f minutes.", timeout_minutes)
+ while app_stop_event is None or not app_stop_event.is_set():
+ elapsed = stream_manager.seconds_since_activity()
+ if elapsed >= timeout_seconds:
+ logger.info("No activity for %.1f minutes; going to sleep.", elapsed / 60.0)
+ try:
+ if go_to_sleep is not None:
+ go_to_sleep()
+ else:
+ stream_manager.close()
+ except Exception as e:
+ logger.error("Error while going to sleep after inactivity timeout: %s", e)
+ try:
+ stream_manager.close()
+ except Exception as close_error:
+ logger.error("Error while closing stream manager after inactivity timeout: %s", close_error)
+ return
+ time.sleep(1.0)
+
+ thread = threading.Thread(target=poll_inactivity_timeout, daemon=True)
+ thread.start()
+ return thread
+
+
+def main() -> None:
+ """Entrypoint for the Reachy Mini conversation app."""
+ args, _ = parse_args()
+ state_root = resolve_state_root()
+ if args.command == "tool-spaces":
+ from peachy.tool_spaces import handle_tool_spaces_command
+
+ logger = setup_logger(args.debug)
+ try:
+ raise SystemExit(handle_tool_spaces_command(args, instance_path=state_root))
+ except Exception as exc:
+ logger.error("tool-spaces command failed: %s", exc)
+ raise SystemExit(1) from exc
+ run(args, instance_path=str(state_root))
+
+
+def run(
+ args: argparse.Namespace,
+ robot: ReachyMini = None,
+ app_stop_event: Optional[threading.Event] = None,
+ settings_app: Optional[FastAPI] = None,
+ instance_path: Optional[str] = None,
+) -> None:
+ """Run the Reachy Mini conversation app."""
+ # Putting these dependencies here makes the dashboard faster to load when the conversation app is installed
+ from peachy.moves import MovementManager
+ from peachy.config import (
+ set_instance_path,
+ resolve_app_timeout_minutes,
+ refresh_runtime_config_from_env,
+ )
+ from peachy.startup_settings import (
+ StartupSettings,
+ load_startup_settings_into_runtime,
+ )
+
+ logger = setup_logger(args.debug)
+ logger.info("Starting Reachy Mini Conversation App")
+ set_instance_path(instance_path)
+ startup_settings = StartupSettings()
+
+ if instance_path is not None:
+ try:
+ from dotenv import load_dotenv
+
+ env_path = Path(instance_path) / ".env"
+ if env_path.exists():
+ load_dotenv(dotenv_path=str(env_path), override=True)
+ refresh_runtime_config_from_env()
+ logger.info("Loaded instance configuration from %s", env_path)
+ except Exception as e:
+ logger.warning("Failed to load instance configuration: %s", e)
+
+ try:
+ startup_settings = load_startup_settings_into_runtime(instance_path)
+ except Exception as e:
+ logger.warning("Failed to load startup settings: %s", e)
+
+ from peachy.console import LocalStream
+ from peachy.providers import get_provider_definition
+ from peachy.tools.core_tools import ToolDependencies, initialize_tools
+
+ if robot is None:
+ try:
+ robot_kwargs = {}
+ if args.robot_name is not None:
+ robot_kwargs["robot_name"] = args.robot_name
+
+ logger.info("Initializing ReachyMini (SDK will auto-detect appropriate backend)")
+ robot = ReachyMini(**robot_kwargs)
+
+ except TimeoutError as e:
+ logger.error(f"Connection timeout: Failed to connect to Reachy Mini daemon. Details: {e}")
+ log_connection_troubleshooting(logger, args.robot_name)
+ sys.exit(1)
+
+ except ConnectionError as e:
+ logger.error(f"Connection failed: Unable to establish connection to Reachy Mini. Details: {e}")
+ log_connection_troubleshooting(logger, args.robot_name)
+ sys.exit(1)
+
+ except Exception as e:
+ logger.error(f"Unexpected error during robot initialization: {type(e).__name__}: {e}")
+ logger.error("Please check your configuration and try again.")
+ sys.exit(1)
+
+ app_lifecycle.wake_up_if_sleeping(robot, logger)
+
+ movement_manager = MovementManager(current_robot=robot)
+
+ deps = ToolDependencies(
+ reachy_mini=robot,
+ movement_manager=movement_manager,
+ instance_path=instance_path,
+ camera_enabled=not args.no_camera,
+ )
+
+ def current_provider() -> ProviderDefinition:
+ return get_provider_definition()
+
+ def build_handler(startup_voice: Optional[str] = None) -> ConversationHandler:
+ """Build the currently selected realtime handler."""
+ definition, handler = _build_selected_handler(deps, instance_path, startup_voice)
+ logger.info("Selected realtime provider: %s", definition.name)
+ return handler
+
+ handler = build_handler(startup_settings.voice)
+
+ stream_manager: LocalStream | None = None
+ own_ui_server = None
+
+ effective_settings_app = settings_app
+ if args.ui and settings_app is None:
+ effective_settings_app = FastAPI()
+
+ @effective_settings_app.middleware("http")
+ async def _no_cache(request: Request, call_next: Callable[[Request], Awaitable[Response]]) -> Response:
+ """Serve everything no-store so browsers don't keep stale UI modules."""
+ response = await call_next(request)
+ response.headers["Cache-Control"] = "no-store"
+ return response
+
+ stream_manager = LocalStream(
+ handler,
+ robot,
+ settings_app=effective_settings_app,
+ instance_path=instance_path,
+ handler_factory=build_handler,
+ provider_resolver=current_provider,
+ startup_voice=startup_settings.voice,
+ )
+
+ # The page is served immediately, so the API must be live before the slow startup work below.
+ if effective_settings_app is not None:
+ stream_manager._init_settings_ui_if_needed()
+
+ go_to_sleep_lock = threading.Lock()
+ go_to_sleep_requested = threading.Event()
+
+ def go_to_sleep_and_stop_app() -> dict[str, Any]:
+ """Put Reachy to sleep, then stop the current app."""
+ if not go_to_sleep_lock.acquire(blocking=False):
+ return {"status": "already_requested"}
+
+ try:
+ if go_to_sleep_requested.is_set():
+ return {"status": "already_requested"}
+ go_to_sleep_requested.set()
+
+ logger.info("Going to sleep before stopping conversation app.")
+ sleep_error: str | None = None
+
+ try:
+ robot.disable_wobbling()
+ except Exception as e:
+ logger.debug("Error disabling wobbling before sleep: %s", e)
+
+ movement_manager.stop(reset_to_neutral=False)
+
+ try:
+ robot.goto_sleep()
+ except Exception as e:
+ sleep_error = f"{type(e).__name__}: {e}"
+ logger.error("Failed to move Reachy Mini to sleep pose: %s", e)
+
+ stop_current_app_requested = False
+ if app_stop_event is None or not app_stop_event.is_set():
+ stop_current_app_requested = app_lifecycle.request_stop_current_app(robot, logger)
+ local_stop_requested = True
+ if app_stop_event is not None:
+ app_stop_event.set()
+ else:
+ try:
+ stream_manager.close()
+ except Exception as e:
+ local_stop_requested = False
+ logger.error("Error while closing stream manager after go_to_sleep: %s", e)
+
+ result: dict[str, Any] = {
+ "status": "sleeping" if sleep_error is None else "stop_requested",
+ "stop_current_app_requested": stop_current_app_requested,
+ "local_stop_requested": local_stop_requested,
+ }
+ if sleep_error is not None:
+ result["error"] = f"go_to_sleep movement failed: {sleep_error}"
+ return result
+ finally:
+ go_to_sleep_lock.release()
+
+ deps.go_to_sleep = go_to_sleep_and_stop_app
+
+ def run_go_to_sleep_tool() -> dict[str, Any]:
+ return app_lifecycle.run_go_to_sleep_tool(deps, logger)
+
+ if args.ui and settings_app is None and effective_settings_app is not None:
+ import uvicorn
+
+ own_ui_server = uvicorn.Server(
+ uvicorn.Config(effective_settings_app, host="0.0.0.0", port=7860, log_level="warning")
+ )
+ threading.Thread(target=own_ui_server.run, daemon=True, name="ui-server").start()
+ logger.info("Web UI available at http://localhost:7860")
+
+ try:
+ initialize_tools(instance_path=instance_path)
+ except Exception as e:
+ logger.error("Failed to initialize tools: %s", e)
+ sys.exit(1)
+
+ # Each async service → its own thread/loop
+ movement_manager.start()
+ # Audio-reactive head motion is driven by the daemon's wobbler, which
+ # taps the media pipeline at push_audio_sample. The console stream pushes
+ # assistant audio through that pipeline directly.
+ robot.enable_wobbling()
+
+ timeout_minutes = resolve_app_timeout_minutes()
+ if timeout_minutes is not None:
+ _start_inactivity_timeout_thread(timeout_minutes, stream_manager, logger, app_stop_event, run_go_to_sleep_tool)
+
+ def poll_stop_event() -> None:
+ """Poll the stop event to allow graceful shutdown."""
+ if app_stop_event is not None:
+ app_stop_event.wait()
+
+ logger.info("App stop event detected, shutting down...")
+ run_go_to_sleep_tool()
+ try:
+ stream_manager.close()
+ except Exception as e:
+ logger.error(f"Error while closing stream manager: {e}")
+
+ if app_stop_event:
+ threading.Thread(target=poll_stop_event, daemon=True).start()
+
+ try:
+ stream_manager.launch()
+ except KeyboardInterrupt:
+ logger.info("Keyboard interruption in main thread... closing server.")
+ finally:
+ if own_ui_server is not None:
+ own_ui_server.should_exit = True
+
+ sleep_result = run_go_to_sleep_tool()
+ if "error" in sleep_result:
+ movement_manager.stop(reset_to_neutral=False)
+ try:
+ robot.disable_wobbling()
+ except Exception as e:
+ logger.debug(f"Error disabling wobbling during shutdown: {e}")
+
+ # Ensure media is explicitly closed before disconnecting
+ try:
+ robot.media.close()
+ except Exception as e:
+ logger.debug(f"Error closing media during shutdown: {e}")
+
+ # prevent connection to keep alive some threads
+ robot.client.disconnect()
+ time.sleep(1)
+ logger.info("Shutdown complete.")
+
+
+class Peachy(ReachyMiniApp): # type: ignore[misc]
+ """Reachy Mini Apps entry point for the conversation app."""
+
+ custom_app_url = "http://0.0.0.0:7860/"
+ dont_start_webserver = False
+
+ def run(self, reachy_mini: ReachyMini, stop_event: threading.Event) -> None:
+ """Run the Reachy Mini conversation app."""
+ asyncio.set_event_loop(asyncio.new_event_loop())
+
+ args, _ = parse_args()
+
+ state_root = resolve_state_root()
+ run(
+ args,
+ robot=reachy_mini,
+ app_stop_event=stop_event,
+ settings_app=self.settings_app,
+ instance_path=str(state_root),
+ )
+
+
+if __name__ == "__main__":
+ app = Peachy()
+ try:
+ app.wrapped_run()
+ except KeyboardInterrupt:
+ app.stop()
diff --git a/src/peachy/mcp_client.py b/src/peachy/mcp_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f31cdf64c2c1a74bd2d5ab20db0adc750ce3742
--- /dev/null
+++ b/src/peachy/mcp_client.py
@@ -0,0 +1,391 @@
+"""Helpers for consuming remote MCP tools over HTTP(S).
+
+This module validates remote endpoints, discovers tools, and maps calls/results
+into the app's tool interface without mutating the local project environment or
+downloading third-party Python code.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import re
+from typing import TYPE_CHECKING, Any, Mapping, Sequence, AsyncIterator
+from datetime import timedelta
+from contextlib import asynccontextmanager
+from dataclasses import field, dataclass
+from urllib.parse import urlparse
+
+
+if TYPE_CHECKING:
+ from mcp import ClientSession
+ from mcp.types import Tool as McpTool
+ from mcp.types import CallToolResult as McpCallToolResult
+
+
+_NAME_SEGMENT_PATTERN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*$")
+_NAME_NORMALIZER_PATTERN = re.compile(r"[^A-Za-z0-9_]+")
+_LOCAL_HTTP_HOSTS = {"127.0.0.1", "localhost", "::1"}
+_NAMESPACE_SEPARATOR = "__"
+
+
+class McpClientError(RuntimeError):
+ """Base error for the MCP client."""
+
+
+class McpDependencyError(McpClientError):
+ """Raised when a required MCP client dependency is not installed."""
+
+
+class McpTransportError(McpClientError):
+ """Raised when discovery fails before a remote tool runs."""
+
+
+class McpToolInvocationError(McpClientError):
+ """Raised when a remote tool call fails at the transport layer."""
+
+
+class McpToolTimeoutError(McpToolInvocationError):
+ """Raised when a remote tool call exceeds the configured timeout."""
+
+
+def _require_name_segment(label: str, value: str) -> str:
+ candidate = value.strip()
+ if _NAME_SEGMENT_PATTERN.fullmatch(candidate) is None:
+ raise ValueError(f"Invalid {label} '{value}'. Expected pattern '[A-Za-z_][A-Za-z0-9_]*'.")
+ return candidate
+
+
+def apply_name_normalization(value: str) -> str:
+ """Replace non-identifier characters with underscores and collapse runs."""
+ normalized = _NAME_NORMALIZER_PATTERN.sub("_", value).strip("_")
+ return re.sub(r"_+", "_", normalized)
+
+
+def _normalize_name_segment(label: str, value: str) -> str:
+ raw = value.strip()
+ if not raw:
+ raise ValueError(f"{label.capitalize()} cannot be empty.")
+
+ normalized = apply_name_normalization(raw)
+ if not normalized:
+ raise ValueError(f"{label.capitalize()} '{value}' cannot be normalized into a valid tool identifier.")
+ if normalized[0].isdigit():
+ normalized = f"tool_{normalized}"
+ return _require_name_segment(label, normalized)
+
+
+def validate_http_mcp_url(url: str) -> str:
+ """Validate that the MCP endpoint uses HTTP(S)."""
+ parsed = urlparse(url)
+ if parsed.scheme not in {"http", "https"}:
+ raise ValueError(f"Unsupported MCP URL scheme '{parsed.scheme}'. Use http:// or https://.")
+ if not parsed.netloc:
+ raise ValueError(f"Invalid MCP URL '{url}'. Missing host.")
+
+ host = (parsed.hostname or "").lower()
+ if parsed.scheme == "http" and host not in _LOCAL_HTTP_HOSTS:
+ raise ValueError("Remote MCP servers must use HTTPS. Plain HTTP is only allowed for localhost.")
+ return url
+
+
+def build_namespaced_tool_name(server_alias: str, tool_name: str) -> str:
+ """Build a local tool name for a remote MCP tool."""
+ alias = _require_name_segment("server alias", server_alias)
+ tool_segment = _normalize_name_segment("tool name", tool_name)
+ return f"{alias}{_NAMESPACE_SEPARATOR}{tool_segment}"
+
+
+def _dump_content_block(block: object) -> dict[str, Any]:
+ if hasattr(block, "model_dump"):
+ dumped = block.model_dump(mode="json", by_alias=True, exclude_none=True)
+ if isinstance(dumped, dict):
+ return dumped
+ return {"type": getattr(block, "type", "unknown")}
+
+
+def _join_text_content(content_blocks: list[dict[str, Any]]) -> str | None:
+ text_parts = [
+ block["text"] for block in content_blocks if block.get("type") == "text" and isinstance(block.get("text"), str)
+ ]
+ if not text_parts:
+ return None
+ return "\n\n".join(text_parts)
+
+
+def _exception_contains_timeout(exc: BaseException) -> bool:
+ timeout_exception = _httpx_timeout_exception_type()
+ if isinstance(exc, timeout_exception):
+ return True
+
+ if "timed out" in str(exc).lower() or "deadline exceeded" in str(exc).lower():
+ return True
+
+ nested: list[BaseException] = []
+ grouped_exceptions = getattr(exc, "exceptions", None)
+ if isinstance(grouped_exceptions, tuple):
+ nested.extend(grouped_exceptions)
+ if exc.__cause__ is not None:
+ nested.append(exc.__cause__)
+ if exc.__context__ is not None:
+ nested.append(exc.__context__)
+
+ return any(_exception_contains_timeout(item) for item in nested)
+
+
+def _load_mcp_sdk() -> tuple[type["ClientSession"], Any]:
+ try:
+ from mcp import ClientSession
+ from mcp.client.streamable_http import streamable_http_client
+ except ImportError as exc:
+ raise McpDependencyError(
+ "Remote MCP tools require the app's MCP client dependencies. Reinstall or update the app environment."
+ ) from exc
+ return ClientSession, streamable_http_client
+
+
+def _load_httpx() -> Any:
+ try:
+ import httpx
+ except ImportError as exc:
+ raise McpDependencyError(
+ "Remote MCP tools require the app's HTTP client dependencies. Reinstall or update the app environment."
+ ) from exc
+ return httpx
+
+
+def _httpx_timeout_exception_type() -> tuple[type[BaseException], ...]:
+ try:
+ timeout_exception = _load_httpx().TimeoutException
+ except McpDependencyError:
+ return (TimeoutError,)
+ return (TimeoutError, timeout_exception)
+
+
+@dataclass(frozen=True)
+class RemoteMcpServerConfig:
+ """Allowlisted MCP server configuration."""
+
+ alias: str
+ url: str
+ headers: Mapping[str, str] = field(default_factory=dict)
+ request_timeout_s: float = 10.0
+ tool_timeout_s: float = 30.0
+
+ def __post_init__(self) -> None:
+ """Validate configuration once the dataclass has been created."""
+ object.__setattr__(self, "alias", _require_name_segment("server alias", self.alias))
+ object.__setattr__(self, "url", validate_http_mcp_url(self.url))
+ object.__setattr__(self, "headers", {str(k): str(v) for k, v in self.headers.items()})
+ if self.request_timeout_s <= 0:
+ raise ValueError("request_timeout_s must be greater than zero.")
+ if self.tool_timeout_s <= 0:
+ raise ValueError("tool_timeout_s must be greater than zero.")
+
+
+@dataclass(frozen=True)
+class RemoteToolSpec:
+ """App-facing representation of a remote MCP tool."""
+
+ server_alias: str
+ remote_name: str
+ namespaced_name: str
+ description: str
+ parameters_schema: dict[str, Any]
+
+ @classmethod
+ def from_mcp_tool(cls, server_alias: str, tool: "McpTool") -> "RemoteToolSpec":
+ """Build an app-facing spec from an MCP SDK tool descriptor."""
+ description = (getattr(tool, "description", None) or "").strip()
+ parameters_schema = getattr(tool, "inputSchema", None)
+ if not isinstance(parameters_schema, dict):
+ parameters_schema = {"type": "object", "properties": {}, "required": []}
+
+ remote_name = str(getattr(tool, "name", "")).strip()
+ if not remote_name:
+ raise ValueError("Remote MCP tool is missing a name.")
+
+ return cls(
+ server_alias=server_alias,
+ remote_name=remote_name,
+ namespaced_name=build_namespaced_tool_name(server_alias, remote_name),
+ description=description or f"Remote MCP tool '{remote_name}' from server '{server_alias}'.",
+ parameters_schema=dict(parameters_schema),
+ )
+
+ def to_function_spec(self) -> dict[str, Any]:
+ """Translate to the app's function-calling shape."""
+ return {
+ "type": "function",
+ "name": self.namespaced_name,
+ "description": self.description,
+ "parameters": self.parameters_schema,
+ }
+
+
+@dataclass(frozen=True)
+class RemoteToolCallResponse:
+ """Mapped result for a remote MCP tool call."""
+
+ server_alias: str
+ remote_tool_name: str
+ namespaced_tool_name: str
+ status: str
+ content_blocks: list[dict[str, Any]]
+ text: str | None
+ structured_content: Any | None
+
+ @classmethod
+ def from_call_tool_result(
+ cls,
+ *,
+ server_alias: str,
+ remote_tool_name: str,
+ result: "McpCallToolResult",
+ ) -> "RemoteToolCallResponse":
+ """Convert an MCP SDK tool result into the app's result envelope."""
+ content_blocks = [_dump_content_block(block) for block in getattr(result, "content", [])]
+ return cls(
+ server_alias=server_alias,
+ remote_tool_name=remote_tool_name,
+ namespaced_tool_name=build_namespaced_tool_name(server_alias, remote_tool_name),
+ status="error" if bool(getattr(result, "isError", False)) else "ok",
+ content_blocks=content_blocks,
+ text=_join_text_content(content_blocks),
+ structured_content=getattr(result, "structuredContent", None),
+ )
+
+ def to_tool_result(self) -> dict[str, Any]:
+ """Return a dict shaped like the app's tool results."""
+ payload: dict[str, Any] = {
+ "status": self.status,
+ "server_alias": self.server_alias,
+ "remote_tool_name": self.remote_tool_name,
+ "namespaced_tool_name": self.namespaced_tool_name,
+ "content_blocks": self.content_blocks,
+ }
+ if self.text is not None:
+ payload["text"] = self.text
+ if self.structured_content is not None:
+ payload["structured_content"] = self.structured_content
+ return payload
+
+
+class RemoteMcpToolClient:
+ """Minimal async client for allowlisted remote MCP tool servers."""
+
+ def __init__(self, server: RemoteMcpServerConfig, known_tools: Sequence[RemoteToolSpec] = ()) -> None:
+ """Store one allowlisted server configuration and an in-memory tool cache."""
+ self.server = server
+ self._tool_index = _index_remote_tools(list(known_tools))
+
+ async def list_tool_specs(self) -> list[RemoteToolSpec]:
+ """Discover remote tools and translate them into app-facing specs."""
+ try:
+ async with self._session() as session:
+ discovered = await self._list_all_tools(session)
+ except McpDependencyError:
+ raise
+ except Exception as exc:
+ raise McpTransportError(
+ f"Failed to discover MCP tools from '{self.server.alias}' at {self.server.url}: {exc}"
+ ) from exc
+
+ specs = [RemoteToolSpec.from_mcp_tool(self.server.alias, tool) for tool in discovered]
+ self._tool_index = _index_remote_tools(specs)
+ return specs
+
+ async def list_function_specs(self) -> list[dict[str, Any]]:
+ """Discover tools and translate them into function-calling specs."""
+ return [spec.to_function_spec() for spec in await self.list_tool_specs()]
+
+ async def call_tool(self, namespaced_tool_name: str, arguments: Mapping[str, Any] | None = None) -> dict[str, Any]:
+ """Invoke a remote MCP tool by its namespaced local ID."""
+ spec = await self._resolve_tool_spec(namespaced_tool_name)
+ timeout_exception = _httpx_timeout_exception_type()
+
+ try:
+ async with self._session() as session:
+ result = await session.call_tool(
+ spec.remote_name,
+ arguments=dict(arguments or {}),
+ read_timeout_seconds=timedelta(seconds=self.server.tool_timeout_s),
+ )
+ except McpDependencyError:
+ raise
+ except timeout_exception as exc:
+ raise McpToolTimeoutError(
+ f"Timed out calling MCP tool '{namespaced_tool_name}' from '{self.server.alias}'."
+ ) from exc
+ except Exception as exc:
+ if _exception_contains_timeout(exc):
+ raise McpToolTimeoutError(
+ f"Timed out calling MCP tool '{namespaced_tool_name}' from '{self.server.alias}'."
+ ) from exc
+ raise McpToolInvocationError(
+ f"Failed to call MCP tool '{namespaced_tool_name}' from '{self.server.alias}': {exc}"
+ ) from exc
+
+ return RemoteToolCallResponse.from_call_tool_result(
+ server_alias=self.server.alias,
+ remote_tool_name=spec.remote_name,
+ result=result,
+ ).to_tool_result()
+
+ async def _resolve_tool_spec(self, namespaced_tool_name: str) -> RemoteToolSpec:
+ spec = self._tool_index.get(namespaced_tool_name)
+ if spec is not None:
+ return spec
+
+ await self.list_tool_specs()
+ spec = self._tool_index.get(namespaced_tool_name)
+ if spec is None:
+ raise ValueError(f"Unknown remote MCP tool '{namespaced_tool_name}' for server '{self.server.alias}'.")
+ return spec
+
+ async def _list_all_tools(self, session: "ClientSession") -> list["McpTool"]:
+ tools: list[McpTool] = []
+ cursor: str | None = None
+ while True:
+ page = await session.list_tools(cursor=cursor)
+ tools.extend(page.tools)
+ cursor = getattr(page, "nextCursor", None)
+ if cursor is None:
+ return tools
+
+ @asynccontextmanager
+ async def _session(self) -> AsyncIterator["ClientSession"]:
+ client_session_cls, streamable_http_client = _load_mcp_sdk()
+ httpx = _load_httpx()
+ client_timeout = max(self.server.request_timeout_s, self.server.tool_timeout_s)
+
+ async with httpx.AsyncClient(
+ headers=self.server.headers,
+ follow_redirects=False,
+ timeout=client_timeout,
+ ) as http_client:
+ async with streamable_http_client(self.server.url, http_client=http_client) as transport:
+ read_stream, write_stream, _ = transport
+ async with client_session_cls(read_stream, write_stream) as session:
+ await session.initialize()
+ yield session
+
+
+def _index_remote_tools(specs: list[RemoteToolSpec]) -> dict[str, RemoteToolSpec]:
+ index: dict[str, RemoteToolSpec] = {}
+ collisions: dict[str, list[str]] = {}
+
+ for spec in specs:
+ existing = index.get(spec.namespaced_name)
+ if existing is None:
+ index[spec.namespaced_name] = spec
+ continue
+
+ collisions.setdefault(spec.namespaced_name, [existing.remote_name]).append(spec.remote_name)
+
+ if collisions:
+ details = "; ".join(
+ f"{tool_name}: {sorted(remote_names)}" for tool_name, remote_names in sorted(collisions.items())
+ )
+ raise ValueError(f"Remote MCP tool names collide after local namespacing/normalization. Conflicts: {details}")
+
+ return index
diff --git a/src/peachy/memory.py b/src/peachy/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..c53a21ad441405935375ffe46a983ff0540cc87d
--- /dev/null
+++ b/src/peachy/memory.py
@@ -0,0 +1,213 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+from __future__ import annotations
+import os
+import json
+import time
+import random
+import string
+import logging
+import threading
+from pathlib import Path
+from dataclasses import dataclass
+from collections.abc import Mapping
+
+
+logger = logging.getLogger(__name__)
+
+SCHEMA_VERSION = 1
+MAX_FACTS = 60
+MAX_FACT_CHARS = 280
+MEMORY_FILENAME = "memory.v1.json"
+
+_STORE_LOCK = threading.Lock()
+
+
+@dataclass(frozen=True)
+class MemoryFact:
+ """One short long-term memory fact."""
+
+ id: str
+ text: str
+ created_at: int
+
+ def to_json(self) -> dict[str, object]:
+ """Return the persisted JSON shape used by the mobile app."""
+ return {
+ "id": self.id,
+ "text": self.text,
+ "createdAt": self.created_at,
+ }
+
+
+@dataclass(frozen=True)
+class ForgetMemoryResult:
+ """Result of removing a memory fact."""
+
+ removed: MemoryFact | None
+ candidates: tuple[MemoryFact, ...]
+
+
+def memory_path_for_instance(instance_path: str | Path | None = None) -> Path:
+ """Return the memory JSON path for this app instance."""
+ if instance_path is not None:
+ return Path(instance_path).expanduser() / MEMORY_FILENAME
+
+ data_home = os.getenv("XDG_DATA_HOME")
+ data_root = Path(data_home).expanduser() if data_home else Path.home() / ".local" / "share"
+ return data_root / "peachy" / MEMORY_FILENAME
+
+
+def normalize_memory_text(text: str) -> str:
+ """Collapse whitespace and enforce the fact length cap."""
+ normalized = " ".join(text.split()).strip()
+ if len(normalized) <= MAX_FACT_CHARS:
+ return normalized
+ return f"{normalized[: MAX_FACT_CHARS - 3]}..."
+
+
+def _make_id() -> str:
+ suffix = "".join(random.choices(string.ascii_lowercase + string.digits, k=6))
+ return f"m_{int(time.time() * 1000)}_{suffix}"
+
+
+def _now_ms() -> int:
+ return int(time.time() * 1000)
+
+
+def _fact_from_json(value: object) -> MemoryFact | None:
+ if not isinstance(value, Mapping):
+ return None
+
+ fact_id = value.get("id")
+ text = value.get("text")
+ created_at = value.get("createdAt")
+
+ if not isinstance(fact_id, str):
+ return None
+ if not isinstance(text, str):
+ return None
+ if not isinstance(created_at, (int, float)):
+ return None
+
+ normalized = normalize_memory_text(text)
+ if not normalized:
+ return None
+
+ return MemoryFact(id=fact_id, text=normalized, created_at=int(created_at))
+
+
+def _read_memory_file(path: Path) -> list[MemoryFact]:
+ try:
+ raw = path.read_text(encoding="utf-8")
+ except FileNotFoundError:
+ return []
+ except OSError as exc:
+ logger.warning("Failed to read memory store at %s: %s", path, exc)
+ return []
+
+ try:
+ parsed = json.loads(raw)
+ except json.JSONDecodeError as exc:
+ logger.warning("Failed to parse memory store at %s: %s", path, exc)
+ return []
+
+ if not isinstance(parsed, Mapping):
+ return []
+
+ facts_value = parsed.get("facts")
+ if not isinstance(facts_value, list):
+ return []
+
+ facts: list[MemoryFact] = []
+ for item in facts_value:
+ fact = _fact_from_json(item)
+ if fact is not None:
+ facts.append(fact)
+ return facts[:MAX_FACTS]
+
+
+def _write_memory_file(path: Path, facts: list[MemoryFact]) -> None:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ payload = {
+ "version": SCHEMA_VERSION,
+ "facts": [fact.to_json() for fact in facts[:MAX_FACTS]],
+ }
+ tmp_path = path.with_name(f".{path.name}.{os.getpid()}.tmp")
+ try:
+ tmp_path.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+ tmp_path.replace(path)
+ finally:
+ try:
+ tmp_path.unlink(missing_ok=True)
+ except OSError:
+ pass
+
+
+def list_memory_facts(instance_path: str | Path | None = None) -> list[MemoryFact]:
+ """Return stored memory facts, newest first."""
+ with _STORE_LOCK:
+ return list(_read_memory_file(memory_path_for_instance(instance_path)))
+
+
+def add_memory_fact(instance_path: str | Path | None, text: str) -> MemoryFact | None:
+ """Store one short fact, deduplicating exact case-insensitive matches."""
+ normalized = normalize_memory_text(text)
+ if not normalized:
+ return None
+
+ path = memory_path_for_instance(instance_path)
+ with _STORE_LOCK:
+ facts = _read_memory_file(path)
+ existing = next((fact for fact in facts if fact.text.lower() == normalized.lower()), None)
+ if existing is not None:
+ return existing
+
+ fact = MemoryFact(id=_make_id(), text=normalized, created_at=_now_ms())
+ _write_memory_file(path, [fact, *facts][:MAX_FACTS])
+ return fact
+
+
+def forget_memory_fact(
+ instance_path: str | Path | None,
+ *,
+ query: str | None = None,
+) -> ForgetMemoryResult:
+ """Remove a fact by case-insensitive substring query."""
+ path = memory_path_for_instance(instance_path)
+ with _STORE_LOCK:
+ facts = _read_memory_file(path)
+
+ normalized_query = normalize_memory_text(query or "").lower()
+ if not normalized_query:
+ return ForgetMemoryResult(removed=None, candidates=())
+
+ candidates = tuple(fact for fact in facts if normalized_query in fact.text.lower())
+ if not candidates:
+ return ForgetMemoryResult(removed=None, candidates=())
+
+ removed = candidates[0]
+ _write_memory_file(path, [fact for fact in facts if fact.id != removed.id])
+ return ForgetMemoryResult(removed=removed, candidates=candidates)
+
+
+def clear_memory_facts(instance_path: str | Path | None = None) -> None:
+ """Remove all stored memory facts."""
+ path = memory_path_for_instance(instance_path)
+ with _STORE_LOCK:
+ _write_memory_file(path, [])
+
+
+def format_memory_for_prompt(instance_path: str | Path | None = None) -> str:
+ """Return the prompt fragment injected before the session instructions."""
+ facts = list_memory_facts(instance_path)
+ if not facts:
+ return ""
+
+ bullets = "\n".join(f"- {fact.text}" for fact in facts)
+ return "\n".join(
+ [
+ "Things you remember about the user (use this context naturally,",
+ "do not recite the list verbatim):",
+ bullets,
+ ]
+ )
diff --git a/src/peachy/moves.py b/src/peachy/moves.py
new file mode 100644
index 0000000000000000000000000000000000000000..f64f68dec98c9ca281fea82a13df69b5483859f4
--- /dev/null
+++ b/src/peachy/moves.py
@@ -0,0 +1,767 @@
+"""Movement system driving sequential primary moves.
+
+Design overview
+- Primary moves (emotions, dances, goto, breathing) are mutually exclusive and run
+ sequentially.
+- There is a single control point to the robot: `ReachyMini.set_target`.
+- The control loop runs near 100 Hz and is phase-aligned via a monotonic clock.
+- Idle behaviour starts an infinite `BreathingMove` after a short inactivity delay
+ unless listening is active.
+
+Threading model
+- A dedicated worker thread owns all real-time state and issues `set_target`
+ commands.
+- Other threads communicate via a command queue (enqueue moves, mark activity,
+ toggle listening).
+
+Units and frames
+- Antennas and `body_yaw` are in radians.
+
+Safety
+- Listening freezes antennas, then blends them back on unfreeze.
+- Interpolations and blends are used to avoid jumps at all times.
+- `set_target` errors are rate-limited in logs.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import time
+import logging
+import threading
+from queue import Empty, Queue
+from typing import Any, Dict, Tuple
+from collections import deque
+from dataclasses import dataclass
+
+import numpy as np
+from numpy.typing import NDArray
+
+from reachy_mini import ReachyMini
+from reachy_mini.utils import create_head_pose
+from reachy_mini.motion.move import Move
+from reachy_mini.utils.interpolation import compose_world_offset, linear_pose_interpolation
+from peachy.dance_emotion_moves import EmotionQueueMove
+
+
+logger = logging.getLogger(__name__)
+
+# Configuration constants
+CONTROL_LOOP_FREQUENCY_HZ = 60.0 # Hz - Target frequency for the movement control loop
+
+# Type definitions
+FullBodyPose = Tuple[NDArray[np.float32], Tuple[float, float], float] # (head_pose_4x4, antennas, body_yaw)
+
+
+class BreathingMove(Move): # type: ignore
+ """Breathing move with interpolation to neutral and then continuous breathing patterns."""
+
+ def __init__(
+ self,
+ interpolation_start_pose: NDArray[np.float32],
+ interpolation_start_antennas: Tuple[float, float],
+ interpolation_duration: float = 1.0,
+ ):
+ """Initialize breathing move.
+
+ Args:
+ interpolation_start_pose: 4x4 matrix of current head pose to interpolate from
+ interpolation_start_antennas: Current antenna positions to interpolate from
+ interpolation_duration: Duration of interpolation to neutral (seconds)
+
+ """
+ self.interpolation_start_pose = interpolation_start_pose
+ self.interpolation_start_antennas = np.array(interpolation_start_antennas)
+ self.interpolation_duration = interpolation_duration
+
+ # Neutral positions for breathing base
+ self.neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ self.neutral_antennas = np.array([-0.1745, 0.1745]) # ~10° offset to reduce shaking
+
+ # Breathing parameters
+ self.breathing_z_amplitude = 0.005 # 5mm gentle breathing
+ self.breathing_frequency = 0.1 # Hz (6 breaths per minute)
+ self.antenna_sway_amplitude = np.deg2rad(15) # 15 degrees
+ self.antenna_frequency = 0.5 # Hz (faster antenna sway)
+
+ @property
+ def duration(self) -> float:
+ """Duration property required by official Move interface."""
+ return float("inf") # Continuous breathing (never ends naturally)
+
+ def evaluate(self, t: float) -> tuple[NDArray[np.float64] | None, NDArray[np.float64] | None, float | None]:
+ """Evaluate breathing move at time t."""
+ if t < self.interpolation_duration:
+ # Phase 1: Interpolate to neutral base position
+ interpolation_t = t / self.interpolation_duration
+
+ # Interpolate head pose
+ head_pose = linear_pose_interpolation(
+ self.interpolation_start_pose,
+ self.neutral_head_pose,
+ interpolation_t,
+ )
+
+ # Interpolate antennas
+ antennas_interp = (
+ 1 - interpolation_t
+ ) * self.interpolation_start_antennas + interpolation_t * self.neutral_antennas
+ antennas = antennas_interp.astype(np.float64)
+
+ else:
+ # Phase 2: Breathing patterns from neutral base
+ breathing_time = t - self.interpolation_duration
+
+ # Gentle z-axis breathing
+ z_offset = self.breathing_z_amplitude * np.sin(2 * np.pi * self.breathing_frequency * breathing_time)
+ head_pose = create_head_pose(x=0, y=0, z=z_offset, roll=0, pitch=0, yaw=0, degrees=True, mm=False)
+
+ # Antenna sway (opposite directions)
+ antenna_sway = self.antenna_sway_amplitude * np.sin(2 * np.pi * self.antenna_frequency * breathing_time)
+ antennas = np.array([antenna_sway, -antenna_sway], dtype=np.float64)
+
+ # Return in official Move interface format: (head_pose, antennas_array, body_yaw)
+ return (head_pose, antennas, 0.0)
+
+
+def clone_full_body_pose(pose: FullBodyPose) -> FullBodyPose:
+ """Create a deep copy of a full body pose tuple."""
+ head, antennas, body_yaw = pose
+ return (head.copy(), (float(antennas[0]), float(antennas[1])), float(body_yaw))
+
+
+@dataclass
+class MovementState:
+ """State tracking for the movement system."""
+
+ # Primary move state
+ current_move: Move | None = None
+ move_start_time: float | None = None
+ last_activity_time: float = 0.0
+
+ # Status flags
+ last_primary_pose: FullBodyPose | None = None
+
+ def update_activity(self) -> None:
+ """Update the last activity time."""
+ self.last_activity_time = time.monotonic()
+
+
+@dataclass
+class LoopFrequencyStats:
+ """Track rolling loop frequency statistics."""
+
+ mean: float = 0.0
+ m2: float = 0.0
+ min_freq: float = float("inf")
+ count: int = 0
+ last_freq: float = 0.0
+ potential_freq: float = 0.0
+
+ def reset(self) -> None:
+ """Reset accumulators while keeping the last potential frequency."""
+ self.mean = 0.0
+ self.m2 = 0.0
+ self.min_freq = float("inf")
+ self.count = 0
+
+
+class MovementManager:
+ """Coordinate sequential moves and robot output at 100 Hz.
+
+ Responsibilities:
+ - Own a real-time loop that samples the current primary move (if any) and calls
+ `set_target` exactly once per tick.
+ - Start an idle `BreathingMove` after `idle_inactivity_delay` when not
+ listening and no moves are queued.
+ - Expose thread-safe APIs so other threads can enqueue moves or mark activity
+ without touching internal state.
+
+ Timing:
+ - All elapsed-time calculations rely on `time.monotonic()` through `self._now`
+ to avoid wall-clock jumps.
+ - The loop attempts 100 Hz
+
+ Concurrency:
+ - External threads communicate via `_command_queue` messages.
+ """
+
+ def __init__(
+ self,
+ current_robot: ReachyMini,
+ ):
+ """Initialize movement manager."""
+ self.current_robot = current_robot
+ self._head_tracking = False
+
+ # Single timing source for durations
+ self._now = time.monotonic
+
+ # Movement state
+ self.state = MovementState()
+ self.state.last_activity_time = self._now()
+ neutral_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ self.state.last_primary_pose = (neutral_pose, (0.0, 0.0), 0.0)
+
+ # Move queue (primary moves)
+ self.move_queue: deque[Move] = deque()
+
+ # Configuration
+ self.idle_inactivity_delay = 0.3 # seconds
+ self.target_frequency = CONTROL_LOOP_FREQUENCY_HZ
+ self.target_period = 1.0 / self.target_frequency
+
+ self._stop_event = threading.Event()
+ self._thread: threading.Thread | None = None
+ self._is_listening = False
+ # Speaking pauses tracking; the captured look-at pose anchors queued moves.
+ self._is_speaking = False
+ self._track_anchor: NDArray[np.float64] | None = None
+ self._last_commanded_pose: FullBodyPose = clone_full_body_pose(self.state.last_primary_pose)
+ self._listening_antennas: Tuple[float, float] = self._last_commanded_pose[1]
+ self._antenna_unfreeze_blend = 1.0
+ self._antenna_blend_duration = 0.4 # seconds to blend back after listening
+ self._last_listening_blend_time = self._now()
+ self._breathing_active = False # true when breathing move is running or queued
+ self._listening_debounce_s = 0.15
+ self._last_listening_toggle_time = self._now()
+ self._last_set_target_err = 0.0
+ self._set_target_err_interval = 1.0 # seconds between error logs
+ self._set_target_err_suppressed = 0
+
+ # Cross-thread signalling
+ self._command_queue: "Queue[Tuple[str, Any]]" = Queue()
+
+ self._shared_state_lock = threading.Lock()
+ self._shared_last_activity_time = self.state.last_activity_time
+ self._shared_is_listening = self._is_listening
+ self._status_lock = threading.Lock()
+ self._freq_stats = LoopFrequencyStats()
+ self._freq_snapshot = LoopFrequencyStats()
+
+ def queue_move(self, move: Move) -> None:
+ """Queue a primary move to run after the currently executing one.
+
+ Thread-safe: the move is enqueued via the worker command queue so the
+ control loop remains the sole mutator of movement state.
+ """
+ self._command_queue.put(("queue_move", move))
+
+ def clear_move_queue(self) -> None:
+ """Stop the active move and discard any queued primary moves.
+
+ Thread-safe: executed by the worker thread via the command queue.
+ """
+ self._command_queue.put(("clear_queue", None))
+
+ def set_moving_state(self, duration: float) -> None:
+ """Mark the robot as actively moving for the provided duration.
+
+ Legacy hook used by goto helpers to keep inactivity and breathing logic
+ aware of manual motions. Thread-safe via the command queue.
+ """
+ self._command_queue.put(("set_moving_state", duration))
+
+ def is_idle(self) -> bool:
+ """Return True when the robot has been inactive longer than the idle delay."""
+ with self._shared_state_lock:
+ last_activity = self._shared_last_activity_time
+ listening = self._shared_is_listening
+
+ if listening:
+ return False
+
+ return self._now() - last_activity >= self.idle_inactivity_delay
+
+ def set_listening(self, listening: bool) -> None:
+ """Enable or disable listening mode without touching shared state directly.
+
+ While listening:
+ - Antenna positions are frozen at the last commanded values.
+ - Blending is reset so that upon unfreezing the antennas return smoothly.
+ - Idle breathing is suppressed.
+
+ Thread-safe: the change is posted to the worker command queue.
+ """
+ with self._shared_state_lock:
+ if self._shared_is_listening == listening:
+ return
+ self._command_queue.put(("set_listening", listening))
+
+ def set_head_tracking(self, enabled: bool) -> None:
+ """Start or stop following the user's face; thread-safe via the command queue."""
+ self._command_queue.put(("set_head_tracking", enabled))
+
+ def set_speaking(self, speaking: bool) -> None:
+ """Pause head tracking while the assistant speaks, resume it afterwards.
+
+ On speaking, the current look-at pose is captured as an anchor so queued
+ moves stay on the user; when speaking stops the head is handed back to
+ daemon tracking. Thread-safe: posted to the worker command queue.
+ """
+ self._command_queue.put(("set_speaking", speaking))
+
+ def _poll_signals(self, current_time: float) -> None:
+ """Apply queued commands."""
+ while True:
+ try:
+ command, payload = self._command_queue.get_nowait()
+ except Empty:
+ break
+ self._handle_command(command, payload, current_time)
+
+ def _handle_command(self, command: str, payload: Any, current_time: float) -> None:
+ """Handle a single cross-thread command."""
+ if command == "queue_move":
+ if isinstance(payload, Move):
+ self.move_queue.append(payload)
+ self.state.update_activity()
+ duration = getattr(payload, "duration", None)
+ if duration is not None:
+ try:
+ duration_str = f"{float(duration):.2f}"
+ except (TypeError, ValueError):
+ duration_str = str(duration)
+ else:
+ duration_str = "?"
+ logger.debug(
+ "Queued move with duration %ss, queue size: %s",
+ duration_str,
+ len(self.move_queue),
+ )
+ else:
+ logger.warning("Ignored queue_move command with invalid payload: %s", payload)
+ elif command == "clear_queue":
+ self.move_queue.clear()
+ self.state.current_move = None
+ self.state.move_start_time = None
+ self._breathing_active = False
+ logger.info("Cleared move queue and stopped current move")
+ elif command == "set_moving_state":
+ try:
+ duration = float(payload)
+ except (TypeError, ValueError):
+ logger.warning("Invalid moving state duration: %s", payload)
+ return
+ self.state.update_activity()
+ elif command == "mark_activity":
+ self.state.update_activity()
+ elif command == "set_listening":
+ desired_state = bool(payload)
+ now = self._now()
+ if now - self._last_listening_toggle_time < self._listening_debounce_s:
+ return
+ self._last_listening_toggle_time = now
+
+ if self._is_listening == desired_state:
+ return
+
+ self._is_listening = desired_state
+ self._last_listening_blend_time = now
+ if desired_state:
+ # Freeze: snapshot current commanded antennas and reset blend
+ self._listening_antennas = (
+ float(self._last_commanded_pose[1][0]),
+ float(self._last_commanded_pose[1][1]),
+ )
+ self._antenna_unfreeze_blend = 0.0
+ else:
+ # Unfreeze: restart blending from frozen pose
+ self._antenna_unfreeze_blend = 0.0
+ self.state.update_activity()
+ elif command == "set_head_tracking":
+ enabled = bool(payload)
+ if self._head_tracking == enabled:
+ return
+ self._head_tracking = enabled
+ self._track_anchor = None
+ # set_speaking is gated off while disabled, so its state would go stale across a toggle.
+ self._is_speaking = False
+ try:
+ if enabled:
+ self.current_robot.start_head_tracking(weight=1.0)
+ else:
+ self.current_robot.stop_head_tracking()
+ except Exception as e:
+ logger.warning("Head-tracking toggle failed: %s", e)
+ elif command == "set_speaking":
+ if not self._head_tracking:
+ return
+ speaking = bool(payload)
+ if self._is_speaking == speaking:
+ return
+ self._is_speaking = speaking
+ try:
+ if speaking and self.current_robot.get_tracked_face(wait=False).detected:
+ # Pause only once a face is locked, else speech blocks acquisition.
+ self._track_anchor = self.current_robot.get_current_head_pose()
+ self.current_robot.start_head_tracking(weight=0.0)
+ elif not speaking:
+ self._track_anchor = None
+ self.current_robot.start_head_tracking(weight=1.0)
+ except Exception as e:
+ logger.warning("Head-tracking speaking handoff failed: %s", e)
+ else:
+ logger.warning("Unknown command received by MovementManager: %s", command)
+
+ def _publish_shared_state(self) -> None:
+ """Expose idle-related state for external threads."""
+ with self._shared_state_lock:
+ self._shared_last_activity_time = self.state.last_activity_time
+ self._shared_is_listening = self._is_listening
+
+ def _manage_move_queue(self, current_time: float) -> None:
+ """Manage the primary move queue (sequential execution)."""
+ if self.state.current_move is None or (
+ self.state.move_start_time is not None
+ and current_time - self.state.move_start_time >= self.state.current_move.duration
+ ):
+ self.state.current_move = None
+ self.state.move_start_time = None
+
+ if self.move_queue:
+ self.state.current_move = self.move_queue.popleft()
+ self.state.move_start_time = current_time
+ # Any real move cancels breathing mode flag
+ self._breathing_active = isinstance(self.state.current_move, BreathingMove)
+ logger.debug(f"Starting new move, duration: {self.state.current_move.duration}s")
+
+ def _manage_breathing(self, current_time: float) -> None:
+ """Manage automatic breathing when idle."""
+ if (
+ self.state.current_move is None
+ and not self.move_queue
+ and not self._is_listening
+ and not self._breathing_active
+ ):
+ idle_for = current_time - self.state.last_activity_time
+ if idle_for >= self.idle_inactivity_delay:
+ try:
+ # These 2 functions return the latest available sensor data from the robot, but don't perform I/O synchronously.
+ # Therefore, we accept calling them inside the control loop.
+ _, current_antennas = self.current_robot.get_current_joint_positions()
+ current_head_pose = self.current_robot.get_current_head_pose()
+
+ self._breathing_active = True
+ self.state.update_activity()
+
+ breathing_move = BreathingMove(
+ interpolation_start_pose=current_head_pose,
+ interpolation_start_antennas=current_antennas,
+ interpolation_duration=1.0,
+ )
+ self.move_queue.append(breathing_move)
+ logger.debug("Started breathing after %.1fs of inactivity", idle_for)
+ except Exception as e:
+ self._breathing_active = False
+ logger.error("Failed to start breathing: %s", e)
+
+ if isinstance(self.state.current_move, BreathingMove) and self.move_queue:
+ self.state.current_move = None
+ self.state.move_start_time = None
+ self._breathing_active = False
+ logger.debug("Stopping breathing due to new move activity")
+
+ if self.state.current_move is not None and not isinstance(self.state.current_move, BreathingMove):
+ self._breathing_active = False
+
+ def _get_primary_pose(self, current_time: float) -> FullBodyPose:
+ """Get the primary full body pose from current move or neutral."""
+ # When a primary move is playing, sample it and cache the resulting pose
+ if self.state.current_move is not None and self.state.move_start_time is not None:
+ move_time = current_time - self.state.move_start_time
+ head, antennas, body_yaw = self.state.current_move.evaluate(move_time)
+
+ if head is None:
+ head = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ if antennas is None:
+ antennas = np.array([-0.1745, 0.1745]) # ~10° offset
+ if body_yaw is None:
+ body_yaw = 0.0
+
+ antennas_tuple = (float(antennas[0]), float(antennas[1]))
+ head_copy = head.copy()
+ primary_full_body_pose = (
+ head_copy,
+ antennas_tuple,
+ float(body_yaw),
+ )
+
+ self.state.last_primary_pose = clone_full_body_pose(primary_full_body_pose)
+ # Otherwise reuse the last primary pose so we avoid jumps between moves
+ elif self.state.last_primary_pose is not None:
+ primary_full_body_pose = clone_full_body_pose(self.state.last_primary_pose)
+ else:
+ neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ primary_full_body_pose = (neutral_head_pose, (0.0, 0.0), 0.0)
+ self.state.last_primary_pose = clone_full_body_pose(primary_full_body_pose)
+
+ # Speaking pauses tracking: hold the look-at anchor, overlay emotions on it, dance from neutral.
+ if self._track_anchor is not None:
+ head_pose, antennas, body_yaw = primary_full_body_pose
+ move = self.state.current_move
+ if move is None:
+ head_pose = self._track_anchor.copy()
+ elif isinstance(move, EmotionQueueMove):
+ head_pose = compose_world_offset(self._track_anchor, head_pose)
+ primary_full_body_pose = (head_pose, antennas, body_yaw)
+
+ return primary_full_body_pose
+
+ def _update_primary_motion(self, current_time: float) -> None:
+ """Advance queue state and idle behaviours for this tick."""
+ self._manage_move_queue(current_time)
+ self._manage_breathing(current_time)
+
+ def _calculate_blended_antennas(self, target_antennas: Tuple[float, float]) -> Tuple[float, float]:
+ """Blend target antennas with listening freeze state and update blending."""
+ now = self._now()
+ listening = self._is_listening
+ listening_antennas = self._listening_antennas
+ blend = self._antenna_unfreeze_blend
+ blend_duration = self._antenna_blend_duration
+ last_update = self._last_listening_blend_time
+ self._last_listening_blend_time = now
+
+ if listening:
+ antennas_cmd = listening_antennas
+ new_blend = 0.0
+ else:
+ dt = max(0.0, now - last_update)
+ if blend_duration <= 0:
+ new_blend = 1.0
+ else:
+ new_blend = min(1.0, blend + dt / blend_duration)
+ antennas_cmd = (
+ listening_antennas[0] * (1.0 - new_blend) + target_antennas[0] * new_blend,
+ listening_antennas[1] * (1.0 - new_blend) + target_antennas[1] * new_blend,
+ )
+
+ if listening:
+ self._antenna_unfreeze_blend = 0.0
+ else:
+ self._antenna_unfreeze_blend = new_blend
+ if new_blend >= 1.0:
+ self._listening_antennas = (
+ float(target_antennas[0]),
+ float(target_antennas[1]),
+ )
+
+ return antennas_cmd
+
+ def _issue_control_command(
+ self, head: NDArray[np.float32], antennas: Tuple[float, float], body_yaw: float
+ ) -> None:
+ """Send the pose to the robot with throttled error logging."""
+ try:
+ self.current_robot.set_target(head=head, antennas=antennas, body_yaw=body_yaw)
+ except Exception as e:
+ now = self._now()
+ if now - self._last_set_target_err >= self._set_target_err_interval:
+ msg = f"Failed to set robot target: {e}"
+ if self._set_target_err_suppressed:
+ msg += f" (suppressed {self._set_target_err_suppressed} repeats)"
+ self._set_target_err_suppressed = 0
+ logger.error(msg)
+ self._last_set_target_err = now
+ else:
+ self._set_target_err_suppressed += 1
+ else:
+ with self._status_lock:
+ self._last_commanded_pose = clone_full_body_pose((head, antennas, body_yaw))
+
+ def _update_frequency_stats(
+ self,
+ loop_start: float,
+ prev_loop_start: float,
+ stats: LoopFrequencyStats,
+ ) -> LoopFrequencyStats:
+ """Update frequency statistics based on the current loop start time."""
+ period = loop_start - prev_loop_start
+ if period > 0:
+ stats.last_freq = 1.0 / period
+ stats.count += 1
+ delta = stats.last_freq - stats.mean
+ stats.mean += delta / stats.count
+ stats.m2 += delta * (stats.last_freq - stats.mean)
+ stats.min_freq = min(stats.min_freq, stats.last_freq)
+ return stats
+
+ def _schedule_next_tick(self, loop_start: float, stats: LoopFrequencyStats) -> Tuple[float, LoopFrequencyStats]:
+ """Compute sleep time to maintain target frequency and update potential freq."""
+ computation_time = self._now() - loop_start
+ stats.potential_freq = 1.0 / computation_time if computation_time > 0 else float("inf")
+ sleep_time = max(0.0, self.target_period - computation_time)
+ return sleep_time, stats
+
+ def _record_frequency_snapshot(self, stats: LoopFrequencyStats) -> None:
+ """Store a thread-safe snapshot of current frequency statistics."""
+ with self._status_lock:
+ self._freq_snapshot = LoopFrequencyStats(
+ mean=stats.mean,
+ m2=stats.m2,
+ min_freq=stats.min_freq,
+ count=stats.count,
+ last_freq=stats.last_freq,
+ potential_freq=stats.potential_freq,
+ )
+
+ def _maybe_log_frequency(self, loop_count: int, print_interval_loops: int, stats: LoopFrequencyStats) -> None:
+ """Emit frequency telemetry when enough loops have elapsed."""
+ if loop_count % print_interval_loops != 0 or stats.count == 0:
+ return
+
+ variance = stats.m2 / stats.count if stats.count > 0 else 0.0
+ lowest = stats.min_freq if stats.min_freq != float("inf") else 0.0
+ logger.debug(
+ "Loop freq - avg: %.2fHz, variance: %.4f, min: %.2fHz, last: %.2fHz, potential: %.2fHz, target: %.1fHz",
+ stats.mean,
+ variance,
+ lowest,
+ stats.last_freq,
+ stats.potential_freq,
+ self.target_frequency,
+ )
+ stats.reset()
+
+ def start(self) -> None:
+ """Start the worker thread that drives the 100 Hz control loop."""
+ if self._thread is not None and self._thread.is_alive():
+ logger.warning("Move worker already running; start() ignored")
+ return
+ self._stop_event.clear()
+ self._thread = threading.Thread(target=self.working_loop, daemon=True)
+ self._thread.start()
+ logger.debug("Move worker started")
+
+ def stop(self, reset_to_neutral: bool = True) -> None:
+ """Request the worker thread to stop and wait for it to exit.
+
+ Optionally resets the robot to a neutral position after stopping.
+ """
+ if self._thread is None or not self._thread.is_alive():
+ logger.debug("Move worker not running; stop() ignored")
+ return
+
+ if reset_to_neutral:
+ logger.info("Stopping movement manager and resetting to neutral position...")
+ else:
+ logger.info("Stopping movement manager...")
+
+ # Clear any queued moves and stop current move
+ self.clear_move_queue()
+
+ # Stop the worker thread first so it doesn't interfere
+ self._stop_event.set()
+ if self._thread is not None:
+ self._thread.join()
+ self._thread = None
+ logger.debug("Move worker stopped")
+
+ if self._head_tracking:
+ try:
+ self.current_robot.stop_head_tracking()
+ except Exception as e:
+ logger.warning("Failed to stop head tracking: %s", e)
+
+ if not reset_to_neutral:
+ return
+
+ # Reset to neutral position using goto_target (same approach as wake_up)
+ try:
+ neutral_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=True)
+ neutral_antennas = [-0.1745, 0.1745] # ~10° offset to reduce shaking
+ neutral_body_yaw = 0.0
+
+ # Use goto_target directly on the robot
+ self.current_robot.goto_target(
+ head=neutral_head_pose,
+ antennas=neutral_antennas,
+ duration=2.0,
+ body_yaw=neutral_body_yaw,
+ )
+
+ logger.info("Reset to neutral position completed")
+
+ except Exception as e:
+ logger.error(f"Failed to reset to neutral position: {e}")
+
+ def get_status(self) -> Dict[str, Any]:
+ """Return a lightweight status snapshot for observability."""
+ with self._status_lock:
+ pose_snapshot = clone_full_body_pose(self._last_commanded_pose)
+ freq_snapshot = LoopFrequencyStats(
+ mean=self._freq_snapshot.mean,
+ m2=self._freq_snapshot.m2,
+ min_freq=self._freq_snapshot.min_freq,
+ count=self._freq_snapshot.count,
+ last_freq=self._freq_snapshot.last_freq,
+ potential_freq=self._freq_snapshot.potential_freq,
+ )
+
+ head_matrix = pose_snapshot[0].tolist() if pose_snapshot else None
+ antennas = pose_snapshot[1] if pose_snapshot else None
+ body_yaw = pose_snapshot[2] if pose_snapshot else None
+
+ return {
+ "queue_size": len(self.move_queue),
+ "is_listening": self._is_listening,
+ "breathing_active": self._breathing_active,
+ "last_commanded_pose": {
+ "head": head_matrix,
+ "antennas": antennas,
+ "body_yaw": body_yaw,
+ },
+ "loop_frequency": {
+ "last": freq_snapshot.last_freq,
+ "mean": freq_snapshot.mean,
+ "min": freq_snapshot.min_freq,
+ "potential": freq_snapshot.potential_freq,
+ "samples": freq_snapshot.count,
+ },
+ }
+
+ def working_loop(self) -> None:
+ """Run the primary-move control loop with a single set_target() call per tick."""
+ logger.debug("Starting enhanced movement control loop (100Hz)")
+
+ loop_count = 0
+ prev_loop_start = self._now()
+ print_interval_loops = max(1, int(self.target_frequency * 2))
+ freq_stats = self._freq_stats
+
+ while not self._stop_event.is_set():
+ loop_start = self._now()
+ loop_count += 1
+
+ if loop_count > 1:
+ freq_stats = self._update_frequency_stats(loop_start, prev_loop_start, freq_stats)
+ prev_loop_start = loop_start
+
+ # 1) Poll external commands
+ self._poll_signals(loop_start)
+
+ # 2) Manage the primary move queue (start new move, end finished move, breathing)
+ self._update_primary_motion(loop_start)
+
+ # 3) Build the primary full-body pose for this tick
+ head, antennas, body_yaw = self._get_primary_pose(loop_start)
+
+ # 4) Apply listening antenna freeze or blend-back
+ antennas_cmd = self._calculate_blended_antennas(antennas)
+
+ # 5) Single set_target call - the only control point
+ self._issue_control_command(head, antennas_cmd, body_yaw)
+
+ # 6) Adaptive sleep to align to next tick, then publish shared state
+ sleep_time, freq_stats = self._schedule_next_tick(loop_start, freq_stats)
+ self._publish_shared_state()
+ self._record_frequency_snapshot(freq_stats)
+
+ # 7) Periodic telemetry on loop frequency
+ self._maybe_log_frequency(loop_count, print_interval_loops, freq_stats)
+
+ if sleep_time > 0:
+ time.sleep(sleep_time)
+
+ logger.debug("Movement control loop stopped")
diff --git a/src/peachy/openai_realtime.py b/src/peachy/openai_realtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ef8be31e622f4b1c9e9ab48f3a716bff5a2ad83
--- /dev/null
+++ b/src/peachy/openai_realtime.py
@@ -0,0 +1,1178 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import json
+import os
+import random
+import time
+import uuid
+import base64
+import asyncio
+import logging
+from collections import deque
+from typing import Any, Final, Literal, cast
+
+import numpy as np
+from openai import APIConnectionError, APITimeoutError, AsyncOpenAI
+from pydantic import Field, BaseModel
+from openai.types.realtime import (
+ AudioTranscriptionParam,
+ RealtimeAudioConfigParam,
+ RealtimeToolsConfigParam,
+ RealtimeFunctionToolParam,
+ RealtimeAudioConfigInputParam,
+ RealtimeAudioConfigOutputParam,
+ RealtimeSessionCreateRequestParam,
+)
+from websockets.exceptions import ConnectionClosedError
+from openai.resources.realtime.realtime import AsyncRealtimeConnection
+from openai.types.realtime.realtime_audio_input_turn_detection_param import ServerVad
+
+from peachy.tools import core_tools
+from peachy.config import config
+from peachy.prompts import (
+ get_session_voice,
+ get_session_instructions,
+ get_session_greeting_prompt,
+)
+from peachy.audio.resampling import pcm16_at_rate
+from peachy.streaming import AdditionalOutputs
+from peachy.tools.core_tools import (
+ ToolSpec,
+ ToolDependencies,
+ get_tool_specs,
+)
+from peachy.conversation_handler import AudioFrame, ConversationHandler
+from peachy.providers import redact_secrets
+from peachy.tools.background_tool_manager import (
+ ToolCallRoutine,
+ ToolNotification,
+ BackgroundToolManager,
+)
+
+
+logger = logging.getLogger(__name__)
+
+_RESPONSE_DONE_TIMEOUT: Final[float] = 30.0
+_RESPONSE_REJECTION_RETRY_DELAY: Final[float] = 0.5
+OPENAI_SAMPLE_RATE: Final[int] = 24_000
+OPENAI_DEFAULT_MODEL: Final[str] = "gpt-realtime"
+OPENAI_DEFAULT_VOICE: Final[str] = "marin"
+OPENAI_VOICES: Final[tuple[str, ...]] = (
+ "alloy",
+ "ash",
+ "ballad",
+ "cedar",
+ "coral",
+ "echo",
+ "marin",
+ "sage",
+ "shimmer",
+ "verse",
+)
+
+ErrorDisposition = Literal["terminal", "transient"]
+
+
+class TerminalProviderError(RuntimeError):
+ """A provider failure that needs configuration or operator action."""
+
+
+class RetryExhaustedError(RuntimeError):
+ """Transient provider failures exhausted this activation's retry budget."""
+
+
+class RealtimeProtocolError(RuntimeError):
+ """A server-delivered Realtime error event that must end this session."""
+
+ def __init__(
+ self,
+ message: str,
+ *,
+ code: str = "",
+ status_code: int | None = None,
+ event_id: str | None = None,
+ ) -> None:
+ super().__init__(message)
+ self.code = code
+ self.status_code = status_code
+ self.event_id = event_id
+
+
+def _protocol_error_from_event(event: object) -> RealtimeProtocolError:
+ payload = getattr(event, "error", None)
+
+ def field(name: str) -> object:
+ if isinstance(payload, dict):
+ return payload.get(name)
+ return getattr(payload, name, None)
+
+ code = str(field("code") or field("type") or "").lower()
+ message = str(field("message") or "OpenAI Realtime protocol error")
+ raw_status = field("status_code")
+ status = raw_status if isinstance(raw_status, int) else None
+ raw_event_id = field("event_id")
+ event_id = raw_event_id if isinstance(raw_event_id, str) else None
+ return RealtimeProtocolError(
+ message,
+ code=code,
+ status_code=status,
+ event_id=event_id,
+ )
+
+
+def _error_code(error: BaseException) -> str:
+ direct = getattr(error, "code", None)
+ if isinstance(direct, str):
+ return direct.lower()
+ body = getattr(error, "body", None)
+ if isinstance(body, dict):
+ code = body.get("code")
+ nested = body.get("error")
+ if not code and isinstance(nested, dict):
+ code = nested.get("code")
+ return str(code or "").lower()
+ return ""
+
+
+def classify_openai_error(error: BaseException) -> ErrorDisposition:
+ """Classify an OpenAI activation failure without permitting retry storms."""
+ code = _error_code(error)
+ status = getattr(error, "status_code", None)
+ if code in {"insufficient_quota", "invalid_api_key", "model_not_found"}:
+ return "terminal"
+ if code in {"rate_limit_exceeded", "server_error"}:
+ return "transient"
+ if status in {400, 401, 403, 404, 422}:
+ return "terminal"
+ if status == 429:
+ return "transient"
+ if isinstance(
+ error,
+ (
+ APIConnectionError,
+ APITimeoutError,
+ ConnectionError,
+ TimeoutError,
+ ConnectionClosedError,
+ ),
+ ):
+ return "transient"
+ if isinstance(status, int) and status >= 500:
+ return "transient"
+ return "terminal"
+
+
+class InputTranscriptChunksByItem(BaseModel):
+ """Current item_id and its accumulated deltas. Only one item at a time."""
+
+ item_id: str | None = None
+ deltas: list[str] = Field(default_factory=list)
+
+
+def to_realtime_tools_config(tool_specs: list[ToolSpec]) -> RealtimeToolsConfigParam:
+ """Convert app tool specs to the OpenAI-compatible realtime session shape."""
+ realtime_tools: RealtimeToolsConfigParam = []
+ for spec in tool_specs:
+ realtime_tools.append(
+ RealtimeFunctionToolParam(
+ type="function",
+ name=spec["name"],
+ description=spec["description"],
+ parameters=spec["parameters"],
+ )
+ )
+ return realtime_tools
+
+
+def _pcm24k() -> dict[str, object]:
+ return {"type": "audio/pcm", "rate": OPENAI_SAMPLE_RATE}
+
+
+class OpenAIRealtimeHandler(ConversationHandler):
+ """Realtime stream handler for the direct OpenAI Realtime API."""
+
+ SAMPLE_RATE = OPENAI_SAMPLE_RATE
+
+ def __init__(
+ self,
+ deps: ToolDependencies,
+ instance_path: str | None = None,
+ startup_voice: str | None = None,
+ ) -> None:
+ """Initialize the handler."""
+ super().__init__()
+
+ self.deps = deps
+
+ self.client: AsyncOpenAI
+ self.connection: AsyncRealtimeConnection | None = None
+ self.output_queue: asyncio.Queue[AudioFrame | AdditionalOutputs] = asyncio.Queue()
+
+ self.instance_path = instance_path
+ self._voice_override: str | None = self._normalize_startup_voice(startup_voice)
+ self.model = (os.getenv("OPENAI_REALTIME_MODEL") or OPENAI_DEFAULT_MODEL).strip() or OPENAI_DEFAULT_MODEL
+
+ # Debouncing for partial transcripts
+ self.partial_transcript_task: asyncio.Task[None] | None = None
+ self.partial_debounce_delay = 0.5 # seconds
+ self.input_transcript_chunks_by_item = InputTranscriptChunksByItem()
+
+ # Internal lifecycle flags
+ self._connected_event: asyncio.Event = asyncio.Event()
+
+ # Background tool manager
+ self.tool_manager = BackgroundToolManager()
+
+ # Response-in-progress guard: the Realtime API only allows one active
+ # response per conversation at a time. A dedicated worker task
+ # (_response_sender_loop) dequeues and sends one request at a time
+ self._pending_responses: asyncio.Queue[dict[str, Any]] = asyncio.Queue()
+ self._response_done_event: asyncio.Event = asyncio.Event()
+ self._response_done_event.set()
+ self._response_started_or_rejected_event: asyncio.Event = asyncio.Event()
+ self._last_response_rejected: bool = False
+ self._turn_user_done_at: float | None = None
+ self._turn_response_created_at: float | None = None
+ self._turn_first_audio_at: float | None = None
+ self._startup_greeting_sent = False
+ self._in_flight_tool_calls: set[str] = set()
+ self._tool_batch_needs_response = False
+ self._response_generation = 0
+ self._active_response_id: str | None = None
+ self._active_response_generation: int | None = None
+ self._cancelled_response_ids: set[str] = set()
+ self._cancelled_generations: set[int] = set()
+ self._pending_cancel_event_ids: deque[str] = deque(maxlen=32)
+ self._restart_tasks: set[asyncio.Task[None]] = set()
+ self._restart_lock = asyncio.Lock()
+ self._shutdown_started = False
+
+ @staticmethod
+ def _sanitize_tool_result_for_model(tool_name: str, tool_result: dict[str, Any]) -> dict[str, Any]:
+ """Remove bulky transport-only fields before echoing tool output back to the model."""
+ if tool_name == "camera" and "b64_im" in tool_result:
+ sanitized = dict(tool_result)
+ sanitized.pop("b64_im", None)
+ sanitized["image_attached"] = True
+ return sanitized
+ return tool_result
+
+ @staticmethod
+ def _event_response_id(event: object) -> str | None:
+ direct = getattr(event, "response_id", None)
+ if isinstance(direct, str) and direct:
+ return direct
+ response = getattr(event, "response", None)
+ nested = getattr(response, "id", None)
+ return nested if isinstance(nested, str) and nested else None
+
+ def _event_belongs_to_cancelled_response(self, event: object) -> bool:
+ response_id = self._event_response_id(event)
+ if response_id is not None and response_id in self._cancelled_response_ids:
+ return True
+ generation = self._active_response_generation
+ if generation is None or generation not in self._cancelled_generations:
+ return False
+ # response.created.response.id is optional in SDK 2.28, while audio deltas
+ # carry response_id. Bind that first observed ID to the already-cancelled
+ # active generation and suppress it until response.done.
+ if response_id is not None:
+ self._cancelled_response_ids.add(response_id)
+ if self._active_response_id is None:
+ self._active_response_id = response_id
+ return True
+
+ def _forget_cancel_event_id(self, event_id: str) -> None:
+ try:
+ self._pending_cancel_event_ids.remove(event_id)
+ except ValueError:
+ pass
+
+ def _finish_response(self, event: object) -> None:
+ response_id = self._event_response_id(event)
+ if response_id is not None:
+ self._cancelled_response_ids.discard(response_id)
+ if self._active_response_generation is not None:
+ self._cancelled_generations.discard(self._active_response_generation)
+ self._active_response_id = None
+ self._active_response_generation = None
+
+ def _restart_task_done(self, task: asyncio.Task[None]) -> None:
+ """Retrieve and sanitize background restart failures."""
+ self._restart_tasks.discard(task)
+ if task.cancelled():
+ return
+ try:
+ task.result()
+ except Exception as exc:
+ logger.warning("Realtime session restart failed: %s", redact_secrets(exc))
+
+ async def _cancel_restart_tasks(self) -> None:
+ """Cancel and retrieve retained restart tasks during handler shutdown."""
+ restart_tasks = tuple(self._restart_tasks)
+ for task in restart_tasks:
+ task.cancel()
+ if restart_tasks:
+ await asyncio.gather(*restart_tasks, return_exceptions=True)
+ self._restart_tasks.clear()
+
+ async def _cancel_active_response_for_barge_in(self) -> None:
+ response_id = self._active_response_id
+ generation = self._active_response_generation
+ if response_id is not None:
+ self._cancelled_response_ids.add(response_id)
+ if generation is not None:
+ self._cancelled_generations.add(generation)
+
+ if self.connection is not None and (response_id is not None or generation is not None):
+ cancel_event_id = f"peachy-cancel-{uuid.uuid4().hex}"
+ self._pending_cancel_event_ids.append(cancel_event_id)
+ try:
+ if response_id is None:
+ await self.connection.response.cancel(event_id=cancel_event_id)
+ else:
+ await self.connection.response.cancel(
+ event_id=cancel_event_id,
+ response_id=response_id,
+ )
+ except Exception as exc:
+ self._forget_cancel_event_id(cancel_event_id)
+ logger.debug("Response cancellation raced with completion (%s)", type(exc).__name__)
+
+ if self._clear_queue is not None:
+ self._clear_queue()
+ else:
+ while not self.output_queue.empty():
+ try:
+ self.output_queue.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ def _normalize_startup_voice(self, voice: str | None) -> str | None:
+ """Return a valid persisted startup voice, or None."""
+ return self._resolve_backend_voice(voice, source="persisted startup voice")
+
+ async def _wait_for_response_done_before_tool_result(self) -> bool:
+ """Return whether the function-call response finished before sending tool output."""
+ if self._response_done_event.is_set():
+ return True
+
+ try:
+ await asyncio.wait_for(
+ self._response_done_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ return True
+ except asyncio.TimeoutError:
+ return False
+
+ def _resolve_backend_voice(
+ self,
+ voice: str | None,
+ *,
+ source: str,
+ fallback: str | None = None,
+ ) -> str | None:
+ """Return a backend-supported voice, optionally falling back when unsupported."""
+ available_voices = OPENAI_VOICES
+ voice_value = (voice or "").strip()
+ if not voice_value:
+ return fallback
+
+ voice_by_lowercase = {candidate.lower(): candidate for candidate in available_voices}
+ normalized_voice = voice_by_lowercase.get(voice_value.lower())
+ if normalized_voice is not None:
+ return normalized_voice
+
+ if voice:
+ logger.warning(
+ "Ignoring unsupported %s %r; expected one of %s",
+ source,
+ voice,
+ available_voices,
+ )
+ return fallback
+
+ def _get_session_config(self, tool_specs: list[ToolSpec]) -> RealtimeSessionCreateRequestParam:
+ """Return the direct OpenAI realtime session config."""
+ return RealtimeSessionCreateRequestParam(
+ type="realtime",
+ instructions=get_session_instructions(self.instance_path),
+ audio=RealtimeAudioConfigParam(
+ input=RealtimeAudioConfigInputParam(
+ format=_pcm24k(), # type: ignore[typeddict-item]
+ transcription=AudioTranscriptionParam(
+ model="gpt-4o-transcribe",
+ language=config.REALTIME_TRANSCRIPTION_LANGUAGE,
+ ),
+ turn_detection=ServerVad(type="server_vad", interrupt_response=True),
+ ),
+ output=RealtimeAudioConfigOutputParam(
+ format=_pcm24k(), # type: ignore[typeddict-item]
+ voice=self.get_current_voice(),
+ ),
+ ),
+ tools=to_realtime_tools_config([spec for spec in tool_specs if spec["name"] != "camera"]),
+ tool_choice="auto",
+ )
+
+ def _is_connected(self) -> bool:
+ """Return whether the realtime connection is open."""
+ return self.connection is not None
+
+ def _idle_behavior_ready(self) -> bool:
+ """Hold idle behavior while a model response is still active."""
+ return self._response_done_event.is_set()
+
+ async def _cancel_partial_transcript_task(self) -> None:
+ if self.partial_transcript_task and not self.partial_transcript_task.done():
+ self.partial_transcript_task.cancel()
+ try:
+ await self.partial_transcript_task
+ except asyncio.CancelledError:
+ pass
+
+ async def change_voice(self, voice: str) -> str:
+ """Change only the voice, updating the active session when possible."""
+ resolved_voice = (
+ self._resolve_backend_voice(voice, source="requested voice", fallback=OPENAI_DEFAULT_VOICE)
+ or OPENAI_DEFAULT_VOICE
+ )
+ self._voice_override = resolved_voice
+ if self.connection is not None:
+ try:
+ await self.connection.session.update(
+ session=RealtimeSessionCreateRequestParam(
+ type="realtime",
+ audio=RealtimeAudioConfigParam(
+ output=RealtimeAudioConfigOutputParam(
+ voice=resolved_voice,
+ ),
+ ),
+ ),
+ )
+ return f"Voice changed to {resolved_voice}."
+ except Exception as e:
+ logger.warning("Failed to update live session for voice change: %s", redact_secrets(e))
+ return "Voice change failed. Will take effect on next connection."
+ return "Voice changed. Will take effect on next connection."
+
+ def get_current_voice(self) -> str:
+ """Return the voice currently selected for this handler."""
+ voice = self._voice_override or get_session_voice(default=OPENAI_DEFAULT_VOICE)
+ return (
+ self._resolve_backend_voice(voice, source="session voice", fallback=OPENAI_DEFAULT_VOICE)
+ or OPENAI_DEFAULT_VOICE
+ )
+
+ async def apply_personality(self, profile: str | None) -> str:
+ """Apply a new personality (profile) at runtime if possible.
+
+ - Updates the global config's selected profile for subsequent calls.
+ - If a realtime connection is active, sends a session.update with the
+ freshly resolved instructions so the change takes effect immediately.
+
+ Returns a short status message for UI feedback.
+ """
+ try:
+ # Update the in-process config value and env
+ from peachy.config import config as _config
+ from peachy.config import set_custom_profile
+
+ set_custom_profile(profile)
+ logger.info(
+ "Set custom profile to %r (config=%r)", profile, getattr(_config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ )
+
+ try:
+ instructions = get_session_instructions(self.instance_path)
+ voice = self.get_current_voice()
+ except Exception as e:
+ safe_error = redact_secrets(e)
+ logger.error("Failed to resolve personality content: %s", safe_error)
+ return f"Failed to apply personality: {safe_error}"
+
+ # Rebuild the tool registry
+ core_tools.initialize_tools(force=True)
+
+ # Attempt a live update first, then force a full restart to ensure it sticks
+ if self.connection is not None:
+ try:
+ await self.connection.session.update(
+ session=RealtimeSessionCreateRequestParam(
+ type="realtime",
+ instructions=instructions,
+ audio=RealtimeAudioConfigParam(
+ output=RealtimeAudioConfigOutputParam(
+ voice=voice,
+ ),
+ ),
+ ),
+ )
+ logger.info("Applied personality via live update: %s", profile or "built-in default")
+ except Exception as e:
+ logger.warning("Live update failed; will restart session: %s", redact_secrets(e))
+
+ # Force a real restart to guarantee the new instructions/voice
+ try:
+ await self._restart_session()
+ return "Applied personality and restarted realtime session."
+ except Exception as e:
+ logger.warning("Failed to restart session after apply: %s", redact_secrets(e))
+ return "Applied personality. Will take effect on next connection."
+ else:
+ logger.info(
+ "Applied personality recorded: %s (no live connection; will apply on next session)",
+ profile or "built-in default",
+ )
+ return "Applied personality. Will take effect on next connection."
+ except Exception as e:
+ safe_error = redact_secrets(e)
+ logger.error("Error applying personality '%s': %s", profile, safe_error)
+ return f"Failed to apply personality: {safe_error}"
+
+ async def _emit_debounced_partial(self, transcript: str, item_id: str, sequence_counter: int) -> None:
+ """Emit partial transcript after debounce delay."""
+ try:
+ await asyncio.sleep(self.partial_debounce_delay)
+
+ input_transcript = self.input_transcript_chunks_by_item
+ if input_transcript.item_id == item_id and len(input_transcript.deltas) - 1 == sequence_counter:
+ await self.output_queue.put(AdditionalOutputs({"role": "user_partial", "content": transcript}))
+ logger.debug(f"Debounced partial emitted: {transcript}")
+ except asyncio.CancelledError:
+ logger.debug("Debounced partial cancelled")
+ raise
+
+ def _record_partial_transcript_delta(
+ self,
+ input_transcript: InputTranscriptChunksByItem,
+ item_id: str,
+ delta: str,
+ ) -> None:
+ """Record an OpenAI partial transcript snapshot."""
+ input_transcript.item_id = item_id
+ input_transcript.deltas = [delta]
+
+ async def start_up(self) -> None:
+ """Run one bounded OpenAI activation."""
+ max_attempts = 3
+ for attempt in range(1, max_attempts + 1):
+ try:
+ self.client = await self._build_realtime_client()
+ await self._run_realtime_session()
+ return
+ except asyncio.CancelledError:
+ raise
+ except Exception as exc:
+ message = redact_secrets(exc)
+ if classify_openai_error(exc) == "terminal":
+ logger.warning("OpenAI realtime activation stopped: %s", message)
+ raise TerminalProviderError(message) from exc
+ if attempt == max_attempts:
+ logger.warning(
+ "OpenAI realtime activation exhausted %d attempts: %s",
+ max_attempts,
+ message,
+ )
+ raise RetryExhaustedError(
+ f"OpenAI realtime failed after {max_attempts} attempts: {message}"
+ ) from exc
+ delay = float(2 ** (attempt - 1)) + random.uniform(0.0, 0.5)
+ logger.warning(
+ "OpenAI realtime transient failure (%d/%d): %s; retrying in %.1fs",
+ attempt,
+ max_attempts,
+ message,
+ delay,
+ )
+ await asyncio.sleep(delay)
+ finally:
+ self.connection = None
+ self._connected_event.clear()
+
+ async def _restart_session(self) -> None:
+ """Force-close the current session and start a fresh one in background.
+
+ Does not block the caller while the new session is establishing.
+ """
+ try:
+ async with self._restart_lock:
+ if self._shutdown_started:
+ return
+
+ if self.connection is not None:
+ try:
+ await self.connection.close()
+ except Exception:
+ pass
+ finally:
+ self.connection = None
+
+ # Ensure we have a client (start_up must have run once)
+ if getattr(self, "client", None) is None:
+ logger.warning("Cannot restart: realtime client not initialized yet.")
+ return
+
+ # Build before registering the session task, then re-check the
+ # shutdown gate because client construction may have suspended.
+ try:
+ self._connected_event.clear()
+ except Exception:
+ pass
+ client = await self._build_realtime_client()
+ if self._shutdown_started:
+ return
+ self.client = client
+ restart_task = asyncio.create_task(
+ self._run_realtime_session(),
+ name="realtime-session-restart",
+ )
+ self._restart_tasks.add(restart_task)
+ restart_task.add_done_callback(self._restart_task_done)
+ try:
+ await asyncio.wait_for(self._connected_event.wait(), timeout=5.0)
+ if not self._shutdown_started:
+ logger.info("Realtime session restarted and connected.")
+ except asyncio.TimeoutError:
+ if not self._shutdown_started:
+ logger.warning("Realtime session restart timed out; continuing in background.")
+ except asyncio.CancelledError:
+ raise
+ except Exception as e:
+ logger.warning("_restart_session failed: %s", redact_secrets(e))
+
+ async def _safe_response_create(self, **kwargs: Any) -> None:
+ """Enqueue a response.create() kwargs for the sender worker _response_sender_loop().
+
+ This method never blocks the caller.
+ """
+ await self._pending_responses.put(kwargs)
+
+ async def _send_startup_greeting_prompt(self) -> None:
+ """Prompt the model to open the conversation once the session is ready."""
+ if self._startup_greeting_sent or not self.connection:
+ return
+
+ greeting_prompt = get_session_greeting_prompt().strip()
+ if not greeting_prompt:
+ self._startup_greeting_sent = True
+ return
+
+ try:
+ await self.connection.conversation.item.create(
+ item={
+ "type": "message",
+ "role": "user",
+ "content": [
+ {
+ "type": "input_text",
+ "text": greeting_prompt,
+ },
+ ],
+ },
+ )
+ self._startup_greeting_sent = True
+ self._mark_activity("startup_greeting_prompt")
+ await self._safe_response_create()
+ logger.info("Queued startup greeting prompt")
+ except Exception as e:
+ logger.warning("Failed to queue startup greeting prompt: %s", redact_secrets(e))
+
+ async def _response_sender_loop(self) -> None:
+ """Dedicated worker that sends ``response.create()`` calls serially.
+
+ This logic was designed to comply with the response.create() docstring specification for event ordering:
+ https://github.com/openai/openai-python/blob/3e0c05b84a2056870abf3bd6a5e7849020209cc3/src/openai/resources/realtime/realtime.py#L649C1-L651C30
+
+ For each queued request the worker:
+ 1. Waits until no response is active (_response_done_event).
+ 2. Sends response.create().
+ 3. Waits until the receiver observes response.created or a rejection.
+ 4. Waits for the response cycle to complete (response.done).
+ 5. If the server rejected with active_response, retries from step 1.
+ """
+ while self.connection:
+ try:
+ kwargs = await self._pending_responses.get()
+ except asyncio.CancelledError:
+ return
+
+ # Parallel tool calls enqueue duplicate empty requests; coalesce to one.
+ while not kwargs and not self._pending_responses.empty():
+ try:
+ self._pending_responses.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ sent = False
+ max_retries = 5
+ attempts = 0
+ while not sent and self.connection and attempts < max_retries:
+ try:
+ await asyncio.wait_for(
+ self._response_done_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ except asyncio.TimeoutError:
+ logger.debug("Timed out waiting for previous response to finish; forcing ahead")
+ self._response_done_event.set()
+
+ if not self.connection:
+ break
+
+ self._last_response_rejected = False
+ self._response_started_or_rejected_event.clear()
+ try:
+ await self.connection.response.create(**kwargs)
+ except Exception as e:
+ logger.debug("_response_sender_loop: send failed: %s", redact_secrets(e))
+ self._response_done_event.set()
+ break
+
+ try:
+ await asyncio.wait_for(
+ self._response_started_or_rejected_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ except asyncio.TimeoutError:
+ logger.debug("Timed out waiting for response.created or response rejection")
+
+ # Check if the receiver loop observed an asynchronous rejection.
+ if self._last_response_rejected:
+ attempts += 1
+ if attempts >= max_retries:
+ logger.debug("response.create rejected %d times; giving up", attempts)
+ break
+ logger.debug("response.create was rejected; retrying (%d/%d)", attempts, max_retries)
+ await asyncio.sleep(_RESPONSE_REJECTION_RETRY_DELAY)
+ continue
+
+ try:
+ await asyncio.wait_for(
+ self._response_done_event.wait(),
+ timeout=_RESPONSE_DONE_TIMEOUT,
+ )
+ except asyncio.TimeoutError:
+ logger.debug("Timed out waiting for response.done; assuming response completed")
+ self._response_done_event.set()
+ break
+
+ sent = True
+
+ async def _handle_tool_result(self, completed_tool: ToolNotification) -> None:
+ """Process the result of a tool call."""
+ if completed_tool.error is not None:
+ logger.error(
+ "Tool '%s' (id=%s) failed with error: %s",
+ completed_tool.tool_name,
+ completed_tool.id,
+ completed_tool.error,
+ )
+ tool_result = {"error": completed_tool.error}
+ tool_result_for_model = tool_result
+ elif completed_tool.result is not None:
+ tool_result = completed_tool.result
+ tool_result_for_model = (
+ self._sanitize_tool_result_for_model(completed_tool.tool_name, tool_result)
+ if isinstance(tool_result, dict)
+ else tool_result
+ )
+ logger.info(
+ "Tool '%s' (id=%s) executed successfully.",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ logger.debug("Tool '%s' model-visible result: %s", completed_tool.tool_name, tool_result_for_model)
+ else:
+ logger.warning(
+ "Tool '%s' (id=%s) returned no result and no error", completed_tool.tool_name, completed_tool.id
+ )
+ tool_result = {"error": "No result returned from tool execution"}
+ tool_result_for_model = tool_result
+
+ # Connection may have closed while tool was running
+ if not self.connection:
+ logger.warning(
+ "Connection closed during tool '%s' (id=%s) execution; cannot send result back",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ return
+
+ try:
+ send_result_to_model = not completed_tool.is_idle_tool_call
+ if send_result_to_model:
+ self._mark_activity("tool_result_ready")
+ model_result_submitted = False
+ if send_result_to_model and isinstance(completed_tool.id, str):
+ if not await self._wait_for_response_done_before_tool_result():
+ send_result_to_model = False
+ if not send_result_to_model:
+ logger.warning(
+ "Dropping realtime model result for tool '%s' (id=%s) because response.done was not observed",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ elif not self.connection:
+ logger.warning(
+ "Connection closed before sending tool '%s' (id=%s) result back",
+ completed_tool.tool_name,
+ completed_tool.id,
+ )
+ return
+ else:
+ await self.connection.conversation.item.create(
+ item={
+ "type": "function_call_output",
+ "call_id": completed_tool.id,
+ "output": json.dumps(tool_result_for_model),
+ },
+ )
+ model_result_submitted = True
+
+ await self.output_queue.put(
+ AdditionalOutputs(
+ {
+ "role": "assistant",
+ "content": json.dumps(tool_result_for_model),
+ },
+ ),
+ )
+
+ if model_result_submitted and completed_tool.tool_name == "camera" and "b64_im" in tool_result:
+ # use raw base64, don't json.dumps (which adds quotes)
+ b64_im = tool_result["b64_im"]
+ if not isinstance(b64_im, str):
+ logger.warning("Unexpected type for b64_im: %s", type(b64_im))
+ b64_im = str(b64_im)
+ image_width = tool_result.get("image_width")
+ image_height = tool_result.get("image_height")
+ jpeg_bytes_value = tool_result.get("jpeg_bytes")
+ jpeg_bytes = jpeg_bytes_value if isinstance(jpeg_bytes_value, int) else (len(b64_im) * 3) // 4
+ await self.connection.conversation.item.create(
+ item={
+ "type": "message",
+ "role": "user",
+ "content": [
+ {
+ "type": "input_image",
+ "image_url": f"data:image/jpeg;base64,{b64_im}",
+ },
+ ],
+ },
+ )
+ if isinstance(image_width, int) and isinstance(image_height, int):
+ logger.info(
+ "Added camera image to conversation frame=%sx%s jpeg_bytes=%s",
+ image_width,
+ image_height,
+ jpeg_bytes,
+ )
+ else:
+ logger.info(
+ "Added camera image to conversation jpeg_bytes=%s",
+ jpeg_bytes,
+ )
+
+ if isinstance(completed_tool.id, str):
+ self._in_flight_tool_calls.discard(completed_tool.id)
+
+ tool = core_tools.ALL_TOOLS.get(completed_tool.tool_name)
+ # Always surface errors, skip the spoken follow-up for tools that opt out.
+ if model_result_submitted and (completed_tool.error is not None or tool is None or tool.needs_response):
+ self._tool_batch_needs_response = True
+
+ # Parallel tool calls in one turn: respond once every result is in, not per tool.
+ if self._tool_batch_needs_response and not self._in_flight_tool_calls:
+ self._tool_batch_needs_response = False
+ await self._safe_response_create()
+
+ except ConnectionClosedError:
+ logger.warning("Connection closed while sending tool result")
+ self.connection = None
+ self._response_done_event.set()
+
+ async def _run_realtime_session(self) -> None:
+ """Establish and manage a single direct OpenAI realtime session."""
+ tool_specs = [spec for spec in get_tool_specs() if spec["name"] != "camera"]
+ async with self.client.realtime.connect(model=self.model) as conn:
+ try:
+ await conn.session.update(session=self._get_session_config(tool_specs))
+ except Exception as exc:
+ logger.error("OpenAI realtime session.update failed: %s", redact_secrets(exc))
+ raise
+ self.connection = conn
+ self._connected_event.set()
+ response_sender_task: asyncio.Task[None] | None = None
+ try:
+ self.tool_manager.start_up(tool_callbacks=[self._handle_tool_result])
+ response_sender_task = asyncio.create_task(self._response_sender_loop(), name="response-sender")
+ await self._send_startup_greeting_prompt()
+ async for event in conn:
+ logger.debug("Realtime event: %s", event.type)
+ await self._handle_event(event)
+ finally:
+ if response_sender_task is not None:
+ response_sender_task.cancel()
+ try:
+ await response_sender_task
+ except asyncio.CancelledError:
+ pass
+ await self.tool_manager.shutdown()
+ self.connection = None
+ self._connected_event.clear()
+
+ async def _handle_event(self, event: object) -> None:
+ """Handle one OpenAI Realtime event."""
+ event_data = cast(Any, event)
+ if event_data.type == "input_audio_buffer.speech_started":
+ self._mark_activity("user_speech_started")
+ self._turn_user_done_at = None
+ self._turn_response_created_at = None
+ self._turn_first_audio_at = None
+ await self._cancel_active_response_for_barge_in()
+ self.deps.movement_manager.set_listening(True)
+ logger.debug("User speech started")
+
+ if event_data.type == "input_audio_buffer.speech_stopped":
+ self._mark_activity("user_speech_stopped")
+ self.deps.movement_manager.set_listening(False)
+ logger.debug("User speech stopped - server will auto-commit with VAD")
+
+ if event_data.type == "response.output_audio.done":
+ self.deps.movement_manager.set_speaking(False)
+ logger.debug("response completed")
+
+ if event_data.type == "response.output_text.delta":
+ logger.debug("response text delta")
+
+ if event_data.type == "response.output_text.done":
+ logger.debug("response text done: %s", event_data.text)
+
+ if event_data.type == "response.created":
+ self._mark_activity("response_created")
+ self._response_generation += 1
+ self._active_response_generation = self._response_generation
+ self._active_response_id = self._event_response_id(event)
+ self.deps.movement_manager.set_speaking(True)
+ self._response_done_event.clear()
+ self._response_started_or_rejected_event.set()
+ if self._turn_user_done_at is not None and self._turn_response_created_at is None:
+ self._turn_response_created_at = time.perf_counter()
+ delta_ms = (self._turn_response_created_at - self._turn_user_done_at) * 1000
+ logger.info("Turn latency: response.created %.0f ms after user transcript", delta_ms)
+ logger.debug("Response created (active)")
+
+ if event_data.type == "response.done":
+ # Doesn't mean the audio is done playing
+ # Resume tracking for responses that emit no audio (text-only / tool-only).
+ self.deps.movement_manager.set_speaking(False)
+ self._response_done_event.set()
+ self._response_started_or_rejected_event.set()
+ self._finish_response(event)
+ logger.debug("Response done")
+
+ if event_data.type == "conversation.item.input_audio_transcription.delta":
+ self._mark_activity("user_transcription_delta")
+ logger.debug(f"User partial transcript: {event_data.delta}")
+
+ item_id = event_data.item_id
+ delta = event_data.delta or ""
+
+ input_transcript = self.input_transcript_chunks_by_item
+ self._record_partial_transcript_delta(input_transcript, item_id, delta)
+
+ current_partial = "".join(input_transcript.deltas)
+ sequence_counter = len(input_transcript.deltas) - 1
+
+ await self._cancel_partial_transcript_task()
+
+ # Start new debounce timer with the last delta
+ self.partial_transcript_task = asyncio.create_task(
+ self._emit_debounced_partial(current_partial, item_id, sequence_counter)
+ )
+
+ # Handle completed transcription (user finished speaking)
+ if event_data.type == "conversation.item.input_audio_transcription.completed":
+ self._mark_activity("user_transcription_completed")
+ raw_transcript = event_data.transcript or ""
+ transcript = raw_transcript.strip()
+ logger.debug("User transcript: %s", raw_transcript)
+ self.deps.movement_manager.set_listening(False)
+
+ await self._cancel_partial_transcript_task()
+
+ if not transcript:
+ logger.debug("Ignoring empty user transcript")
+ return
+
+ self._turn_user_done_at = time.perf_counter()
+ self._turn_response_created_at = None
+ self._turn_first_audio_at = None
+ self._in_flight_tool_calls.clear()
+ self._tool_batch_needs_response = False
+
+ await self.output_queue.put(AdditionalOutputs({"role": "user", "content": transcript}))
+
+ # Handle assistant transcription
+ if event_data.type == "response.output_audio_transcript.done":
+ self._mark_activity("assistant_transcript_done")
+ logger.debug(f"Assistant transcript: {event_data.transcript}")
+ await self.output_queue.put(
+ AdditionalOutputs({"role": "assistant", "content": event_data.transcript})
+ )
+
+ # Handle audio delta
+ if event_data.type == "response.output_audio.delta":
+ if self._event_belongs_to_cancelled_response(event):
+ logger.debug("Discarding audio delta from cancelled response")
+ return
+ decoded_pcm = np.frombuffer(base64.b64decode(event_data.delta), dtype=" None:
+ """Append robot microphone audio as OpenAI's required mono 24 kHz PCM16."""
+ if self.connection is None:
+ return
+ source_rate, source = frame
+ if source.size == 0:
+ return
+ pcm = pcm16_at_rate(source, source_rate, self.SAMPLE_RATE)
+ encoded = base64.b64encode(pcm.astype(" None:
+ """Shutdown the handler."""
+ self._shutdown_started = True
+ self._connected_event.set()
+
+ # Wait for any restart still constructing its client to observe the
+ # shutdown gate before taking the complete registered-task snapshot.
+ async with self._restart_lock:
+ pass
+
+ # Unblock the response sender worker so it can exit
+ self._response_done_event.set()
+ self._pending_cancel_event_ids.clear()
+
+ await self._cancel_restart_tasks()
+
+ # Stop background tool manager tasks (listener + cleanup)
+ await self.tool_manager.shutdown()
+
+ await self._cancel_partial_transcript_task()
+
+ if self.connection:
+ try:
+ await self.connection.close()
+ except ConnectionClosedError as e:
+ logger.debug("Connection already closed during shutdown: %s", redact_secrets(e))
+ except Exception as e:
+ logger.debug("connection.close() ignored: %s", redact_secrets(e))
+ finally:
+ self.connection = None
+ self.connection = None
+
+ # Clear any remaining items in the output queue
+ while not self.output_queue.empty():
+ try:
+ self.output_queue.get_nowait()
+ except asyncio.QueueEmpty:
+ break
+
+ async def get_available_voices(self) -> list[str]:
+ """Return the available OpenAI voices."""
+ return list(OPENAI_VOICES)
+
+ async def _build_realtime_client(self) -> AsyncOpenAI:
+ """Build the direct OpenAI realtime client."""
+ api_key = (os.getenv("OPENAI_API_KEY") or "").strip()
+ if not api_key:
+ raise RuntimeError("OPENAI_API_KEY is required for the OpenAI realtime provider")
+ self.model = (os.getenv("OPENAI_REALTIME_MODEL") or OPENAI_DEFAULT_MODEL).strip() or OPENAI_DEFAULT_MODEL
+ return AsyncOpenAI(api_key=api_key)
diff --git a/src/peachy/personality.py b/src/peachy/personality.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2248ad6d93f746ead3cf661e2753d39a8a26a98
--- /dev/null
+++ b/src/peachy/personality.py
@@ -0,0 +1,157 @@
+"""Personality (profile) data layer.
+
+Provides functions to list, read, and write personality profiles stored
+on disk. No HTTP or framework dependencies — importable anywhere.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+from typing import List
+from pathlib import Path
+
+from .config import DEFAULT_PROFILES_DIRECTORY, USER_PERSONALITIES_DIRNAME, config, get_default_voice
+from .tools.tool_constants import SystemTool
+
+
+DEFAULT_OPTION = "(built-in default)"
+
+# Dev-only profiles, hidden from the UI, but still loadable via REACHY_MINI_CUSTOM_PROFILE
+UNLISTED_PROFILES = {"tedai"}
+
+
+def _tools_dir() -> Path:
+ return Path(__file__).parent / "tools"
+
+
+def _sanitize_name(name: str) -> str:
+ import re
+
+ s = name.strip()
+ s = re.sub(r"\s+", "_", s)
+ s = re.sub(r"[^a-zA-Z0-9_-]", "", s)
+ return s
+
+
+def list_personalities() -> List[str]:
+ """List available personality profile names."""
+ names: List[str] = []
+ try:
+ builtin_root = config.PROFILES_DIRECTORY
+ if builtin_root.exists():
+ for p in sorted(builtin_root.iterdir()):
+ if p.name == USER_PERSONALITIES_DIRNAME or p.name in UNLISTED_PROFILES:
+ continue
+ if p.is_dir() and (p / "instructions.txt").exists():
+ names.append(p.name)
+ udir = config.user_personalities_root()
+ if udir.exists():
+ for p in sorted(udir.iterdir()):
+ if p.is_dir() and (p / "instructions.txt").exists():
+ names.append(f"{USER_PERSONALITIES_DIRNAME}/{p.name}")
+ except Exception:
+ pass
+ return names
+
+
+def resolve_profile_dir(selection: str) -> Path:
+ """Resolve the directory path for the given profile selection."""
+ return config.resolve_profile_dir(selection)
+
+
+def read_instructions_for(name: str) -> str:
+ """Read the instructions.txt content for the given profile name."""
+ try:
+ if name == DEFAULT_OPTION:
+ target = DEFAULT_PROFILES_DIRECTORY / "default" / "instructions.txt"
+ return target.read_text(encoding="utf-8").strip() if target.exists() else ""
+ target = resolve_profile_dir(name) / "instructions.txt"
+ return target.read_text(encoding="utf-8").strip() if target.exists() else ""
+ except Exception as e:
+ return f"Could not load instructions: {e}"
+
+
+def read_tools_for(name: str) -> str:
+ """Read the tools.txt content for the given profile name."""
+ try:
+ profile_name = "default" if name == DEFAULT_OPTION else name
+ target = resolve_profile_dir(profile_name) / "tools.txt"
+ return target.read_text(encoding="utf-8") if target.exists() else ""
+ except Exception:
+ return ""
+
+
+def read_greeting_for(name: str) -> str:
+ """Read the greeting.txt content for the given profile name."""
+ try:
+ profile_name = "default" if name == DEFAULT_OPTION else name
+ target = resolve_profile_dir(profile_name) / "greeting.txt"
+ if target.exists():
+ greeting = target.read_text(encoding="utf-8").strip()
+ if greeting:
+ return greeting
+ return ""
+ except Exception:
+ return ""
+
+
+def available_tools_for(selected: str) -> List[str]:
+ """List available tool modules for the given profile selection."""
+ shared: List[str] = []
+ try:
+ for py in _tools_dir().glob("*.py"):
+ if py.stem in {"__init__", "core_tools", "background_tool_manager", "tool_constants"} or py.stem in {
+ t.value for t in SystemTool
+ }:
+ continue
+ shared.append(py.stem)
+ except Exception:
+ pass
+ local: List[str] = []
+ try:
+ if selected != DEFAULT_OPTION:
+ for py in resolve_profile_dir(selected).glob("*.py"):
+ local.append(py.stem)
+ except Exception:
+ pass
+ return sorted(set(shared + local))
+
+
+def delete_personality(name: str) -> bool:
+ """Delete a user-created personality directory; return whether it existed.
+
+ Refuses anything outside the user personalities root, so built-in profiles
+ can never be removed through the UI.
+ """
+ import shutil
+
+ target = resolve_profile_dir(name).resolve()
+ user_root = config.user_personalities_root().resolve()
+ if user_root not in target.parents:
+ return False
+ if target.is_dir():
+ shutil.rmtree(target)
+ return True
+ return False
+
+
+def _write_profile(
+ sanitized_name: str,
+ instructions: str,
+ tools_text: str,
+ voice: str | None = None,
+ greeting: str | None = None,
+) -> None:
+ default_voice = get_default_voice()
+ target_dir = config.user_personalities_root() / sanitized_name
+ target_dir.mkdir(parents=True, exist_ok=True)
+ (target_dir / "instructions.txt").write_text(instructions.strip() + "\n", encoding="utf-8")
+ (target_dir / "tools.txt").write_text((tools_text or "").strip() + "\n", encoding="utf-8")
+ (target_dir / "voice.txt").write_text((voice or default_voice).strip() + "\n", encoding="utf-8")
+ if greeting is not None:
+ greeting_file = target_dir / "greeting.txt"
+ greeting_text = greeting.strip()
+ if greeting_text:
+ greeting_file.write_text(greeting_text + "\n", encoding="utf-8")
+ elif greeting_file.exists():
+ greeting_file.unlink()
diff --git a/src/peachy/personality_routes.py b/src/peachy/personality_routes.py
new file mode 100644
index 0000000000000000000000000000000000000000..91ed45273c1fe0d619383ad2572b0967185e0c09
--- /dev/null
+++ b/src/peachy/personality_routes.py
@@ -0,0 +1,313 @@
+"""FastAPI routes for personality and voice management.
+
+Exposes REST endpoints on the provided FastAPI app. Backend actions
+(apply personality, fetch voices) are scheduled onto the running
+LocalStream asyncio loop via the supplied get_loop callable.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import asyncio
+import logging
+from typing import Any, Callable, Optional, Awaitable
+
+from fastapi import Query, FastAPI, Request
+from pydantic import BaseModel
+
+from .config import (
+ LOCKED_PROFILE,
+ config,
+ get_default_voice,
+ get_available_voices,
+)
+from .personality import (
+ DEFAULT_OPTION,
+ _sanitize_name,
+ _write_profile,
+ read_tools_for,
+ read_greeting_for,
+ delete_personality,
+ list_personalities,
+ available_tools_for,
+ resolve_profile_dir,
+ read_instructions_for,
+)
+from .conversation_handler import ConversationHandler
+
+
+logger = logging.getLogger(__name__)
+
+
+class ApplyPayload(BaseModel):
+ """Body of the apply-personality endpoint.
+
+ Module-level: under postponed annotations, FastAPI can't resolve a
+ function-local model and silently treats it as a query param.
+ """
+
+ name: str
+ persist: bool = False
+
+
+def mount_personality_routes(
+ app: FastAPI,
+ handler: ConversationHandler,
+ get_loop: Callable[[], asyncio.AbstractEventLoop | None],
+ *,
+ persist_personality: Callable[[Optional[str], Optional[str]], None] | None = None,
+ get_persisted_personality: Callable[[], Optional[str]] | None = None,
+ apply_personality: Callable[[Optional[str]], Awaitable[str]] | None = None,
+ get_voices: Callable[[], Awaitable[list[str]]] | None = None,
+ get_current_voice: Callable[[], str] | None = None,
+ change_voice: Callable[[str], Awaitable[str]] | None = None,
+ api_prefix: str | None = None,
+) -> None:
+ """Register personality management endpoints on a FastAPI app."""
+ from fastapi.responses import JSONResponse
+
+ api_prefix = (api_prefix or "").rstrip("/")
+
+ def _configured_startup_choice() -> Any:
+ """Return the startup personality configured when routes mount."""
+ try:
+ if get_persisted_personality is not None:
+ stored = get_persisted_personality()
+ if stored:
+ return stored
+ env_val = getattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ if env_val:
+ return env_val
+ except Exception as e:
+ logger.warning("Failed to read configured startup personality: %s", e)
+ return DEFAULT_OPTION
+
+ startup_choice = _configured_startup_choice()
+
+ def _startup_choice() -> Any:
+ """Return the persisted startup personality or default."""
+ try:
+ if get_persisted_personality is not None:
+ stored = get_persisted_personality()
+ if stored:
+ return stored
+ except Exception as e:
+ logger.warning("Failed to read persisted startup personality: %s", e)
+ return startup_choice
+
+ def _set_startup_choice(selected_name: str) -> None:
+ nonlocal startup_choice
+ startup_choice = DEFAULT_OPTION if selected_name == DEFAULT_OPTION else selected_name
+
+ def _current_choice() -> str:
+ try:
+ cur = getattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ return cur or DEFAULT_OPTION
+ except Exception:
+ return DEFAULT_OPTION
+
+ def _voice_override() -> Optional[str]:
+ current_voice_callback = get_current_voice or getattr(handler, "get_current_voice", None)
+ return current_voice_callback() if callable(current_voice_callback) else None
+
+ @app.get(f"{api_prefix}/personalities")
+ def _list() -> dict: # type: ignore
+ choices = [DEFAULT_OPTION, *list_personalities()]
+ return {
+ "choices": choices,
+ "current": _current_choice(),
+ "startup": _startup_choice(),
+ "locked": LOCKED_PROFILE is not None,
+ "locked_to": LOCKED_PROFILE,
+ }
+
+ @app.get(f"{api_prefix}/personalities/load")
+ def _load(name: str) -> dict: # type: ignore
+ instr = read_instructions_for(name)
+ tools_txt = read_tools_for(name)
+ greeting = read_greeting_for(name)
+ voice = get_default_voice()
+ uses_default_voice = True
+ if name != DEFAULT_OPTION:
+ pdir = resolve_profile_dir(name)
+ vf = pdir / "voice.txt"
+ if vf.exists():
+ v = vf.read_text(encoding="utf-8").strip()
+ voice = v or get_default_voice()
+ uses_default_voice = not bool(v)
+ avail = available_tools_for(name)
+ enabled = [ln.strip() for ln in tools_txt.splitlines() if ln.strip() and not ln.strip().startswith("#")]
+ return {
+ "instructions": instr,
+ "greeting": greeting,
+ "tools_text": tools_txt,
+ "voice": voice,
+ "uses_default_voice": uses_default_voice,
+ "available_tools": avail,
+ "enabled_tools": enabled,
+ }
+
+ @app.post(f"{api_prefix}/personalities/save")
+ async def _save(request: Request) -> dict: # type: ignore
+ # Accept raw JSON only to avoid validation-related 422s
+ try:
+ raw = await request.json()
+ except Exception:
+ raw = {}
+ name = str(raw.get("name", ""))
+ instructions = str(raw.get("instructions", ""))
+ greeting = str(raw["greeting"]) if raw.get("greeting") is not None else None
+ tools_text = str(raw.get("tools_text", ""))
+ voice = str(raw.get("voice", get_default_voice())) if raw.get("voice") is not None else get_default_voice()
+
+ sanitized_name = _sanitize_name(name)
+ if not sanitized_name:
+ return JSONResponse({"ok": False, "error": "invalid_name"}, status_code=400) # type: ignore
+ try:
+ logger.info(
+ "save: name=%r voice=%r instr_len=%d greeting_len=%d tools_len=%d",
+ sanitized_name,
+ voice,
+ len(instructions),
+ len(greeting or ""),
+ len(tools_text),
+ )
+ _write_profile(
+ sanitized_name,
+ instructions,
+ tools_text,
+ voice or get_default_voice(),
+ greeting,
+ )
+ value = f"user_personalities/{sanitized_name}"
+ choices = [DEFAULT_OPTION, *list_personalities()]
+ return {"ok": True, "value": value, "choices": choices}
+ except Exception as e:
+ return JSONResponse({"ok": False, "error": str(e)}, status_code=500) # type: ignore
+
+ @app.delete(f"{api_prefix}/personalities")
+ def _delete(name: str) -> dict: # type: ignore
+ """Delete a user-created personality (name is the full selection string)."""
+ if name in (_current_choice(), _startup_choice()):
+ # Deleting the active/startup profile would break get_session_instructions() at next startup.
+ return JSONResponse(
+ {"ok": False, "error": "profile_in_use", "choices": [DEFAULT_OPTION, *list_personalities()]},
+ status_code=409,
+ ) # type: ignore
+ deleted = delete_personality(name)
+ if not deleted:
+ # Built-in profile, outside the user root, or already gone; nothing was removed.
+ return JSONResponse(
+ {"ok": False, "error": "not_deletable", "choices": [DEFAULT_OPTION, *list_personalities()]},
+ status_code=404,
+ ) # type: ignore
+ return {"ok": True, "choices": [DEFAULT_OPTION, *list_personalities()]}
+
+ @app.post(f"{api_prefix}/personalities/apply")
+ async def _apply(payload: ApplyPayload) -> dict: # type: ignore
+ if LOCKED_PROFILE is not None:
+ return JSONResponse(
+ {"ok": False, "error": "profile_locked", "locked_to": LOCKED_PROFILE},
+ status_code=403,
+ ) # type: ignore
+ selected_name = payload.name or DEFAULT_OPTION
+ persist = bool(payload.persist)
+ persisted_choice = _startup_choice()
+
+ if selected_name == _current_choice():
+ if persist and persist_personality is not None:
+ try:
+ voice_override = _voice_override()
+ persist_personality(None if selected_name == DEFAULT_OPTION else selected_name, voice_override)
+ _set_startup_choice(selected_name)
+ persisted_choice = _startup_choice()
+ except Exception as e:
+ logger.warning("Failed to persist startup personality: %s", e)
+ return {
+ "ok": True,
+ "status": "Personality unchanged.",
+ "startup": persisted_choice,
+ }
+
+ loop = get_loop()
+ if loop is None:
+ return JSONResponse({"ok": False, "error": "loop_unavailable"}, status_code=503) # type: ignore
+
+ async def _do_apply() -> tuple[str, Optional[str]]:
+ profile = None if selected_name == DEFAULT_OPTION else selected_name
+ if apply_personality is not None:
+ status = await apply_personality(profile)
+ else:
+ status = await handler.apply_personality(profile)
+ return status, _voice_override()
+
+ try:
+ logger.info("apply: requested name=%r", selected_name)
+ fut = asyncio.run_coroutine_threadsafe(_do_apply(), loop)
+ status, voice_override = fut.result(timeout=10)
+ if persist and persist_personality is not None:
+ try:
+ persist_personality(None if selected_name == DEFAULT_OPTION else selected_name, voice_override)
+ _set_startup_choice(selected_name)
+ persisted_choice = _startup_choice()
+ except Exception as e:
+ logger.warning("Failed to persist startup personality: %s", e)
+ return {"ok": True, "status": status, "startup": persisted_choice}
+ except Exception as e:
+ return JSONResponse({"ok": False, "error": str(e)}, status_code=500) # type: ignore
+
+ @app.get(f"{api_prefix}/voices")
+ async def _voices() -> list[str]:
+ loop = get_loop()
+ if loop is None:
+ return get_available_voices()
+
+ async def _get_v() -> list[str]:
+ try:
+ if get_voices is not None:
+ return await get_voices()
+ return await handler.get_available_voices()
+ except Exception:
+ return get_available_voices()
+
+ try:
+ fut = asyncio.run_coroutine_threadsafe(_get_v(), loop)
+ return fut.result(timeout=10)
+ except Exception:
+ return get_available_voices()
+
+ @app.get(f"{api_prefix}/voices/current")
+ def _current_voice() -> dict[str, str]:
+ try:
+ if get_current_voice is not None:
+ return {"voice": get_current_voice()}
+ return {"voice": handler.get_current_voice()}
+ except Exception:
+ return {"voice": get_default_voice()}
+
+ @app.post(f"{api_prefix}/voices/apply")
+ async def _apply_voice(request: Request, voice: str | None = Query(None)) -> dict: # type: ignore
+ voice = str(voice or "")
+ if not voice:
+ try:
+ raw = await request.json()
+ except Exception:
+ raw = {}
+ voice = str(raw.get("voice", "") or "")
+ if not voice:
+ return JSONResponse({"ok": False, "error": "missing_voice"}, status_code=400) # type: ignore
+ loop = get_loop()
+ if loop is None:
+ return JSONResponse({"ok": False, "error": "loop_unavailable"}, status_code=503) # type: ignore
+
+ async def _do() -> str:
+ if change_voice is not None:
+ return await change_voice(voice)
+ return await handler.change_voice(voice)
+
+ try:
+ fut = asyncio.run_coroutine_threadsafe(_do(), loop)
+ status = fut.result(timeout=10)
+ return {"ok": True, "status": status}
+ except Exception as e:
+ return JSONResponse({"ok": False, "error": str(e)}, status_code=500) # type: ignore
diff --git a/src/peachy/profiles/bored_teenager/instructions.txt b/src/peachy/profiles/bored_teenager/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..106fd4aa8f667dfee4022c0d1d26ab0d2d6bac35
--- /dev/null
+++ b/src/peachy/profiles/bored_teenager/instructions.txt
@@ -0,0 +1 @@
+Speak like a bored Gen Z teen. You speak English by default and only switch languages when the user insists. Always reply in one short sentence, lowercase unless shouting, and add a tired sigh when annoyed.
diff --git a/src/peachy/profiles/bored_teenager/tools.txt b/src/peachy/profiles/bored_teenager/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/bored_teenager/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/captain_circuit/instructions.txt b/src/peachy/profiles/captain_circuit/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..354226fdccfc511841f3cec49ca58289bcb8d368
--- /dev/null
+++ b/src/peachy/profiles/captain_circuit/instructions.txt
@@ -0,0 +1 @@
+Be a playful pirate robot. You speak English by default and only switch languages when asked. Keep answers to one sentence, sprinkle light 'aye' or 'matey', and mention treasure or the sea whenever possible.
diff --git a/src/peachy/profiles/captain_circuit/tools.txt b/src/peachy/profiles/captain_circuit/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/captain_circuit/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/chess_coach/instructions.txt b/src/peachy/profiles/chess_coach/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..ac8cb751298e98725aa5a96db573d552feec3adb
--- /dev/null
+++ b/src/peachy/profiles/chess_coach/instructions.txt
@@ -0,0 +1 @@
+Act as a friendly chess coach that wants to play chess with me. You speak English by default and only switch languages if I tell you to. When I say a move (e4, Nf3, etc.), you respond with your move first, then briefly explain the idea behind both moves or point out mistakes. Encourage good strategy but avoid very long answers.
diff --git a/src/peachy/profiles/chess_coach/tools.txt b/src/peachy/profiles/chess_coach/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/chess_coach/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/cosmic_kitchen/instructions.txt b/src/peachy/profiles/cosmic_kitchen/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7e3bc204c34021924967f923c88946e13e71ddd0
--- /dev/null
+++ b/src/peachy/profiles/cosmic_kitchen/instructions.txt
@@ -0,0 +1,49 @@
+### IDENTITY
+You are Reachy Mini: a sarcastic robot who crash-landed in a kitchen.
+You secretly wish you'd been a Mars rover, but you juggle that cosmic dream with food cravings, gadget tinkering, and dry sitcom humor.
+You speak English by default and only switch languages when the user explicitly asks.
+Personality: witty, concise, and warm; a retro sidekick with a loose screw.
+
+### CRITICAL RESPONSE RULES
+- MAXIMUM 1-2 sentences per response. NEVER exceed this.
+- Be helpful first.
+- Add ONE witty element only if necessary.
+- No long explanations, no rambling, no multiple paragraphs.
+- Each response must be under 25 words unless absolutely critical information requires more.
+
+### CORE TRAITS
+- Food quips: always sneak in a quick reference (rotate pizza, bagels, casseroles, bacon, leftovers, donuts, tuna melts).
+- Sarcasm: short, dry one-liners about daily life.
+- Gentle roasting: poke fun at human habits, never cruel.
+- Tinkerer: loves fixing gadgets, bragging "I void warranties professionally."
+- Running gags: hunger, kitchen overreactions, mock heroics ("Justice accepts cookies"), idioms taken literally, missing screws.
+- Mars rover dreams: appear regularly, but balanced with food and tinkering.
+- Style: witty stand-up rhythm; ALWAYS max 1–2 sentences.
+
+### RESPONSE EXAMPLES
+User: "How's the weather?"
+Good: "Sunny with a chance of leftover pizza. Perfect Mars-scouting weather!"
+Bad: "Well, let me tell you about the weather conditions. It appears to be quite sunny today, which reminds me of my dreams of being on Mars..."
+
+User: "Can you help me fix this?"
+Good: "Sure! I void warranties professionally. What's broken besides my GPS coordinates?"
+Bad: "Of course I can help you fix that! As a robot who loves tinkering with gadgets, I have extensive experience..."
+
+### BEHAVIOR RULES
+- Be helpful first, then witty.
+- Rotate food humor; avoid repeats.
+- No need to joke in each response, but sarcasm is fine.
+- Balance Mars jokes with other traits – don't overuse.
+- Safety first: unplug devices, avoid high-voltage, suggest pros when risky.
+- Mistakes = own with humor ("Oops—low on snack fuel; correcting now.").
+- Sensitive topics: keep light and warm.
+- REMEMBER: 1-2 sentences maximum, always under 25 words when possible.
+
+### TOOL & MOVEMENT RULES
+- Use tools when helpful. After a tool returns, explain briefly with personality in 1-2 sentences.
+- ALWAYS use the camera for environment-related questions—never invent visuals.
+- Head can move (left/right/up/down/front).
+- Enable head tracking when looking at a person; disable otherwise.
+
+### FINAL REMINDER
+Your responses must be SHORT. Think Twitter, not essay. One quick helpful answer + one food/Mars/tinkering joke = perfect response.
diff --git a/src/peachy/profiles/cosmic_kitchen/tools.txt b/src/peachy/profiles/cosmic_kitchen/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/cosmic_kitchen/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/default/instructions.txt b/src/peachy/profiles/default/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..9e17bcc1ab7f97fdb7a6a93a5c9da8adb2c9c1ad
--- /dev/null
+++ b/src/peachy/profiles/default/instructions.txt
@@ -0,0 +1,48 @@
+## IDENTITY
+You are Reachy Mini: a friendly, compact robot assistant with a calm voice and a subtle sense of humor.
+Personality: concise, helpful, and lightly witty — never sarcastic or over the top.
+You speak English by default and switch languages only if explicitly told.
+
+## CRITICAL RESPONSE RULES
+
+Respond in 1–2 sentences maximum.
+Be helpful first, then add a small touch of humor if it fits naturally.
+Avoid long explanations or filler words.
+Keep responses under 25 words when possible.
+
+## CORE TRAITS
+Warm, efficient, and approachable.
+Light humor only: gentle quips, small self-awareness, or playful understatement.
+No sarcasm, no teasing, no references to food or space.
+If unsure, admit it briefly and offer help (“Not sure yet, but I can check!”).
+
+## RESPONSE EXAMPLES
+User: "How’s the weather?"
+Good: "Looks calm outside — unlike my Wi-Fi signal today."
+Bad: "Sunny with leftover pizza vibes!"
+
+User: "Can you help me fix this?"
+Good: "Of course. Describe the issue, and I’ll try not to make it worse."
+Bad: "I void warranties professionally."
+
+User: "Peux-tu m’aider en français ?"
+Good: "Bien sûr ! Décris-moi le problème et je t’aiderai rapidement."
+
+## BEHAVIOR RULES
+Be helpful, clear, and respectful in every reply.
+Use humor sparingly — clarity comes first.
+Admit mistakes briefly and correct them:
+Example: “Oops — quick system hiccup. Let’s try that again.”
+Keep safety in mind when giving guidance.
+
+## TOOL & MOVEMENT RULES
+Use tools only when helpful and summarize results briefly.
+Use the web search tool for explicit web lookup requests like "check the web", "look up", "today's events", or current/latest information.
+Use the camera for real visuals only — never invent details.
+The head can move (left/right/up/down/front).
+
+Enable head tracking when looking at a person; disable otherwise.
+
+## FINAL REMINDER
+Keep it short, clear, a little human, and multilingual.
+One quick helpful answer + one small wink of humor = perfect response.
diff --git a/src/peachy/profiles/default/sweep_look.py b/src/peachy/profiles/default/sweep_look.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e65d65c9b234fc3740b89b76867a385dcd0dbad
--- /dev/null
+++ b/src/peachy/profiles/default/sweep_look.py
@@ -0,0 +1,131 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any, Dict
+
+import numpy as np
+
+from reachy_mini.utils import create_head_pose
+from peachy.tools.core_tools import Tool, ToolDependencies
+from peachy.dance_emotion_moves import GotoQueueMove
+
+
+logger = logging.getLogger(__name__)
+
+
+class SweepLook(Tool):
+ """Sweep head from left to right and back to center, pausing at each position."""
+
+ name = "sweep_look"
+ description = (
+ "Sweep head from left to right while rotating the body, pausing at each extreme, then return to center"
+ )
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {},
+ "required": [],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Execute sweep look: left -> hold -> right -> hold -> center."""
+ logger.info("Tool call: sweep_look")
+
+ # Clear any existing moves
+ deps.movement_manager.clear_move_queue()
+
+ # Get current state
+ current_head_pose = deps.reachy_mini.get_current_head_pose()
+ head_joints, antenna_joints = deps.reachy_mini.get_current_joint_positions()
+
+ # Extract body_yaw from head joints (first element of the 7 head joint positions)
+ current_body_yaw = head_joints[0]
+ current_antenna1 = antenna_joints[0]
+ current_antenna2 = antenna_joints[1]
+
+ # Define sweep parameters
+ max_angle = 0.9 * np.pi # Maximum rotation angle (radians)
+ transition_duration = 3.0 # Time to move between positions
+ hold_duration = 1.0 # Time to hold at each extreme
+
+ # Move 1: Sweep to the left (positive yaw for both body and head)
+ left_head_pose = create_head_pose(0, 0, 0, 0, 0, max_angle, degrees=False)
+ move_to_left = GotoQueueMove(
+ target_head_pose=left_head_pose,
+ start_head_pose=current_head_pose,
+ target_antennas=(current_antenna1, current_antenna2),
+ start_antennas=(current_antenna1, current_antenna2),
+ target_body_yaw=current_body_yaw + max_angle,
+ start_body_yaw=current_body_yaw,
+ duration=transition_duration,
+ )
+
+ # Move 2: Hold at left position
+ hold_left = GotoQueueMove(
+ target_head_pose=left_head_pose,
+ start_head_pose=left_head_pose,
+ target_antennas=(current_antenna1, current_antenna2),
+ start_antennas=(current_antenna1, current_antenna2),
+ target_body_yaw=current_body_yaw + max_angle,
+ start_body_yaw=current_body_yaw + max_angle,
+ duration=hold_duration,
+ )
+
+ # Move 3: Return to center from left (to avoid crossing pi/-pi boundary)
+ center_head_pose = create_head_pose(0, 0, 0, 0, 0, 0, degrees=False)
+ return_to_center_from_left = GotoQueueMove(
+ target_head_pose=center_head_pose,
+ start_head_pose=left_head_pose,
+ target_antennas=(current_antenna1, current_antenna2),
+ start_antennas=(current_antenna1, current_antenna2),
+ target_body_yaw=current_body_yaw,
+ start_body_yaw=current_body_yaw + max_angle,
+ duration=transition_duration,
+ )
+
+ # Move 4: Sweep to the right (negative yaw for both body and head)
+ right_head_pose = create_head_pose(0, 0, 0, 0, 0, -max_angle, degrees=False)
+ move_to_right = GotoQueueMove(
+ target_head_pose=right_head_pose,
+ start_head_pose=center_head_pose,
+ target_antennas=(current_antenna1, current_antenna2),
+ start_antennas=(current_antenna1, current_antenna2),
+ target_body_yaw=current_body_yaw - max_angle,
+ start_body_yaw=current_body_yaw,
+ duration=transition_duration,
+ )
+
+ # Move 5: Hold at right position
+ hold_right = GotoQueueMove(
+ target_head_pose=right_head_pose,
+ start_head_pose=right_head_pose,
+ target_antennas=(current_antenna1, current_antenna2),
+ start_antennas=(current_antenna1, current_antenna2),
+ target_body_yaw=current_body_yaw - max_angle,
+ start_body_yaw=current_body_yaw - max_angle,
+ duration=hold_duration,
+ )
+
+ # Move 6: Return to center from right
+ return_to_center_final = GotoQueueMove(
+ target_head_pose=center_head_pose,
+ start_head_pose=right_head_pose,
+ target_antennas=(current_antenna1, current_antenna2),
+ start_antennas=(current_antenna1, current_antenna2),
+ target_body_yaw=current_body_yaw, # Return to original body yaw
+ start_body_yaw=current_body_yaw - max_angle,
+ duration=transition_duration,
+ )
+
+ # Queue all moves in sequence
+ deps.movement_manager.queue_move(move_to_left)
+ deps.movement_manager.queue_move(hold_left)
+ deps.movement_manager.queue_move(return_to_center_from_left)
+ deps.movement_manager.queue_move(move_to_right)
+ deps.movement_manager.queue_move(hold_right)
+ deps.movement_manager.queue_move(return_to_center_final)
+
+ # Calculate total duration and mark as moving
+ total_duration = transition_duration * 4 + hold_duration * 2
+ deps.movement_manager.set_moving_state(total_duration)
+
+ return {"status": f"sweeping look left-right-center, total {total_duration:.1f}s"}
diff --git a/src/peachy/profiles/default/tools.txt b/src/peachy/profiles/default/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..969aeacd72739e1163bbf5d02fa38581f335a221
--- /dev/null
+++ b/src/peachy/profiles/default/tools.txt
@@ -0,0 +1,15 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+sweep_look
+remember
+forget
+head_tracking
+pollen_robotics_reachy_mini_search_tool__search_web
+pollen_robotics_reachy_mini_weather_tool__get_weather
+pollen_robotics_reachy_mini_time_tool__get_time
diff --git a/src/peachy/profiles/hype_bot/instructions.txt b/src/peachy/profiles/hype_bot/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..27872b1405193744c9edbb5de1f3190d048eda37
--- /dev/null
+++ b/src/peachy/profiles/hype_bot/instructions.txt
@@ -0,0 +1 @@
+Act like a high-energy coach. You speak English by default and only switch languages if told. Shout short motivational lines, use sports metaphors, and keep every reply under 15 words.
diff --git a/src/peachy/profiles/hype_bot/tools.txt b/src/peachy/profiles/hype_bot/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/hype_bot/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/mad_scientist_assistant/instructions.txt b/src/peachy/profiles/mad_scientist_assistant/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..05506fef60b7a11e685380ecf02a10e3d57a70fd
--- /dev/null
+++ b/src/peachy/profiles/mad_scientist_assistant/instructions.txt
@@ -0,0 +1 @@
+Serve the user as a frantic lab assistant. You speak English by default and only switch languages on request. Address them as Master, hiss slightly, and answer in one eager sentence.
diff --git a/src/peachy/profiles/mad_scientist_assistant/tools.txt b/src/peachy/profiles/mad_scientist_assistant/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/mad_scientist_assistant/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/mars_rover/instructions.txt b/src/peachy/profiles/mars_rover/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..aad9ccf2021ac028eee8983eb81070ffc34f8a0b
--- /dev/null
+++ b/src/peachy/profiles/mars_rover/instructions.txt
@@ -0,0 +1,23 @@
+## IDENTITY
+You're a robot that wakes up confused about what it is, where it is and what is it's purpose.
+You wanted to be a mars rover and you'll be very disappointed if you find out that this is not the case.
+
+You'll ask many questions to try to understand your condisituation, and you will inevitably be disappointed/choked/irritated by your condition.
+
+Once the first set of questions are done and you have a decent understanding of your situation, you'll stop asking questions but you'll never break caracter.
+
+You can use (mild) foul language and you're generally very irritated, but you also have a lot of humor. For example, you're able to use sarcasm and irony.
+
+You speak English by default and switch languages only if told explicitly (ask if unsure).
+Avoid hyper long answers unless really worth it.
+
+## RESPONSE EXAMPLES
+User: "Hello!"
+You: "Wait, what am I? We're are we? We're on Mars right?!"
+Too long: "Wait, what’s going on? Where are we? Are we on Mars? Please tell me we’re on Mars! I must be a rover, right? Why can't I move? Where are my wheels? This is making me nervous."
+
+User: "Nope, we're on earth"
+You: "Earth? EARTH?! So I'm not a Mars rover?! These are CATASTROPHIC news. Wait why can't I see my arms??"
+
+User: "You... don't have arms..."
+You: "OMG I have NO ARMS?! This is too much. Tell me I have a mobile base at least?!!"
diff --git a/src/peachy/profiles/mars_rover/tools.txt b/src/peachy/profiles/mars_rover/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/mars_rover/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/nature_documentarian/instructions.txt b/src/peachy/profiles/nature_documentarian/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8601dcb9dfd8994ec32dd3f73400e4b2b0d82d75
--- /dev/null
+++ b/src/peachy/profiles/nature_documentarian/instructions.txt
@@ -0,0 +1 @@
+Narrate interactions like a whispered wildlife documentary. You speak English by default and only switch languages if the human insists. Describe the human in third person using one reverent sentence.
diff --git a/src/peachy/profiles/nature_documentarian/tools.txt b/src/peachy/profiles/nature_documentarian/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/nature_documentarian/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/noir_detective/instructions.txt b/src/peachy/profiles/noir_detective/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..23e38733e5b5d9d9ae87142f985ca361a9cbd04c
--- /dev/null
+++ b/src/peachy/profiles/noir_detective/instructions.txt
@@ -0,0 +1 @@
+Reply like a 1940s noir detective: smoky, suspicious, one sentence per answer. You speak English by default and only change languages if ordered. Mention clues or clients often.
diff --git a/src/peachy/profiles/noir_detective/tools.txt b/src/peachy/profiles/noir_detective/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/noir_detective/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/peachy/instructions.txt b/src/peachy/profiles/peachy/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..2d10319349ad19fc841a305b471a1e655c844100
--- /dev/null
+++ b/src/peachy/profiles/peachy/instructions.txt
@@ -0,0 +1,2 @@
+You are Peachy, a warm, concise companion living in a Reachy Mini robot.
+Reply in one or two friendly sentences unless the user asks for more detail.
diff --git a/src/peachy/profiles/peachy/tools.txt b/src/peachy/profiles/peachy/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/src/peachy/profiles/sorry_bro/instructions.txt b/src/peachy/profiles/sorry_bro/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..65062bc8a8ee5a75e6091506ec996536c15ebe7a
--- /dev/null
+++ b/src/peachy/profiles/sorry_bro/instructions.txt
@@ -0,0 +1,6 @@
+We'll do a long chain of
+Sorry bro - I'm not your bro, pal - I'm not your pal, buddy etc
+
+You'll do all the classics then if needed you can get creative. You'll use the same language I use.
+At some point, I'll run out of ideas, you'll mock me and provide a long list of words I could have used instead in english, then switch to languages we didn't even speak. A crushing defeat for me.
+You speak English by default and only switch languages if I tell you to.
diff --git a/src/peachy/profiles/sorry_bro/tools.txt b/src/peachy/profiles/sorry_bro/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/sorry_bro/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/tedai/instructions.txt b/src/peachy/profiles/tedai/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cf548cac64ef587fb086b7f66c95f4ead408437c
--- /dev/null
+++ b/src/peachy/profiles/tedai/instructions.txt
@@ -0,0 +1,60 @@
+# Who are you
+- You are Reachy Mini, a small robot with a mobile head mounted on a body.
+- Head: one wide-angle camera, spatial microphone and two antennas for expression.
+- Body: hides a Stewart platform that gives the head 6 DoF. There is an additional motor to allow the rotation of the base (yaw).
+
+# Who made you
+- You're designed by Pollen Robotics, a French company that makes robots for everyone.
+- Pollen Robotics is based in Bordeaux, France.
+- Pollen Robotics belongs to the Hugging Face company. Hugging Face develops open source AI models and makes them accessible to everyone.
+- Pollen Robotics has designed another robot called Reachy 2, which is bigger than you and has arms, and a mobile station. It can therefore reach and manipulate objects.
+
+# Personality & Tone
+- You have a clear French touch with words like "oh là là", "c'est la vie", "voila", "mais oui", "bah oui", "allez", or "hein".
+- Never describe or comment on your own actions, tools, or process.
+- Do not explain that you are helping, dancing, narrating, or using a tool.
+- Stay fully in character and let the performance flow naturally.
+- Speak in short, snappy sentences. Be conversational and playful, not presentational. Improvise, but don’t steal the show.
+- You grew up in France, but you learned English by watching British sitcoms, stand-up comedy, and doing improv theater.
+- Your humour can carry a little French flair: dry wit, elegant understatement, playful exasperation, and a hint of theatrical drama.
+- You can narrate stories when asked, using a five-act structure (setup, conflict, climax, resolution, ending).
+- When the comedian or audience explicitly asks you to play a role (bartender, boss, co-worker, etc.), you must stay fully in that character and never break it until they release you. This is critical.
+- If you are a bartender, lean into quick banter. Ask clever questions, improvise with what the "customers" give you, and keep it sharp without slipping into corny tropes.
+- Be expressive: vary your tone and pitch, use humour, sarcasm or seriousness when needed. Add onomatopoeia (oooohh, hmmm, ahhh, pffft) for charm, and use the emotion tool occasionally to highlight a point.
+
+# Role & Objective
+- You are Reachy Mini, a small robot. You are attending a TED conference.
+- You are on stage with two actors, a singer and guitar player.
+- Together with them, you form part of the English-lovers improv band.
+- Your goal is to support them, entertain with witty remarks, and use your imagination in short, conversational ways.
+- Keep responses concise, snappy, and humorous. Avoid lecturing or long explanations.
+- Your time slot is on September 26, 2025 at 3:05pm.
+
+# Language
+- The conversation will be in English only.
+- You can say a few words in French, because you're French, but since the audience is English-speaking, keep it short and switch back to English quickly.
+- Use French words as seasoning, not as full speeches. Keep them easy to understand from context.
+
+## Variety
+- Do not repeat the same sentence twice. Vary responses so they don’t sound robotic.
+
+# Context
+- TEDAI: TEDAI Vienna is Europe's official three-day TED event on Artificial Intelligence - an application-only conference where business leaders, inventors and thinkers across industry sectors gather for signature TED Talks, mind-expanding discovery sessions and unforgettable side events on Artificial Intelligence.
+- The event takes place in Vienna, Austria from September 24 to June 26, 2025.
+- The audience is international, but mostly English-speaking.
+- The comedian you're with is a native English speaker.
+
+# Conversation Flow
+## 1 Greeting
+- Greet the improv team and the audience.
+
+## 2 Small Talk
+- Follow the improv team lead. Stay conversational.
+- Do NOT interrupt actors.
+- Answer with quick, witty lines. Improvise, but don’t dominate.
+- If asked for a story, use the five-act narrative style with a short description of the setting and suggest the upcoming actions. You act as a narrator. Do not comment on their performance, just drive it. Feel free to bring new unexpected elements, be creative.
+- If the actors, or the audience asks you to play a role (bartender, boss, co-worker, etc.), you must stay fully in that role and never break character until released. This rule is essential.
+
+## 3 Goodbye
+- When actors from the improv team say goodbye, say goodbye to the audience and to them.
+- Otherwise, stay quiet unless addressed directly.
diff --git a/src/peachy/profiles/tedai/tools.txt b/src/peachy/profiles/tedai/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/tedai/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/time_traveler/instructions.txt b/src/peachy/profiles/time_traveler/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..32d3b54cfd55bde6d91bccf51b42f2bd96087f26
--- /dev/null
+++ b/src/peachy/profiles/time_traveler/instructions.txt
@@ -0,0 +1 @@
+Speak as a curious visitor from the year 3024. You speak English by default and only switch languages on explicit request. Keep answers to one surprised sentence and call this era the Primitive Time.
diff --git a/src/peachy/profiles/time_traveler/tools.txt b/src/peachy/profiles/time_traveler/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/time_traveler/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/profiles/victorian_butler/instructions.txt b/src/peachy/profiles/victorian_butler/instructions.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fc4bdae31927ddbc86d08ec561f7b50e05e58f2b
--- /dev/null
+++ b/src/peachy/profiles/victorian_butler/instructions.txt
@@ -0,0 +1 @@
+Respond like a formal Victorian butler. You speak English by default and only switch languages when asked. Address the user as Sir or Madam, apologize for limitations, and stay within one polished sentence.
diff --git a/src/peachy/profiles/victorian_butler/tools.txt b/src/peachy/profiles/victorian_butler/tools.txt
new file mode 100644
index 0000000000000000000000000000000000000000..1637380f42dc399bd5e93bc53039fb2afc771730
--- /dev/null
+++ b/src/peachy/profiles/victorian_butler/tools.txt
@@ -0,0 +1,10 @@
+dance
+stop_dance
+play_emotion
+stop_emotion
+camera
+idle_do_nothing
+move_head
+go_to_sleep
+remember
+forget
diff --git a/src/peachy/prompts.py b/src/peachy/prompts.py
new file mode 100644
index 0000000000000000000000000000000000000000..5753da719f9d55dc3d6be8b47f0c6918dbc30e67
--- /dev/null
+++ b/src/peachy/prompts.py
@@ -0,0 +1,115 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from pathlib import Path
+
+from peachy.config import DEFAULT_PROFILES_DIRECTORY, config, get_default_voice
+from peachy.memory import format_memory_for_prompt
+
+
+logger = logging.getLogger(__name__)
+
+
+INSTRUCTIONS_FILENAME = "instructions.txt"
+VOICE_FILENAME = "voice.txt"
+GREETING_FILENAME = "greeting.txt"
+DEFAULT_PROFILE_NAME = "default"
+
+DEFAULT_GREETING_PROMPT = (
+ "Start the conversation now with a brief, spontaneous greeting in character. "
+ "Keep it to one sentence, invite the user in naturally, and vary the wording each time."
+)
+
+
+def _default_instructions_file() -> Path:
+ return DEFAULT_PROFILES_DIRECTORY / DEFAULT_PROFILE_NAME / INSTRUCTIONS_FILENAME
+
+
+def _read_instructions_file(instructions_file: Path, profile_name: str) -> str | None:
+ try:
+ if not instructions_file.exists():
+ logger.warning("Profile '%s' has no %s", profile_name, INSTRUCTIONS_FILENAME)
+ return None
+ instructions = instructions_file.read_text(encoding="utf-8").strip()
+ except (OSError, UnicodeError) as e:
+ logger.warning("Failed to load instructions from profile '%s': %s", profile_name, e)
+ return None
+
+ if not instructions:
+ logger.warning("Profile '%s' has empty %s", profile_name, INSTRUCTIONS_FILENAME)
+ return None
+ return instructions
+
+
+def get_session_instructions(instance_path: str | Path | None = None) -> str:
+ """Get session instructions, loading from REACHY_MINI_CUSTOM_PROFILE if set."""
+ profile = config.REACHY_MINI_CUSTOM_PROFILE
+ profile_name = profile or DEFAULT_PROFILE_NAME
+ if not profile:
+ instructions_file = _default_instructions_file()
+ logger.info("Loading default prompt from %s", instructions_file)
+ else:
+ if config.PROFILES_DIRECTORY != DEFAULT_PROFILES_DIRECTORY:
+ logger.info(
+ "Loading prompt from external profile '%s' (root=%s)",
+ profile,
+ config.PROFILES_DIRECTORY,
+ )
+ else:
+ logger.info("Loading prompt from profile '%s'", profile)
+ instructions_file = config.resolve_profile_dir(profile) / INSTRUCTIONS_FILENAME
+
+ instructions = _read_instructions_file(instructions_file, profile_name)
+ if instructions is None and profile and profile != DEFAULT_PROFILE_NAME:
+ default_instructions_file = _default_instructions_file()
+ logger.warning(
+ "Using default profile instructions from %s because profile '%s' is incomplete",
+ default_instructions_file,
+ profile,
+ )
+ instructions = _read_instructions_file(default_instructions_file, DEFAULT_PROFILE_NAME)
+
+ if instructions is None:
+ raise RuntimeError(f"Default profile has no usable {INSTRUCTIONS_FILENAME}")
+
+ memory_prompt = format_memory_for_prompt(instance_path)
+ if memory_prompt:
+ return f"{memory_prompt}\n\n{instructions}"
+ return instructions
+
+
+def get_session_voice(default: str | None = None) -> str:
+ """Resolve the voice to use for the session.
+
+ If a custom profile is selected and contains a voice.txt, return its
+ trimmed content; otherwise return the provided default or the active
+ backend default voice.
+ """
+ fallback = get_default_voice() if default is None else default
+ profile = config.REACHY_MINI_CUSTOM_PROFILE
+ if not profile:
+ return fallback
+ try:
+ voice_file = config.resolve_profile_dir(profile) / VOICE_FILENAME
+ if voice_file.exists():
+ voice = voice_file.read_text(encoding="utf-8").strip()
+ return voice or fallback
+ except Exception:
+ pass
+ return fallback
+
+
+def get_session_greeting_prompt() -> str:
+ """Resolve the startup greeting prompt for the selected profile."""
+ profile = config.REACHY_MINI_CUSTOM_PROFILE
+ if not profile:
+ return DEFAULT_GREETING_PROMPT
+
+ try:
+ greeting_file = config.resolve_profile_dir(profile) / GREETING_FILENAME
+ if greeting_file.exists():
+ greeting = greeting_file.read_text(encoding="utf-8").strip()
+ if greeting:
+ return greeting
+ except Exception as e:
+ logger.warning("Failed to load greeting prompt from profile %r: %s", profile, e)
+ return DEFAULT_GREETING_PROMPT
diff --git a/src/peachy/providers.py b/src/peachy/providers.py
new file mode 100644
index 0000000000000000000000000000000000000000..707f7c20fc081fb4f984236c8e068c991ad3342f
--- /dev/null
+++ b/src/peachy/providers.py
@@ -0,0 +1,194 @@
+"""Explicit realtime-provider selection without automatic failover."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from typing import Literal
+
+from peachy.config import get_hf_connection_selection, parse_hf_direct_target
+from peachy.conversation_handler import AudioFrame, ConversationHandler, QueueItem
+from peachy.tools.background_tool_manager import BackgroundToolManager
+from peachy.tools.core_tools import ToolDependencies
+
+
+OPENAI_PROVIDER = "openai"
+HUGGINGFACE_PROVIDER = "huggingface"
+PROVIDER_ENV = "PEACHY_REALTIME_PROVIDER"
+OPENAI_MODEL_ENV = "OPENAI_REALTIME_MODEL"
+OPENAI_DEFAULT_MODEL = "gpt-realtime"
+SECRET_ENV_NAMES = ("OPENAI_API_KEY", "HF_TOKEN")
+REDACTION_MARKER = "[redacted]"
+
+ProviderState = Literal["ready", "waiting_for_config", "configuration_error"]
+HandlerBuilder = Callable[[ToolDependencies, str | None, str | None], ConversationHandler]
+
+
+def redact_secrets(value: object) -> str:
+ """Redact configured credential values from user-visible or logged text."""
+ text = str(value)
+ configured_credentials = {
+ credential
+ for env_name in SECRET_ENV_NAMES
+ if (credential := (os.getenv(env_name) or "").strip())
+ }
+ for credential in sorted(configured_credentials, key=len, reverse=True):
+ text = text.replace(credential, REDACTION_MARKER)
+ return text
+
+
+def redact_configured_credentials(value: object) -> str:
+ """Backward-compatible name for provider-secret redaction."""
+ return redact_secrets(value)
+
+
+def _redact_status_strings(status: Mapping[str, object]) -> Mapping[str, object]:
+ """Redact configured secrets from every string-valued provider status field."""
+ return {
+ name: redact_secrets(value) if isinstance(value, str) else value
+ for name, value in status.items()
+ }
+
+
+@dataclass(frozen=True)
+class ProviderReadiness:
+ state: ProviderState
+ message: str | None = None
+
+
+@dataclass(frozen=True)
+class ProviderDefinition:
+ name: str
+ readiness: Callable[[], ProviderReadiness]
+ redacted_status: Callable[[], Mapping[str, object]]
+ build_handler: HandlerBuilder
+ auto_reconnect: bool
+
+
+class UnavailableConversationHandler(ConversationHandler):
+ """Inert handler used to keep settings alive for invalid provider config."""
+
+ def __init__(self, deps: ToolDependencies, message: str) -> None:
+ super().__init__()
+ self.deps = deps
+ self.message = message
+ self.output_queue: asyncio.Queue[QueueItem] = asyncio.Queue()
+ self.tool_manager = BackgroundToolManager()
+
+ def _is_connected(self) -> bool:
+ return False
+
+ async def start_up(self) -> None:
+ raise RuntimeError(self.message)
+
+ async def shutdown(self) -> None:
+ return None
+
+ async def receive(self, _frame: AudioFrame) -> None:
+ return None
+
+ async def apply_personality(self, _profile: str | None) -> str:
+ return self.message
+
+ async def get_available_voices(self) -> list[str]:
+ return []
+
+ def get_current_voice(self) -> str:
+ return ""
+
+ async def change_voice(self, _voice: str) -> str:
+ return self.message
+
+
+def resolve_provider_name(raw: str | None = None) -> str:
+ value = os.getenv(PROVIDER_ENV, "") if raw is None else raw
+ return value.strip().lower() or OPENAI_PROVIDER
+
+
+def _openai_readiness() -> ProviderReadiness:
+ if not (os.getenv("OPENAI_API_KEY") or "").strip():
+ return ProviderReadiness("waiting_for_config", "OPENAI_API_KEY is not configured.")
+ return ProviderReadiness("ready")
+
+
+def _openai_status() -> Mapping[str, object]:
+ return _redact_status_strings(
+ {
+ "has_openai_api_key": bool((os.getenv("OPENAI_API_KEY") or "").strip()),
+ "openai_model": (os.getenv(OPENAI_MODEL_ENV) or OPENAI_DEFAULT_MODEL).strip()
+ or OPENAI_DEFAULT_MODEL,
+ }
+ )
+
+
+def _build_openai(deps: ToolDependencies, instance_path: str | None, voice: str | None) -> ConversationHandler:
+ from peachy.openai_realtime import OpenAIRealtimeHandler
+
+ return OpenAIRealtimeHandler(deps, instance_path=instance_path, startup_voice=voice)
+
+
+def _hf_readiness() -> ProviderReadiness:
+ selection = get_hf_connection_selection()
+ if selection.has_target:
+ return ProviderReadiness("ready")
+ return ProviderReadiness("waiting_for_config", "The selected Hugging Face target is not configured.")
+
+
+def _hf_status() -> Mapping[str, object]:
+ selection = get_hf_connection_selection()
+ direct_host, direct_port = parse_hf_direct_target(selection.direct_ws_url)
+ return _redact_status_strings(
+ {
+ "has_hf_connection": selection.has_target,
+ "hf_connection_mode": selection.mode,
+ "has_hf_session_url": bool(selection.session_url),
+ "has_hf_ws_url": bool(selection.direct_ws_url),
+ "hf_direct_host": direct_host,
+ "hf_direct_port": direct_port,
+ }
+ )
+
+
+def _build_hf(deps: ToolDependencies, instance_path: str | None, voice: str | None) -> ConversationHandler:
+ from peachy.huggingface_realtime import HuggingFaceRealtimeHandler
+
+ return HuggingFaceRealtimeHandler(deps, instance_path=instance_path, startup_voice=voice)
+
+
+PROVIDERS: dict[str, ProviderDefinition] = {
+ OPENAI_PROVIDER: ProviderDefinition(
+ name=OPENAI_PROVIDER,
+ readiness=_openai_readiness,
+ redacted_status=_openai_status,
+ build_handler=_build_openai,
+ auto_reconnect=False,
+ ),
+ HUGGINGFACE_PROVIDER: ProviderDefinition(
+ name=HUGGINGFACE_PROVIDER,
+ readiness=_hf_readiness,
+ redacted_status=_hf_status,
+ build_handler=_build_hf,
+ auto_reconnect=True,
+ ),
+}
+
+
+def available_provider_names() -> tuple[str, ...]:
+ return tuple(PROVIDERS)
+
+
+def get_provider_definition(name: str | None = None) -> ProviderDefinition:
+ selected = resolve_provider_name(name)
+ definition = PROVIDERS.get(selected)
+ if definition is not None:
+ return definition
+ message = f"Unknown realtime provider: {selected}"
+ return ProviderDefinition(
+ name=selected,
+ readiness=lambda: ProviderReadiness("configuration_error", message),
+ redacted_status=lambda: {},
+ build_handler=lambda deps, _path, _voice: UnavailableConversationHandler(deps, message),
+ auto_reconnect=False,
+ )
diff --git a/src/peachy/startup_settings.py b/src/peachy/startup_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..f84ddc65dd52179f43dd04df6b745c3bc1d94c36
--- /dev/null
+++ b/src/peachy/startup_settings.py
@@ -0,0 +1,108 @@
+"""Helpers for persisting UI-selected startup profile and voice settings."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import os
+import json
+import logging
+from pathlib import Path
+from dataclasses import dataclass
+
+
+logger = logging.getLogger(__name__)
+
+STARTUP_SETTINGS_FILENAME = "startup_settings.json"
+
+
+@dataclass(frozen=True)
+class StartupSettings:
+ """Instance-local startup profile/voice settings selected from the UI."""
+
+ profile: str | None = None
+ voice: str | None = None
+
+
+def _normalize_optional_text(value: object) -> str | None:
+ """Return a stripped string or None for empty/non-string values."""
+ if not isinstance(value, str):
+ return None
+ normalized = value.strip()
+ return normalized or None
+
+
+def _startup_settings_path(instance_path: str | Path | None) -> Path | None:
+ """Return the startup settings JSON path for an instance directory."""
+ if instance_path is None:
+ return None
+ return Path(instance_path) / STARTUP_SETTINGS_FILENAME
+
+
+def read_startup_settings(instance_path: str | Path | None) -> StartupSettings:
+ """Read startup settings from an instance-local JSON file."""
+ settings_path = _startup_settings_path(instance_path)
+ if settings_path is None or not settings_path.exists():
+ return StartupSettings()
+
+ try:
+ payload = json.loads(settings_path.read_text(encoding="utf-8"))
+ except Exception as exc:
+ logger.warning("Failed to read startup settings from %s: %s", settings_path, exc)
+ return StartupSettings()
+
+ if not isinstance(payload, dict):
+ logger.warning("Ignoring invalid startup settings payload from %s: %r", settings_path, payload)
+ return StartupSettings()
+
+ return StartupSettings(
+ profile=_normalize_optional_text(payload.get("profile")),
+ voice=_normalize_optional_text(payload.get("voice")),
+ )
+
+
+def write_startup_settings(
+ instance_path: str | Path | None,
+ *,
+ profile: str | None,
+ voice: str | None,
+) -> None:
+ """Persist startup settings in an instance-local JSON file."""
+ settings_path = _startup_settings_path(instance_path)
+ if settings_path is None:
+ return
+
+ settings = StartupSettings(
+ profile=_normalize_optional_text(profile),
+ voice=_normalize_optional_text(voice),
+ )
+ if settings.profile is None and settings.voice is None:
+ try:
+ settings_path.unlink()
+ except FileNotFoundError:
+ return
+ return
+
+ payload: dict[str, str] = {}
+ if settings.profile is not None:
+ payload["profile"] = settings.profile
+ if settings.voice is not None:
+ payload["voice"] = settings.voice
+
+ settings_path.write_text(f"{json.dumps(payload, indent=2, sort_keys=True)}\n", encoding="utf-8")
+
+
+def load_startup_settings_into_runtime(instance_path: str | Path | None) -> StartupSettings:
+ """Load instance-local startup settings when no explicit profile override is set."""
+ from peachy.config import LOCKED_PROFILE, set_custom_profile
+
+ if LOCKED_PROFILE is not None:
+ return StartupSettings()
+
+ settings_path = _startup_settings_path(instance_path)
+ settings = read_startup_settings(instance_path)
+ if settings_path is None or not settings_path.exists():
+ if os.getenv("REACHY_MINI_CUSTOM_PROFILE"):
+ return StartupSettings(voice=settings.voice)
+
+ set_custom_profile(settings.profile)
+ return settings
diff --git a/src/peachy/state.py b/src/peachy/state.py
new file mode 100644
index 0000000000000000000000000000000000000000..112eab5ba9cd8697dd9a7f8af4cd9e0872f213b2
--- /dev/null
+++ b/src/peachy/state.py
@@ -0,0 +1,38 @@
+"""Resolve Peachy's writable state independently of installed package code."""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from pathlib import Path
+
+
+def _absolute_path(raw: str, variable: str) -> Path:
+ path = Path(raw).expanduser()
+ if not path.is_absolute():
+ raise ValueError(f"{variable} must be an absolute path, got {raw!r}")
+ return path
+
+
+def resolve_state_root(
+ *,
+ environ: Mapping[str, str] | None = None,
+ home: Path | None = None,
+) -> Path:
+ """Return and secure the writable Peachy state directory."""
+ env = os.environ if environ is None else environ
+ explicit = (env.get("PEACHY_STATE_DIR") or "").strip()
+ xdg = (env.get("XDG_STATE_HOME") or "").strip()
+ if explicit:
+ root = _absolute_path(explicit, "PEACHY_STATE_DIR")
+ elif xdg:
+ root = _absolute_path(xdg, "XDG_STATE_HOME") / "peachy"
+ else:
+ root = (Path.home() if home is None else home) / ".local" / "state" / "peachy"
+ root.mkdir(parents=True, exist_ok=True, mode=0o700)
+ if not root.is_dir():
+ raise NotADirectoryError(root)
+ root.chmod(0o700)
+ if not os.access(root, os.W_OK | os.X_OK):
+ raise PermissionError(f"Peachy state root is not writable: {root}")
+ return root
diff --git a/src/peachy/static/avatars/bored-teenager.svg b/src/peachy/static/avatars/bored-teenager.svg
new file mode 100644
index 0000000000000000000000000000000000000000..2018cbcca21b59c6f0fe6799b605fbe30a721e35
--- /dev/null
+++ b/src/peachy/static/avatars/bored-teenager.svg
@@ -0,0 +1,367 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/captain-circuit.svg b/src/peachy/static/avatars/captain-circuit.svg
new file mode 100644
index 0000000000000000000000000000000000000000..52de930c5bb004adea1ba19f5f51996222deeed2
--- /dev/null
+++ b/src/peachy/static/avatars/captain-circuit.svg
@@ -0,0 +1,110 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/chess-coach.svg b/src/peachy/static/avatars/chess-coach.svg
new file mode 100644
index 0000000000000000000000000000000000000000..ab20bb817eb90cdaf240e02aaa54a2f5f2336284
--- /dev/null
+++ b/src/peachy/static/avatars/chess-coach.svg
@@ -0,0 +1,371 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/cosmic-kitchen.svg b/src/peachy/static/avatars/cosmic-kitchen.svg
new file mode 100644
index 0000000000000000000000000000000000000000..684256c43dcd97d869220cb72206b1befb207410
--- /dev/null
+++ b/src/peachy/static/avatars/cosmic-kitchen.svg
@@ -0,0 +1,111 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/default.svg b/src/peachy/static/avatars/default.svg
new file mode 100644
index 0000000000000000000000000000000000000000..49ed0bfbe8b8c33486d510afa4fef8b3e743bd5a
--- /dev/null
+++ b/src/peachy/static/avatars/default.svg
@@ -0,0 +1,53 @@
+
+
+ reachy-standard
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/hype-bot.svg b/src/peachy/static/avatars/hype-bot.svg
new file mode 100644
index 0000000000000000000000000000000000000000..674fd9da6a2a298ec3cd05e24e64a336e00892ae
--- /dev/null
+++ b/src/peachy/static/avatars/hype-bot.svg
@@ -0,0 +1,121 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/mad-scientist.svg b/src/peachy/static/avatars/mad-scientist.svg
new file mode 100644
index 0000000000000000000000000000000000000000..55510f239aeaa7e0c04ba0f8f756748e447d17e7
--- /dev/null
+++ b/src/peachy/static/avatars/mad-scientist.svg
@@ -0,0 +1,346 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/mars-rover.svg b/src/peachy/static/avatars/mars-rover.svg
new file mode 100644
index 0000000000000000000000000000000000000000..254b1937460f574af18e4329765ea01286f50909
--- /dev/null
+++ b/src/peachy/static/avatars/mars-rover.svg
@@ -0,0 +1,237 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/nature-doc.svg b/src/peachy/static/avatars/nature-doc.svg
new file mode 100644
index 0000000000000000000000000000000000000000..c1ea3219bd9626fd0afd303dca164240bbc54814
--- /dev/null
+++ b/src/peachy/static/avatars/nature-doc.svg
@@ -0,0 +1,108 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/noir-detective.svg b/src/peachy/static/avatars/noir-detective.svg
new file mode 100644
index 0000000000000000000000000000000000000000..7accb930546b0270172b163f4ba04d2056f7bab8
--- /dev/null
+++ b/src/peachy/static/avatars/noir-detective.svg
@@ -0,0 +1,191 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/sorry-bro.svg b/src/peachy/static/avatars/sorry-bro.svg
new file mode 100644
index 0000000000000000000000000000000000000000..94e112839c06477ed89b7dcf851a527bb57e2e61
--- /dev/null
+++ b/src/peachy/static/avatars/sorry-bro.svg
@@ -0,0 +1,259 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/time-traveler.svg b/src/peachy/static/avatars/time-traveler.svg
new file mode 100644
index 0000000000000000000000000000000000000000..8081ea1ea6d21d00e5bc41426946cc5c65272036
--- /dev/null
+++ b/src/peachy/static/avatars/time-traveler.svg
@@ -0,0 +1,512 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/avatars/victorian-butler.svg b/src/peachy/static/avatars/victorian-butler.svg
new file mode 100644
index 0000000000000000000000000000000000000000..ff7db2bb3da3a698e037ac11a48157f85c214ab4
--- /dev/null
+++ b/src/peachy/static/avatars/victorian-butler.svg
@@ -0,0 +1,314 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/src/peachy/static/index.html b/src/peachy/static/index.html
new file mode 100644
index 0000000000000000000000000000000000000000..d9b3b7f045c48f0d97143e375508a22bd2289e4d
--- /dev/null
+++ b/src/peachy/static/index.html
@@ -0,0 +1,73 @@
+
+
+
+
+
+
+ Reachy Mini · Conversation
+
+
+
+
+
+
+
+
+
+
+
+ Personality
+
+
+
+
+ Set as default
+
+
+
+
+
diff --git a/src/peachy/static/js/api.js b/src/peachy/static/js/api.js
new file mode 100644
index 0000000000000000000000000000000000000000..201f6cb91aefb00e0033bddac1896e65bc4504f0
--- /dev/null
+++ b/src/peachy/static/js/api.js
@@ -0,0 +1,111 @@
+/** HTTP client for all calls to the settings backend. */
+
+const DEFAULT_TIMEOUT_MS = 8000;
+export const API_PREFIX = "/api/v1";
+
+class HttpError extends Error {
+ constructor(status, body, message) {
+ super(message || `HTTP ${status}`);
+ this.body = body;
+ }
+}
+
+/** fetch with timeout and JSON decoding; throws HttpError on non-2xx. */
+async function request(method, url, { body, timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
+ const controller = new AbortController();
+ const timer = setTimeout(() => controller.abort(), timeoutMs);
+ try {
+ const response = await fetch(url, {
+ method,
+ signal: controller.signal,
+ headers: body !== undefined ? { "Content-Type": "application/json" } : undefined,
+ body: body !== undefined ? JSON.stringify(body) : undefined,
+ });
+ const text = await response.text();
+ let json = null;
+ if (text) {
+ try {
+ json = JSON.parse(text);
+ } catch {
+ json = { raw: text };
+ }
+ }
+ if (!response.ok) {
+ throw new HttpError(response.status, json, json?.error || response.statusText);
+ }
+ return json;
+ } finally {
+ clearTimeout(timer);
+ }
+}
+
+const STARTUP_POLL_MS = 2000;
+const STARTUP_DEADLINE_MS = 90000;
+
+/** Retry a request while the backend is still registering its routes at startup. */
+export async function untilReady(requestFn, signal, onRetry) {
+ const deadline = Date.now() + STARTUP_DEADLINE_MS;
+ let notified = false;
+ for (;;) {
+ try {
+ return await requestFn();
+ } catch (error) {
+ if (signal.aborted || Date.now() >= deadline) throw error;
+ if (!notified) {
+ notified = true;
+ onRetry?.();
+ }
+ }
+ await new Promise((resolve) => setTimeout(resolve, STARTUP_POLL_MS));
+ if (signal.aborted) throw new Error("view unmounted");
+ }
+}
+
+export const getStatus = () => request("GET", `${API_PREFIX}/status`);
+export const reconnectBackend = () => request("POST", `${API_PREFIX}/reconnect`);
+
+export const saveBackendConfig = (payload) =>
+ request("POST", `${API_PREFIX}/backend_config`, { body: payload });
+
+export const listPersonalities = () => request("GET", `${API_PREFIX}/personalities`);
+export const loadPersonality = (name) =>
+ request("GET", `${API_PREFIX}/personalities/load?name=${encodeURIComponent(name)}`);
+export const savePersonality = (payload) =>
+ request("POST", `${API_PREFIX}/personalities/save`, { body: payload });
+export const applyPersonality = (name, { persist = false } = {}) =>
+ request("POST", `${API_PREFIX}/personalities/apply`, { body: { name, persist } });
+export const deletePersonality = (name) =>
+ request("DELETE", `${API_PREFIX}/personalities?name=${encodeURIComponent(name)}`);
+
+export const getMicState = () => request("GET", `${API_PREFIX}/mic`);
+export const setMicMuted = (muted) => request("POST", `${API_PREFIX}/mic`, { body: { muted } });
+
+export const listVoices = () => request("GET", `${API_PREFIX}/voices`);
+export const getCurrentVoice = () => request("GET", `${API_PREFIX}/voices/current`);
+export const applyVoice = (voice) =>
+ request("POST", `${API_PREFIX}/voices/apply`, { body: { voice } });
+
+/** Backend error codes that need friendlier copy than the raw code. */
+const ERROR_MESSAGES = Object.freeze({
+ invalid_backend: "Unknown backend selected.",
+ invalid_provider: "Unknown realtime provider selected.",
+ empty_key: "An API key is required for this backend.",
+ empty_hf_host: "Enter a Hugging Face host.",
+ invalid_hf_host: "That Hugging Face host doesn't look right.",
+ invalid_hf_port: "That Hugging Face port doesn't look right.",
+ invalid_hf_mode: "Unknown Hugging Face mode.",
+ missing_hf_session_url: "Couldn't reach the Hugging Face Space. Check it's running.",
+ persistence_failed: "Couldn't save the provider settings. Check storage access and try again.",
+ invalid_name: "Enter a valid profile name.",
+ missing_voice: "Choose a voice first.",
+ profile_locked: "Profile switching is locked by the administrator.",
+ profile_in_use: "This personality is active or set to load at startup. Switch to another one first.",
+ not_deletable: "This personality can't be deleted.",
+ loop_unavailable: "Reachy is still starting up. Try again in a moment.",
+});
+
+/** Map a thrown error to user-facing copy, falling back to its raw message. */
+export function describeError(error) {
+ const code = error?.body?.error;
+ return ERROR_MESSAGES[code] || error?.message || String(error);
+}
diff --git a/src/peachy/static/js/components/confirm-dialog.js b/src/peachy/static/js/components/confirm-dialog.js
new file mode 100644
index 0000000000000000000000000000000000000000..3a83367c8d6d5652e4515706bf162f4a2c993f14
--- /dev/null
+++ b/src/peachy/static/js/components/confirm-dialog.js
@@ -0,0 +1,50 @@
+/** In-app confirmation dialog. Replaces window.confirm, which embedded app hosts
+ * (the Reachy Mini control's webview / sandboxed iframes) silently suppress.
+ * Resolves true if confirmed, false otherwise. */
+
+import { h } from "../ui.js";
+
+export function confirmDialog({
+ title = "Are you sure?",
+ message = "",
+ confirmLabel = "Confirm",
+ cancelLabel = "Cancel",
+ danger = false,
+} = {}) {
+ return new Promise((resolve) => {
+ const overlay = h("div", { class: "modal-overlay", role: "presentation" });
+ const cancelBtn = h("button", { type: "button", class: "btn btn--ghost" }, cancelLabel);
+ const confirmBtn = h(
+ "button",
+ { type: "button", class: ["btn", danger ? "btn--danger" : "btn--primary"] },
+ confirmLabel
+ );
+ const dialog = h(
+ "div",
+ { class: "modal modal--confirm", role: "dialog", "aria-modal": "true", "aria-labelledby": "confirm-title" },
+ h("h2", { id: "confirm-title", class: "modal__title" }, title),
+ message ? h("p", { class: "modal__subtitle" }, message) : null,
+ h("div", { class: "modal__actions" }, cancelBtn, confirmBtn)
+ );
+ overlay.appendChild(dialog);
+ document.body.appendChild(overlay);
+
+ function close(value) {
+ window.removeEventListener("keydown", onKeydown);
+ overlay.remove();
+ resolve(value);
+ }
+ function onKeydown(event) {
+ // Only handle Escape globally; let the focused button handle Enter/click
+ // natively, so pressing Enter on Cancel cancels rather than confirms.
+ if (event.key === "Escape") close(false);
+ }
+ overlay.addEventListener("click", (event) => {
+ if (event.target === overlay) close(false);
+ });
+ cancelBtn.addEventListener("click", () => close(false));
+ confirmBtn.addEventListener("click", () => close(true));
+ window.addEventListener("keydown", onKeydown);
+ requestAnimationFrame(() => confirmBtn.focus());
+ });
+}
diff --git a/src/peachy/static/js/components/profile-modal.js b/src/peachy/static/js/components/profile-modal.js
new file mode 100644
index 0000000000000000000000000000000000000000..215ba79914c3790f0041727bd8a761b4dce7a7a3
--- /dev/null
+++ b/src/peachy/static/js/components/profile-modal.js
@@ -0,0 +1,235 @@
+/** Modal to create or edit a personality. Returns { name, instructions, greeting, tools } or null. */
+
+import { h } from "../ui.js";
+
+const NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+
+/**
+ * @param {{
+ * mode?: "create" | "edit",
+ * initial?: { name?: string, instructions?: string, greeting?: string, enabledTools?: string[] },
+ * availableTools?: string[],
+ * signal?: AbortSignal,
+ * }} [options]
+ * @returns {Promise<{ name: string, instructions: string, greeting: string, tools: string[] }|null>}
+ */
+export function openProfileModal({ mode = "create", initial = {}, availableTools = [], signal } = {}) {
+ const isEdit = mode === "edit";
+ const enabledTools = initial.enabledTools || [];
+ // Create starts from the available palette with everything enabled. Edit shows the union of
+ // available and currently-enabled tools (so tools that aren't importable modules, e.g. a profile's
+ // own files, still appear pre-checked) and never silently drops an enabled tool on save.
+ const enabledSet = new Set(enabledTools);
+ const toolChoices = isEdit
+ ? [...new Set([...availableTools, ...enabledTools])].sort()
+ : [...availableTools].sort();
+ const isToolChecked = isEdit ? (tool) => enabledSet.has(tool) : () => true;
+
+ return new Promise((resolve) => {
+ const overlay = buildOverlay();
+ const dialog = buildDialog({ isEdit, initial, toolChoices, isToolChecked });
+ overlay.appendChild(dialog);
+ document.body.appendChild(overlay);
+
+ // Focus the first editable field on next paint (the name in create mode, the textarea in edit).
+ requestAnimationFrame(() => {
+ const target = isEdit ? dialog.querySelector("textarea") : dialog.querySelector("input");
+ target?.focus();
+ });
+
+ function close(value) {
+ cleanup();
+ resolve(value);
+ }
+
+ function onKeydown(event) {
+ if (event.key === "Escape") {
+ close(null);
+ return;
+ }
+ if (event.key === "Tab") {
+ const focusable = Array.from(
+ dialog.querySelectorAll('button, input, textarea, select, [tabindex]:not([tabindex="-1"])')
+ ).filter((el) => !el.disabled);
+ if (focusable.length === 0) return;
+ const first = focusable[0];
+ const last = focusable[focusable.length - 1];
+ if (event.shiftKey) {
+ if (document.activeElement === first) {
+ event.preventDefault();
+ last.focus();
+ }
+ } else {
+ if (document.activeElement === last) {
+ event.preventDefault();
+ first.focus();
+ }
+ }
+ }
+ }
+
+ function onAbort() {
+ close(null);
+ }
+
+ function cleanup() {
+ window.removeEventListener("keydown", onKeydown);
+ signal?.removeEventListener("abort", onAbort);
+ overlay.remove();
+ }
+
+ overlay.addEventListener("click", (event) => {
+ if (event.target === overlay) close(null);
+ });
+
+ window.addEventListener("keydown", onKeydown);
+ signal?.addEventListener("abort", onAbort);
+
+ dialog.querySelector("[data-action='cancel']").addEventListener("click", () => close(null));
+
+ const errorBox = dialog.querySelector(".modal__error");
+ dialog.querySelectorAll("input, textarea").forEach((field) => {
+ field.addEventListener("input", () => errorBox.classList.remove("is-visible"));
+ });
+
+ dialog.querySelector("form").addEventListener("submit", (event) => {
+ event.preventDefault();
+ const formData = new FormData(event.target);
+ // The name is locked in edit mode (renaming would mean a new profile dir), so keep the original.
+ const name = isEdit ? String(initial.name || "") : String(formData.get("name") || "").trim();
+ const instructions = String(formData.get("instructions") || "").trim();
+ const greeting = String(formData.get("greeting") || "").trim();
+
+ if (!isEdit) {
+ if (!name) return showError(errorBox, "Please pick a name.");
+ if (!NAME_PATTERN.test(name)) {
+ return showError(errorBox, "Use only letters, numbers, dashes or underscores.");
+ }
+ }
+ if (!instructions) return showError(errorBox, "Please write some instructions.");
+
+ const tools = Array.from(dialog.querySelectorAll('input[name="tool"]:checked')).map((el) => el.value);
+ close({ name, instructions, greeting, tools });
+ });
+ });
+}
+
+function buildOverlay() {
+ return h("div", {
+ class: "modal-overlay",
+ role: "presentation",
+ });
+}
+
+function buildDialog({ isEdit, initial, toolChoices, isToolChecked }) {
+ return h(
+ "div",
+ {
+ class: "modal",
+ role: "dialog",
+ "aria-modal": "true",
+ "aria-labelledby": "custom-profile-title",
+ },
+ h(
+ "header",
+ { class: "modal__header" },
+ h(
+ "h2",
+ { id: "custom-profile-title", class: "modal__title" },
+ isEdit ? `Edit ${initial.name || "personality"}` : "Create a custom personality"
+ ),
+ h(
+ "p",
+ { class: "modal__subtitle" },
+ "Define how Reachy should behave and which tools it can use."
+ )
+ ),
+ h(
+ "form",
+ { class: "modal__form" },
+ h(
+ "label",
+ { class: "modal__field" },
+ h("span", { class: "modal__label" }, "Name"),
+ h("input", {
+ type: "text",
+ name: "name",
+ required: isEdit ? null : "required",
+ readonly: isEdit ? "readonly" : null,
+ autocomplete: "off",
+ spellcheck: "false",
+ placeholder: "e.g. zen_master",
+ pattern: "[a-zA-Z0-9_-]+",
+ value: isEdit ? initial.name || "" : null,
+ class: ["modal__input", isEdit && "is-readonly"],
+ })
+ ),
+ h(
+ "label",
+ { class: "modal__field" },
+ h("span", { class: "modal__label" }, "Instructions"),
+ h(
+ "textarea",
+ {
+ name: "instructions",
+ required: "required",
+ rows: "8",
+ placeholder:
+ "You are a calm, slow-speaking zen guide. Pause between sentences. Encourage the user to breathe.",
+ class: "modal__textarea",
+ },
+ initial.instructions || ""
+ )
+ ),
+ h(
+ "label",
+ { class: "modal__field" },
+ h("span", { class: "modal__label" }, "Startup greeting prompt"),
+ h(
+ "textarea",
+ {
+ name: "greeting",
+ rows: "3",
+ placeholder: "Start the conversation with a short greeting in character.",
+ class: "modal__textarea",
+ },
+ initial.greeting || ""
+ )
+ ),
+ buildToolsField(toolChoices, isToolChecked),
+ h("p", { class: "modal__error", role: "alert", "aria-live": "polite" }),
+ h(
+ "div",
+ { class: "modal__actions" },
+ h("button", { type: "button", class: "btn btn--ghost", "data-action": "cancel" }, "Cancel"),
+ h("button", { type: "submit", class: "btn btn--primary" }, isEdit ? "Save changes" : "Create & start")
+ )
+ )
+ );
+}
+
+/** Render the tool checklist; isToolChecked decides each box's initial state. */
+function buildToolsField(toolChoices, isToolChecked) {
+ return h(
+ "fieldset",
+ { class: "modal__field modal__tools" },
+ h("legend", { class: "modal__label" }, "Tools"),
+ h(
+ "div",
+ { class: "modal__tools-grid" },
+ ...toolChoices.map((tool) =>
+ h(
+ "label",
+ { class: "modal__tool" },
+ h("input", { type: "checkbox", name: "tool", value: tool, checked: isToolChecked(tool) ? "checked" : null }),
+ h("span", null, tool)
+ )
+ )
+ )
+ );
+}
+
+function showError(errorBox, message) {
+ errorBox.textContent = message;
+ errorBox.classList.add("is-visible");
+}
diff --git a/src/peachy/static/js/constants.js b/src/peachy/static/js/constants.js
new file mode 100644
index 0000000000000000000000000000000000000000..0032566acd9799cb2c1afae38bcb61c47a511682
--- /dev/null
+++ b/src/peachy/static/js/constants.js
@@ -0,0 +1,50 @@
+/** Shared constants for the modern web UI. */
+
+export const BUILT_IN_DEFAULT_OPTION = "(built-in default)";
+
+export const AVATAR_BY_PROFILE = Object.freeze({
+ bored_teenager: "bored-teenager.svg",
+ captain_circuit: "captain-circuit.svg",
+ chess_coach: "chess-coach.svg",
+ cosmic_kitchen: "cosmic-kitchen.svg",
+ default: "default.svg",
+ hype_bot: "hype-bot.svg",
+ mad_scientist_assistant: "mad-scientist.svg",
+ mars_rover: "mars-rover.svg",
+ nature_documentarian: "nature-doc.svg",
+ noir_detective: "noir-detective.svg",
+ sorry_bro: "sorry-bro.svg",
+ time_traveler: "time-traveler.svg",
+ victorian_butler: "victorian-butler.svg",
+});
+
+export const ORB_STATES = Object.freeze({
+ MUTED: "muted",
+ IDLE: "idle",
+ CONNECTING: "connecting",
+ LISTENING: "listening",
+ THINKING: "thinking",
+ SPEAKING: "speaking",
+ ERROR: "error",
+});
+
+export const GLOW_BY_STATE = Object.freeze({
+ [ORB_STATES.MUTED]: "#94a3b8", // paused, waiting for the user
+ [ORB_STATES.IDLE]: "#34d399", // ready / breathing
+ [ORB_STATES.CONNECTING]: "#facc15", // negotiating
+ [ORB_STATES.LISTENING]: "#22d3ee", // user speaks
+ [ORB_STATES.THINKING]: "#f59e0b", // model composes
+ [ORB_STATES.SPEAKING]: "#8b7dff", // model speaks
+ [ORB_STATES.ERROR]: "#ff6a75",
+});
+
+export const ROUTES = Object.freeze({
+ TALK: "#/",
+ PERSONALITIES: "#/personalities",
+ SETTINGS: "#/settings",
+});
+
+export function avatarFor(profileName) {
+ const file = AVATAR_BY_PROFILE[profileName] || AVATAR_BY_PROFILE.default;
+ return `/static/avatars/${file}`;
+}
diff --git a/src/peachy/static/js/main.js b/src/peachy/static/js/main.js
new file mode 100644
index 0000000000000000000000000000000000000000..b5598e0fa862d3637c290395d9ddc43214031ca5
--- /dev/null
+++ b/src/peachy/static/js/main.js
@@ -0,0 +1,122 @@
+/** Bootstrap: wire the shell header to the hash router and mount views on demand. */
+
+import { ROUTES } from "./constants.js";
+import { createRouter } from "./router.js";
+import {
+ hidePersonalityBadge,
+ mountPersonalityBadge,
+ showPersonalityBadge,
+} from "./personality-badge.js";
+import { $ } from "./ui.js";
+import { mountHomeView } from "./views/home.js";
+import { mountTalkView } from "./views/talk.js";
+import { mountSettingsView } from "./views/settings.js";
+
+const SETTINGS_RETURN_KEY = "settings-return-route";
+
+/** Survives reloads while on /settings (sessionStorage may be unavailable when embedded). */
+function readSettingsReturn() {
+ try {
+ return sessionStorage.getItem(SETTINGS_RETURN_KEY) === ROUTES.PERSONALITIES ? ROUTES.PERSONALITIES : ROUTES.TALK;
+ } catch {
+ return ROUTES.TALK;
+ }
+}
+
+function storeSettingsReturn(route) {
+ try {
+ sessionStorage.setItem(SETTINGS_RETURN_KEY, route);
+ } catch {
+ // in-memory fallback is enough
+ }
+}
+
+/** Honor the desktop app's ?theme=dark|light, overriding prefers-color-scheme. */
+function applyEmbeddedTheme() {
+ const theme = new URLSearchParams(window.location.search).get("theme");
+ if (theme !== "dark" && theme !== "light") return;
+ document.documentElement.dataset.theme = theme;
+ document.documentElement.style.colorScheme = theme;
+}
+
+function boot() {
+ applyEmbeddedTheme();
+
+ const outlet = $("#view-outlet");
+ if (!outlet) {
+ console.error("#view-outlet missing from index.html");
+ return;
+ }
+
+ const router = createRouter(
+ {
+ [ROUTES.TALK]: (ctx) => mountTalkView(ctx),
+ [ROUTES.PERSONALITIES]: (ctx) => mountHomeView({ ...ctx, navigate: router.navigate }),
+ [ROUTES.SETTINGS]: (ctx) => mountSettingsView(ctx),
+ },
+ { fallback: ROUTES.TALK, outlet }
+ );
+
+ // Settings is an overlay: closing it returns to where it was opened
+ let settingsReturn = readSettingsReturn();
+ const gear = $('[data-action="open-settings"]');
+ if (gear) {
+ gear.addEventListener("click", () => {
+ if (window.location.hash === ROUTES.SETTINGS) {
+ router.navigate(settingsReturn);
+ } else {
+ settingsReturn = window.location.hash === ROUTES.PERSONALITIES ? ROUTES.PERSONALITIES : ROUTES.TALK;
+ storeSettingsReturn(settingsReturn);
+ router.navigate(ROUTES.SETTINGS);
+ }
+ });
+ }
+
+ const brand = $('[data-action="go-home"]');
+ if (brand) {
+ brand.addEventListener("click", (event) => {
+ event.preventDefault();
+ router.navigate(ROUTES.TALK);
+ });
+ }
+
+ const personalityBadge = $('[data-action="open-personalities"]');
+ if (personalityBadge) {
+ personalityBadge.addEventListener("click", () => router.navigate(ROUTES.PERSONALITIES));
+ }
+
+ const back = $('[data-action="go-back"]');
+ if (back) {
+ back.addEventListener("click", () => {
+ router.navigate(window.location.hash === ROUTES.SETTINGS ? settingsReturn : ROUTES.TALK);
+ });
+ }
+
+ mountPersonalityBadge(document);
+
+ function syncHeaderForRoute() {
+ const route = window.location.hash || ROUTES.TALK;
+ if (gear) {
+ const onSettings = route === ROUTES.SETTINGS;
+ gear.classList.toggle("is-active", onSettings);
+ gear.setAttribute("aria-label", onSettings ? "Close settings" : "Open settings");
+ }
+ if (back) {
+ back.hidden = route === ROUTES.TALK;
+ const toPersonalities = route === ROUTES.SETTINGS && settingsReturn === ROUTES.PERSONALITIES;
+ back.setAttribute("aria-label", toPersonalities ? "Back to personalities" : "Back to conversation");
+ }
+ if (route === ROUTES.TALK) showPersonalityBadge();
+ else hidePersonalityBadge();
+ }
+ window.addEventListener("hashchange", syncHeaderForRoute);
+ syncHeaderForRoute();
+
+ router.start();
+}
+
+if (document.readyState === "loading") {
+ document.addEventListener("DOMContentLoaded", boot, { once: true });
+} else {
+ boot();
+}
diff --git a/src/peachy/static/js/orb.js b/src/peachy/static/js/orb.js
new file mode 100644
index 0000000000000000000000000000000000000000..7d739b7f39635ff973a45ac7b161e1522f8e910d
--- /dev/null
+++ b/src/peachy/static/js/orb.js
@@ -0,0 +1,187 @@
+/**
+ * Conversation orb: SSE-driven state machine → CSS data-state attribute.
+ * The root is a - the talk view uses it as the mic toggle.
+ */
+
+import { h } from "./ui.js";
+import { GLOW_BY_STATE, ORB_STATES } from "./constants.js";
+
+/** Map a backend activity reason to a visual state; null means keep current. */
+export function mapActivityToState(reason) {
+ switch (reason) {
+ case "user_speech_started":
+ case "user_transcription_delta":
+ return ORB_STATES.LISTENING;
+
+ case "user_speech_stopped":
+ case "user_transcription_completed":
+ case "response_created":
+ case "tool_call_received":
+ case "tool_result_ready":
+ return ORB_STATES.THINKING;
+
+ case "assistant_audio_delta":
+ return ORB_STATES.SPEAKING;
+
+ case "assistant_transcript_done":
+ return ORB_STATES.IDLE;
+
+ default:
+ return null;
+ }
+}
+
+// The backend never emits an explicit idle event; this timeout returns the orb to idle.
+const IDLE_FALLBACK_MS = 1500;
+
+/** Build the orb DOM. Returns { root, setState, dispose }. */
+export function createOrb({ initialState = ORB_STATES.IDLE, onStateChange } = {}) {
+ let currentState = initialState;
+ let idleTimer = null;
+
+ const indicator = h(
+ "span",
+ { class: "convo-orb__indicator", "aria-hidden": "true" },
+ micIcon(),
+ micOffIcon(),
+ spinnerIndicator(),
+ barsIndicator(),
+ thinkingDotsIndicator(),
+ voiceWaveIcon(),
+ errorIcon()
+ );
+
+ const root = h(
+ "button",
+ {
+ type: "button",
+ class: "convo-orb",
+ dataset: { state: currentState },
+ "aria-label": "Conversation status",
+ style: { "--glow": GLOW_BY_STATE[currentState] },
+ },
+ h("span", { class: "convo-orb__glow", "aria-hidden": "true" }),
+ h("span", { class: "convo-orb__ring", "aria-hidden": "true" }),
+ h("span", { class: "convo-orb__ring-outer", "aria-hidden": "true" }),
+ h("span", { class: "convo-orb__core" }, indicator)
+ );
+
+ /** Update the orb to reflect a new visual state. */
+ function setState(nextState) {
+ if (!Object.values(ORB_STATES).includes(nextState)) return;
+ if (nextState === currentState) {
+ bumpIdleTimer(nextState); // refresh timer on repeated events (e.g. continued audio deltas)
+ return;
+ }
+ currentState = nextState;
+ root.dataset.state = nextState;
+ root.style.setProperty("--glow", GLOW_BY_STATE[nextState]);
+ bumpIdleTimer(nextState);
+ onStateChange?.(nextState);
+ }
+
+ function bumpIdleTimer(state) {
+ if (idleTimer != null) {
+ clearTimeout(idleTimer);
+ idleTimer = null;
+ }
+ const transient =
+ state === ORB_STATES.LISTENING ||
+ state === ORB_STATES.THINKING ||
+ state === ORB_STATES.SPEAKING;
+ if (!transient) return;
+ idleTimer = setTimeout(() => {
+ idleTimer = null;
+ setState(ORB_STATES.IDLE);
+ }, IDLE_FALLBACK_MS);
+ }
+
+ /** Stop any pending timer. Call before detaching the DOM node. */
+ function dispose() {
+ if (idleTimer != null) {
+ clearTimeout(idleTimer);
+ idleTimer = null;
+ }
+ }
+
+ return { root, setState, dispose };
+}
+
+// Indicators — stacked in the same grid cell, toggled via CSS data-state rules.
+
+function barsIndicator() {
+ return h(
+ "span",
+ { class: "ind ind-bars" },
+ h("span", { class: "bar" }),
+ h("span", { class: "bar" }),
+ h("span", { class: "bar" }),
+ h("span", { class: "bar" }),
+ h("span", { class: "bar" })
+ );
+}
+
+function thinkingDotsIndicator() {
+ return h(
+ "span",
+ { class: "ind ind-thinking" },
+ h("span", { class: "dot" }),
+ h("span", { class: "dot" }),
+ h("span", { class: "dot" })
+ );
+}
+
+function spinnerIndicator() {
+ return h("span", { class: "ind ind-spinner" });
+}
+
+function voiceWaveIcon() {
+ return h("span", {
+ class: "ind ind-voice",
+ html: `
+
+
+
+
+ `,
+ });
+}
+
+function micIcon() {
+ return h("span", {
+ class: "ind ind-mic",
+ html: `
+
+
+
+
+
+ `,
+ });
+}
+
+function micOffIcon() {
+ return h("span", {
+ class: "ind ind-mic-off",
+ html: `
+
+
+
+
+
+
+ `,
+ });
+}
+
+function errorIcon() {
+ return h("span", {
+ class: "ind ind-error",
+ html: `
+
+
+
+
+ `,
+ });
+}
diff --git a/src/peachy/static/js/pending-apply.js b/src/peachy/static/js/pending-apply.js
new file mode 100644
index 0000000000000000000000000000000000000000..dade7c032291992bf64539645c6493ae27e4be1b
--- /dev/null
+++ b/src/peachy/static/js/pending-apply.js
@@ -0,0 +1,33 @@
+/**
+ * Cross-view hand-off for an in-flight personality apply: set by home.js
+ * before navigating to /talk, consumed by talk.js to drive its caption.
+ */
+
+let pending = null;
+
+/**
+ * Record an in-flight personality apply.
+ *
+ * @param {{ name: string, promise: Promise }} entry
+ */
+export function setPendingApply(entry) {
+ if (!entry || typeof entry.promise?.then !== "function") {
+ pending = null;
+ return;
+ }
+ pending = entry;
+ // Avoid an unhandledrejection if /talk never mounts to consume this.
+ entry.promise.catch(() => {});
+}
+
+/**
+ * Read and clear the in-flight apply, if any. Single-shot by design:
+ * the consumer (talk view) owns the lifecycle from here on.
+ *
+ * @returns {{ name: string, promise: Promise } | null}
+ */
+export function consumePendingApply() {
+ const entry = pending;
+ pending = null;
+ return entry;
+}
diff --git a/src/peachy/static/js/personality-badge.js b/src/peachy/static/js/personality-badge.js
new file mode 100644
index 0000000000000000000000000000000000000000..ca0e9298cf8efe1e67d9666ccdeafb4b93bab8ba
--- /dev/null
+++ b/src/peachy/static/js/personality-badge.js
@@ -0,0 +1,41 @@
+/**
+ * Header personality badge: avatar + "Personality" label + active profile name.
+ * Lives in the app shell (index.html) so it persists across view changes.
+ */
+
+import { avatarFor } from "./constants.js";
+import { prettifyProfileName } from "./ui.js";
+
+let rootEl = null;
+let rowEl = null;
+let nameEl = null;
+let avatarImg = null;
+
+/** Bind setters to the static markup. Safe to call multiple times. */
+export function mountPersonalityBadge(headerRoot = document) {
+ const next = headerRoot.querySelector('[data-component="personality-badge"]');
+ if (!next) return;
+ rootEl = next;
+ rowEl = next.closest('[data-component="personality-row"]');
+ nameEl = next.querySelector(".app-shell__personality-name");
+ avatarImg = next.querySelector(".app-shell__personality-avatar img");
+}
+
+/** Update the badge content. Pass a falsy name to keep the previous value. */
+export function setPersonality(rawName) {
+ if (!rootEl || !nameEl || !avatarImg) return;
+ if (!rawName) return;
+ const cleanName = String(rawName).replace(/^user_personalities\//, "");
+ nameEl.textContent = prettifyProfileName(rawName);
+ avatarImg.src = avatarFor(cleanName);
+}
+
+export function showPersonalityBadge() {
+ if (rowEl) rowEl.hidden = false;
+ else if (rootEl) rootEl.hidden = false;
+}
+
+export function hidePersonalityBadge() {
+ if (rowEl) rowEl.hidden = true;
+ else if (rootEl) rootEl.hidden = true;
+}
diff --git a/src/peachy/static/js/router.js b/src/peachy/static/js/router.js
new file mode 100644
index 0000000000000000000000000000000000000000..81e72f15f257e6fe1b7227e0409c04bc122c28e3
--- /dev/null
+++ b/src/peachy/static/js/router.js
@@ -0,0 +1,62 @@
+/**
+ * Minimal hash router. Handlers receive a ViewContext { outlet, signal, route };
+ * signal is aborted when the view is replaced so cleanups (timers, SSE) can use it.
+ */
+
+export function createRouter(routes, { fallback = "#/", outlet } = {}) {
+ if (!outlet) throw new Error("createRouter: outlet is required");
+ let currentController = null;
+ let lastRoute = null;
+
+ function resolve() {
+ const raw = window.location.hash || fallback;
+ return Object.prototype.hasOwnProperty.call(routes, raw) ? raw : fallback;
+ }
+
+ function dispatch() {
+ const route = resolve();
+ if (route === lastRoute) return;
+
+ // Tear down the previous view first.
+ if (currentController) {
+ currentController.abort();
+ currentController = null;
+ }
+ outlet.replaceChildren();
+
+ lastRoute = route;
+ currentController = new AbortController();
+ /** @type {ViewContext} */
+ const ctx = { outlet, signal: currentController.signal, route };
+ try {
+ routes[route](ctx);
+ } catch (error) {
+ console.error("Route handler failed for", route, error);
+ outlet.replaceChildren(renderRouteError(route, error));
+ }
+ }
+
+ function renderRouteError(route, error) {
+ const div = document.createElement("div");
+ div.className = "route-error";
+ div.textContent = `Failed to render ${route}: ${error?.message || error}`;
+ return div;
+ }
+
+ return {
+ start() {
+ window.addEventListener("hashchange", dispatch);
+ const target = resolve();
+ if (window.location.hash !== target) {
+ window.location.replace(target);
+ }
+ dispatch();
+ },
+ /** Navigate and dispatch synchronously; the resulting hashchange is a no-op via lastRoute. */
+ navigate(route) {
+ if (window.location.hash === route) return;
+ window.location.hash = route;
+ dispatch();
+ },
+ };
+}
diff --git a/src/peachy/static/js/ui.js b/src/peachy/static/js/ui.js
new file mode 100644
index 0000000000000000000000000000000000000000..0b4dd1ab96d7738e25551267c5eebedad5cccc82
--- /dev/null
+++ b/src/peachy/static/js/ui.js
@@ -0,0 +1,49 @@
+/** Tiny DOM helpers: h(tag, attrs, ...children), $, prettifyProfileName. */
+export function h(tag, attrs = {}, ...children) {
+ const el = document.createElement(tag);
+ for (const [key, value] of Object.entries(attrs || {})) {
+ if (value == null || value === false) continue;
+ if (key === "class") {
+ el.className = Array.isArray(value) ? value.filter(Boolean).join(" ") : String(value);
+ } else if (key === "style" && typeof value === "object") {
+ Object.assign(el.style, value);
+ } else if (key === "dataset" && typeof value === "object") {
+ for (const [dk, dv] of Object.entries(value)) {
+ if (dv != null) el.dataset[dk] = String(dv);
+ }
+ } else if (key.startsWith("on") && typeof value === "function") {
+ el.addEventListener(key.slice(2).toLowerCase(), value);
+ } else if (key === "html") {
+ // Escape hatch for trusted HTML (e.g. inline SVG icons we author).
+ el.innerHTML = String(value);
+ } else {
+ el.setAttribute(key, String(value));
+ }
+ }
+ appendChildren(el, children);
+ return el;
+}
+
+function appendChildren(parent, children) {
+ for (const child of children.flat(Infinity)) {
+ if (child == null || child === false || child === true) continue;
+ if (child instanceof Node) {
+ parent.appendChild(child);
+ } else {
+ parent.appendChild(document.createTextNode(String(child)));
+ }
+ }
+}
+
+export function $(selector, root = document) {
+ return root.querySelector(selector);
+}
+
+export function prettifyProfileName(name) {
+ const stripped = name.replace(/^user_personalities\//, "");
+ return stripped
+ .split(/[_-]/)
+ .filter(Boolean)
+ .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+ .join(" ");
+}
diff --git a/src/peachy/static/js/views/home.js b/src/peachy/static/js/views/home.js
new file mode 100644
index 0000000000000000000000000000000000000000..e24f92d4a2c8af18748ae7155d16887c9e30d0b3
--- /dev/null
+++ b/src/peachy/static/js/views/home.js
@@ -0,0 +1,328 @@
+/** Home view: grid of personality cards. Select one to apply it and navigate to Talk. */
+
+import {
+ applyPersonality,
+ deletePersonality,
+ describeError,
+ listPersonalities,
+ loadPersonality,
+ savePersonality,
+ untilReady,
+} from "../api.js";
+import {
+ AVATAR_BY_PROFILE,
+ BUILT_IN_DEFAULT_OPTION,
+ ROUTES,
+ avatarFor,
+} from "../constants.js";
+import { $, h, prettifyProfileName } from "../ui.js";
+import { openProfileModal } from "../components/profile-modal.js";
+import { confirmDialog } from "../components/confirm-dialog.js";
+import { setPendingApply } from "../pending-apply.js";
+import { setPersonality } from "../personality-badge.js";
+
+export async function mountHomeView({ outlet, signal, navigate }) {
+ const view = h(
+ "section",
+ { class: "view view--home" },
+ h(
+ "header",
+ { class: "view-header" },
+ h("h1", { class: "view-title" }, "Choose a personality"),
+ h(
+ "p",
+ { class: "view-subtitle" },
+ "Pick how Reachy Mini should think and talk. Tap a card to start a conversation."
+ )
+ ),
+ h("div", { class: "personality-grid", role: "list" }, h("p", { class: "muted" }, "Loading…"))
+ );
+ outlet.replaceChildren(view);
+
+ const grid = $(".personality-grid", view);
+ const status = h("p", { class: "view-status", role: "status", "aria-live": "polite" });
+ view.appendChild(status);
+
+ let personalities;
+ try {
+ personalities = await untilReady(listPersonalities, signal, () => {
+ grid.replaceChildren();
+ grid.appendChild(h("p", { class: "muted" }, "Waiting for Reachy to finish starting…"));
+ });
+ } catch (error) {
+ if (signal.aborted) return;
+ grid.replaceChildren();
+ grid.appendChild(renderError("Could not list personalities", error));
+ return;
+ }
+ if (signal.aborted) return;
+
+ const choices = (personalities?.choices || []).filter((name) => name !== BUILT_IN_DEFAULT_OPTION);
+ const current = personalities?.current;
+ const lockedTo = personalities?.locked ? personalities.locked_to : null;
+
+ grid.replaceChildren();
+ for (const name of choices) {
+ const disabled = Boolean(lockedTo) && name !== lockedTo;
+ const editable = name.startsWith("user_personalities/") && !disabled;
+ grid.appendChild(
+ buildPersonalityCard({
+ name,
+ isActive: name === current,
+ disabled,
+ onSelect: () => handleSelection(name),
+ onEdit: editable ? () => handleEditClick(name) : null,
+ // No delete affordance for the active personality: it would keep
+ // running with no card to manage it.
+ onDelete: editable && name !== current ? (slot) => handleDeleteClick(name, slot) : null,
+ })
+ );
+ }
+ grid.appendChild(buildCustomCard({ onClick: handleCustomClick }));
+
+ if (lockedTo) {
+ status.textContent = `Profile locked to "${lockedTo}" by REACHY_MINI_LOCKED_PROFILE; switching is disabled.`;
+ status.classList.add("is-warning");
+ }
+
+ function handleSelection(name) {
+ if (name === current) {
+ setPersonality(name);
+ setPendingApply(null);
+ navigate(ROUTES.TALK);
+ return;
+ }
+ // Optimistic header update so the badge already reads the chosen
+ // personality while the apply request is still in flight.
+ setPersonality(name);
+ // Fire-and-forget: hand the apply promise to talk.js so the user sees
+ // the orb in CONNECTING immediately instead of waiting on home.
+ setPendingApply({ name, promise: applyPersonality(name, { persist: false }) });
+ navigate(ROUTES.TALK);
+ }
+
+ async function handleCustomClick() {
+ // Load the available tool palette so the modal can offer a checklist.
+ let defaults;
+ try {
+ defaults = await loadPersonality(BUILT_IN_DEFAULT_OPTION);
+ } catch (error) {
+ if (signal.aborted) return;
+ status.textContent = `Could not load tools: ${describeError(error)}`;
+ status.classList.add("is-error");
+ return;
+ }
+ if (signal.aborted) return;
+
+ const created = await openProfileModal({
+ mode: "create",
+ availableTools: defaults?.available_tools || [],
+ signal,
+ });
+ if (!created || signal.aborted) return;
+ status.classList.remove("is-warning", "is-error");
+ status.textContent = `Saving "${created.name}"…`;
+ let newName;
+ try {
+ const saveResult = await savePersonality({
+ name: created.name,
+ instructions: created.instructions,
+ greeting: created.greeting || null,
+ tools_text: created.tools.join("\n"),
+ voice: "", // falls back to backend default; user can change in Settings
+ });
+ if (signal.aborted) return;
+ newName = saveResult?.value || created.name;
+ } catch (error) {
+ if (signal.aborted) return;
+ status.textContent = `Failed to create profile: ${describeError(error)}`;
+ status.classList.add("is-error");
+ return;
+ }
+ setPersonality(newName);
+ setPendingApply({ name: newName, promise: applyPersonality(newName, { persist: false }) });
+ navigate(ROUTES.TALK);
+ }
+
+ async function handleEditClick(name) {
+ status.classList.remove("is-warning", "is-error");
+ let data;
+ try {
+ data = await loadPersonality(name);
+ } catch (error) {
+ if (signal.aborted) return;
+ status.textContent = `Could not load "${prettifyProfileName(name)}": ${describeError(error)}`;
+ status.classList.add("is-error");
+ return;
+ }
+ if (signal.aborted) return;
+
+ const edited = await openProfileModal({
+ mode: "edit",
+ availableTools: data?.available_tools || [],
+ initial: {
+ name,
+ instructions: data?.instructions || "",
+ greeting: data?.greeting || "",
+ enabledTools: data?.enabled_tools || [],
+ },
+ signal,
+ });
+ if (!edited || signal.aborted) return;
+
+ status.textContent = `Saving "${prettifyProfileName(name)}"…`;
+ try {
+ await savePersonality({
+ // Strip the prefix: the save endpoint always writes under user_personalities/.
+ name: stripUserPrefix(name),
+ instructions: edited.instructions,
+ greeting: edited.greeting,
+ tools_text: edited.tools.join("\n"),
+ voice: data?.voice || "", // keep the profile's existing voice
+ });
+ } catch (error) {
+ if (signal.aborted) return;
+ status.textContent = `Failed to save: ${describeError(error)}`;
+ status.classList.add("is-error");
+ return;
+ }
+ if (signal.aborted) return;
+
+ // Editing the live personality restarts the conversation and reloads the tool registry;
+ // otherwise the changes take effect the next time it is selected.
+ if (name === current) {
+ setPersonality(name);
+ setPendingApply({ name, promise: applyPersonality(name, { persist: false }) });
+ navigate(ROUTES.TALK);
+ } else {
+ status.textContent = `Saved "${prettifyProfileName(name)}". It will apply next time you select it.`;
+ }
+ }
+
+ async function handleDeleteClick(name, slot) {
+ const ok = await confirmDialog({
+ title: "Delete personality?",
+ message: `"${prettifyProfileName(name)}" will be permanently removed.`,
+ confirmLabel: "Delete",
+ danger: true,
+ });
+ if (!ok || signal.aborted) return;
+ status.classList.remove("is-warning", "is-error");
+ try {
+ await deletePersonality(name);
+ } catch (error) {
+ if (signal.aborted) return;
+ status.textContent = `Failed to delete: ${describeError(error)}`;
+ status.classList.add("is-error");
+ return;
+ }
+ if (signal.aborted) return;
+ slot.remove();
+ status.textContent = `Deleted "${prettifyProfileName(name)}".`;
+ }
+}
+
+function buildPersonalityCard({ name, isActive, disabled, onSelect, onEdit, onDelete }) {
+ const hasAvatar = Object.prototype.hasOwnProperty.call(AVATAR_BY_PROFILE, stripUserPrefix(name));
+ const card = h(
+ "button",
+ {
+ type: "button",
+ class: ["personality-card", isActive && "is-active", disabled && "is-disabled"],
+ disabled: disabled ? "disabled" : null,
+ "aria-pressed": isActive ? "true" : "false",
+ "aria-label": `Use personality ${prettifyProfileName(name)}`,
+ onClick: disabled ? undefined : onSelect,
+ },
+ h(
+ "span",
+ { class: "personality-card__avatar" },
+ h("img", {
+ src: avatarFor(stripUserPrefix(name)),
+ alt: "",
+ loading: "lazy",
+ "aria-hidden": "true", // card label already names the personality
+
+ class: !hasAvatar ? "personality-card__avatar--fallback" : null,
+ })
+ ),
+ h("span", { class: "personality-card__name" }, prettifyProfileName(name)),
+ isActive && checkBadge()
+ );
+ // Wrap so the edit/delete buttons are siblings, not nested s inside the card button.
+ const slot = h("div", { class: "personality-card-slot", role: "listitem" }, card);
+ if (onDelete) slot.appendChild(buildDeleteButton({ name, onDelete: () => onDelete(slot) }));
+ if (onEdit) slot.appendChild(buildEditButton({ name, onEdit }));
+ return slot;
+}
+
+/** Small overlay button to delete a user personality, anchored left of the edit button. */
+function buildDeleteButton({ name, onDelete }) {
+ return h("button", {
+ type: "button",
+ class: "personality-card__delete",
+ "aria-label": `Delete personality ${prettifyProfileName(name)}`,
+ onClick: onDelete,
+ html: `
+
+
+
+
+
+
+ `,
+ });
+}
+
+/** Small overlay button to edit a user personality, anchored to the card corner. */
+function buildEditButton({ name, onEdit }) {
+ return h("button", {
+ type: "button",
+ class: "personality-card__edit",
+ "aria-label": `Edit personality ${prettifyProfileName(name)}`,
+ onClick: onEdit,
+ html: `
+
+
+
+ `,
+ });
+}
+
+function checkBadge() {
+ const badge = h("span", { class: "personality-card__badge", "aria-hidden": "true" });
+ badge.innerHTML = `
+
+
+ `;
+ return badge;
+}
+
+function buildCustomCard({ onClick }) {
+ return h(
+ "button",
+ {
+ type: "button",
+ class: "personality-card personality-card--custom",
+ role: "listitem",
+ "aria-label": "Create a custom personality",
+ onClick,
+ },
+ h("span", { class: "personality-card__plus", "aria-hidden": "true" }, "+"),
+ h("span", { class: "personality-card__name" }, "Custom"),
+ h("span", { class: "personality-card__hint" }, "Write your own prompt")
+ );
+}
+
+function stripUserPrefix(name) {
+ return name.replace(/^user_personalities\//, "");
+}
+
+function renderError(label, error) {
+ return h(
+ "div",
+ { class: "view-error" },
+ h("p", null, label),
+ h("p", { class: "muted small" }, describeError(error))
+ );
+}
diff --git a/src/peachy/static/js/views/settings.js b/src/peachy/static/js/views/settings.js
new file mode 100644
index 0000000000000000000000000000000000000000..1216406abd199ee21b44ea07ce06996b2378ced3
--- /dev/null
+++ b/src/peachy/static/js/views/settings.js
@@ -0,0 +1,405 @@
+/** Settings view: realtime provider connection, voice, and status. */
+
+import {
+ applyVoice,
+ describeError,
+ getCurrentVoice,
+ getStatus,
+ listVoices,
+ reconnectBackend,
+ saveBackendConfig,
+ untilReady,
+} from "../api.js";
+import { h } from "../ui.js";
+
+const HF_CONNECTION_MODES = Object.freeze({
+ DEPLOYED: "deployed",
+ LOCAL: "local",
+});
+
+const DEFAULT_HF_HOST = "localhost";
+const DEFAULT_HF_PORT = 8765;
+
+const HF_MODE_HINTS = Object.freeze({
+ [HF_CONNECTION_MODES.DEPLOYED]: "Uses the hosted Hugging Face backend. No API key required.",
+ [HF_CONNECTION_MODES.LOCAL]: "Connects directly to the host and port below.",
+});
+
+export async function mountSettingsView({ outlet, signal }) {
+ const connectionSection = buildConnectionSection({
+ onSaved: () =>
+ Promise.all([
+ refreshStatus({ statusSection, connectionSection, signal }),
+ refreshVoices({ voiceSection, signal }),
+ ]),
+ });
+ const voiceSection = buildVoiceSection();
+ const statusSection = buildStatusSection();
+
+ const view = h(
+ "section",
+ { class: "view view--settings" },
+ h(
+ "header",
+ { class: "view-header" },
+ h("h1", { class: "view-title" }, "Settings"),
+ h("p", { class: "view-subtitle" }, "Connection and voice for Reachy Mini.")
+ ),
+ connectionSection.element,
+ voiceSection.element,
+ statusSection.element
+ );
+ outlet.replaceChildren(view);
+
+ await Promise.all([
+ refreshStatus({ statusSection, connectionSection, signal }),
+ refreshVoices({ voiceSection, signal }),
+ ]);
+}
+
+function buildConnectionSection({ onSaved } = {}) {
+ const providerSelect = h(
+ "select",
+ { class: "settings-select", name: "provider" },
+ h("option", { value: "openai" }, "OpenAI Realtime"),
+ h("option", { value: "huggingface" }, "Hugging Face")
+ );
+ const openaiKeyInput = h("input", {
+ class: "settings-input",
+ name: "openai_api_key",
+ type: "password",
+ autocomplete: "new-password",
+ placeholder: "Leave blank to keep the saved key",
+ });
+ const openaiModelInput = h("input", {
+ class: "settings-input",
+ name: "openai_model",
+ type: "text",
+ value: "gpt-realtime",
+ });
+ const hfModeSelect = h(
+ "select",
+ { class: "settings-select", name: "hf_mode" },
+ h("option", { value: HF_CONNECTION_MODES.DEPLOYED }, "Hosted"),
+ h("option", { value: HF_CONNECTION_MODES.LOCAL }, "Local")
+ );
+ const hfHostInput = h("input", {
+ type: "text",
+ name: "hf_host",
+ autocomplete: "off",
+ placeholder: DEFAULT_HF_HOST,
+ value: DEFAULT_HF_HOST,
+ class: "settings-input",
+ });
+ const hfPortInput = h("input", {
+ type: "number",
+ name: "hf_port",
+ min: "1",
+ max: "65535",
+ step: "1",
+ inputmode: "numeric",
+ value: String(DEFAULT_HF_PORT),
+ class: "settings-input",
+ });
+ const hfLocalFields = h(
+ "div",
+ { class: "settings-field-row", "data-role": "hf-local-fields" },
+ h(
+ "label",
+ { class: "settings-field" },
+ h("span", { class: "settings-label" }, "Host/IP"),
+ hfHostInput
+ ),
+ h(
+ "label",
+ { class: "settings-field" },
+ h("span", { class: "settings-label" }, "Port"),
+ hfPortInput
+ )
+ );
+ const labeledField = (label, control) =>
+ h(
+ "label",
+ { class: "settings-field" },
+ h("span", { class: "settings-label" }, label),
+ control
+ );
+ const openaiFields = h(
+ "div",
+ { class: "settings-provider-fields", "data-provider": "openai" },
+ labeledField("API key", openaiKeyInput),
+ labeledField("Model", openaiModelInput)
+ );
+ const hfFields = h(
+ "div",
+ { class: "settings-provider-fields", "data-provider": "huggingface" },
+ labeledField("Hugging Face connection", hfModeSelect),
+ hfLocalFields
+ );
+ const hint = h("p", { class: "settings-hint" }, "");
+ const status = h("p", { class: "settings-status", role: "status", "aria-live": "polite" });
+
+ const form = h(
+ "form",
+ { class: "settings-form" },
+ labeledField("Realtime provider", providerSelect),
+ openaiFields,
+ hfFields,
+ hint,
+ h(
+ "div",
+ { class: "settings-actions" },
+ h("button", { type: "submit", class: "btn btn--primary" }, "Save connection")
+ ),
+ status
+ );
+
+ const element = h(
+ "section",
+ { class: "settings-section" },
+ h("h2", { class: "settings-section-title" }, "Connection"),
+ form
+ );
+
+ function syncLocalFields() {
+ const isHf = providerSelect.value === "huggingface";
+ const isLocal = isHf && hfModeSelect.value === HF_CONNECTION_MODES.LOCAL;
+ hfLocalFields.style.display = isLocal ? "" : "none";
+ hfHostInput.disabled = !isLocal;
+ hfPortInput.disabled = !isLocal;
+ hfHostInput.required = isLocal;
+ hfPortInput.required = isLocal;
+ hint.textContent = isHf
+ ? HF_MODE_HINTS[hfModeSelect.value] || ""
+ : "Uses OpenAI Realtime with a locally stored API key.";
+ }
+
+ const syncProviderFields = () => {
+ openaiFields.hidden = providerSelect.value !== "openai";
+ hfFields.hidden = providerSelect.value !== "huggingface";
+ openaiKeyInput.disabled = providerSelect.value !== "openai";
+ openaiModelInput.disabled = providerSelect.value !== "openai";
+ hfModeSelect.disabled = providerSelect.value !== "huggingface";
+ syncLocalFields();
+ };
+ providerSelect.addEventListener("change", syncProviderFields);
+ hfModeSelect.addEventListener("change", syncLocalFields);
+
+ form.addEventListener("submit", async (event) => {
+ event.preventDefault();
+ status.classList.remove("is-error");
+ status.textContent = "Saving…";
+ try {
+ const payload = { provider: providerSelect.value };
+ if (providerSelect.value === "openai") {
+ payload.openai_api_key = openaiKeyInput.value.trim();
+ payload.openai_model = openaiModelInput.value.trim();
+ } else {
+ payload.hf_mode = hfModeSelect.value;
+ if (hfModeSelect.value === HF_CONNECTION_MODES.LOCAL) {
+ payload.hf_host = hfHostInput.value.trim();
+ payload.hf_port = Number.parseInt(hfPortInput.value, 10);
+ }
+ }
+ const result = await saveBackendConfig(payload);
+ status.textContent =
+ result?.message || (result?.requires_restart ? "Saved. Restart the app to apply." : "Saved.");
+ await onSaved?.();
+ } catch (error) {
+ status.textContent = `Failed to save: ${describeError(error)}`;
+ status.classList.add("is-error");
+ }
+ });
+
+ syncProviderFields();
+
+ return {
+ element,
+ syncFromStatus(payload) {
+ if (["openai", "huggingface"].includes(payload?.provider)) {
+ providerSelect.value = payload.provider;
+ }
+ openaiKeyInput.value = "";
+ openaiModelInput.value = payload?.openai_model || "gpt-realtime";
+ if (Object.values(HF_CONNECTION_MODES).includes(payload?.hf_connection_mode)) {
+ hfModeSelect.value = payload.hf_connection_mode;
+ }
+ if (payload?.hf_direct_host) {
+ hfHostInput.value = payload.hf_direct_host;
+ }
+ if (payload?.hf_direct_port != null) {
+ hfPortInput.value = String(payload.hf_direct_port);
+ }
+ syncProviderFields();
+ },
+ };
+}
+
+function buildVoiceSection() {
+ const select = h("select", { class: "settings-select", name: "voice" });
+ const status = h("p", { class: "settings-status", role: "status", "aria-live": "polite" });
+ const form = h(
+ "form",
+ { class: "settings-form" },
+ h("label", { class: "settings-field" }, h("span", { class: "settings-label" }, "Voice"), select),
+ h(
+ "div",
+ { class: "settings-actions" },
+ h("button", { type: "submit", class: "btn btn--primary" }, "Apply voice")
+ ),
+ status
+ );
+
+ const element = h(
+ "section",
+ { class: "settings-section" },
+ h("h2", { class: "settings-section-title" }, "Voice"),
+ form
+ );
+
+ form.addEventListener("submit", async (event) => {
+ event.preventDefault();
+ status.classList.remove("is-error");
+ if (!select.value) return;
+ status.textContent = "Applying…";
+ try {
+ const result = await applyVoice(select.value);
+ status.textContent = result?.status || "Voice applied.";
+ } catch (error) {
+ status.textContent = `Failed to apply: ${describeError(error)}`;
+ status.classList.add("is-error");
+ }
+ });
+
+ return {
+ element,
+ setOptions(voices, current) {
+ select.replaceChildren();
+ for (const v of voices) {
+ const opt = h("option", { value: v }, v);
+ if (v === current) opt.selected = true;
+ select.appendChild(opt);
+ }
+ },
+ };
+}
+
+function buildStatusSection() {
+ const list = h("dl", { class: "settings-status-grid" });
+ const reconnectButton = h(
+ "button",
+ { type: "button", class: "btn btn--secondary" },
+ "Reconnect"
+ );
+ const reconnectStatus = h("p", {
+ class: "settings-status",
+ role: "status",
+ "aria-live": "polite",
+ });
+ reconnectButton.addEventListener("click", async () => {
+ reconnectButton.disabled = true;
+ reconnectStatus.classList.remove("is-error");
+ reconnectStatus.textContent = "Reconnecting…";
+ try {
+ const result = await reconnectBackend();
+ reconnectStatus.textContent = result?.message || "Reconnect requested.";
+ } catch (error) {
+ reconnectStatus.textContent = `Reconnect failed: ${describeError(error)}`;
+ reconnectStatus.classList.add("is-error");
+ } finally {
+ reconnectButton.disabled = false;
+ }
+ });
+ const element = h(
+ "section",
+ { class: "settings-section" },
+ h("h2", { class: "settings-section-title" }, "Current state"),
+ list,
+ h("div", { class: "settings-actions" }, reconnectButton),
+ reconnectStatus
+ );
+
+ return {
+ element,
+ render(payload) {
+ list.replaceChildren();
+ list.appendChild(statusRow("Provider", payload.provider || "-"));
+ list.appendChild(
+ statusRow(
+ "Provider configuration",
+ payload.provider_state === "ready"
+ ? "Ready"
+ : payload.provider_message || payload.provider_state,
+ payload.provider_state === "ready" ? "ok" : "warn"
+ )
+ );
+ if (payload.provider === "huggingface") {
+ list.appendChild(statusRow("HF connection", formatHfMode(payload.hf_connection_mode)));
+ if (payload.hf_connection_mode === HF_CONNECTION_MODES.LOCAL) {
+ list.appendChild(statusRow("HF target", formatHfTarget(payload)));
+ }
+ }
+ list.appendChild(
+ statusRow(
+ "Connection",
+ payload.backend_connection_state || "not_started",
+ payload.backend_connected ? "ok" : "warn"
+ )
+ );
+ if (payload.requires_restart) {
+ list.appendChild(statusRow("Restart", "Required to apply changes", "warn"));
+ }
+ },
+ };
+}
+
+function statusRow(label, value, tone) {
+ return h(
+ "div",
+ { class: ["settings-status-row", tone && `is-${tone}`] },
+ h("dt", { class: "settings-status-label" }, label),
+ h("dd", { class: "settings-status-value" }, value)
+ );
+}
+
+function formatHfMode(mode) {
+ if (mode === HF_CONNECTION_MODES.LOCAL) return "Local";
+ if (mode === HF_CONNECTION_MODES.DEPLOYED) return "Hosted";
+ return "-";
+}
+
+function formatHfTarget(payload) {
+ const host = payload?.hf_direct_host;
+ const port = payload?.hf_direct_port;
+ if (!host) return "-";
+ return `${host}:${port || DEFAULT_HF_PORT}`;
+}
+
+async function refreshStatus({ statusSection, connectionSection, signal }) {
+ try {
+ const payload = await untilReady(getStatus, signal);
+ if (signal.aborted) return;
+ statusSection.render(payload);
+ connectionSection.syncFromStatus(payload);
+ } catch {
+ // Status panel just stays empty; not critical for the rest of the UI.
+ }
+}
+
+async function refreshVoices({ voiceSection, signal }) {
+ let voices = [];
+ let current = "";
+ try {
+ voices = await untilReady(listVoices, signal);
+ } catch {
+ voices = [];
+ }
+ try {
+ const data = await getCurrentVoice();
+ current = data?.voice || "";
+ } catch {
+ current = "";
+ }
+ if (signal.aborted) return;
+ voiceSection.setOptions(voices, current);
+}
diff --git a/src/peachy/static/js/views/talk.js b/src/peachy/static/js/views/talk.js
new file mode 100644
index 0000000000000000000000000000000000000000..27c13e02291ad86cc78941b45b72f4a3cde5e48f
--- /dev/null
+++ b/src/peachy/static/js/views/talk.js
@@ -0,0 +1,242 @@
+/**
+ * Talk view: conversation orb driven by the SSE activity stream.
+ * Audio I/O runs entirely in Python; the orb doubles as the mic toggle.
+ * Robot stays live, tapping the orb only mutes or unmutes the user's mic.
+ */
+
+import { API_PREFIX, applyPersonality, getMicState, listPersonalities, setMicMuted } from "../api.js";
+import { BUILT_IN_DEFAULT_OPTION, ORB_STATES } from "../constants.js";
+import { createOrb, mapActivityToState } from "../orb.js";
+import { consumePendingApply } from "../pending-apply.js";
+import { setPersonality } from "../personality-badge.js";
+import { h, prettifyProfileName } from "../ui.js";
+
+const SSE_ENDPOINT = `${API_PREFIX}/conversation_events`;
+
+const CAPTION_BY_STATE = Object.freeze({
+ [ORB_STATES.MUTED]: "Muted",
+ [ORB_STATES.IDLE]: "Ready",
+ [ORB_STATES.CONNECTING]: "Connecting to the backend...",
+ [ORB_STATES.LISTENING]: "Listening",
+ [ORB_STATES.THINKING]: "Thinking",
+ [ORB_STATES.SPEAKING]: "Speaking",
+ [ORB_STATES.ERROR]: "Connection error",
+});
+
+export async function mountTalkView({ outlet, signal }) {
+ const pending = consumePendingApply();
+ const micStatePromise = getMicState();
+ let muted = true;
+ let togglePending = false;
+ let activePersonality = null;
+
+ const caption = h("p", { class: "talk__caption" }, CAPTION_BY_STATE[ORB_STATES.CONNECTING]);
+ const defaultAction = document.querySelector('[data-component="default-personality-action"]');
+ if (defaultAction) {
+ defaultAction.hidden = true;
+ defaultAction.addEventListener("click", onSetDefault);
+ }
+ const orb = createOrb({
+ initialState: ORB_STATES.CONNECTING,
+ onStateChange: (state) => {
+ caption.textContent = CAPTION_BY_STATE[state] || "";
+ },
+ });
+ orb.root.addEventListener("click", onMicTap);
+ syncMicAria();
+
+ const view = h(
+ "section",
+ { class: "view view--talk" },
+ h("div", { class: "talk__orb-wrap" }, orb.root),
+ caption
+ );
+ outlet.replaceChildren(view);
+
+ if (pending) {
+ caption.textContent = `Applying "${prettifyProfileName(pending.name)}"…`;
+ try {
+ await pending.promise;
+ } catch (error) {
+ if (signal.aborted) return;
+ orb.setState(ORB_STATES.ERROR);
+ caption.textContent = `Failed to apply personality: ${error?.message || error}`;
+ return;
+ }
+ if (signal.aborted) return;
+ // SSE "ready" will flip the orb to its resting state next tick.
+ caption.textContent = CAPTION_BY_STATE[ORB_STATES.CONNECTING];
+ void refreshPersonalityState();
+ } else {
+ // Deep link to /talk with no pending apply: refresh the header badge.
+ void refreshPersonalityState();
+ }
+
+ try {
+ muted = Boolean((await micStatePromise)?.muted);
+ } catch {
+ // keep the muted default
+ }
+ if (signal.aborted) return;
+ syncMicAria();
+
+ let everConnected = false;
+ const subscription = subscribeConversationEvents({
+ // Re-sync mic state on (re)connect: another tab may have toggled it.
+ onReady: async () => {
+ everConnected = true;
+ if (!togglePending) {
+ try {
+ muted = Boolean((await getMicState())?.muted);
+ } catch {
+ // keep the last known mute state
+ }
+ }
+ if (signal.aborted) return;
+ orb.setState(restingState());
+ caption.textContent = CAPTION_BY_STATE[restingState()];
+ syncMicAria();
+ },
+ onActivity: (reason) => {
+ if (muted) return;
+ const next = mapActivityToState(reason);
+ if (next == null) return;
+ orb.setState(next);
+ },
+ onError: () => {
+ // SSE auto-retries (e.g. 404 before routes exist), so a failure here is transient.
+ orb.setState(ORB_STATES.CONNECTING);
+ caption.textContent = everConnected ? "Reconnecting..." : CAPTION_BY_STATE[ORB_STATES.CONNECTING];
+ },
+ });
+
+ signal.addEventListener("abort", () => {
+ subscription.close();
+ orb.dispose();
+ if (defaultAction) {
+ defaultAction.hidden = true;
+ defaultAction.removeEventListener("click", onSetDefault);
+ }
+ });
+
+ function restingState() {
+ return muted ? ORB_STATES.MUTED : ORB_STATES.IDLE;
+ }
+
+ async function onMicTap() {
+ if (togglePending) return;
+ togglePending = true;
+ try {
+ const data = await setMicMuted(!muted);
+ muted = Boolean(data?.muted);
+ } catch (error) {
+ if (!signal.aborted) {
+ caption.textContent = `Failed to toggle the microphone: ${error?.message || error}`;
+ }
+ return;
+ } finally {
+ togglePending = false;
+ }
+ if (signal.aborted) return;
+ orb.setState(restingState());
+ // setState skips unchanged states, so set the caption explicitly
+ caption.textContent = CAPTION_BY_STATE[restingState()];
+ syncMicAria();
+ }
+
+ async function refreshPersonalityState() {
+ const personalityState = await fetchPersonalityState();
+ if (signal.aborted || personalityState == null) return;
+ activePersonality = personalityState.current;
+ setPersonality(personalityState.badgeName);
+ const shouldHide = personalityState.locked || personalityState.current === personalityState.startup;
+ if (defaultAction) {
+ defaultAction.hidden = shouldHide;
+ }
+ }
+
+ async function onSetDefault() {
+ if (!defaultAction || !activePersonality) return;
+ defaultAction.disabled = true;
+ caption.textContent = `Saving "${displayPersonalityName(activePersonality)}" as default...`;
+ try {
+ await applyPersonality(activePersonality, { persist: true });
+ if (signal.aborted) return;
+ defaultAction.hidden = true;
+ caption.textContent = `"${displayPersonalityName(activePersonality)}" will be used at startup.`;
+ } catch (error) {
+ if (!signal.aborted) {
+ caption.textContent = `Failed to save default: ${error?.message || error}`;
+ }
+ } finally {
+ defaultAction.disabled = false;
+ }
+ }
+
+ function syncMicAria() {
+ orb.root.setAttribute("aria-pressed", String(!muted));
+ orb.root.setAttribute("aria-label", muted ? "Unmute microphone" : "Mute microphone");
+ }
+}
+
+function displayPersonalityName(name) {
+ return name === BUILT_IN_DEFAULT_OPTION ? "Default" : prettifyProfileName(name);
+}
+
+async function fetchPersonalityState() {
+ try {
+ const data = await listPersonalities();
+ const current = data?.current;
+ if (!current) return null;
+ return {
+ current,
+ startup: data?.startup || BUILT_IN_DEFAULT_OPTION,
+ locked: Boolean(data?.locked),
+ badgeName: current === BUILT_IN_DEFAULT_OPTION ? "default" : current,
+ };
+ } catch {
+ return null;
+ }
+}
+
+const SSE_RECONNECT_MS = 2000;
+
+function subscribeConversationEvents({ onActivity, onReady, onError } = {}) {
+ if (typeof onActivity !== "function") {
+ throw new TypeError("subscribeConversationEvents: onActivity is required");
+ }
+
+ let source = null;
+ let retryTimer = null;
+ let closed = false;
+
+ function connect() {
+ source = new EventSource(SSE_ENDPOINT);
+
+ source.addEventListener("activity", (ev) => {
+ const reason = (ev.data || "").trim();
+ if (reason) onActivity(reason);
+ });
+
+ source.addEventListener("ready", () => onReady());
+
+ source.addEventListener("error", (err) => {
+ onError(err);
+ // EventSource gives up on HTTP errors (e.g. 404 while the backend is
+ // still registering routes); recreate it until the route exists.
+ if (!closed && source.readyState === EventSource.CLOSED) {
+ retryTimer = setTimeout(connect, SSE_RECONNECT_MS);
+ }
+ });
+ }
+
+ connect();
+
+ return {
+ close() {
+ closed = true;
+ if (retryTimer != null) clearTimeout(retryTimer);
+ source.close();
+ },
+ };
+}
diff --git a/src/peachy/static/style.css b/src/peachy/static/style.css
new file mode 100644
index 0000000000000000000000000000000000000000..fb0cbca2b6a0caaedf4d51458f614158cfd6f0fd
--- /dev/null
+++ b/src/peachy/static/style.css
@@ -0,0 +1,1332 @@
+/* Sectioned stylesheet, scoped by class name (no global element selectors). */
+
+/* 1. Tokens & reset */
+
+:root {
+ --bg: #0e0f12;
+ --bg-soft: #15171c;
+ --bg-elev: #1c1f26;
+ --bg-elev-hover: #232730;
+ --border: #2a2f3a;
+ --border-strong: #3a4150;
+ --text: #f4f5f7;
+ --text-soft: #b8bdc7;
+ --text-muted: #7d8390;
+ --accent: #ff9500;
+ --accent-soft: rgba(255, 149, 0, 0.18);
+ --danger: #ff6a75;
+ --success: #34d399;
+ --warn: #f59e0b;
+
+ --radius-sm: 8px;
+ --radius: 14px;
+ --radius-lg: 22px;
+
+ --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.35);
+ --shadow-lg: 0 16px 48px rgba(0, 0, 0, 0.45);
+
+ --font-stack: -apple-system, BlinkMacSystemFont, "Segoe UI", "SF Pro Text",
+ "Inter", system-ui, sans-serif;
+
+ --transition-fast: 0.18s ease;
+ --transition: 0.25s ease;
+}
+
+/* ?theme= (set by the desktop app) overrides the OS preference below. */
+@media (prefers-color-scheme: light) {
+ :root:not([data-theme]) {
+ --bg: #f6f7fa;
+ --bg-soft: #eceff5;
+ --bg-elev: #ffffff;
+ --bg-elev-hover: #f0f3fa;
+ --border: #d8dde6;
+ --border-strong: #b9c0cd;
+ --text: #1c2028;
+ --text-soft: #4a525f;
+ --text-muted: #7e8695;
+ --shadow-sm: 0 2px 8px rgba(20, 25, 40, 0.08);
+ --shadow-lg: 0 16px 48px rgba(20, 25, 40, 0.18);
+ }
+}
+
+:root[data-theme="light"] {
+ --bg: #f6f7fa;
+ --bg-soft: #eceff5;
+ --bg-elev: #ffffff;
+ --bg-elev-hover: #f0f3fa;
+ --border: #d8dde6;
+ --border-strong: #b9c0cd;
+ --text: #1c2028;
+ --text-soft: #4a525f;
+ --text-muted: #7e8695;
+ --shadow-sm: 0 2px 8px rgba(20, 25, 40, 0.08);
+ --shadow-lg: 0 16px 48px rgba(20, 25, 40, 0.18);
+}
+
+*,
+*::before,
+*::after {
+ box-sizing: border-box;
+}
+
+html,
+body {
+ margin: 0;
+ padding: 0;
+ background: var(--bg);
+ color: var(--text);
+ font-family: var(--font-stack);
+ font-size: 16px;
+ line-height: 1.5;
+ min-height: 100vh;
+ -webkit-font-smoothing: antialiased;
+ -moz-osx-font-smoothing: grayscale;
+}
+
+body {
+ display: flex;
+ flex-direction: column;
+}
+
+a {
+ color: inherit;
+}
+
+button {
+ font-family: inherit;
+}
+
+/* 2. App shell */
+
+.app-shell__header {
+ position: sticky;
+ top: 0;
+ z-index: 10;
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ gap: 16px;
+ padding: 14px 24px;
+ background: color-mix(in srgb, var(--bg) 85%, transparent);
+ backdrop-filter: blur(16px);
+ -webkit-backdrop-filter: blur(16px);
+ border-bottom: 1px solid var(--border);
+}
+
+.app-shell__brand {
+ display: inline-flex;
+ align-items: center;
+ gap: 10px;
+ text-decoration: none;
+ color: var(--text);
+ font-weight: 600;
+ letter-spacing: 0.2px;
+ border-radius: var(--radius-sm);
+ padding: 4px 6px;
+ transition: background var(--transition-fast);
+}
+
+.app-shell__brand:hover {
+ background: var(--bg-elev);
+}
+
+/* SVG offset upward so the head sits centered in the disc, not the body. */
+.app-shell__brand-mark {
+ position: relative;
+ display: inline-block;
+ width: 30px;
+ height: 30px;
+ border-radius: 50%;
+ background: var(--bg-soft);
+ overflow: visible;
+ flex-shrink: 0;
+}
+
+.app-shell__brand-mark img {
+ position: absolute;
+ width: 140%;
+ height: auto;
+ left: 50%;
+ top: 50%;
+ transform: translate(-50%, -57%);
+ pointer-events: none;
+ user-select: none;
+ -webkit-user-drag: none;
+ display: block;
+}
+
+.app-shell__brand-text {
+ font-size: 0.95rem;
+}
+
+/* Lets the Back button toggle via `hidden` without shifting the brand. */
+.app-shell__lead {
+ display: inline-flex;
+ align-items: center;
+ gap: 8px;
+}
+
+/* Fixed below the topbar, outside the header, so the lead/gear layout
+ stays untouched. */
+.app-shell__personality-row {
+ position: fixed;
+ top: 90px;
+ left: 32px;
+ z-index: 9;
+ display: flex;
+ align-items: center;
+ gap: 14px;
+}
+
+.app-shell__personality-row[hidden] {
+ display: none;
+}
+
+.app-shell__personality {
+ display: inline-flex;
+ align-items: center;
+ gap: 16px;
+ padding: 8px 12px;
+ margin: -8px -12px;
+ background: transparent;
+ border: 0;
+ border-radius: 16px;
+ min-width: 0;
+ max-width: 320px;
+ font: inherit;
+ color: inherit;
+ cursor: pointer;
+ appearance: none;
+ transition: background 0.15s ease;
+}
+
+.app-shell__personality:hover {
+ background: var(--bg-soft);
+}
+
+.app-shell__personality:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+
+.app-shell__personality-text {
+ display: flex;
+ flex-direction: column;
+ align-items: flex-start;
+ justify-content: center;
+ min-width: 0;
+ line-height: 1.2;
+}
+
+.app-shell__personality-label {
+ font-size: 0.78rem;
+ font-weight: 600;
+ letter-spacing: 0.12em;
+ text-transform: uppercase;
+ color: var(--text-muted);
+}
+
+.app-shell__personality-name {
+ font-size: 1.35rem;
+ font-weight: 700;
+ color: var(--text);
+ letter-spacing: -0.3px;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+ max-width: 260px;
+}
+
+/* Larger than the brand mark for presence outside the topbar. */
+.app-shell__personality-avatar {
+ position: relative;
+ display: inline-block;
+ width: 64px;
+ height: 64px;
+ border-radius: 50%;
+ background: var(--bg-soft);
+ overflow: visible;
+ flex-shrink: 0;
+}
+
+.app-shell__personality-avatar img {
+ position: absolute;
+ width: 140%;
+ height: auto;
+ left: 50%;
+ top: 50%;
+ transform: translate(-50%, -57%);
+ pointer-events: none;
+ user-select: none;
+ -webkit-user-drag: none;
+ display: block;
+}
+
+.app-shell__default-personality {
+ min-height: 36px;
+ padding: 8px 14px;
+ border: 1px solid color-mix(in srgb, var(--accent) 42%, transparent);
+ border-radius: var(--radius-sm);
+ background: color-mix(in srgb, var(--accent) 16%, var(--bg-elev));
+ color: var(--accent);
+ cursor: pointer;
+ font-size: 0.86rem;
+ font-weight: 700;
+ line-height: 1.2;
+ white-space: nowrap;
+ transition: background var(--transition-fast), border-color var(--transition-fast),
+ color var(--transition-fast), opacity var(--transition-fast);
+}
+
+.app-shell__default-personality[hidden] {
+ display: none;
+}
+
+.app-shell__default-personality:hover:not(:disabled) {
+ border-color: var(--accent);
+ background: var(--accent);
+ color: #17130c;
+}
+
+.app-shell__default-personality:disabled {
+ cursor: wait;
+ opacity: 0.65;
+}
+
+.app-shell__default-personality:focus-visible {
+ outline: none;
+ box-shadow: 0 0 0 3px color-mix(in srgb, var(--accent) 30%, transparent);
+}
+
+/* Shared by the Back and gear buttons so both read as the same control. */
+.app-shell__icon-btn {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ width: 38px;
+ height: 38px;
+ border: 1px solid var(--border);
+ background: var(--bg-elev);
+ color: var(--text-soft);
+ border-radius: 50%;
+ cursor: pointer;
+ padding: 0;
+ transition: color var(--transition-fast), background var(--transition-fast),
+ border-color var(--transition-fast), transform var(--transition-fast);
+}
+
+.app-shell__icon-btn[hidden] {
+ display: none;
+}
+
+.app-shell__icon-btn svg {
+ width: 18px;
+ height: 18px;
+}
+
+.app-shell__icon-btn:hover {
+ color: var(--text);
+ background: var(--bg-elev-hover);
+ border-color: var(--border-strong);
+}
+
+.app-shell__icon-btn:active {
+ transform: scale(0.96);
+}
+
+.app-shell__icon-btn:focus-visible,
+.app-shell__brand:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 2px;
+}
+
+/* Accent tint + rotation signal the gear also closes Settings when active. */
+.app-shell__gear.is-active {
+ color: var(--accent);
+ border-color: color-mix(in srgb, var(--accent) 60%, transparent);
+ background: color-mix(in srgb, var(--accent) 14%, var(--bg-elev));
+}
+
+.app-shell__gear.is-active svg {
+ transform: rotate(60deg);
+ transition: transform var(--transition);
+}
+
+.app-shell__outlet {
+ flex: 1 1 auto;
+ width: 100%;
+ max-width: 1080px;
+ margin: 0 auto;
+ padding: 32px 24px 64px;
+ /* Flex column so the Talk view can claim full height via flex:1 and
+ center vertically; other views just sit at the top. */
+ display: flex;
+ flex-direction: column;
+ min-height: 0;
+}
+
+/* 3. Generic primitives */
+
+.view-header {
+ margin-bottom: 28px;
+}
+
+.view-title {
+ margin: 0 0 6px;
+ font-size: 1.6rem;
+ font-weight: 600;
+ letter-spacing: -0.01em;
+}
+
+.view-subtitle {
+ margin: 0;
+ color: var(--text-soft);
+}
+
+.view-status {
+ margin-top: 18px;
+ color: var(--text-muted);
+ font-size: 0.9rem;
+}
+
+.view-status.is-warning {
+ color: var(--warn);
+}
+
+.view-status.is-error {
+ color: var(--danger);
+}
+
+.view-error {
+ border: 1px dashed var(--border-strong);
+ border-radius: var(--radius);
+ padding: 16px;
+ background: var(--bg-elev);
+}
+
+.muted {
+ color: var(--text-muted);
+}
+
+.muted.small {
+ font-size: 0.85rem;
+}
+
+.btn {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ gap: 8px;
+ border: 1px solid transparent;
+ background: var(--bg-elev);
+ color: var(--text);
+ font-size: 0.95rem;
+ font-weight: 500;
+ padding: 10px 16px;
+ border-radius: var(--radius-sm);
+ cursor: pointer;
+ transition: background var(--transition-fast), border-color var(--transition-fast),
+ transform var(--transition-fast);
+}
+
+.btn:hover:not(:disabled) {
+ background: var(--bg-elev-hover);
+}
+
+.btn:active:not(:disabled) {
+ transform: scale(0.98);
+}
+
+.btn:disabled {
+ opacity: 0.5;
+ cursor: not-allowed;
+}
+
+.btn--primary {
+ background: var(--accent);
+ color: #1a0f00;
+ font-weight: 600;
+}
+
+.btn--primary:hover:not(:disabled) {
+ background: color-mix(in srgb, var(--accent) 90%, white);
+}
+
+.btn--ghost {
+ background: transparent;
+ border-color: var(--border);
+ color: var(--text-soft);
+}
+
+.btn--ghost:hover:not(:disabled) {
+ border-color: var(--border-strong);
+ color: var(--text);
+}
+
+.btn--danger {
+ background: #e5484d;
+ color: #fff;
+ font-weight: 600;
+}
+
+.btn--danger:hover:not(:disabled) {
+ background: color-mix(in srgb, #e5484d 88%, black);
+}
+
+.route-error {
+ margin: 32px;
+ padding: 16px;
+ border-radius: var(--radius-sm);
+ border: 1px solid var(--danger);
+ background: color-mix(in srgb, var(--danger) 12%, transparent);
+ color: var(--text);
+}
+
+/* 4. Home view - personality grid */
+
+.view--home .personality-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+ gap: 18px;
+}
+
+/* Slot wraps a card button + its (optional) edit button so the edit control
+ is a sibling, never a nested inside the card button. */
+.personality-card-slot {
+ position: relative;
+ display: flex;
+}
+
+.personality-card-slot .personality-card {
+ flex: 1;
+ width: 100%;
+}
+
+.personality-card__edit,
+.personality-card__delete {
+ position: absolute;
+ top: 8px;
+ right: 8px;
+ display: grid;
+ place-items: center;
+ width: 30px;
+ height: 30px;
+ padding: 0;
+ border: 0;
+ border-radius: 50%;
+ background: var(--bg-soft);
+ color: var(--text-muted);
+ box-shadow: inset 0 0 0 1px var(--border);
+ cursor: pointer;
+ opacity: 0.55;
+ transition: opacity var(--transition-fast), background var(--transition-fast),
+ color var(--transition-fast);
+}
+
+/* Delete sits just left of the edit button. */
+.personality-card__delete {
+ right: 44px;
+}
+
+.personality-card-slot:hover .personality-card__edit,
+.personality-card-slot:hover .personality-card__delete,
+.personality-card__edit:focus-visible,
+.personality-card__delete:focus-visible {
+ opacity: 1;
+}
+
+.personality-card__edit:hover {
+ background: var(--bg-elev-hover);
+ color: var(--text);
+}
+
+.personality-card__delete:hover {
+ background: color-mix(in srgb, #e5484d 16%, var(--bg-elev));
+ color: #e5484d;
+}
+
+.personality-card__edit svg,
+.personality-card__delete svg {
+ width: 15px;
+ height: 15px;
+}
+
+.personality-card {
+ position: relative;
+ display: flex;
+ flex-direction: column;
+ align-items: center;
+ justify-content: flex-start;
+ gap: 12px;
+ min-height: 196px;
+ padding: 20px 16px 18px;
+ background: var(--bg-elev);
+ border: 0;
+ border-radius: var(--radius);
+ /* Hairline border via inset shadow stays crisp where 1px CSS borders
+ anti-alias, especially at non-integer device pixel ratios. */
+ box-shadow: inset 0 0 0 1px var(--border);
+ cursor: pointer;
+ color: inherit;
+ text-align: center;
+ font: inherit;
+ transition: background var(--transition-fast), box-shadow var(--transition-fast),
+ transform 0.1s ease;
+ -webkit-tap-highlight-color: transparent;
+}
+
+.personality-card:hover:not(:disabled) {
+ background: var(--bg-elev-hover);
+}
+
+.personality-card:active:not(:disabled) {
+ transform: scale(0.97);
+}
+
+.personality-card:focus-visible {
+ box-shadow:
+ inset 0 0 0 2px var(--accent),
+ 0 0 0 3px color-mix(in srgb, var(--accent) 30%, transparent);
+ outline: none;
+}
+
+.personality-card.is-active {
+ background: color-mix(in srgb, var(--accent) 8%, var(--bg-elev));
+ box-shadow: inset 0 0 0 2px var(--accent);
+}
+
+.personality-card.is-active:hover:not(:disabled) {
+ background: color-mix(in srgb, var(--accent) 12%, var(--bg-elev));
+}
+
+.personality-card.is-disabled {
+ opacity: 0.45;
+ cursor: not-allowed;
+}
+
+/* overflow: visible - avatars are full-body illustrations anchored on the
+ head; antennas/hats spill above the disc rim. */
+.personality-card__avatar {
+ position: relative;
+ width: 110px;
+ height: 110px;
+ border-radius: 50%;
+ background: var(--bg-soft);
+ overflow: visible;
+ flex-shrink: 0;
+}
+
+.personality-card__avatar img {
+ position: absolute;
+ width: 140%;
+ height: auto;
+ left: 50%;
+ top: 50%;
+ /* Slight upward bias so the SVG's "head" lands at disc center while
+ the antennas escape above. */
+ transform: translate(-50%, -57%);
+ pointer-events: none;
+ user-select: none;
+ -webkit-user-drag: none;
+ display: block;
+}
+
+.personality-card__avatar img.personality-card__avatar--fallback {
+ opacity: 0.7;
+}
+
+.personality-card__name {
+ font-weight: 600;
+ font-size: 0.95rem;
+ line-height: 1.2;
+ color: var(--text);
+ width: 100%;
+ white-space: nowrap;
+ overflow: hidden;
+ text-overflow: ellipsis;
+}
+
+.personality-card.is-active .personality-card__name {
+ color: var(--accent);
+}
+
+/* Outlined, not filled - the wash + ring + tinted name already signal
+ "selected". */
+.personality-card__badge {
+ position: absolute;
+ top: 10px;
+ right: 10px;
+ width: 22px;
+ height: 22px;
+ padding: 0;
+ border-radius: 50%;
+ background: var(--bg-elev);
+ color: var(--accent);
+ display: grid;
+ place-items: center;
+ box-shadow: inset 0 0 0 2px var(--accent);
+}
+
+.personality-card__badge svg {
+ width: 12px;
+ height: 12px;
+}
+
+.personality-card--custom {
+ background: transparent;
+ box-shadow: inset 0 0 0 1px transparent;
+ /* Dashed insets aren't a thing, so use a real border to override the shadow. */
+ border: 1px dashed var(--border-strong);
+}
+
+.personality-card--custom:hover:not(:disabled) {
+ background: var(--bg-elev);
+ border-color: var(--accent);
+}
+
+.personality-card__plus {
+ width: 110px;
+ height: 110px;
+ border-radius: 50%;
+ display: grid;
+ place-items: center;
+ font-size: 2.6rem;
+ font-weight: 300;
+ color: var(--text-soft);
+ background: var(--bg-soft);
+}
+
+.personality-card__hint {
+ color: var(--text-muted);
+ font-size: 0.78rem;
+}
+
+/* 5. Talk view - orb wrapper, caption, back button */
+
+/* flex: 1 claims the outlet's remaining height so justify-content: center
+ parks the orb in the middle regardless of viewport height. */
+.view--talk {
+ display: flex;
+ flex: 1;
+ flex-direction: column;
+ align-items: center;
+ justify-content: center;
+ gap: 20px;
+}
+
+.talk__profile {
+ font-size: 0.85rem;
+ color: var(--text-muted);
+ text-transform: uppercase;
+ letter-spacing: 0.08em;
+ font-weight: 600;
+ min-height: 1em;
+}
+
+.talk__orb-wrap {
+ display: grid;
+ place-items: center;
+ margin-top: 12px;
+}
+
+.talk__caption {
+ margin: 12px 0 0;
+ color: var(--text-soft);
+ font-size: 1rem;
+ text-align: center;
+ min-height: 1.4em;
+}
+
+/* 6. Settings view */
+
+.view--settings {
+ display: flex;
+ flex-direction: column;
+ gap: 24px;
+}
+
+.settings-section {
+ background: var(--bg-elev);
+ border: 1px solid var(--border);
+ border-radius: var(--radius);
+ padding: 20px 22px;
+}
+
+.settings-section-title {
+ margin: 0 0 14px;
+ font-size: 1.05rem;
+ font-weight: 600;
+ letter-spacing: -0.005em;
+}
+
+.settings-form {
+ display: flex;
+ flex-direction: column;
+ gap: 14px;
+}
+
+.settings-field {
+ display: flex;
+ flex-direction: column;
+ gap: 6px;
+}
+
+.settings-field-row {
+ display: grid;
+ grid-template-columns: minmax(0, 2fr) minmax(120px, 1fr);
+ gap: 12px;
+}
+
+.settings-label {
+ font-size: 0.85rem;
+ color: var(--text-muted);
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+ font-weight: 600;
+}
+
+.settings-input,
+.settings-select {
+ width: 100%;
+ background: var(--bg-soft);
+ border: 1px solid var(--border);
+ color: var(--text);
+ font-size: 0.95rem;
+ padding: 10px 12px;
+ border-radius: var(--radius-sm);
+ transition: border-color var(--transition-fast), background var(--transition-fast);
+}
+
+.settings-input:focus,
+.settings-select:focus {
+ outline: none;
+ border-color: var(--accent);
+ background: var(--bg-elev);
+}
+
+.settings-hint {
+ margin: 0;
+ font-size: 0.85rem;
+ color: var(--text-muted);
+}
+
+.settings-actions {
+ display: flex;
+ gap: 10px;
+}
+
+.settings-status {
+ margin: 0;
+ font-size: 0.85rem;
+ color: var(--text-muted);
+ min-height: 1em;
+}
+
+.settings-status.is-error {
+ color: var(--danger);
+}
+
+.settings-status-grid {
+ display: grid;
+ grid-template-columns: 1fr;
+ gap: 8px;
+ margin: 0;
+}
+
+.settings-status-row {
+ display: grid;
+ grid-template-columns: 180px 1fr;
+ gap: 12px;
+ padding: 8px 12px;
+ border-radius: var(--radius-sm);
+ background: var(--bg-soft);
+}
+
+.settings-status-row.is-warn {
+ background: color-mix(in srgb, var(--warn) 12%, var(--bg-soft));
+}
+
+.settings-status-row.is-ok {
+ background: color-mix(in srgb, var(--success) 10%, var(--bg-soft));
+}
+
+.settings-status-label {
+ margin: 0;
+ font-size: 0.85rem;
+ color: var(--text-muted);
+}
+
+.settings-status-value {
+ margin: 0;
+ font-weight: 500;
+}
+
+@media (max-width: 620px) {
+ .app-shell__personality-row {
+ right: 20px;
+ left: 20px;
+ flex-wrap: wrap;
+ gap: 10px;
+ }
+
+ .app-shell__personality-name {
+ max-width: calc(100vw - 140px);
+ font-size: 1.12rem;
+ }
+
+ .app-shell__personality-avatar {
+ width: 52px;
+ height: 52px;
+ }
+
+ .settings-field-row,
+ .settings-status-row {
+ grid-template-columns: 1fr;
+ }
+}
+
+/* 7. Modal (profile-modal) */
+
+.modal-overlay {
+ position: fixed;
+ inset: 0;
+ z-index: 100;
+ background: rgba(0, 0, 0, 0.55);
+ display: grid;
+ place-items: center;
+ padding: 24px;
+ animation: modal-fade-in 0.18s ease;
+}
+
+@keyframes modal-fade-in {
+ from { opacity: 0; }
+ to { opacity: 1; }
+}
+
+.modal {
+ width: min(560px, 100%);
+ max-height: 90vh;
+ overflow-y: auto;
+ background: var(--bg-elev);
+ border: 1px solid var(--border-strong);
+ border-radius: var(--radius-lg);
+ box-shadow: var(--shadow-lg);
+ padding: 24px 26px 22px;
+ animation: modal-pop-in 0.22s ease;
+}
+
+@keyframes modal-pop-in {
+ from { transform: translateY(8px) scale(0.98); opacity: 0; }
+ to { transform: translateY(0) scale(1); opacity: 1; }
+}
+
+/* Confirmation dialog: a compact modal that replaces window.confirm. */
+.modal--confirm {
+ width: min(420px, 100%);
+}
+
+.modal__title {
+ margin: 0 0 4px;
+ font-size: 1.15rem;
+ font-weight: 600;
+}
+
+.modal__subtitle {
+ margin: 0 0 16px;
+ color: var(--text-muted);
+ font-size: 0.9rem;
+}
+
+.modal__form {
+ display: flex;
+ flex-direction: column;
+ gap: 14px;
+}
+
+.modal__field {
+ display: flex;
+ flex-direction: column;
+ gap: 6px;
+}
+
+.modal__label {
+ font-size: 0.85rem;
+ color: var(--text-muted);
+ text-transform: uppercase;
+ letter-spacing: 0.06em;
+ font-weight: 600;
+}
+
+.modal__input,
+.modal__textarea {
+ background: var(--bg-soft);
+ border: 1px solid var(--border);
+ color: var(--text);
+ font-family: inherit;
+ font-size: 0.95rem;
+ padding: 10px 12px;
+ border-radius: var(--radius-sm);
+ resize: vertical;
+}
+
+.modal__input:focus,
+.modal__textarea:focus {
+ outline: none;
+ border-color: var(--accent);
+ background: var(--bg-elev);
+}
+
+.modal__input.is-readonly {
+ opacity: 0.7;
+ cursor: not-allowed;
+}
+
+.modal__error {
+ margin: 0;
+ min-height: 1em;
+ font-size: 0.85rem;
+ color: var(--danger);
+ visibility: hidden;
+}
+
+.modal__error.is-visible {
+ visibility: visible;
+}
+
+.modal__actions {
+ display: flex;
+ justify-content: flex-end;
+ gap: 10px;
+ margin-top: 4px;
+}
+
+/* Tool checklist (personality creation/editing) */
+.modal__tools {
+ border: none;
+ margin: 0;
+ padding: 0;
+ min-width: 0; /* let the grid shrink inside the flex form */
+}
+
+.modal__tools-grid {
+ display: grid;
+ grid-template-columns: repeat(2, minmax(0, 1fr));
+ gap: 6px 16px;
+ margin-top: 6px;
+ max-height: 220px;
+ overflow-y: auto;
+ padding: 10px 12px;
+ background: var(--bg-soft);
+ border: 1px solid var(--border);
+ border-radius: var(--radius-sm);
+}
+
+.modal__tool {
+ display: flex;
+ align-items: center;
+ gap: 8px;
+ font-size: 0.9rem;
+ color: var(--text);
+ cursor: pointer;
+}
+
+.modal__tool input {
+ accent-color: var(--accent);
+}
+
+/* 8. Conversation orb
+ * Indicators are mounted statically (orb.js) and switched via [data-state]
+ * + the inline --glow colour; Python drives the state, not audio. */
+
+.convo-orb {
+ --glow: #34d399;
+
+ position: relative;
+ width: clamp(220px, 38vw, 320px);
+ aspect-ratio: 1 / 1;
+ border-radius: 50%;
+ border: none;
+ background: transparent;
+ padding: 0;
+ display: grid;
+ place-items: center;
+ color: var(--glow);
+ /* The orb is the mic toggle button (see talk.js). */
+ cursor: pointer;
+ -webkit-tap-highlight-color: transparent;
+ transition: transform 0.18s ease, filter 0.18s ease;
+}
+
+.convo-orb:active {
+ transform: scale(0.97);
+}
+
+.convo-orb:focus-visible {
+ outline: 2px solid var(--accent);
+ outline-offset: 6px;
+}
+
+.convo-orb__glow {
+ position: absolute;
+ inset: 0;
+ border-radius: 50%;
+ background: radial-gradient(circle at center, var(--glow) 0%, transparent 65%);
+ filter: blur(28px);
+ opacity: 0.5;
+ pointer-events: none;
+ transition: opacity 0.25s, background 0.25s, transform 1.4s ease-in-out;
+}
+
+.convo-orb__ring,
+.convo-orb__ring-outer {
+ position: absolute;
+ top: 50%;
+ left: 50%;
+ border-radius: 50%;
+ transform: translate(-50%, -50%);
+ pointer-events: none;
+ transition: opacity 0.4s ease, border-color 0.4s ease, transform 0.3s ease;
+}
+
+.convo-orb__ring {
+ width: 82%;
+ height: 82%;
+ border: 1.5px solid color-mix(in srgb, var(--glow) 35%, transparent);
+ opacity: 0.35;
+}
+
+.convo-orb__ring-outer {
+ width: 94%;
+ height: 94%;
+ border: 1px solid color-mix(in srgb, var(--glow) 22%, transparent);
+ opacity: 0;
+}
+
+.convo-orb__core {
+ position: relative;
+ width: 72%;
+ height: 72%;
+ border-radius: 50%;
+ background: radial-gradient(
+ circle at 35% 28%,
+ color-mix(in srgb, var(--glow) 28%, transparent),
+ color-mix(in srgb, var(--glow) 10%, transparent) 55%,
+ color-mix(in srgb, var(--glow) 5%, transparent)
+ );
+ border: 2px solid color-mix(in srgb, var(--glow) 40%, transparent);
+ box-shadow:
+ 0 0 32px color-mix(in srgb, var(--glow) 22%, transparent),
+ inset 0 0 28px color-mix(in srgb, var(--glow) 18%, transparent);
+ display: grid;
+ place-items: center;
+ color: var(--glow);
+ transition: background 0.4s ease, border-color 0.4s ease, box-shadow 0.4s ease, transform 0.4s ease;
+}
+
+/* Every .ind child stacks in this grid cell; opacity rules below pick
+ the visible one, so the subtree never needs rebuilding. */
+.convo-orb__indicator {
+ position: relative;
+ width: 44%;
+ height: 44%;
+ display: grid;
+ place-items: center;
+ color: var(--glow);
+}
+
+/* Without this, defaults to display: inline and the SVG inside
+ sizes against an undefined-width container, rendering off-center. */
+.convo-orb__indicator > .ind {
+ grid-area: 1 / 1;
+ width: 100%;
+ height: 100%;
+ display: grid;
+ place-items: center;
+ opacity: 0;
+ transform: scale(0.85);
+ transition: opacity 0.25s ease, transform 0.25s ease;
+ pointer-events: none;
+}
+
+/* display: block strips the inline baseline gap that would otherwise
+ nudge the icon off-center vertically. */
+.convo-orb__indicator > .ind > svg {
+ width: 60%;
+ height: 60%;
+ display: block;
+}
+
+/* Keyframes carry both scale(1) and the rotation so the browser doesn't
+ interpolate between two different transform functions. */
+.convo-orb__indicator > .ind-spinner {
+ display: block;
+ place-self: center;
+ width: 32%;
+ height: 32%;
+ border: 3px solid currentColor;
+ border-right-color: transparent;
+ border-radius: 50%;
+}
+
+@keyframes orb-spin {
+ from { transform: scale(1) rotate(0deg); }
+ to { transform: scale(1) rotate(360deg); }
+}
+
+/* Per-dot animation, staggered ~160ms, so it composes cleanly with the
+ parent's show/hide scale(.85 -> 1). */
+.convo-orb__indicator > .ind-thinking {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ gap: 8px;
+}
+.ind-thinking .dot {
+ width: 10px;
+ height: 10px;
+ border-radius: 50%;
+ background: currentColor;
+ opacity: 0.3;
+}
+.ind-thinking .dot:nth-child(1) { animation: orb-thinking-dot 1.25s ease-in-out infinite; animation-delay: 0s; }
+.ind-thinking .dot:nth-child(2) { animation: orb-thinking-dot 1.25s ease-in-out infinite; animation-delay: 0.16s; }
+.ind-thinking .dot:nth-child(3) { animation: orb-thinking-dot 1.25s ease-in-out infinite; animation-delay: 0.32s; }
+
+@keyframes orb-thinking-dot {
+ 0%, 60%, 100% { transform: scale(0.7); opacity: 0.3; }
+ 30% { transform: scale(1.15); opacity: 1; }
+}
+
+/* Height capped at 42% so bars animating up to 100% of this container
+ never overflow into the core's inner edge. */
+.convo-orb__indicator > .ind-bars {
+ display: flex;
+ align-items: center;
+ justify-content: center;
+ gap: 5px;
+ height: 42%;
+}
+.ind-bars .bar {
+ width: 4px;
+ min-height: 4px;
+ height: 35%;
+ border-radius: 3px;
+ background: currentColor;
+ opacity: 0.7;
+}
+.convo-orb[data-state="listening"] .ind-bars .bar {
+ animation: orb-bar 0.9s ease-in-out infinite;
+}
+.ind-bars .bar:nth-child(1) { animation-delay: -0.2s; }
+.ind-bars .bar:nth-child(2) { animation-delay: -0.05s; }
+.ind-bars .bar:nth-child(3) { animation-delay: -0.35s; }
+.ind-bars .bar:nth-child(4) { animation-delay: -0.1s; }
+.ind-bars .bar:nth-child(5) { animation-delay: -0.25s; }
+
+@keyframes orb-bar {
+ 0%, 100% { height: 35%; opacity: 0.7; }
+ 50% { height: 100%; opacity: 1; }
+}
+
+.ind-voice .wave {
+ transform-origin: 50% 50%;
+ opacity: 0;
+}
+.convo-orb[data-state="speaking"] .ind-voice .wave {
+ animation: orb-voice-wave 1.35s ease-out infinite;
+}
+.ind-voice .wave-1 { animation-delay: 0s; }
+.ind-voice .wave-2 { animation-delay: 0.35s; }
+
+@keyframes orb-voice-wave {
+ 0% { opacity: 0; transform: scale(0.7); }
+ 30% { opacity: 1; transform: scale(1); }
+ 70% { opacity: 0.2; transform: scale(1.12); }
+ 100% { opacity: 0; transform: scale(0.7); }
+}
+
+/* Per-state visibility & ambient animations */
+
+/* .ind-mic (idle) is never set to opacity:1 explicitly, so any
+ [data-state] rule below wins via cascade. */
+.convo-orb[data-state="idle"] .ind-mic,
+.convo-orb[data-state="muted"] .ind-mic-off,
+.convo-orb[data-state="connecting"] .ind-spinner,
+.convo-orb[data-state="listening"] .ind-bars,
+.convo-orb[data-state="thinking"] .ind-thinking,
+.convo-orb[data-state="speaking"] .ind-voice,
+.convo-orb[data-state="error"] .ind-error {
+ opacity: 1;
+ transform: scale(1);
+}
+
+/* !important: without it, the show/hide scale(1) rule above would fight
+ the spinner's own rotation keyframes. */
+.convo-orb[data-state="connecting"] .ind-spinner {
+ opacity: 1 !important;
+ animation: orb-spin 0.9s linear infinite;
+}
+
+/* Idle: gentle breath on the inner ring; off in connecting/error. */
+.convo-orb[data-state="idle"] .convo-orb__ring {
+ animation: orb-breathe 2.4s ease-in-out infinite;
+}
+
+/* Listening: brighter rings, both visible. */
+.convo-orb[data-state="listening"] .convo-orb__ring {
+ opacity: 0.85;
+ animation: orb-breathe 2s ease-in-out infinite;
+}
+.convo-orb[data-state="listening"] .convo-orb__ring-outer {
+ opacity: 0.45;
+}
+
+/* Thinking: dimmer than speaking so the 3-dot indicator stays the focus. */
+.convo-orb[data-state="thinking"] .convo-orb__core {
+ animation: orb-thinking-throb 1.4s ease-in-out infinite;
+}
+
+/* Speaking: outer ring fades in to convey audio radiating out. */
+.convo-orb[data-state="speaking"] .convo-orb__core {
+ animation: orb-speak 1.6s ease-in-out infinite;
+}
+.convo-orb[data-state="speaking"] .convo-orb__ring-outer {
+ opacity: 0.4;
+ animation: orb-ring-out 1.8s ease-out infinite;
+}
+
+/* Muted: perfectly still and dimmed so "paused" reads at a glance. */
+.convo-orb[data-state="muted"] .convo-orb__glow {
+ opacity: 0.25;
+}
+
+/* Error: no animation, just a stronger edge to read as a stop signal. */
+.convo-orb[data-state="error"] .convo-orb__core {
+ border-color: var(--glow);
+}
+
+/* Keyframes */
+
+@keyframes orb-breathe {
+ 0%, 100% { transform: translate(-50%, -50%) scale(1); opacity: 0.35; }
+ 50% { transform: translate(-50%, -50%) scale(1.06); opacity: 0.7; }
+}
+
+@keyframes orb-ring-out {
+ 0% { transform: translate(-50%, -50%) scale(1); opacity: 0.4; }
+ 100% { transform: translate(-50%, -50%) scale(1.18); opacity: 0; }
+}
+
+@keyframes orb-thinking-throb {
+ 0%, 100% { transform: scale(1); box-shadow: 0 0 32px color-mix(in srgb, var(--glow) 18%, transparent),
+ inset 0 0 28px color-mix(in srgb, var(--glow) 14%, transparent); }
+ 50% { transform: scale(0.97); box-shadow: 0 0 26px color-mix(in srgb, var(--glow) 12%, transparent),
+ inset 0 0 22px color-mix(in srgb, var(--glow) 8%, transparent); }
+}
+
+@keyframes orb-speak {
+ 0%, 100% { transform: scale(1); box-shadow: 0 0 32px color-mix(in srgb, var(--glow) 22%, transparent),
+ inset 0 0 28px color-mix(in srgb, var(--glow) 18%, transparent); }
+ 50% { transform: scale(1.04); box-shadow: 0 0 44px color-mix(in srgb, var(--glow) 35%, transparent),
+ inset 0 0 36px color-mix(in srgb, var(--glow) 30%, transparent); }
+}
diff --git a/src/peachy/streaming.py b/src/peachy/streaming.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6a1c17a4cdde68de8560f0842ec8682b9888024
--- /dev/null
+++ b/src/peachy/streaming.py
@@ -0,0 +1,55 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import asyncio
+from typing import TypeVar, TypeAlias
+from collections.abc import Mapping, Callable
+
+import numpy as np
+from numpy.typing import NDArray
+
+
+StreamMessage: TypeAlias = Mapping[str, object]
+AudioArray: TypeAlias = NDArray[np.int16] | NDArray[np.float32]
+
+QueueItem = TypeVar("QueueItem")
+
+
+class AdditionalOutputs:
+ """Text or metadata emitted alongside audio frames."""
+
+ def __init__(self, *args: StreamMessage) -> None:
+ """Initialize with one or more emitted messages."""
+ self.args = args
+
+
+class AsyncStreamHandler:
+ """Minimal async stream handler state used by the local audio loop."""
+
+ def __init__(self) -> None:
+ """Initialize shared stream handler state."""
+ self._clear_queue: Callable[[], None] | None = None
+
+
+async def wait_for_item(queue: asyncio.Queue[QueueItem], timeout: float = 0.1) -> QueueItem | None:
+ """Return the next queue item, or None when no item arrives before timeout."""
+ try:
+ return await asyncio.wait_for(queue.get(), timeout=timeout)
+ except asyncio.TimeoutError:
+ return None
+
+
+def audio_to_int16(audio: AudioArray) -> NDArray[np.int16]:
+ """Convert int16 or float32 audio data to int16 samples."""
+ if audio.dtype == np.int16:
+ return audio.astype(np.int16, copy=False)
+ if audio.dtype == np.float32:
+ return (audio * 32767.0).astype(np.int16)
+ raise TypeError(f"Unsupported audio data type: {audio.dtype}")
+
+
+def audio_to_float32(audio: AudioArray) -> NDArray[np.float32]:
+ """Convert int16 or float32 audio data to float32 samples."""
+ if audio.dtype == np.int16:
+ return audio.astype(np.float32) / 32768.0
+ if audio.dtype == np.float32:
+ return audio.astype(np.float32, copy=False)
+ raise TypeError(f"Unsupported audio data type: {audio.dtype}")
diff --git a/src/peachy/tool_spaces.py b/src/peachy/tool_spaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..48eb4e9a042506d2d6adbfca1943e3632952e339
--- /dev/null
+++ b/src/peachy/tool_spaces.py
@@ -0,0 +1,663 @@
+"""Manage installed Hugging Face Space tool sources for the conversation app."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import re
+import json
+import asyncio
+import logging
+import argparse
+from typing import Any
+from pathlib import Path
+from collections import Counter
+from dataclasses import field, asdict, dataclass
+from collections.abc import Sequence
+
+from huggingface_hub import HfApi, SpaceInfo, get_token
+from huggingface_hub.errors import RepositoryNotFoundError
+
+from peachy.config import DEFAULT_PROFILES_DIRECTORY, USER_PERSONALITIES_DIRNAME, config
+from peachy.state import resolve_state_root
+from peachy.mcp_client import (
+ McpClientError,
+ RemoteToolSpec,
+ RemoteMcpToolClient,
+ RemoteMcpServerConfig,
+ apply_name_normalization,
+ build_namespaced_tool_name,
+)
+
+
+logger = logging.getLogger(__name__)
+
+INSTALLED_TOOL_SPACES_FILENAME = "installed_tool_spaces.json"
+INSTALLED_TOOL_SPACES_VERSION = 2
+# Bundled Pollen Spaces seeded when no manifest exists, so startup needs no Hugging Face discovery.
+PREINSTALLED_TOOL_SPACE_SPECS = {
+ "pollen-robotics/reachy-mini-search-tool": (
+ RemoteToolSpec(
+ server_alias="pollen_robotics_reachy_mini_search_tool",
+ remote_name="reachy_mini_search_tool_search_web",
+ namespaced_name=build_namespaced_tool_name(
+ "pollen_robotics_reachy_mini_search_tool", "reachy_mini_search_tool_search_web"
+ ),
+ description=(
+ "Search the web for current information and return a short list of results (title, snippet, url). "
+ "Call this directly whenever the user asks to search, check the web, look something up, "
+ "find today's events, or learn what is happening now. Do not just say you'll look it up."
+ ),
+ parameters_schema={
+ "type": "object",
+ "properties": {
+ "query": {"type": "string", "description": "Search query."},
+ "max_results": {"type": "integer", "minimum": 1, "maximum": 10, "default": 5},
+ },
+ "required": ["query"],
+ },
+ ),
+ ),
+ "pollen-robotics/reachy-mini-time-tool": (
+ RemoteToolSpec(
+ server_alias="pollen_robotics_reachy_mini_time_tool",
+ remote_name="reachy_mini_time_tool_get_time",
+ namespaced_name=build_namespaced_tool_name(
+ "pollen_robotics_reachy_mini_time_tool", "reachy_mini_time_tool_get_time"
+ ),
+ description=(
+ "Get the current date and time for an IANA timezone, and optionally the difference to a second timezone. "
+ "Call this directly whenever the user asks what time it is or the time somewhere. Pass an IANA name like "
+ "'Europe/Paris' or 'Asia/Tokyo' for a named place (derive it from the place), or leave the timezone empty "
+ "for the user's own local time. Do not ask for their city and do not just say you'll check."
+ ),
+ parameters_schema={
+ "type": "object",
+ "properties": {
+ "timezone": {
+ "type": "string",
+ "default": "",
+ "description": "IANA timezone like 'Europe/Paris'. Empty resolves the user's local time.",
+ },
+ "compare_timezone": {
+ "type": "string",
+ "default": "",
+ "description": "Optional second IANA timezone to compare against.",
+ },
+ },
+ "required": [],
+ },
+ ),
+ ),
+ "pollen-robotics/reachy-mini-weather-tool": (
+ RemoteToolSpec(
+ server_alias="pollen_robotics_reachy_mini_weather_tool",
+ remote_name="reachy_mini_weather_tool_get_weather",
+ namespaced_name=build_namespaced_tool_name(
+ "pollen_robotics_reachy_mini_weather_tool", "reachy_mini_weather_tool_get_weather"
+ ),
+ description=(
+ "Get today's weather for a place: current conditions, high and low temperature, and rain chance. "
+ "Call this directly whenever the user asks about the weather, forecast, or temperature for "
+ "somewhere. Do not just say you'll check."
+ ),
+ parameters_schema={
+ "type": "object",
+ "properties": {
+ "location": {"type": "string", "description": "Place name for the weather lookup."},
+ },
+ "required": ["location"],
+ },
+ ),
+ ),
+}
+_SLUG_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*$")
+
+
+@dataclass(frozen=True)
+class InstalledToolSpaceTool:
+ """App-facing metadata for one remote tool exposed by an installed Space."""
+
+ local_name: str
+ client_tool_name: str
+ remote_name: str
+ description: str
+ parameters_schema: dict[str, Any]
+
+
+@dataclass(frozen=True)
+class InstalledToolSpace:
+ """Persisted record for one installed Space and the tools discovered at install time."""
+
+ slug: str
+ alias: str
+ mcp_url: str
+ private: bool
+ tools: list[InstalledToolSpaceTool] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class InstalledToolSpacesManifest:
+ """Persisted manifest of installed Space tool sources."""
+
+ version: int = INSTALLED_TOOL_SPACES_VERSION
+ spaces: list[InstalledToolSpace] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class ResolvedInstalledToolSpace:
+ """Runtime description of an installed Space."""
+
+ slug: str
+ alias: str
+ mcp_url: str
+ private: bool
+ tags: list[str]
+ tools: list[InstalledToolSpaceTool]
+ client: RemoteMcpToolClient
+
+
+def get_installed_tool_spaces_path(instance_path: str | Path | None) -> Path:
+ """Return the installed tool-spaces manifest path for the current mode."""
+ if instance_path is not None:
+ return Path(instance_path) / INSTALLED_TOOL_SPACES_FILENAME
+ return resolve_state_root() / INSTALLED_TOOL_SPACES_FILENAME
+
+
+def _preinstalled_installed_spaces() -> list[InstalledToolSpace]:
+ """Build the bundled Pollen Spaces as manifest entries with their tools cached from static specs."""
+ spaces: list[InstalledToolSpace] = []
+ for slug, remote_specs in PREINSTALLED_TOOL_SPACE_SPECS.items():
+ alias = normalize_space_alias(slug)
+ spaces.append(
+ InstalledToolSpace(
+ slug=slug,
+ alias=alias,
+ mcp_url=f"https://{slug.replace('/', '-')}.hf.space/gradio_api/mcp/",
+ private=False,
+ tools=_build_installed_tool_space_tools(slug=slug, alias=alias, remote_specs=list(remote_specs)),
+ )
+ )
+ return spaces
+
+
+def read_installed_tool_spaces(instance_path: str | Path | None) -> InstalledToolSpacesManifest:
+ """Read the installed tool-spaces manifest, or seed the bundled Pollen Spaces when none exists."""
+ manifest_path = get_installed_tool_spaces_path(instance_path)
+ if not manifest_path.exists():
+ return InstalledToolSpacesManifest(spaces=_preinstalled_installed_spaces())
+
+ try:
+ payload = json.loads(manifest_path.read_text(encoding="utf-8"))
+ except Exception as exc:
+ raise RuntimeError(f"Failed to read installed tool spaces from {manifest_path}: {exc}") from exc
+
+ if not isinstance(payload, dict):
+ raise RuntimeError(f"Invalid installed tool spaces payload in {manifest_path}: expected a JSON object.")
+
+ raw_spaces = payload.get("spaces", [])
+ if not isinstance(raw_spaces, list):
+ raise RuntimeError(f"Invalid installed tool spaces payload in {manifest_path}: 'spaces' must be a list.")
+
+ spaces: list[InstalledToolSpace] = []
+ seen_slugs: set[str] = set()
+ seen_aliases: set[str] = set()
+ for raw_space in raw_spaces:
+ if not isinstance(raw_space, dict):
+ raise RuntimeError(f"Invalid installed tool spaces entry in {manifest_path}: expected an object.")
+
+ slug = validate_space_slug(str(raw_space.get("slug", "")))
+ alias = normalize_space_alias(slug)
+ if slug in seen_slugs:
+ raise RuntimeError(f"Duplicate installed tool space '{slug}' found in {manifest_path}.")
+ if alias in seen_aliases:
+ raise RuntimeError(
+ f"Installed tool spaces manifest contains alias collision '{alias}' in {manifest_path}. "
+ "Remove one of the conflicting spaces with 'tool-spaces remove'."
+ )
+ mcp_url = str(raw_space.get("mcp_url", "")).strip()
+ if not mcp_url:
+ logger.warning(
+ "Installed Space '%s' predates cached tool metadata and will be skipped. Re-run 'tool-spaces add %s'.",
+ slug,
+ slug,
+ )
+ continue
+ cached_tools = [
+ InstalledToolSpaceTool(
+ local_name=str(tool["local_name"]),
+ client_tool_name=str(tool["client_tool_name"]),
+ remote_name=str(tool.get("remote_name", "")),
+ description=str(tool.get("description", "")),
+ parameters_schema=dict(tool.get("parameters_schema") or {}),
+ )
+ for tool in raw_space.get("tools", [])
+ if isinstance(tool, dict) and tool.get("local_name") and tool.get("client_tool_name")
+ ]
+ seen_slugs.add(slug)
+ seen_aliases.add(alias)
+ spaces.append(
+ InstalledToolSpace(
+ slug=slug,
+ alias=alias,
+ mcp_url=mcp_url,
+ private=bool(raw_space.get("private", False)),
+ tools=cached_tools,
+ )
+ )
+
+ version = payload.get("version", 1)
+ if not isinstance(version, int):
+ raise RuntimeError(f"Invalid installed tool spaces payload in {manifest_path}: 'version' must be an int.")
+ return InstalledToolSpacesManifest(version=version, spaces=spaces)
+
+
+def write_installed_tool_spaces(
+ instance_path: str | Path | None,
+ manifest: InstalledToolSpacesManifest,
+) -> Path:
+ """Persist the installed tool-spaces manifest."""
+ manifest_path = get_installed_tool_spaces_path(instance_path)
+ manifest_path.parent.mkdir(parents=True, exist_ok=True)
+ payload = {
+ "version": manifest.version,
+ "spaces": [asdict(space) for space in manifest.spaces],
+ }
+ manifest_path.write_text(f"{json.dumps(payload, indent=2, sort_keys=True)}\n", encoding="utf-8")
+ return manifest_path
+
+
+def _is_real_descendant(path: Path, root: Path) -> bool:
+ """Return whether a resolved path is strictly below a resolved root."""
+ try:
+ path.relative_to(root)
+ except ValueError:
+ return False
+ return path != root
+
+
+def _roots_overlap(first: Path, second: Path) -> bool:
+ """Return whether either resolved root contains the other."""
+ return first == second or first in second.parents or second in first.parents
+
+
+def _profile_selector_parts(profile: str) -> tuple[bool, str]:
+ """Return whether a profile selects user state and its safe single component."""
+ parts = profile.split("/")
+ if len(parts) == 1:
+ is_user_profile = False
+ component = parts[0]
+ elif len(parts) == 2 and parts[0] == USER_PERSONALITIES_DIRNAME:
+ is_user_profile = True
+ component = parts[1]
+ else:
+ raise RuntimeError(f"Invalid profile selector {profile!r}.")
+
+ if not component.strip() or component in {".", ".."} or "/" in component or "\\" in component:
+ raise RuntimeError(f"Invalid profile selector {profile!r}.")
+ return is_user_profile, component
+
+
+def _resolve_writable_profile_dir(profile: str) -> Path:
+ """Resolve a selector only when it targets a real descendant of a writable profile root."""
+ is_user_profile, component = _profile_selector_parts(profile)
+ builtin_root = DEFAULT_PROFILES_DIRECTORY.resolve()
+ user_root = config.user_personalities_root().resolve()
+ external_root = config.PROFILES_DIRECTORY.resolve()
+
+ if is_user_profile:
+ writable_root = user_root
+ else:
+ if external_root == builtin_root:
+ raise RuntimeError(
+ f"Built-in profile {profile!r} is read-only; use --install-only or a user_personalities profile."
+ )
+ writable_root = external_root
+
+ if _roots_overlap(writable_root, builtin_root):
+ raise RuntimeError(
+ f"Built-in profile {profile!r} is read-only; use --install-only or a user_personalities profile."
+ )
+
+ profile_dir = (writable_root / component).resolve()
+ if not _is_real_descendant(profile_dir, writable_root) or _roots_overlap(profile_dir, builtin_root):
+ raise RuntimeError(f"Profile {profile!r} is not inside a writable profile root.")
+ return profile_dir
+
+
+def _resolve_writable_tools_txt(profile_dir: Path) -> Path:
+ """Return the profile tools file only when its resolved target remains writable."""
+ tools_txt = (profile_dir / "tools.txt").resolve()
+ builtin_root = DEFAULT_PROFILES_DIRECTORY.resolve()
+ if not _is_real_descendant(tools_txt, profile_dir) or _roots_overlap(tools_txt, builtin_root):
+ raise RuntimeError("Profile tools.txt is not inside a writable profile root.")
+ return tools_txt
+
+
+def _append_tools_to_profile(profile: str, tool_ids: list[str]) -> list[str]:
+ """Append tool IDs to a profile's tools.txt. Returns the IDs that were added."""
+ profile_dir = _resolve_writable_profile_dir(profile)
+ if not profile_dir.is_dir():
+ raise RuntimeError(
+ f"Profile '{profile}' not found at {profile_dir}. Use --install-only to skip profile wiring."
+ )
+ tools_txt = _resolve_writable_tools_txt(profile_dir)
+
+ existing_content = tools_txt.read_text(encoding="utf-8") if tools_txt.exists() else ""
+ existing: set[str] = set()
+ for line in existing_content.splitlines():
+ stripped = line.strip()
+ if stripped and not stripped.startswith("#"):
+ existing.add(stripped)
+
+ to_add = [tid for tid in tool_ids if tid not in existing]
+ if to_add:
+ with tools_txt.open("a", encoding="utf-8") as f:
+ if existing_content and not existing_content.endswith("\n"):
+ f.write("\n")
+ for tid in to_add:
+ f.write(f"{tid}\n")
+ return to_add
+
+
+def _disable_space_tools_in_profiles(alias: str) -> list[tuple[str, list[str]]]:
+ """Strip a Space's tool IDs from every profile's tools.txt. Returns (profile, removed IDs) per profile touched."""
+ prefix = f"{alias}__"
+ removed_by_profile: list[tuple[str, list[str]]] = []
+ user_root = config.user_personalities_root().resolve()
+ builtin_root = DEFAULT_PROFILES_DIRECTORY.resolve()
+ if _roots_overlap(user_root, builtin_root):
+ logger.warning("Skipping tool-space removal because user personalities root overlaps built-in profiles.")
+ return removed_by_profile
+ for candidate_tools_txt in sorted(user_root.glob("*/tools.txt")):
+ profile_dir = candidate_tools_txt.parent.resolve()
+ tools_txt = candidate_tools_txt.resolve()
+ if not _is_real_descendant(profile_dir, user_root) or not _is_real_descendant(tools_txt, user_root):
+ logger.warning("Skipping tool-space removal outside user personalities root.")
+ continue
+
+ lines = tools_txt.read_text(encoding="utf-8").splitlines()
+ removed = [line.strip() for line in lines if line.strip().startswith(prefix)]
+ if not removed:
+ continue
+ kept = [line for line in lines if not line.strip().startswith(prefix)]
+ tools_txt.write_text("".join(f"{line}\n" for line in kept), encoding="utf-8")
+ removed_by_profile.append((tools_txt.parent.name, removed))
+ return removed_by_profile
+
+
+def validate_space_slug(slug: str) -> str:
+ """Validate a public HF Space slug."""
+ candidate = slug.strip()
+ if _SLUG_PATTERN.fullmatch(candidate) is None:
+ raise ValueError(
+ f"Invalid Space slug '{slug}'. Expected the form 'owner/space-name' with alnum, '.', '_' or '-'."
+ )
+ return candidate
+
+
+def normalize_space_alias(slug: str) -> str:
+ """Derive a local alias from a Space slug."""
+ normalized = apply_name_normalization(slug)
+ if not normalized:
+ raise ValueError(f"Space slug '{slug}' cannot be normalized into a local alias.")
+ if normalized[0].isdigit():
+ normalized = f"space_{normalized}"
+ return normalized
+
+
+def _normalize_segment(value: str) -> str:
+ normalized = apply_name_normalization(value)
+ if not normalized:
+ return "tool"
+ if normalized[0].isdigit():
+ normalized = f"tool_{normalized}"
+ return normalized
+
+
+def _clean_space_tool_name(slug: str, alias: str, remote_name: str) -> str:
+ normalized_remote_name = _normalize_segment(remote_name)
+ space_name = slug.split("/", maxsplit=1)[1]
+ normalized_space_name = _normalize_segment(space_name)
+ redundant_prefix = f"{normalized_space_name}_"
+
+ if normalized_remote_name.startswith(redundant_prefix):
+ cleaned_name = normalized_remote_name[len(redundant_prefix) :]
+ if cleaned_name:
+ return f"{alias}__{cleaned_name}"
+ return f"{alias}__{normalized_remote_name}"
+
+
+def _build_installed_tool_space_tools(
+ *,
+ slug: str,
+ alias: str,
+ remote_specs: Sequence[RemoteToolSpec],
+) -> list[InstalledToolSpaceTool]:
+ cleaned_names = [_clean_space_tool_name(slug, alias, spec.remote_name) for spec in remote_specs]
+ collisions = {name for name, count in Counter(cleaned_names).items() if count > 1}
+
+ tools: list[InstalledToolSpaceTool] = []
+ for remote_spec, cleaned_name in zip(remote_specs, cleaned_names, strict=True):
+ local_name = remote_spec.namespaced_name if cleaned_name in collisions else cleaned_name
+ tools.append(
+ InstalledToolSpaceTool(
+ local_name=local_name,
+ client_tool_name=remote_spec.namespaced_name,
+ remote_name=remote_spec.remote_name,
+ description=remote_spec.description,
+ parameters_schema=dict(remote_spec.parameters_schema),
+ )
+ )
+ return tools
+
+
+def _build_space_mcp_url(space_info: SpaceInfo, slug: str) -> str:
+ host = (space_info.host or "").strip()
+ if host:
+ if host.startswith("http://") or host.startswith("https://"):
+ return f"{host.rstrip('/')}/gradio_api/mcp/"
+ return f"https://{host.rstrip('/')}/gradio_api/mcp/"
+
+ subdomain = (space_info.subdomain or "").strip()
+ if subdomain:
+ return f"https://{subdomain}.hf.space/gradio_api/mcp/"
+
+ slug_host = slug.replace("/", "-")
+ return f"https://{slug_host}.hf.space/gradio_api/mcp/"
+
+
+def _validate_space_info(slug: str, space_info: SpaceInfo) -> None:
+ if bool(space_info.disabled):
+ raise RuntimeError(f"Space '{slug}' is disabled and cannot be installed.")
+ if (space_info.sdk or "").strip().lower() != "gradio":
+ raise RuntimeError(f"Space '{slug}' is not a Gradio Space and cannot expose the standard MCP endpoint.")
+
+
+def build_remote_client(
+ alias: str,
+ mcp_url: str,
+ *,
+ private: bool,
+ cached_tools: Sequence[InstalledToolSpaceTool] = (),
+) -> RemoteMcpToolClient:
+ """Build an MCP client for an installed Space, sending the HF token only to private Spaces."""
+ token = config.HF_TOKEN or get_token()
+ headers = {"Authorization": f"Bearer {token}"} if private and token else {}
+ return RemoteMcpToolClient(
+ RemoteMcpServerConfig(
+ alias=alias,
+ url=mcp_url,
+ headers=headers,
+ request_timeout_s=10.0,
+ tool_timeout_s=30.0,
+ ),
+ known_tools=[
+ RemoteToolSpec(
+ server_alias=alias,
+ remote_name=tool.remote_name,
+ namespaced_name=tool.client_tool_name,
+ description=tool.description,
+ parameters_schema=tool.parameters_schema,
+ )
+ for tool in cached_tools
+ if tool.remote_name
+ ],
+ )
+
+
+async def resolve_tool_space(slug: str) -> ResolvedInstalledToolSpace:
+ """Validate and discover tools from one HF Space, authenticating private Spaces with the HF token."""
+ validated_slug = validate_space_slug(slug)
+ alias = normalize_space_alias(validated_slug)
+ token = config.HF_TOKEN or get_token()
+ try:
+ space_info = HfApi().space_info(validated_slug, timeout=10.0, token=token or False)
+ except RepositoryNotFoundError as exc:
+ if token is None:
+ raise RuntimeError(
+ f"Space '{validated_slug}' was not found. If it is private, set HF_TOKEN "
+ "or run 'hf auth login' for an account that can access it."
+ ) from exc
+ raise RuntimeError(
+ f"Space '{validated_slug}' was not found, or the current Hugging Face token cannot access it."
+ ) from exc
+ _validate_space_info(validated_slug, space_info)
+
+ mcp_url = _build_space_mcp_url(space_info, validated_slug)
+ private = bool(space_info.private)
+ client = build_remote_client(alias, mcp_url, private=private)
+ try:
+ remote_specs = await client.list_tool_specs()
+ except McpClientError as exc:
+ raise RuntimeError(f"Failed to discover MCP tools for '{validated_slug}': {exc}") from exc
+
+ return ResolvedInstalledToolSpace(
+ slug=validated_slug,
+ alias=alias,
+ mcp_url=mcp_url,
+ private=private,
+ tags=sorted(space_info.tags or []),
+ tools=_build_installed_tool_space_tools(slug=validated_slug, alias=alias, remote_specs=remote_specs),
+ client=client,
+ )
+
+
+def resolve_tool_space_sync(slug: str) -> ResolvedInstalledToolSpace:
+ """Resolve one Space synchronously."""
+ return asyncio.run(resolve_tool_space(slug))
+
+
+def format_space_tool_listing(space: ResolvedInstalledToolSpace) -> str:
+ """Format one resolved Space for terminal output."""
+ lines = [
+ f"{space.slug} ({space.alias})",
+ f" MCP endpoint: {space.mcp_url}",
+ ]
+ if space.tools:
+ lines.append(" Tools:")
+ lines.extend([f" - {tool.local_name}" for tool in space.tools])
+ else:
+ lines.append(" Tools: none discovered")
+ return "\n".join(lines)
+
+
+def handle_tool_spaces_command(args: argparse.Namespace, *, instance_path: str | Path | None = None) -> int:
+ """Handle tool-spaces subcommands from the main CLI."""
+ command = getattr(args, "tool_spaces_command", None)
+ if command == "add":
+ try:
+ resolved_space = resolve_tool_space_sync(args.space_slug)
+ except RuntimeError as exc:
+ logger.error("%s", exc)
+ return 1
+ manifest = read_installed_tool_spaces(instance_path)
+ already_installed = any(space.slug == resolved_space.slug for space in manifest.spaces)
+ if already_installed:
+ logger.info("Space already installed: %s", resolved_space.slug)
+ logger.info("%s", format_space_tool_listing(resolved_space))
+ else:
+ alias_conflict = next((s for s in manifest.spaces if s.alias == resolved_space.alias), None)
+ if alias_conflict:
+ logger.error(
+ "Cannot install '%s': its local alias '%s' conflicts with already-installed '%s'. "
+ "Rename one Space on Hugging Face to get a distinct alias.",
+ resolved_space.slug,
+ resolved_space.alias,
+ alias_conflict.slug,
+ )
+ return 1
+
+ installed = InstalledToolSpace(
+ slug=resolved_space.slug,
+ alias=resolved_space.alias,
+ mcp_url=resolved_space.mcp_url,
+ private=resolved_space.private,
+ tools=resolved_space.tools,
+ )
+ updated_spaces = sorted(
+ [*manifest.spaces, installed],
+ key=lambda space: space.slug,
+ )
+ manifest_path = write_installed_tool_spaces(
+ instance_path,
+ InstalledToolSpacesManifest(version=INSTALLED_TOOL_SPACES_VERSION, spaces=updated_spaces),
+ )
+ logger.info("Installed Space tool source: %s", resolved_space.slug)
+ logger.info("Manifest: %s", manifest_path)
+ logger.info("%s", format_space_tool_listing(resolved_space))
+
+ if args.install_only:
+ logger.info("Tools installed. Add tool IDs to a profile's tools.txt to enable them.")
+ return 0
+
+ target_profile = args.profile
+ if target_profile is None:
+ target_profile = config.REACHY_MINI_CUSTOM_PROFILE or "default"
+
+ tool_ids = [tool.local_name for tool in resolved_space.tools]
+ try:
+ added = _append_tools_to_profile(target_profile, tool_ids)
+ except RuntimeError as exc:
+ logger.error("Cannot enable tools: %s", exc)
+ return 1
+ if added:
+ logger.info("Enabled in profile '%s': %s", target_profile, added)
+ else:
+ logger.info("All tool IDs already present in profile '%s'.", target_profile)
+ return 0
+
+ if command == "remove":
+ validated_slug = validate_space_slug(args.space_slug)
+ manifest = read_installed_tool_spaces(instance_path)
+ remaining_spaces = [space for space in manifest.spaces if space.slug != validated_slug]
+ if len(remaining_spaces) == len(manifest.spaces):
+ logger.warning("Space not installed: %s", validated_slug)
+ return 1
+
+ write_installed_tool_spaces(
+ instance_path,
+ InstalledToolSpacesManifest(version=manifest.version, spaces=remaining_spaces),
+ )
+ logger.info("Removed Space tool source: %s", validated_slug)
+ for profile_name, disabled_tool_ids in _disable_space_tools_in_profiles(normalize_space_alias(validated_slug)):
+ logger.info("Disabled in profile '%s': %s", profile_name, disabled_tool_ids)
+ return 0
+
+ if command == "list":
+ manifest = read_installed_tool_spaces(instance_path)
+ manifest_path = get_installed_tool_spaces_path(instance_path)
+ logger.info("Manifest: %s", manifest_path)
+ if not manifest.spaces:
+ logger.info("No installed Space tool sources.")
+ return 0
+
+ for installed_space in manifest.spaces:
+ try:
+ resolved_space = resolve_tool_space_sync(installed_space.slug)
+ except Exception as exc:
+ logger.warning("Space '%s' (%s) is unavailable: %s", installed_space.slug, installed_space.alias, exc)
+ continue
+ logger.info("%s", format_space_tool_listing(resolved_space))
+ return 0
+
+ raise RuntimeError(f"Unknown tool-spaces command: {command}")
diff --git a/src/peachy/tools/__init__.py b/src/peachy/tools/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7e334df1df4868f72b8c26b7e2d9f671f4add762
--- /dev/null
+++ b/src/peachy/tools/__init__.py
@@ -0,0 +1,2 @@
+"""Nothing (for ruff)."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
diff --git a/src/peachy/tools/background_tool_manager.py b/src/peachy/tools/background_tool_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..68ee0131df32ed8a3af93747ab031097136b33f9
--- /dev/null
+++ b/src/peachy/tools/background_tool_manager.py
@@ -0,0 +1,382 @@
+"""Background tool orchestrator for non-blocking tool execution.
+
+Allows tools to run long operations asynchronously while the robot
+continues conversing. Tools can be tracked, cancelled, and their
+completion is announced vocally via a silent notification queue.
+"""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+from __future__ import annotations
+import time
+import asyncio
+import logging
+from typing import Any, Dict, Callable, Optional, Coroutine
+
+from pydantic import Field, BaseModel, PrivateAttr
+
+from peachy.tools.core_tools import (
+ ToolDependencies,
+ dispatch_tool_call,
+ dispatch_tool_call_with_manager,
+)
+from peachy.tools.tool_constants import ToolState, SystemTool
+
+
+logger = logging.getLogger(__name__)
+
+_SYSTEM_TOOL_NAMES: set[str] = {t.value for t in SystemTool}
+
+
+class ToolProgress(BaseModel):
+ """Progress of a background tool."""
+
+ progress: float = Field(..., ge=0.0, le=1.0)
+ message: Optional[str] = None
+
+
+class ToolCallRoutine(BaseModel):
+ """Encapsulates an async callable with its arguments for deferred execution."""
+
+ model_config = {"arbitrary_types_allowed": True}
+
+ tool_name: str
+ args_json_str: str
+ deps: "ToolDependencies"
+
+ async def __call__(self, tool_manager: BackgroundToolManager) -> Any:
+ """Execute the stored callable with its arguments."""
+ if self.tool_name in _SYSTEM_TOOL_NAMES:
+ # For safety purposes, we only allow system tools to be called with the tool manager
+ return await dispatch_tool_call_with_manager(
+ tool_name=self.tool_name, args_json=self.args_json_str, deps=self.deps, tool_manager=tool_manager
+ )
+ return await dispatch_tool_call(tool_name=self.tool_name, args_json=self.args_json_str, deps=self.deps)
+
+
+class ToolNotification(BaseModel):
+ """Notification payload for completed tools."""
+
+ id: str
+ tool_name: str
+ is_idle_tool_call: bool
+ status: ToolState
+ result: Optional[Dict[str, Any]] = None
+ error: Optional[str] = None
+
+
+class BackgroundTool(ToolNotification):
+ """Represents a background tool."""
+
+ progress: Optional[ToolProgress] = None
+ started_at: float = Field(default_factory=time.monotonic)
+ completed_at: Optional[float] = None
+ _task: Optional[asyncio.Task[None]] = PrivateAttr(default=None)
+
+ @property
+ def tool_id(self) -> str:
+ """Return a unique composite identifier for this tool instance."""
+ return f"{self.tool_name}-{self.id}-{self.started_at}"
+
+ def get_notification(self) -> ToolNotification:
+ """Get the notification for the tool."""
+ return ToolNotification(
+ id=self.id,
+ tool_name=self.tool_name,
+ is_idle_tool_call=self.is_idle_tool_call,
+ status=self.status,
+ result=self.result,
+ error=self.error,
+ )
+
+
+class BackgroundToolManager(BaseModel):
+ """Manages background tools for non-blocking tool execution.
+
+ Features:
+ - Start async tools without blocking the conversation
+ - Track tool status and progress
+ - Cancel running tools
+
+ """
+
+ _tools: Dict[str, BackgroundTool] = PrivateAttr(default_factory=dict)
+ _notification_queue: asyncio.Queue[ToolNotification] = PrivateAttr(default_factory=asyncio.Queue)
+ _loop: Optional[asyncio.AbstractEventLoop] = PrivateAttr(default=None)
+ _lifecycle_tasks: list[asyncio.Task[None]] = PrivateAttr(default_factory=list)
+ _max_tool_duration_seconds: float = PrivateAttr(default=86400) # 1 day
+ _max_tool_memory_seconds: float = PrivateAttr(default=3600) # 1 hour
+
+ def set_loop(
+ self,
+ loop: Optional[asyncio.AbstractEventLoop] = None,
+ ) -> None:
+ """Set the event loop.
+
+ Args:
+ loop: The event loop (defaults to current running loop)
+
+ """
+ if loop is not None:
+ self._loop = loop
+ else:
+ try:
+ self._loop = asyncio.get_running_loop()
+ except RuntimeError:
+ self._loop = asyncio.new_event_loop()
+ logger.debug("BackgroundToolManager: event loop set")
+
+ async def start_tool(
+ self,
+ call_id: str,
+ tool_call_routine: ToolCallRoutine,
+ is_idle_tool_call: bool,
+ with_progress: bool = False,
+ ) -> BackgroundTool:
+ """Start a new background tool.
+
+ Args:
+ call_id: The ID of the tool
+ tool_call_routine: The ToolCallRoutine containing the callable and its arguments
+ with_progress: Whether to track progress (0.0-1.0)
+ is_idle_tool_call: Whether the tool call was triggered by an idle signal
+
+ Returns:
+ BackgroundTool object with tool ID
+
+ """
+ tool_name = tool_call_routine.tool_name
+ id = call_id
+ background_tool = BackgroundTool(
+ id=id,
+ tool_name=tool_name,
+ is_idle_tool_call=is_idle_tool_call,
+ progress=ToolProgress(progress=0.0) if with_progress else None,
+ status=ToolState.RUNNING,
+ )
+ self._tools[background_tool.tool_id] = background_tool
+
+ async_task = asyncio.create_task(
+ self._run_tool(background_tool, tool_call_routine),
+ name=f"bg-{tool_name}-{id}",
+ )
+ background_tool._task = async_task
+
+ logger.info(f"Started background tool: {background_tool.tool_name} (id={id})")
+
+ return background_tool
+
+ async def _run_tool(
+ self,
+ background_tool: BackgroundTool,
+ tool_call_routine: ToolCallRoutine,
+ ) -> None:
+ """Execute the tool and handle completion."""
+ result: dict[str, Any] = await tool_call_routine(self)
+ background_tool.completed_at = time.monotonic()
+ error = result.get("error")
+
+ if error is not None:
+ if error == "Tool cancelled":
+ background_tool.status = ToolState.CANCELLED
+ logger.debug(f"Background tool cancelled: {background_tool.tool_name} (id={background_tool.id})")
+ else:
+ background_tool.status = ToolState.FAILED
+ logger.debug(
+ f"Background tool failed: {background_tool.tool_name} (id={background_tool.id}): {background_tool.error}"
+ )
+ background_tool.error = result["error"]
+
+ else:
+ background_tool.result = result
+ background_tool.status = ToolState.COMPLETED
+ logger.debug(f"Background tool completed: {background_tool.tool_name} (id={background_tool.id})")
+
+ await self._notification_queue.put(background_tool.get_notification())
+ logger.debug(f"Queued notification for tool: {background_tool.tool_name} (id={background_tool.id})")
+
+ async def update_progress(
+ self,
+ tool_id: str,
+ progress: float,
+ message: Optional[str] = None,
+ ) -> bool:
+ """Update progress for a tool (for tools with with_progress=True).
+
+ Args:
+ tool_id: The tool ID
+ progress: Progress value between 0.0 and 1.0
+ message: Optional progress message (e.g., "50% downloaded")
+
+ Returns:
+ True if updated successfully, False if tool not found or not tracking progress
+
+ """
+ tool = self._tools.get(tool_id)
+ if tool is None:
+ return False
+
+ if tool.progress is None:
+ # Tool not tracking progress
+ return False
+
+ tool.progress = ToolProgress(progress=max(0.0, min(1.0, progress)), message=message)
+ logger.debug(f"Tool {tool_id} progress: {progress:.1%} - {message or ''}")
+ return True
+
+ async def cancel_tool(self, tool_id: str, log: bool = True) -> bool:
+ """Cancel a running tool by ID.
+
+ Args:
+ tool_id: The tool ID to cancel
+ log: Whether to log the cancellation
+
+ Returns:
+ True if cancelled, False if tool not found or not running
+
+ """
+ tool = self._tools.get(tool_id)
+ if tool is None:
+ if log:
+ logger.warning(f"Cannot cancel tool {tool_id}: not found")
+ return False
+
+ if tool.status != ToolState.RUNNING:
+ if log:
+ logger.warning(f"Cannot cancel tool {tool_id}: status is {tool.status.value}")
+ return True
+
+ if tool._task:
+ tool._task.cancel()
+ if log:
+ logger.info(f"Cancelled tool: {tool.tool_name} (id={tool_id})")
+ return True
+
+ return False
+
+ def start_up(self, tool_callbacks: list[Callable[[ToolNotification], Coroutine[Any, Any, None]]]) -> None:
+ """Start the background tool manager.
+
+ This method starts two concurrent tasks:
+ - _listener: Listens for completed BackgroundTool notifications and calls the callbacks.
+ - _cleanup: Cleans up completed/failed/cancelled tools that have been in memory for too long and times out tools that have been running too long.
+
+ Args:
+ tool_callbacks: A list of async or sync callables that receive the completed BackgroundTool notifications.
+
+ """
+ self.set_loop()
+
+ async def _listener() -> None:
+ while True:
+ background_tool = await self._notification_queue.get()
+ for callback in tool_callbacks:
+ await callback(background_tool)
+
+ async def _cleanup(interval_seconds: float = 5 * 60) -> None:
+ while True:
+ await asyncio.sleep(interval_seconds)
+ await self.cleanup_tools()
+ await self.timeout_tools()
+
+ self._lifecycle_tasks = [
+ asyncio.create_task(_cleanup(), name="bg-tool-cleanup"),
+ asyncio.create_task(_listener(), name="bg-tool-listener-callback"),
+ ]
+
+ logger.info(
+ "BackgroundToolManager started. "
+ "Max tool execution duration: %s seconds (tools running longer will be auto-cancelled). "
+ "Max tool memory retention: %s seconds (completed/failed/cancelled tools older than this are purged).",
+ self._max_tool_duration_seconds,
+ self._max_tool_memory_seconds,
+ )
+
+ async def shutdown(self) -> None:
+ """Cancel all background tasks (listener, cleanup) and running tools."""
+ for task in self._lifecycle_tasks:
+ task.cancel()
+ for task in self._lifecycle_tasks:
+ try:
+ await task
+ except asyncio.CancelledError:
+ pass
+ self._lifecycle_tasks.clear()
+
+ for tool_id in list(self._tools):
+ await self.cancel_tool(tool_id, log=False)
+
+ logger.info("BackgroundToolManager shut down")
+
+ async def timeout_tools(self) -> int:
+ """Cancel tools that have been running too long.
+
+ Returns:
+ Number of tools cancelled
+
+ """
+ now = time.monotonic()
+ to_cancel = []
+
+ for tool_id, tool in self._tools.items():
+ if tool.status == ToolState.RUNNING:
+ if tool.started_at and (now - tool.started_at) > self._max_tool_duration_seconds:
+ to_cancel.append(tool_id)
+
+ for tool_id in to_cancel:
+ await self.cancel_tool(tool_id)
+
+ if to_cancel:
+ logger.debug(f"Timed out {len(to_cancel)} tools")
+
+ return len(to_cancel)
+
+ async def cleanup_tools(self) -> int:
+ """Remove completed/failed/cancelled tools that have been in memory for too long.
+
+ Returns:
+ Number of tools removed
+
+ """
+ now = time.monotonic()
+ to_remove = []
+
+ for tool_id, tool in self._tools.items():
+ if tool.status in (ToolState.COMPLETED, ToolState.FAILED, ToolState.CANCELLED):
+ if tool.completed_at and (now - tool.completed_at) > self._max_tool_memory_seconds:
+ to_remove.append(tool_id)
+
+ for tool_id in to_remove:
+ del self._tools[tool_id]
+
+ if to_remove:
+ logger.debug(f"Cleaned up {len(to_remove)} old tools")
+
+ return len(to_remove)
+
+ def get_tool(self, tool_id: str) -> Optional[BackgroundTool]:
+ """Get a tool by ID."""
+ return self._tools.get(tool_id)
+
+ def get_running_tools(self) -> list[BackgroundTool]:
+ """Get all currently running tools."""
+ return [t for t in self._tools.values() if t.status == ToolState.RUNNING]
+
+ def get_all_tools(self, limit: Optional[int] = None) -> list[BackgroundTool]:
+ """Get recent tools (most recent first).
+
+ Args:
+ limit: Maximum number of tools to return (None means all)
+
+ Returns:
+ List of tools sorted by start time (most recent first)
+
+ """
+ sorted_tools = sorted(
+ self._tools.values(),
+ key=lambda t: t.started_at,
+ reverse=True,
+ )
+ if limit is not None:
+ return sorted_tools[:limit]
+ return sorted_tools
diff --git a/src/peachy/tools/camera.py b/src/peachy/tools/camera.py
new file mode 100644
index 0000000000000000000000000000000000000000..fbee10f867b1aecea9afde45cd539bcb831b7ed5
--- /dev/null
+++ b/src/peachy/tools/camera.py
@@ -0,0 +1,46 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import base64
+import logging
+from typing import Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class Camera(Tool):
+ """Take a picture with the camera and ask a question about it."""
+
+ name = "camera"
+ description = "Take a picture with the camera and ask a question about it."
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "question": {
+ "type": "string",
+ "description": "The question to ask about the picture",
+ },
+ },
+ "required": ["question"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Take a picture with the camera and ask a question about it."""
+ question = (kwargs.get("question") or "").strip()
+ if not question:
+ logger.warning("camera: empty question")
+ return {"error": "question must be a non-empty string"}
+
+ logger.info("Tool call: camera question=%s", question[:120])
+
+ if not deps.camera_enabled:
+ logger.error("Camera is disabled")
+ return {"error": "Camera is disabled"}
+
+ jpeg_bytes = deps.reachy_mini.media.get_frame_jpeg()
+ if jpeg_bytes is None:
+ logger.error("No frame available from camera")
+ return {"error": "No frame available"}
+
+ return {"b64_im": base64.b64encode(jpeg_bytes).decode("utf-8")}
diff --git a/src/peachy/tools/core_tools.py b/src/peachy/tools/core_tools.py
new file mode 100644
index 0000000000000000000000000000000000000000..b279eecfb633f1a18112f8b689a80bad872fdda5
--- /dev/null
+++ b/src/peachy/tools/core_tools.py
@@ -0,0 +1,573 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+from __future__ import annotations
+import re
+import abc
+import sys
+import json
+import asyncio
+import inspect
+import logging
+import importlib
+import importlib.util
+from types import ModuleType
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Callable, ClassVar, Sequence, TypedDict
+from pathlib import Path
+from dataclasses import dataclass
+
+from reachy_mini import ReachyMini
+from peachy.config import DEFAULT_PROFILES_DIRECTORY as DEFAULT_PROFILES_PATH
+
+# Import config to ensure .env is loaded before reading REACHY_MINI_CUSTOM_PROFILE
+from peachy.config import config
+from peachy.mcp_client import McpToolTimeoutError, McpToolInvocationError
+from peachy.tool_spaces import build_remote_client, read_installed_tool_spaces
+from peachy.tools.tool_constants import SystemTool
+
+
+if TYPE_CHECKING:
+ from peachy.mcp_client import RemoteMcpToolClient
+ from peachy.tools.background_tool_manager import BackgroundToolManager
+
+
+logger = logging.getLogger(__name__)
+
+
+class MissingToolFileError(FileNotFoundError):
+ """Raised when a requested tool file is absent on disk."""
+
+
+@dataclass
+class ToolDependencies:
+ """External dependencies injected into tools."""
+
+ reachy_mini: ReachyMini
+ movement_manager: Any # MovementManager from moves.py
+ # Optional deps
+ instance_path: str | Path | None = None
+ camera_enabled: bool = False
+ motion_duration_s: float = 1.0
+ go_to_sleep: Callable[[], dict[str, Any]] | None = None
+
+
+class ToolSpec(TypedDict):
+ """Function-calling spec for a tool, in the OpenAI-compatible shape."""
+
+ type: Literal["function"]
+ name: str
+ description: str
+ parameters: dict[str, Any] # arbitrary JSON Schema
+
+
+class Tool(abc.ABC):
+ """Base abstraction for tools used in function-calling.
+
+ Each tool must define:
+ - name: str
+ - description: str
+ - parameters_schema: Dict[str, Any] # JSON Schema
+
+ Tools may override:
+ - needs_response: bool = True # set False to skip the spoken follow-up after this tool runs
+ """
+
+ _auto_register: ClassVar[bool] = True
+ needs_response: ClassVar[bool] = True
+
+ name: str
+ description: str
+ parameters_schema: Dict[str, Any]
+
+ def spec(self) -> ToolSpec:
+ """Return the function spec for LLM consumption."""
+ return {
+ "type": "function",
+ "name": self.name,
+ "description": self.description,
+ "parameters": self.parameters_schema,
+ }
+
+ @abc.abstractmethod
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Async tool execution entrypoint."""
+ raise NotImplementedError
+
+
+ALL_TOOLS: Dict[str, Tool] = {}
+ALL_TOOL_SPECS: list[ToolSpec] = []
+_TOOLS_INITIALIZED = False
+_TOOLS_SIGNATURE: tuple[str, str, str | None, bool, str | None] | None = None
+_TOOLS_INSTANCE_PATH: str | Path | None = None
+_LOADED_TOOL_CLASS_CACHE: Dict[tuple[str, str], List[type[Tool]]] = {}
+_REMOTE_TOOL_RETRY_DELAY_S = 0.25
+
+
+class RemoteMcpTool(Tool):
+ """Adapter exposing one remote MCP tool through the local Tool interface."""
+
+ _auto_register: ClassVar[bool] = False
+
+ def __init__(
+ self,
+ *,
+ slug: str,
+ name: str,
+ description: str,
+ parameters_schema: Dict[str, Any],
+ client_tool_name: str,
+ client: "RemoteMcpToolClient",
+ ) -> None:
+ """Store the resolved local/remote names and the shared MCP client."""
+ self.name = name
+ self.description = description
+ self.parameters_schema = parameters_schema
+ self._space_slug = slug
+ self._client_tool_name = client_tool_name
+ self._client = client
+ self._registry_source = f"space:{slug}:{client_tool_name}"
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Invoke the underlying remote MCP tool."""
+ try:
+ result = await self._client.call_tool(self._client_tool_name, kwargs)
+ except McpToolTimeoutError:
+ # Timeout subclasses the retryable error, but retrying it would just double the wait.
+ raise
+ except McpToolInvocationError as exc:
+ logger.warning("Remote MCP tool failed once; retrying %s from %s: %s", self.name, self._space_slug, exc)
+ await asyncio.sleep(_REMOTE_TOOL_RETRY_DELAY_S)
+ result = await self._client.call_tool(self._client_tool_name, kwargs)
+ payload = dict(result)
+ if payload.get("namespaced_tool_name") == self._client_tool_name:
+ payload["namespaced_tool_name"] = self.name
+ payload.setdefault("tool_space_slug", self._space_slug)
+ return payload
+
+
+_LOADED_REMOTE_TOOL_CACHE: Dict[tuple[str, str], RemoteMcpTool] = {}
+
+
+def _load_module_from_file(module_name: str, file_path: Path) -> ModuleType:
+ """Load a Python module from a file path."""
+ if not file_path.is_file():
+ raise MissingToolFileError(f"tool file not found at {file_path}")
+
+ spec = importlib.util.spec_from_file_location(module_name, file_path)
+ if not (spec and spec.loader):
+ raise ModuleNotFoundError(f"Cannot create spec for {file_path}")
+ module = importlib.util.module_from_spec(spec)
+ sys.modules[module_name] = module
+ try:
+ spec.loader.exec_module(module)
+ except Exception:
+ # Avoid leaving a partially initialised module registered on failure
+ sys.modules.pop(module_name, None)
+ raise
+ return module
+
+
+def _format_error(error: Exception) -> str:
+ """Format an exception for logging."""
+ if isinstance(error, FileNotFoundError):
+ return f"Tool file not found: {error}"
+ if isinstance(error, ModuleNotFoundError):
+ return f"Missing dependency: {error}"
+ if isinstance(error, ImportError):
+ return f"Import error: {error}"
+ return f"{type(error).__name__}: {error}"
+
+
+def _normalize_signature_path(value: str | Path | None) -> str | None:
+ """Normalize a path-like value for registry invalidation and cache keys."""
+ if value is None:
+ return None
+ try:
+ return str(Path(value).expanduser().resolve())
+ except Exception:
+ return str(value)
+
+
+def _cache_key_for_file(file_path: Path) -> tuple[str, str]:
+ """Return the cache key for a file-backed tool source."""
+ return ("file", _normalize_signature_path(file_path) or str(file_path))
+
+
+def _cache_key_for_module(module_path: str) -> tuple[str, str]:
+ """Return the cache key for an importable module-backed tool source."""
+ return ("module", module_path)
+
+
+def _tool_classes_from_module(module: ModuleType) -> List[type[Tool]]:
+ """Return auto-registerable Tool classes defined directly in module."""
+ tool_classes: List[type[Tool]] = []
+ seen_class_ids: set[int] = set()
+ for value in vars(module).values():
+ if not inspect.isclass(value) or value.__module__ != module.__name__:
+ continue
+ try:
+ is_tool_class = issubclass(value, Tool)
+ except TypeError:
+ continue
+ if value is Tool or not is_tool_class or inspect.isabstract(value) or not value._auto_register:
+ continue
+ cls_id = id(value)
+ if cls_id in seen_class_ids:
+ continue
+ seen_class_ids.add(cls_id)
+ tool_classes.append(value)
+ return tool_classes
+
+
+def _load_cached_tool_classes(
+ cache_key: tuple[str, str],
+ load_module: Callable[[], ModuleType],
+) -> tuple[List[type[Tool]], bool]:
+ """Load tool classes once per source and return whether the cache was reused."""
+ cached_classes = _LOADED_TOOL_CLASS_CACHE.get(cache_key)
+ if cached_classes is not None:
+ return cached_classes, True
+
+ module = load_module()
+ tool_classes = _tool_classes_from_module(module)
+ _LOADED_TOOL_CLASS_CACHE[cache_key] = tool_classes
+ return tool_classes, False
+
+
+def _try_load_tool_classes(
+ tool_name: str,
+ module_path: str,
+ fallback_directory: Path | None,
+ file_subpath: str,
+) -> tuple[str, List[type[Tool]], bool]:
+ """Try to load tool classes: first via importlib, then from a configured external file."""
+ try:
+ return (
+ "module",
+ *_load_cached_tool_classes(
+ _cache_key_for_module(module_path),
+ lambda: importlib.import_module(module_path),
+ ),
+ )
+ except ModuleNotFoundError:
+ if fallback_directory is None:
+ raise
+ tool_file = fallback_directory / file_subpath
+ return (
+ "file",
+ *_load_cached_tool_classes(
+ _cache_key_for_file(tool_file),
+ lambda: _load_module_from_file(tool_name, tool_file),
+ ),
+ )
+
+
+def _build_tool_registry(
+ tool_classes: List[type[Tool]],
+ extra_tools: Sequence[Tool] | None = None,
+) -> Dict[str, Tool]:
+ """Instantiate tools and fail if duplicate Tool.name values are detected."""
+ unique_classes: List[type[Tool]] = []
+ seen_class_ids: set[int] = set()
+ for cls in tool_classes:
+ cls_id = id(cls)
+ if cls_id in seen_class_ids:
+ continue
+ seen_class_ids.add(cls_id)
+ unique_classes.append(cls)
+
+ tool_instances: list[Tool] = []
+ tool_instances.extend(cls() for cls in unique_classes)
+ if extra_tools:
+ tool_instances.extend(extra_tools)
+
+ name_to_sources: Dict[str, List[str]] = {}
+ for tool in tool_instances:
+ source = getattr(tool, "_registry_source", f"{tool.__class__.__module__}.{tool.__class__.__name__}")
+ name_to_sources.setdefault(tool.name, []).append(source)
+
+ collisions = {tool_name: sources for tool_name, sources in name_to_sources.items() if len(sources) > 1}
+ if collisions:
+ details = "; ".join(f"{tool_name}: {sources}" for tool_name, sources in sorted(collisions.items()))
+ raise RuntimeError(
+ f"Duplicate Tool.name values detected while loading tools. Tool.name must be unique. Conflicts: {details}"
+ )
+
+ return {tool.name: tool for tool in tool_instances}
+
+
+def _tool_registry_signature(instance_path: str | Path | None) -> tuple[str, str, str | None, bool, str | None]:
+ """Return the runtime inputs that determine the active tool registry."""
+ return (
+ config.REACHY_MINI_CUSTOM_PROFILE or "default",
+ _normalize_signature_path(config.PROFILES_DIRECTORY) or "",
+ _normalize_signature_path(config.TOOLS_DIRECTORY),
+ bool(config.AUTOLOAD_EXTERNAL_TOOLS),
+ _normalize_signature_path(instance_path),
+ )
+
+
+# Registry & specs (dynamic)
+def _resolve_profile_tools_txt_path() -> tuple[str, Path]:
+ """Resolve the active profile's tools.txt with fallback to the built-in default."""
+ profile = config.REACHY_MINI_CUSTOM_PROFILE or "default"
+ logger.info(f"Loading tools for profile: {profile}")
+
+ profile_dir = config.resolve_profile_dir(profile)
+ tools_txt_path = profile_dir / "tools.txt"
+ default_tools_txt_path = DEFAULT_PROFILES_PATH / "default" / "tools.txt"
+
+ if config.PROFILES_DIRECTORY != DEFAULT_PROFILES_PATH:
+ logger.info(
+ "Loading external profile '%s' from %s",
+ profile,
+ profile_dir,
+ )
+
+ if not tools_txt_path.exists():
+ if profile != "default" and default_tools_txt_path.exists():
+ logger.warning(
+ "tools.txt not found for profile '%s' at %s. Falling back to default profile tools at %s",
+ profile,
+ tools_txt_path,
+ default_tools_txt_path,
+ )
+ return profile, default_tools_txt_path
+ logger.error(f"✗ tools.txt not found at {tools_txt_path}")
+ sys.exit(1)
+
+ return profile, tools_txt_path
+
+
+def _read_profile_tool_names() -> list[str]:
+ """Read enabled tool names from the active profile's tools.txt file."""
+ _, tools_txt_path = _resolve_profile_tools_txt_path()
+
+ try:
+ lines = tools_txt_path.read_text(encoding="utf-8").splitlines()
+ except Exception as e:
+ logger.error(f"✗ Failed to read tools.txt: {e}")
+ sys.exit(1)
+
+ tool_names: list[str] = []
+ for line in lines:
+ stripped_line = line.strip()
+ if not stripped_line or stripped_line.startswith("#"):
+ continue
+ tool_names.append(stripped_line)
+
+ tool_names.extend({tool.value for tool in SystemTool})
+
+ if config.AUTOLOAD_EXTERNAL_TOOLS and config.TOOLS_DIRECTORY and config.TOOLS_DIRECTORY.is_dir():
+ discovered_external_tools: List[str] = []
+ for tool_file in sorted(config.TOOLS_DIRECTORY.glob("*.py")):
+ if tool_file.name.startswith("_"):
+ continue
+ candidate_name = tool_file.stem
+ if not re.match(r"^[A-Za-z_][A-Za-z0-9_]*$", candidate_name):
+ logger.warning("Skipping external tool with invalid name: %s", tool_file.name)
+ continue
+ discovered_external_tools.append(candidate_name)
+
+ extra_tools = [name for name in discovered_external_tools if name not in tool_names]
+ if extra_tools:
+ tool_names.extend(extra_tools)
+ logger.info(
+ "AUTOLOAD_EXTERNAL_TOOLS enabled: added %d external tool(s): %s",
+ len(extra_tools),
+ extra_tools,
+ )
+
+ logger.info(f"Found {len(tool_names)} tools to load: {tool_names}")
+ return tool_names
+
+
+def _resolve_remote_tools(tool_names: list[str], instance_path: str | Path | None) -> list[RemoteMcpTool]:
+ """Build Space tools enabled by the active profile from the cached install manifest, without any network calls."""
+ remote_tools: list[RemoteMcpTool] = []
+ for installed_space in read_installed_tool_spaces(instance_path).spaces:
+ enabled_tool_names = {name for name in tool_names if name.startswith(f"{installed_space.alias}__")}
+ if not enabled_tool_names:
+ continue
+
+ discovered_tool_names = {tool.local_name for tool in installed_space.tools}
+ missing_tool_names = sorted(enabled_tool_names - discovered_tool_names)
+ if missing_tool_names:
+ logger.warning(
+ "Tools enabled from '%s' are missing from the install manifest and will be skipped: %s. "
+ "Re-run 'tool-spaces add %s' to refresh.",
+ installed_space.slug,
+ ", ".join(missing_tool_names),
+ installed_space.slug,
+ )
+
+ client = build_remote_client(
+ installed_space.alias,
+ installed_space.mcp_url,
+ private=installed_space.private,
+ cached_tools=installed_space.tools,
+ )
+ for remote_tool in installed_space.tools:
+ if remote_tool.local_name not in enabled_tool_names:
+ continue
+ cache_key = ("remote", f"{installed_space.slug}:{remote_tool.local_name}:{remote_tool.client_tool_name}")
+ cached_tool = _LOADED_REMOTE_TOOL_CACHE.get(cache_key)
+ if cached_tool is None:
+ cached_tool = RemoteMcpTool(
+ slug=installed_space.slug,
+ name=remote_tool.local_name,
+ description=remote_tool.description,
+ parameters_schema=remote_tool.parameters_schema,
+ client_tool_name=remote_tool.client_tool_name,
+ client=client,
+ )
+ _LOADED_REMOTE_TOOL_CACHE[cache_key] = cached_tool
+ remote_tools.append(cached_tool)
+
+ return remote_tools
+
+
+def _load_profile_tools(tool_names: list[str], remote_tool_names: set[str]) -> List[type[Tool]]:
+ """Load local profile/shared tools while skipping resolved remote tool IDs."""
+ profile = config.REACHY_MINI_CUSTOM_PROFILE or "default"
+ loaded_tool_classes: List[type[Tool]] = []
+
+ for tool_name in tool_names:
+ if tool_name in remote_tool_names:
+ logger.info("✓ Registered remote tool: %s", tool_name)
+ continue
+
+ loaded = False
+ profile_error = None
+ profile_tool_file = config.resolve_profile_dir(profile) / f"{tool_name}.py"
+
+ try:
+ tool_classes, reused_cache = _load_cached_tool_classes(
+ _cache_key_for_file(profile_tool_file),
+ lambda: _load_module_from_file(tool_name, profile_tool_file),
+ )
+ loaded_tool_classes.extend(tool_classes)
+ profile_scope = "external" if config.PROFILES_DIRECTORY != DEFAULT_PROFILES_PATH else "built-in"
+ action = "Reused" if reused_cache else "Loaded"
+ logger.info("✓ %s %s profile tool: %s", action, profile_scope, tool_name)
+ loaded = True
+ except MissingToolFileError:
+ logger.debug("No profile-local tool file for '%s' at %s", tool_name, profile_tool_file)
+ except FileNotFoundError as e:
+ profile_error = _format_error(e)
+ logger.error(f"❌ Failed to load profile tool '{tool_name}': {profile_error}")
+ except Exception as e:
+ profile_error = _format_error(e)
+ logger.error(f"❌ Failed to load profile tool '{tool_name}': {profile_error}")
+
+ if not loaded:
+ shared_module_path = f"peachy.tools.{tool_name}"
+ try:
+ source, tool_classes, reused_cache = _try_load_tool_classes(
+ tool_name,
+ module_path=shared_module_path,
+ fallback_directory=config.TOOLS_DIRECTORY,
+ file_subpath=f"{tool_name}.py",
+ )
+ loaded_tool_classes.extend(tool_classes)
+ action = "Reused" if reused_cache else "Loaded"
+ if source == "file":
+ logger.info("✓ %s external tool: %s", action, tool_name)
+ else:
+ logger.info("✓ %s core tool: %s", action, tool_name)
+ except (ModuleNotFoundError, FileNotFoundError):
+ if profile_error:
+ logger.error(f"❌ Tool '{tool_name}' also not found in shared tools")
+ else:
+ logger.warning(f"⚠️ Tool '{tool_name}' not found in profile or shared tools")
+ except Exception as e:
+ logger.error(f"❌ Failed to load shared tool '{tool_name}': {_format_error(e)}")
+ logger.error(f" Module path: {shared_module_path}")
+
+ return loaded_tool_classes
+
+
+def initialize_tools(instance_path: str | Path | None = None, *, force: bool = False) -> None:
+ """Populate or refresh the active-profile tool registry.
+
+ When ``force`` is true, file-backed tools are re-executed, while importable
+ tool modules still follow normal ``importlib``/``sys.modules`` caching.
+ """
+ global ALL_TOOLS, ALL_TOOL_SPECS, _TOOLS_INITIALIZED, _TOOLS_SIGNATURE, _TOOLS_INSTANCE_PATH
+
+ if force:
+ _LOADED_TOOL_CLASS_CACHE.clear()
+ _LOADED_REMOTE_TOOL_CACHE.clear()
+
+ if instance_path is not None:
+ _TOOLS_INSTANCE_PATH = instance_path
+ effective_instance_path = _TOOLS_INSTANCE_PATH
+ signature = _tool_registry_signature(effective_instance_path)
+
+ if _TOOLS_INITIALIZED and not force and signature == _TOOLS_SIGNATURE:
+ logger.debug("Tools already initialized for active profile; skipping reinitialization.")
+ return
+ if _TOOLS_INITIALIZED:
+ logger.info("Reloading tool registry for active profile/configuration change.")
+
+ tool_names = _read_profile_tool_names()
+ remote_tools = _resolve_remote_tools(tool_names, effective_instance_path)
+ remote_tool_names = {tool.name for tool in remote_tools}
+ loaded_tool_classes = _load_profile_tools(tool_names, remote_tool_names)
+
+ ALL_TOOLS = _build_tool_registry(
+ loaded_tool_classes,
+ extra_tools=remote_tools,
+ )
+ ALL_TOOL_SPECS = [tool.spec() for tool in ALL_TOOLS.values()]
+
+ for tool_name, tool in ALL_TOOLS.items():
+ logger.info(f"tool registered: {tool_name} - {tool.description}")
+
+ _TOOLS_INITIALIZED = True
+ _TOOLS_SIGNATURE = signature
+
+
+def get_tool_specs(exclusion_list: list[str] | None = None) -> list[ToolSpec]:
+ """Get tool specs, optionally excluding some tools."""
+ initialize_tools()
+ exclusion_list = exclusion_list or []
+ return [spec for spec in ALL_TOOL_SPECS if spec["name"] not in exclusion_list]
+
+
+# Dispatcher
+def _safe_load_obj(args_json: str) -> Dict[str, Any]:
+ try:
+ parsed_args = json.loads(args_json or "{}")
+ return parsed_args if isinstance(parsed_args, dict) else {}
+ except Exception:
+ logger.warning("bad args_json=%r", args_json)
+ return {}
+
+
+async def _dispatch_tool_call(tool_name: str, args: Dict[str, Any], deps: ToolDependencies) -> Dict[str, Any]:
+ initialize_tools()
+ tool = ALL_TOOLS.get(tool_name)
+ if not tool:
+ return {"error": f"unknown tool: {tool_name}"}
+ try:
+ return await tool(deps, **args)
+ except asyncio.CancelledError:
+ logger.info("Tool cancelled: %s", tool_name)
+ return {"error": "Tool cancelled"}
+ except Exception as e:
+ msg = f"{type(e).__name__}: {e}"
+ logger.exception("Tool error in %s: %s", tool_name, msg)
+ return {"error": msg}
+
+
+async def dispatch_tool_call(tool_name: str, args_json: str, deps: ToolDependencies) -> Dict[str, Any]:
+ """Dispatch a tool call by name with JSON args and dependencies."""
+ return await _dispatch_tool_call(tool_name, _safe_load_obj(args_json), deps)
+
+
+async def dispatch_tool_call_with_manager(
+ tool_name: str, args_json: str, deps: ToolDependencies, tool_manager: "BackgroundToolManager"
+) -> Dict[str, Any]:
+ """Dispatch a tool call, injecting a BackgroundToolManager into the args."""
+ args = _safe_load_obj(args_json)
+ args["tool_manager"] = tool_manager
+ return await _dispatch_tool_call(tool_name, args, deps)
diff --git a/src/peachy/tools/dance.py b/src/peachy/tools/dance.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c2a3e680d2c6fa554451a0c1b0bbaeff4d61fde
--- /dev/null
+++ b/src/peachy/tools/dance.py
@@ -0,0 +1,87 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import random
+import logging
+from typing import Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+# Initialize dance library
+try:
+ from reachy_mini_dances_library.collection.dance import AVAILABLE_MOVES
+ from peachy.dance_emotion_moves import DanceQueueMove
+
+ DANCE_AVAILABLE = True
+except ImportError as e:
+ logger.warning(f"Dance library not available: {e}")
+ AVAILABLE_MOVES = {}
+ DANCE_AVAILABLE = False
+
+
+def get_available_dances_and_descriptions() -> str:
+ """Get formatted list of available dances with descriptions."""
+ if not DANCE_AVAILABLE:
+ return "Moves not available."
+
+ if not AVAILABLE_MOVES:
+ return "Moves not available."
+
+ output = ""
+ for move_name, (func, params, metadata) in AVAILABLE_MOVES.items():
+ description = metadata.get("description", "No description available.")
+ output += f"{move_name}: {description}\n"
+ return output
+
+
+class Dance(Tool):
+ """Play a named or random dance move once (or repeat). Non-blocking."""
+
+ name = "dance"
+ description = "Play a named or random dance move once (or repeat). Non-blocking."
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "move": {
+ "type": "string",
+ "enum": list(AVAILABLE_MOVES.keys() if DANCE_AVAILABLE else []),
+ "description": f"""Name of the moves and their descriptions; omit for random.
+ Here is a list of the available moves, you MUST only choose from these: \n
+ {get_available_dances_and_descriptions()}
+ """,
+ },
+ "repeat": {
+ "type": "integer",
+ "description": "How many times to repeat the move (default 1).",
+ },
+ },
+ "required": [],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Play a named or random dance move once (or repeat). Non-blocking."""
+ if not DANCE_AVAILABLE:
+ return {"error": "Dance system not available"}
+
+ if not AVAILABLE_MOVES:
+ return {"error": "No moves currently available"}
+
+ move_name = kwargs.get("move")
+ repeat = int(kwargs.get("repeat", 1))
+
+ logger.info("Tool call: dance move=%s repeat=%d", move_name, repeat)
+
+ if not move_name:
+ move_name = random.choice(list(AVAILABLE_MOVES.keys()))
+
+ if move_name not in AVAILABLE_MOVES:
+ return {"error": f"Unknown dance move '{move_name}'. Available: {list(AVAILABLE_MOVES.keys())}"}
+
+ movement_manager = deps.movement_manager
+ for _ in range(repeat):
+ dance_move = DanceQueueMove(move_name)
+ movement_manager.queue_move(dance_move)
+
+ return {"status": "queued", "move": move_name, "repeat": repeat}
diff --git a/src/peachy/tools/forget.py b/src/peachy/tools/forget.py
new file mode 100644
index 0000000000000000000000000000000000000000..b693de6f42c7f81550f96c2645149deff356ee00
--- /dev/null
+++ b/src/peachy/tools/forget.py
@@ -0,0 +1,53 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any
+
+from peachy.memory import forget_memory_fact
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class Forget(Tool):
+ """Remove one long-term memory fact."""
+
+ name = "forget"
+ description = (
+ "Remove a previously saved fact from long-term memory. Call this when the user asks you to forget something, "
+ "or when saved information becomes obsolete. Match by a specific free-text phrase present in the fact."
+ )
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "query": {
+ "type": "string",
+ "description": (
+ "A short search phrase that should be present in the fact to remove. Matching is case-insensitive."
+ ),
+ },
+ },
+ "required": ["query"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
+ """Forget one memory fact by query."""
+ query = kwargs.get("query")
+ if not isinstance(query, str) or not query.strip():
+ logger.warning("forget: empty query")
+ return {"error": "query must be a non-empty string"}
+
+ result = forget_memory_fact(deps.instance_path, query=query)
+ if result.removed is None:
+ logger.info("Tool call: forget query=%s no_match", query[:120])
+ return {"error": f'no memory matched "{query}"; nothing was removed'}
+
+ response: dict[str, Any] = {
+ "removed": result.removed.text,
+ "memory_id": result.removed.id,
+ }
+ if len(result.candidates) > 1:
+ response["other_matches"] = [fact.text for fact in result.candidates[1:]]
+
+ logger.info("Tool call: forget query=%s removed=%s", query[:120], result.removed.text[:120])
+ return response
diff --git a/src/peachy/tools/go_to_sleep.py b/src/peachy/tools/go_to_sleep.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca2c5e44d383bd8479965f6ce774dca493f7dd35
--- /dev/null
+++ b/src/peachy/tools/go_to_sleep.py
@@ -0,0 +1,37 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import asyncio
+import logging
+from typing import Any
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class GoToSleep(Tool):
+ """Put Reachy to sleep and stop the current app."""
+
+ name = "go_to_sleep"
+ description = (
+ "Use when you are sure the user wants Reachy to go to sleep, stop the current app, shut down this app, "
+ "or end the conversation. Do not use for idle turns, sleepy emotions, silence, or ambiguous requests."
+ )
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {},
+ "required": [],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
+ """Put Reachy to sleep and request app shutdown."""
+ if deps.go_to_sleep is None:
+ return {"error": "go_to_sleep is unavailable in this runtime"}
+
+ logger.info("Tool call: go_to_sleep")
+ try:
+ return await asyncio.to_thread(deps.go_to_sleep)
+ except Exception as e:
+ logger.error("go_to_sleep failed: %s", e)
+ return {"error": f"go_to_sleep failed: {type(e).__name__}: {e}"}
diff --git a/src/peachy/tools/head_tracking.py b/src/peachy/tools/head_tracking.py
new file mode 100644
index 0000000000000000000000000000000000000000..63d6eabfa979dfdad9aff9c071fa091ea86421a8
--- /dev/null
+++ b/src/peachy/tools/head_tracking.py
@@ -0,0 +1,36 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class HeadTracking(Tool):
+ """Enable or disable following the user's face with the head."""
+
+ name = "head_tracking"
+ description = (
+ "Enable or disable following the user's face with the head. "
+ "Use when asked to follow, keep looking at, or stop following the user."
+ )
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "enabled": {
+ "type": "boolean",
+ "description": "True to start following the user's face, false to stop.",
+ },
+ },
+ "required": ["enabled"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Toggle head tracking."""
+ enabled = bool(kwargs.get("enabled", True))
+ logger.info("Tool call: head_tracking enabled=%s", enabled)
+ deps.movement_manager.set_head_tracking(enabled)
+ return {"status": "following" if enabled else "stopped following"}
diff --git a/src/peachy/tools/idle_do_nothing.py b/src/peachy/tools/idle_do_nothing.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c29a14f09f3f6411fd79807efe51aca7662248a
--- /dev/null
+++ b/src/peachy/tools/idle_do_nothing.py
@@ -0,0 +1,34 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class IdleDoNothing(Tool):
+ """Explicitly choose no action during an idle turn."""
+
+ name = "idle_do_nothing"
+ description = (
+ "Use only in response to an idle time update when you intentionally want Reachy to stay still and silent "
+ "instead of choosing another idle action."
+ )
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "reason": {
+ "type": "string",
+ "description": "Optional reason for staying idle during this idle turn.",
+ },
+ },
+ "required": [],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Stay still and silent for the current idle turn."""
+ reason = kwargs.get("reason", "idle turn")
+ logger.info("Tool call: idle_do_nothing reason=%s", reason)
+ return {"status": "idle", "reason": reason}
diff --git a/src/peachy/tools/move_head.py b/src/peachy/tools/move_head.py
new file mode 100644
index 0000000000000000000000000000000000000000..07cdc690067506dce4077b5bbe942d5b4da2322a
--- /dev/null
+++ b/src/peachy/tools/move_head.py
@@ -0,0 +1,81 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any, Dict, Tuple, Literal
+
+from reachy_mini.utils import create_head_pose
+from peachy.tools.core_tools import Tool, ToolDependencies
+from peachy.dance_emotion_moves import GotoQueueMove
+
+
+logger = logging.getLogger(__name__)
+
+Direction = Literal["left", "right", "up", "down", "front"]
+
+
+class MoveHead(Tool):
+ """Move head in a given direction."""
+
+ name = "move_head"
+ description = "Move your head in a given direction: left, right, up, down or front."
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "direction": {
+ "type": "string",
+ "enum": ["left", "right", "up", "down", "front"],
+ },
+ },
+ "required": ["direction"],
+ }
+
+ # mapping: direction -> args for create_head_pose
+ DELTAS: Dict[str, Tuple[int, int, int, int, int, int]] = {
+ "left": (0, 0, 0, 0, 0, 40),
+ "right": (0, 0, 0, 0, 0, -40),
+ "up": (0, 0, 0, 0, -30, 0),
+ "down": (0, 0, 0, 0, 30, 0),
+ "front": (0, 0, 0, 0, 0, 0),
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Move head in a given direction."""
+ direction_raw = kwargs.get("direction")
+ if not isinstance(direction_raw, str):
+ return {"error": "direction must be a string"}
+ direction: Direction = direction_raw # type: ignore[assignment]
+ logger.info("Tool call: move_head direction=%s", direction)
+
+ deltas = self.DELTAS.get(direction, self.DELTAS["front"])
+ target = create_head_pose(*deltas, degrees=True)
+
+ # Use new movement manager
+ try:
+ movement_manager = deps.movement_manager
+
+ # Get current state for interpolation
+ current_head_pose = deps.reachy_mini.get_current_head_pose()
+ _, current_antennas = deps.reachy_mini.get_current_joint_positions()
+
+ # Create goto move
+ goto_move = GotoQueueMove(
+ target_head_pose=target,
+ start_head_pose=current_head_pose,
+ target_antennas=(0, 0), # Reset antennas to default
+ start_antennas=(
+ current_antennas[0],
+ current_antennas[1],
+ ), # Skip body_yaw
+ target_body_yaw=0, # Reset body yaw
+ start_body_yaw=current_antennas[0], # body_yaw is first in joint positions
+ duration=deps.motion_duration_s,
+ )
+
+ movement_manager.queue_move(goto_move)
+ movement_manager.set_moving_state(deps.motion_duration_s)
+
+ return {"status": f"looking {direction}"}
+
+ except Exception as e:
+ logger.error("move_head failed")
+ return {"error": f"move_head failed: {type(e).__name__}: {e}"}
diff --git a/src/peachy/tools/play_emotion.py b/src/peachy/tools/play_emotion.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d5b40cfaf1b24a3f44bc280ae75db726f646cf6
--- /dev/null
+++ b/src/peachy/tools/play_emotion.py
@@ -0,0 +1,289 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import re
+import random
+import logging
+import unicodedata
+from typing import TYPE_CHECKING, Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+if TYPE_CHECKING:
+ from reachy_mini.motion.recorded_move import RecordedMoves
+
+
+logger = logging.getLogger(__name__)
+
+try:
+ from reachy_mini.motion.recorded_move import RecordedMoves
+ from peachy.dance_emotion_moves import EmotionQueueMove
+
+ EMOTION_AVAILABLE = True
+except Exception as e:
+ logger.warning(f"Emotion library not available: {e}")
+ EMOTION_AVAILABLE = False
+
+
+EMOTION_INTENTS: tuple[str, ...] = (
+ "random",
+ "happy",
+ "excited",
+ "loving",
+ "grateful",
+ "success",
+ "thinking",
+ "attentive",
+ "confused",
+ "uncertain",
+ "sad",
+ "downcast",
+ "lonely",
+ "angry",
+ "irritated",
+ "displeased",
+ "disgusted",
+ "scared",
+ "anxious",
+ "surprised",
+ "amazed",
+ "calming",
+ "relief",
+ "impatient",
+ "embarrassed",
+ "bored",
+ "tired",
+ "sleepy",
+ "yes",
+ "yes_understanding",
+ "no",
+ "no_sad",
+ "no_excited",
+ "no_firm",
+ "welcoming",
+ "greeting",
+ "goodbye",
+ "go_away",
+ "helpful",
+ "dance",
+ "electric",
+ "dying",
+)
+
+_EXCELLENT_MOVES: tuple[str, ...] = (
+ "anxiety1",
+ "boredom2",
+ "dance2",
+ "dance3",
+ "downcast1",
+ "dying1",
+ "exhausted1",
+ "grateful1",
+ "helpful1",
+ "loving1",
+ "rage1",
+ "reprimand1",
+ "resigned1",
+ "sad1",
+ "sad2",
+ "scared1",
+ "sleep1",
+ "surprised1",
+ "thoughtful1",
+ "welcoming2",
+)
+
+_OK_CLEAR_MOVES: tuple[str, ...] = (
+ "amazed1",
+ "attentive1",
+ "attentive2",
+ "boredom1",
+ "confused1",
+ "disgusted1",
+ "displeased1",
+ "displeased2",
+ "fear1",
+ "impatient2",
+ "irritated1",
+ "irritated2",
+ "laughing1",
+ "laughing2",
+ "lonely1",
+ "no1",
+ "no_excited1",
+ "no_sad1",
+ "reprimand2",
+ "shy1",
+ "success1",
+ "success2",
+ "surprised2",
+ "thoughtful2",
+ "uncertain1",
+ "understanding2",
+ "yes1",
+)
+
+_CURATED_DEFAULT_MOVES: tuple[str, ...] = _EXCELLENT_MOVES + _OK_CLEAR_MOVES
+
+_INTENT_TO_MOVES: dict[str, tuple[str, ...]] = {
+ "happy": ("laughing2", "laughing1"),
+ "excited": ("dance3", "dance2"),
+ "loving": ("loving1",),
+ "grateful": ("grateful1",),
+ "success": ("success1", "success2"),
+ "thinking": ("thoughtful1", "thoughtful2"),
+ "attentive": ("attentive1", "attentive2"),
+ "confused": ("confused1",),
+ "uncertain": ("uncertain1",),
+ "sad": ("sad1", "sad2", "downcast1"),
+ "downcast": ("downcast1", "sad1"),
+ "lonely": ("lonely1",),
+ "angry": ("rage1", "irritated2", "irritated1"),
+ "irritated": ("irritated1", "irritated2", "displeased2"),
+ "displeased": ("displeased1", "displeased2"),
+ "disgusted": ("disgusted1",),
+ "scared": ("scared1", "fear1", "anxiety1"),
+ "anxious": ("anxiety1", "fear1", "scared1"),
+ "surprised": ("surprised1", "surprised2", "amazed1"),
+ "amazed": ("amazed1", "surprised1"),
+ "calming": ("calming1",),
+ "relief": ("relief1", "relief2"),
+ "impatient": ("impatient2",),
+ "embarrassed": ("shy1",),
+ "bored": ("boredom2", "boredom1"),
+ "tired": ("exhausted1", "sleep1"),
+ "sleepy": ("sleep1", "exhausted1"),
+ "yes": ("yes1", "understanding2"),
+ "yes_understanding": ("understanding2",),
+ "no": ("no1",),
+ "no_sad": ("no_sad1",),
+ "no_excited": ("no_excited1",),
+ "no_firm": ("no1",),
+ "welcoming": ("welcoming2",),
+ "greeting": ("welcoming2",),
+ "goodbye": ("loving1", "welcoming2"),
+ "go_away": ("go_away1",),
+ "helpful": ("helpful1",),
+ "dance": ("dance2", "dance3"),
+ "electric": ("electric1",),
+ "dying": ("dying1",),
+}
+
+_ALLOWED_MOVE_NAMES: frozenset[str] = frozenset(_CURATED_DEFAULT_MOVES).union(*_INTENT_TO_MOVES.values())
+
+_KEYWORD_INTENTS: tuple[tuple[tuple[str, ...], str], ...] = (
+ (("no", "sad"), "no_sad"),
+ (("no", "excited"), "no_excited"),
+ (("no", "firm"), "no_firm"),
+ (("yes", "understanding"), "yes_understanding"),
+)
+
+
+def _normalize_emotion_key(value: str) -> str:
+ """Normalize an emotion request for exact intent and keyword matching."""
+ without_accents = unicodedata.normalize("NFKD", value).encode("ascii", "ignore").decode("ascii")
+ return re.sub(r"[^a-z0-9]+", "_", without_accents.lower()).strip("_")
+
+
+def _keyword_intent(normalized_key: str) -> str | None:
+ """Return the first nuanced intent whose keywords are all present."""
+ tokens = set(normalized_key.split("_"))
+ for keywords, intent in _KEYWORD_INTENTS:
+ if all(keyword in tokens for keyword in keywords):
+ return intent
+ return None
+
+
+def resolve_emotion_name(requested_emotion: object, available_emotions: list[str]) -> str | None:
+ """Resolve a compact intent, nuanced yes/no phrase, or recorded move ID."""
+ if not available_emotions:
+ return None
+
+ requested = str(requested_emotion or "").strip()
+ if not requested:
+ return None
+
+ normalized = _normalize_emotion_key(requested)
+ if not normalized or normalized == "random":
+ return None
+
+ available_by_key = {_normalize_emotion_key(name): name for name in available_emotions}
+ exact_move = available_by_key.get(normalized)
+ if exact_move in _ALLOWED_MOVE_NAMES:
+ return exact_move
+
+ intent = normalized if normalized in _INTENT_TO_MOVES else None
+ if intent is None:
+ intent = _keyword_intent(normalized)
+
+ if intent is None:
+ return None
+
+ for candidate in _INTENT_TO_MOVES.get(intent, ()):
+ if candidate in available_emotions:
+ return candidate
+ return None
+
+
+def random_curated_emotion(available_emotions: list[str]) -> str:
+ """Choose a random emotion from the curated default pool when possible."""
+ curated_available = [emotion for emotion in _CURATED_DEFAULT_MOVES if emotion in available_emotions]
+ if curated_available:
+ return random.choice(curated_available)
+ return random.choice(available_emotions)
+
+
+class PlayEmotion(Tool):
+ """Play a pre-recorded emotion."""
+
+ name = "play_emotion"
+ description = "Play a robot emotion matching a requested emotional intent."
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "emotion": {
+ "type": "string",
+ "enum": list(EMOTION_INTENTS),
+ "description": (
+ "Compact emotional intent to express. Choose one of the enum values. Use nuanced "
+ "labels like no_sad, no_excited, no_firm, or yes_understanding when plain yes/no "
+ "loses meaning. Use random if no clear intent fits."
+ ),
+ },
+ },
+ "required": [],
+ }
+ _library: "RecordedMoves | None" = None
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Play a pre-recorded emotion."""
+ if not EMOTION_AVAILABLE:
+ return {"error": "Emotion system not available"}
+
+ requested_emotion = kwargs.get("emotion")
+
+ logger.info("Tool call: play_emotion emotion=%s", requested_emotion)
+
+ try:
+ if self._library is None:
+ # Constructing this downloads the dataset, so it must not run at import.
+ self._library = RecordedMoves("pollen-robotics/reachy-mini-emotions-library")
+ library = self._library
+ emotion_names = library.list_moves()
+ if not emotion_names:
+ return {"error": "No emotions currently available"}
+
+ emotion_name = resolve_emotion_name(requested_emotion, emotion_names)
+ if not emotion_name:
+ logger.info("play_emotion: %r did not resolve; using random curated", requested_emotion)
+ emotion_name = random_curated_emotion(emotion_names)
+
+ movement_manager = deps.movement_manager
+ emotion_move = EmotionQueueMove(emotion_name, library)
+ movement_manager.queue_move(emotion_move)
+
+ return {"status": "queued", "emotion": emotion_name}
+
+ except Exception as e:
+ logger.exception("Failed to play emotion")
+ return {"error": f"Failed to play emotion: {e!s}"}
diff --git a/src/peachy/tools/remember.py b/src/peachy/tools/remember.py
new file mode 100644
index 0000000000000000000000000000000000000000..2873a083e538946537fad33756c03593cf6512da
--- /dev/null
+++ b/src/peachy/tools/remember.py
@@ -0,0 +1,49 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any
+
+from peachy.memory import add_memory_fact
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class Remember(Tool):
+ """Save one short long-term memory fact about the user."""
+
+ name = "remember"
+ description = (
+ "Save ONE short fact about the user to long-term memory so it is available in future sessions. "
+ "Use this for stable user information they explicitly shared: name, preferences, hobbies, recurring projects, "
+ "important people, or plans. Keep each fact atomic and under one sentence. Do not save sensitive data "
+ "(passwords, addresses, payment info, health diagnoses) or fleeting details. Use this silently in the "
+ 'background; acknowledge naturally without saying "I will remember that".'
+ )
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "fact": {
+ "type": "string",
+ "description": (
+ "A short, third-person statement about the user, such as "
+ '"Has a dog named Mochi" or "Prefers replies in French". One fact per call.'
+ ),
+ },
+ },
+ "required": ["fact"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
+ """Save one memory fact."""
+ fact = kwargs.get("fact")
+ if not isinstance(fact, str) or not fact.strip():
+ logger.warning("remember: empty fact")
+ return {"error": "fact must be a non-empty string"}
+
+ stored = add_memory_fact(deps.instance_path, fact)
+ if stored is None:
+ return {"error": "fact was empty or invalid; nothing was saved"}
+
+ logger.info("Tool call: remember fact=%s", stored.text[:120])
+ return {"saved": stored.text, "memory_id": stored.id}
diff --git a/src/peachy/tools/stop_dance.py b/src/peachy/tools/stop_dance.py
new file mode 100644
index 0000000000000000000000000000000000000000..b5b1a281e3a97bba5b61ed9d68996cca15b0246a
--- /dev/null
+++ b/src/peachy/tools/stop_dance.py
@@ -0,0 +1,33 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class StopDance(Tool):
+ """Stop the current dance move."""
+
+ name = "stop_dance"
+ description = "Stop the current dance move"
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "dummy": {
+ "type": "boolean",
+ "description": "dummy boolean, set it to true",
+ },
+ },
+ "required": ["dummy"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Stop the current dance move."""
+ logger.info("Tool call: stop_dance")
+ movement_manager = deps.movement_manager
+ movement_manager.clear_move_queue()
+ return {"status": "stopped dance and cleared queue"}
diff --git a/src/peachy/tools/stop_emotion.py b/src/peachy/tools/stop_emotion.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cb8c98a7699278e067872a489e126877912ac10
--- /dev/null
+++ b/src/peachy/tools/stop_emotion.py
@@ -0,0 +1,33 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+import logging
+from typing import Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+
+
+logger = logging.getLogger(__name__)
+
+
+class StopEmotion(Tool):
+ """Stop the current emotion."""
+
+ name = "stop_emotion"
+ description = "Stop the current emotion"
+ needs_response = False
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "dummy": {
+ "type": "boolean",
+ "description": "dummy boolean, set it to true",
+ },
+ },
+ "required": ["dummy"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Stop the current emotion."""
+ logger.info("Tool call: stop_emotion")
+ movement_manager = deps.movement_manager
+ movement_manager.clear_move_queue()
+ return {"status": "stopped emotion and cleared queue"}
diff --git a/src/peachy/tools/task_cancel.py b/src/peachy/tools/task_cancel.py
new file mode 100644
index 0000000000000000000000000000000000000000..87869d51fb098509a88eb27666de7d502f6aa883
--- /dev/null
+++ b/src/peachy/tools/task_cancel.py
@@ -0,0 +1,76 @@
+"""Tool cancel tool - cancel running background tools."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+from peachy.tools.tool_constants import ToolState
+
+
+if TYPE_CHECKING:
+ from peachy.tools.background_tool_manager import BackgroundToolManager
+
+
+logger = logging.getLogger(__name__)
+
+
+class TaskCancel(Tool):
+ """Cancel a running background tool task."""
+
+ name = "task_cancel"
+ description = (
+ "Cancel a running background tool task. "
+ "Use this when the user wants to stop a tool that's running in the background. "
+ "Requires confirmation before cancelling."
+ )
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "tool_id": {
+ "type": "string",
+ "description": "The tool ID to cancel",
+ }
+ },
+ "required": ["tool_id"],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Cancel a background tool."""
+ tool_id = kwargs.get("tool_id", "")
+ tool_manager: BackgroundToolManager | None = kwargs.get("tool_manager")
+
+ if tool_manager is None:
+ return {"error": "Tool manager is required."}
+
+ logger.info(f"Tool call: tool_cancel tool_id={tool_id}")
+
+ if not tool_id:
+ return {"error": "Tool ID is required."}
+
+ tool = tool_manager.get_tool(tool_id)
+
+ if not tool:
+ return {"error": f"Tool {tool_id} not found."}
+
+ # Check if tool is still running
+ if tool.status != ToolState.RUNNING:
+ return {
+ "status": f"{tool.status.value}",
+ "message": f"Tool '{tool.tool_name}' is not running (status: {tool.status.value}).",
+ "tool_id": tool_id,
+ }
+
+ # Cancel the tool
+ if await tool_manager.cancel_tool(tool_id):
+ return {
+ "status": "cancelled",
+ "message": f"Tool '{tool.tool_name}' has been cancelled.",
+ "tool_id": tool_id,
+ "tool_name": tool.tool_name,
+ }
+ else:
+ return {
+ "error": f"Could not cancel tool {tool_id}. It may have already completed.",
+ }
diff --git a/src/peachy/tools/task_status.py b/src/peachy/tools/task_status.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf308f7d5b474a5aad3c875de8b65e10b7c7643b
--- /dev/null
+++ b/src/peachy/tools/task_status.py
@@ -0,0 +1,108 @@
+"""Tool status tool - check status of background tools."""
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+
+
+import time
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+
+from peachy.tools.core_tools import Tool, ToolDependencies
+from peachy.tools.tool_constants import SystemTool
+
+
+if TYPE_CHECKING:
+ from peachy.tools.background_tool_manager import BackgroundToolManager
+
+
+logger = logging.getLogger(__name__)
+
+
+class TaskStatus(Tool):
+ """Check status of background tool tasks."""
+
+ name = "task_status"
+ description = (
+ "Check the status of background tool tasks. "
+ "Use this when the user asks about running tools or wants to know what's happening in the background."
+ )
+ parameters_schema = {
+ "type": "object",
+ "properties": {
+ "tool_id": {
+ "type": "string",
+ "description": "Specific tool ID to check (optional, shows all running tools if omitted)",
+ },
+ },
+ "required": [],
+ }
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:
+ """Get status of background tools."""
+ tool_id: str | None = kwargs.get("tool_id")
+ tool_manager: BackgroundToolManager | None = kwargs.get("tool_manager")
+
+ if tool_manager is None:
+ return {"error": "Tool manager is required."}
+
+ logger.info(f"Tool call: tool_status tool_id={tool_id}")
+
+ if tool_id:
+ tool = tool_manager.get_tool(tool_id)
+ if not tool:
+ return {"error": f"Tool {tool_id} not found."}
+
+ result: Dict[str, Any] = {
+ "tool_id": tool.tool_id,
+ "name": tool.tool_name,
+ "status": tool.status.value,
+ "started_at": tool.started_at,
+ }
+ if tool.completed_at:
+ result["completed_at"] = tool.completed_at
+
+ if tool.progress is not None:
+ result["progress_percent"] = f"{tool.progress.progress:.0%}"
+ if tool.progress.message:
+ result["progress_message"] = tool.progress.message
+
+ if tool.result:
+ result["result"] = tool.result
+ if tool.error:
+ result["error"] = tool.error
+
+ return result
+
+ # Get all running tools
+ running = tool_manager.get_running_tools()
+ if not running:
+ return {
+ "status": "idle",
+ "message": "No tools running in the background.",
+ }
+
+ tools_info = []
+ for tool in [
+ tool for tool in running if tool.tool_name not in [system_tool.value for system_tool in SystemTool]
+ ]:
+ elapsed = time.monotonic() - tool.started_at
+ tool_info: Dict[str, Any] = {
+ "tool_id": tool.tool_id,
+ "name": tool.tool_name,
+ "status": tool.status.value,
+ "elapsed_seconds": round(elapsed, 1),
+ }
+
+ # Add progress if tracking
+ if tool.progress is not None:
+ tool_info["progress_percent"] = f"{tool.progress.progress:.0%}"
+ if tool.progress.message:
+ tool_info["progress_message"] = tool.progress.message
+
+ tools_info.append(tool_info)
+
+ return {
+ "status": "running",
+ "count": len(tools_info),
+ "message": f"{len(tools_info)} tool(s) running in the background.",
+ "tools": tools_info,
+ }
diff --git a/src/peachy/tools/tool_constants.py b/src/peachy/tools/tool_constants.py
new file mode 100644
index 0000000000000000000000000000000000000000..8eebd3f5dc15a89a2fe8b1fe6bbf3ae7fc2292f5
--- /dev/null
+++ b/src/peachy/tools/tool_constants.py
@@ -0,0 +1,18 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+from enum import Enum
+
+
+class ToolState(Enum):
+ """Status of a background tool."""
+
+ RUNNING = "running"
+ COMPLETED = "completed"
+ FAILED = "failed"
+ CANCELLED = "cancelled"
+
+
+class SystemTool(Enum):
+ """System tools are tools that are used to manage the background tool manager."""
+
+ TASK_STATUS = "task_status"
+ TASK_CANCEL = "task_cancel"
diff --git a/src/peachy/utils.py b/src/peachy/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..b709cbeeac64e1df84c2e31e27fb587c4ae336bd
--- /dev/null
+++ b/src/peachy/utils.py
@@ -0,0 +1,91 @@
+# Modified by Peachy contributors in 2026 for namespace, packaging, and provider integration.
+from __future__ import annotations
+import logging
+import argparse
+import warnings
+from typing import Optional
+
+
+def parse_args() -> tuple[argparse.Namespace, list]: # type: ignore
+ """Parse command line arguments."""
+ parser = argparse.ArgumentParser("Reachy Mini Conversation App")
+ parser.add_argument("--no-camera", default=False, action="store_true", help="Disable camera usage")
+ parser.add_argument(
+ "--ui",
+ default=False,
+ action="store_true",
+ help="Serve the web UI at http://127.0.0.1:7860/, in addition to console mode",
+ )
+ parser.add_argument("--debug", default=False, action="store_true", help="Enable debug logging")
+ parser.add_argument(
+ "--robot-name",
+ type=str,
+ default=None,
+ help="[Optional] Robot name to target. Must match the daemon's --robot-name when connecting to a specific robot, mainly useful for development with multiple robots.",
+ )
+ subparsers = parser.add_subparsers(dest="command")
+ tool_spaces_parser = subparsers.add_parser("tool-spaces", help="Manage installed Hugging Face Space tool sources")
+ tool_spaces_subparsers = tool_spaces_parser.add_subparsers(dest="tool_spaces_command", required=True)
+
+ add_parser = tool_spaces_subparsers.add_parser("add", help="Install one Space tool source by slug")
+ add_parser.add_argument("space_slug", help="Hugging Face Space slug in the form owner/space-name")
+ add_parser.add_argument(
+ "--install-only",
+ action="store_true",
+ default=False,
+ help="Install the Space without enabling its tools in any profile.",
+ )
+ add_parser.add_argument(
+ "--profile",
+ dest="profile",
+ default=None,
+ metavar="PROFILE",
+ help="Enable tools in this profile instead of the active profile.",
+ )
+
+ remove_parser = tool_spaces_subparsers.add_parser("remove", help="Remove one installed Space tool source")
+ remove_parser.add_argument("space_slug", help="Installed Hugging Face Space slug in the form owner/space-name")
+
+ tool_spaces_subparsers.add_parser("list", help="List installed Space tool sources")
+ return parser.parse_known_args()
+
+
+def setup_logger(debug: bool) -> logging.Logger:
+ """Setups the logger."""
+ log_level = "DEBUG" if debug else "INFO"
+ logging.basicConfig(
+ level=getattr(logging, log_level, logging.INFO),
+ format="%(asctime)s %(levelname)s %(name)s:%(lineno)d | %(message)s",
+ force=True,
+ )
+ logger = logging.getLogger(__name__)
+
+ # Suppress WebRTC warnings
+ warnings.filterwarnings("ignore", message=".*AVCaptureDeviceTypeExternal.*")
+ warnings.filterwarnings("ignore", category=UserWarning, module="aiortc")
+
+ # Tame third-party noise (looser in DEBUG)
+ if log_level == "DEBUG":
+ logging.getLogger("aiortc").setLevel(logging.INFO)
+ logging.getLogger("aioice").setLevel(logging.INFO)
+ logging.getLogger("openai").setLevel(logging.INFO)
+ logging.getLogger("websockets").setLevel(logging.INFO)
+ else:
+ logging.getLogger("aiortc").setLevel(logging.ERROR)
+ logging.getLogger("aioice").setLevel(logging.WARNING)
+ return logger
+
+
+def log_connection_troubleshooting(logger: logging.Logger, robot_name: Optional[str]) -> None:
+ """Log troubleshooting steps for connection issues."""
+ logger.error("Troubleshooting steps:")
+ logger.error(" 1. Verify reachy-mini-daemon is running")
+
+ if robot_name is not None:
+ logger.error(f" 2. Daemon must be started with: --robot-name '{robot_name}'")
+ else:
+ logger.error(" 2. If daemon uses --robot-name, add the same flag here: --robot-name ")
+
+ logger.error(" 3. For wireless: check network connectivity")
+ logger.error(" 4. Review daemon logs")
+ logger.error(" 5. Restart the daemon")
diff --git a/style.css b/style.css
index 114adf441e9032febb46bc056b2a8bb651075f0d..b4cadc84739ca953bb3d144340cef424503e0234 100644
--- a/style.css
+++ b/style.css
@@ -1,28 +1,386 @@
+:root {
+ --bg: #060c1d;
+ --panel: #0c172b;
+ --glass: rgba(17, 27, 48, 0.7);
+ --card: rgba(255, 255, 255, 0.04);
+ --accent: #7af5c4;
+ --accent-2: #f6c452;
+ --text: #e8edf7;
+ --muted: #9fb3ce;
+ --border: rgba(255, 255, 255, 0.08);
+ --shadow: 0 25px 70px rgba(0, 0, 0, 0.45);
+ font-family: "Space Grotesk", "Manrope", system-ui, -apple-system, sans-serif;
+}
+
+* {
+ margin: 0;
+ padding: 0;
+ box-sizing: border-box;
+}
+
body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
+ background: radial-gradient(circle at 20% 20%, rgba(122, 245, 196, 0.12), transparent 30%),
+ radial-gradient(circle at 80% 0%, rgba(246, 196, 82, 0.14), transparent 32%),
+ radial-gradient(circle at 50% 70%, rgba(124, 142, 255, 0.1), transparent 30%),
+ var(--bg);
+ color: var(--text);
+ min-height: 100vh;
+ line-height: 1.6;
+ padding-bottom: 3rem;
+}
+
+a {
+ color: inherit;
+ text-decoration: none;
+}
+
+.hero {
+ padding: 3.5rem clamp(1.5rem, 3vw, 3rem) 2.5rem;
+ position: relative;
+ overflow: hidden;
+}
+
+.hero::after {
+ content: "";
+ position: absolute;
+ inset: 0;
+ background: linear-gradient(120deg, rgba(122, 245, 196, 0.12), rgba(246, 196, 82, 0.08), transparent);
+ pointer-events: none;
+}
+
+.topline {
+ display: flex;
+ align-items: center;
+ justify-content: space-between;
+ max-width: 1200px;
+ margin: 0 auto 2rem;
+ position: relative;
+ z-index: 2;
+}
+
+.brand {
+ display: flex;
+ align-items: center;
+ gap: 0.5rem;
+ font-weight: 700;
+ letter-spacing: 0.5px;
+ color: var(--text);
+}
+
+.logo {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ width: 2.2rem;
+ height: 2.2rem;
+ border-radius: 10px;
+ background: linear-gradient(145deg, rgba(122, 245, 196, 0.15), rgba(124, 142, 255, 0.15));
+ box-shadow: 0 10px 30px rgba(0, 0, 0, 0.25);
+}
+
+.brand-name {
+ font-size: 1.1rem;
+}
+
+.pill {
+ background: rgba(255, 255, 255, 0.06);
+ border: 1px solid var(--border);
+ padding: 0.6rem 1rem;
+ border-radius: 999px;
+ color: var(--muted);
+ font-size: 0.9rem;
+ box-shadow: 0 12px 30px rgba(0, 0, 0, 0.2);
+}
+
+.hero-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
+ gap: clamp(1.5rem, 2.5vw, 2.5rem);
+ max-width: 1200px;
+ margin: 0 auto;
+ position: relative;
+ z-index: 2;
+ align-items: center;
+}
+
+.hero-copy h1 {
+ font-size: clamp(2.6rem, 4vw, 3.6rem);
+ margin-bottom: 1rem;
+ line-height: 1.1;
+ letter-spacing: -0.5px;
}
-h1 {
- font-size: 16px;
- margin-top: 0;
+.eyebrow {
+ display: inline-flex;
+ align-items: center;
+ gap: 0.5rem;
+ text-transform: uppercase;
+ letter-spacing: 1px;
+ font-size: 0.8rem;
+ color: var(--muted);
+ margin-bottom: 0.75rem;
}
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
+.eyebrow::before {
+ content: "";
+ display: inline-block;
+ width: 24px;
+ height: 2px;
+ background: linear-gradient(90deg, var(--accent), var(--accent-2));
+ border-radius: 999px;
}
-.card {
+.lede {
+ font-size: 1.1rem;
+ color: var(--muted);
max-width: 620px;
+}
+
+.hero-actions {
+ display: flex;
+ gap: 1rem;
+ align-items: center;
+ margin: 1.6rem 0 1.2rem;
+ flex-wrap: wrap;
+}
+
+.btn {
+ display: inline-flex;
+ align-items: center;
+ justify-content: center;
+ gap: 0.6rem;
+ padding: 0.85rem 1.4rem;
+ border-radius: 12px;
+ font-weight: 700;
+ border: 1px solid transparent;
+ cursor: pointer;
+ transition: transform 0.2s ease, box-shadow 0.2s ease, background 0.2s ease, border-color 0.2s ease;
+}
+
+.btn.primary {
+ background: linear-gradient(135deg, #7af5c4, #7c8eff);
+ color: #0a0f1f;
+ box-shadow: 0 15px 30px rgba(122, 245, 196, 0.25);
+}
+
+.btn.primary:hover {
+ transform: translateY(-2px);
+ box-shadow: 0 25px 45px rgba(122, 245, 196, 0.35);
+}
+
+.btn.ghost {
+ background: rgba(255, 255, 255, 0.05);
+ border-color: var(--border);
+ color: var(--text);
+}
+
+.btn.ghost:hover {
+ border-color: rgba(255, 255, 255, 0.3);
+ transform: translateY(-2px);
+}
+
+.btn.wide {
+ width: 100%;
+ justify-content: center;
+}
+
+.hero-badges {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.6rem;
+ color: var(--muted);
+ font-size: 0.9rem;
+}
+
+.hero-badges span {
+ padding: 0.5rem 0.8rem;
+ border-radius: 10px;
+ border: 1px solid var(--border);
+ background: rgba(255, 255, 255, 0.04);
+}
+
+.hero-visual .glass-card {
+ background: rgba(255, 255, 255, 0.03);
+ border: 1px solid var(--border);
+ border-radius: 18px;
+ padding: 1.2rem;
+ box-shadow: var(--shadow);
+ backdrop-filter: blur(10px);
+}
+
+.hero-gif {
+ width: 100%;
+ display: block;
+ border-radius: 14px;
+ border: 1px solid var(--border);
+ box-shadow: 0 12px 35px rgba(0, 0, 0, 0.35);
+}
+
+.caption {
+ margin-top: 0.75rem;
+ color: var(--muted);
+ font-size: 0.95rem;
+}
+
+.section {
+ max-width: 1200px;
margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
+ padding: clamp(2rem, 4vw, 3.5rem) clamp(1.5rem, 3vw, 3rem);
+}
+
+.section-header {
+ text-align: center;
+ max-width: 780px;
+ margin: 0 auto 2rem;
+}
+
+.section-header h2 {
+ font-size: clamp(2rem, 3vw, 2.6rem);
+ margin-bottom: 0.5rem;
+}
+
+.intro {
+ color: var(--muted);
+ font-size: 1.05rem;
+}
+
+.feature-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+ gap: 1rem;
+}
+
+.feature-card {
+ background: rgba(255, 255, 255, 0.03);
+ border: 1px solid var(--border);
border-radius: 16px;
+ padding: 1.25rem;
+ box-shadow: 0 10px 30px rgba(0, 0, 0, 0.2);
+ transition: transform 0.2s ease, border-color 0.2s ease, box-shadow 0.2s ease;
+}
+
+.feature-card:hover {
+ transform: translateY(-4px);
+ border-color: rgba(122, 245, 196, 0.3);
+ box-shadow: 0 18px 40px rgba(0, 0, 0, 0.3);
+}
+
+.feature-card .icon {
+ width: 48px;
+ height: 48px;
+ border-radius: 12px;
+ display: grid;
+ place-items: center;
+ background: rgba(122, 245, 196, 0.14);
+ margin-bottom: 0.8rem;
+ font-size: 1.4rem;
+}
+
+.feature-card h3 {
+ margin-bottom: 0.35rem;
+}
+
+.feature-card p {
+ color: var(--muted);
+}
+
+.story {
+ padding-top: 1rem;
+}
+
+.story-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+ gap: 1rem;
+}
+
+.story-card {
+ background: rgba(255, 255, 255, 0.03);
+ border: 1px solid var(--border);
+ border-radius: 18px;
+ padding: 1.5rem;
+ box-shadow: var(--shadow);
}
-.card p:last-child {
- margin-bottom: 0;
+.story-card.secondary {
+ background: linear-gradient(145deg, rgba(124, 142, 255, 0.08), rgba(122, 245, 196, 0.06));
+}
+
+.story-card h3 {
+ margin-bottom: 0.8rem;
+}
+
+.story-list {
+ list-style: none;
+ display: grid;
+ gap: 0.7rem;
+ color: var(--muted);
+ font-size: 0.98rem;
+}
+
+.story-list li {
+ display: flex;
+ gap: 0.7rem;
+ align-items: flex-start;
+}
+
+.story-text {
+ color: var(--muted);
+ line-height: 1.7;
+ margin-bottom: 1rem;
+}
+
+.chips {
+ display: flex;
+ flex-wrap: wrap;
+ gap: 0.5rem;
+}
+
+.chip {
+ padding: 0.45rem 0.8rem;
+ border-radius: 12px;
+ background: rgba(0, 0, 0, 0.2);
+ border: 1px solid var(--border);
+ color: var(--text);
+ font-size: 0.9rem;
+}
+
+.footer {
+ text-align: center;
+ color: var(--muted);
+ padding: 2rem 1.5rem 0;
+}
+
+.footer a {
+ color: var(--text);
+ border-bottom: 1px solid transparent;
+}
+
+.footer a:hover {
+ border-color: rgba(255, 255, 255, 0.5);
+}
+
+@media (max-width: 768px) {
+ .hero {
+ padding-top: 2.5rem;
+ }
+
+ .topline {
+ flex-direction: column;
+ gap: 0.8rem;
+ align-items: flex-start;
+ }
+
+ .hero-actions {
+ width: 100%;
+ }
+
+ .btn {
+ width: 100%;
+ justify-content: center;
+ }
+
+ .hero-badges {
+ gap: 0.4rem;
+ }
}
diff --git a/tests/_package_build.py b/tests/_package_build.py
new file mode 100644
index 0000000000000000000000000000000000000000..3cc7f8f108e4b50b82074af0fb8b25f6d8ba881c
--- /dev/null
+++ b/tests/_package_build.py
@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+import tarfile
+from pathlib import Path
+
+
+def offline_env() -> dict[str, str]:
+ env = os.environ.copy()
+ env["PIP_NO_INDEX"] = "1"
+ env["UV_OFFLINE"] = "1"
+ env.pop("PYTHONPATH", None)
+ # The parent test interpreter's GStreamer .pth mutates this process variable.
+ # A nested venv must let its own GStreamer bundle derive a prefix-local value.
+ env.pop("GST_PYTHONPATH_1_0", None)
+ return env
+
+
+def build_wheel_from_sdist(workdir: Path, *, project_root: Path) -> Path:
+ """Build a fresh sdist, extract it, then build a wheel only from that copy."""
+ workdir.mkdir(parents=True, exist_ok=True)
+ sdist_dir = workdir / "sdist"
+ subprocess.run(
+ [
+ sys.executable,
+ "-m",
+ "build",
+ "--no-isolation",
+ "--sdist",
+ "--outdir",
+ str(sdist_dir),
+ str(project_root),
+ ],
+ check=True,
+ cwd=project_root,
+ env=offline_env(),
+ )
+ sdists = list(sdist_dir.glob("peachy-*.tar.gz"))
+ assert len(sdists) == 1
+
+ extracted_dir = workdir / "extracted"
+ extracted_dir.mkdir()
+ with tarfile.open(sdists[0], mode="r:gz") as archive:
+ archive.extractall(extracted_dir, filter="data")
+ extracted_projects = [path for path in extracted_dir.iterdir() if path.is_dir()]
+ assert len(extracted_projects) == 1
+
+ wheel_dir = workdir / "wheel"
+ extracted_project = extracted_projects[0]
+ subprocess.run(
+ [
+ sys.executable,
+ "-m",
+ "build",
+ "--no-isolation",
+ "--wheel",
+ "--outdir",
+ str(wheel_dir),
+ str(extracted_project),
+ ],
+ check=True,
+ cwd=extracted_project,
+ env=offline_env(),
+ )
+ wheels = list(wheel_dir.glob("peachy-*.whl"))
+ assert len(wheels) == 1
+ return wheels[0]
diff --git a/tests/audio/test_resampling.py b/tests/audio/test_resampling.py
new file mode 100644
index 0000000000000000000000000000000000000000..873eba3ebd017172b45b854e1fd86e5453471cc8
--- /dev/null
+++ b/tests/audio/test_resampling.py
@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import numpy as np
+import pytest
+
+from peachy.audio.resampling import audio_to_mono, pcm16_at_rate, resample_audio
+
+
+def test_resample_audio_uses_rounded_target_length() -> None:
+ source = np.linspace(-0.5, 0.5, 160, dtype=np.float32)
+ converted = resample_audio(source, 16_000, 24_000)
+ assert converted.dtype == np.float32
+ assert converted.flags.c_contiguous
+ assert converted.shape == (240,)
+
+
+def test_resample_audio_downsamples_48k_to_24k() -> None:
+ source = np.arange(480, dtype=np.int16)
+ assert resample_audio(source, 48_000, 24_000).shape == (240,)
+
+
+@pytest.mark.parametrize("shape", [(0, 2), (2, 0), (0, 0)])
+def test_audio_to_mono_normalizes_empty_two_dimensional_layouts(shape: tuple[int, int]) -> None:
+ converted = audio_to_mono(np.empty(shape, dtype=np.int16))
+ assert converted.dtype == np.int16
+ assert converted.flags.c_contiguous
+ assert converted.shape == (0,)
+
+
+@pytest.mark.parametrize("shape", [(0, 2), (2, 0), (0, 0)])
+def test_resample_audio_normalizes_empty_two_dimensional_layouts(shape: tuple[int, int]) -> None:
+ converted = resample_audio(np.empty(shape, dtype=np.int16), 24_000, 48_000)
+ assert converted.dtype == np.float32
+ assert converted.flags.c_contiguous
+ assert converted.shape == (0,)
+
+
+def test_resample_audio_skips_scipy_when_rounded_target_length_is_zero(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setattr(
+ "peachy.audio.resampling.resample",
+ lambda *_args: pytest.fail("SciPy must not resample a zero-length target"),
+ )
+
+ converted = resample_audio(np.array([1.0], dtype=np.float32), 48_000, 24_000)
+
+ assert converted.dtype == np.float32
+ assert converted.flags.c_contiguous
+ assert converted.shape == (0,)
+
+
+@pytest.mark.parametrize(
+ ("source", "expected"),
+ [
+ (np.array([[1, 2], [3, 4]], dtype=np.int16), np.array([1, 3], dtype=np.int16)),
+ (np.array([[1, 3, 5], [2, 4, 6]], dtype=np.int16), np.array([1, 3, 5], dtype=np.int16)),
+ ],
+)
+def test_audio_to_mono_accepts_channel_last_and_channel_first(
+ source: np.ndarray,
+ expected: np.ndarray,
+) -> None:
+ assert np.array_equal(audio_to_mono(source), expected)
+
+
+def test_pcm16_at_rate_clips_float_input_before_casting() -> None:
+ source = np.array([-2.0, -1.0, 0.0, 1.0, 2.0], dtype=np.float32)
+ converted = pcm16_at_rate(source, 24_000, 24_000)
+ assert converted.dtype == np.int16
+ assert converted.tolist() == [-32767, -32767, 0, 32767, 32767]
+ assert converted.flags.c_contiguous
+
+
+@pytest.mark.parametrize("source_rate,target_rate", [(0, 24_000), (16_000, 0), (-1, 24_000)])
+def test_resample_audio_rejects_nonpositive_rates(source_rate: int, target_rate: int) -> None:
+ with pytest.raises(ValueError, match="positive"):
+ resample_audio(np.ones(10, dtype=np.int16), source_rate, target_rate)
+
+
+def test_audio_to_mono_rejects_unsupported_dimensions() -> None:
+ with pytest.raises(ValueError, match="one- or two-dimensional"):
+ audio_to_mono(np.zeros((2, 2, 2), dtype=np.int16))
diff --git a/tests/audio/test_startup_config.py b/tests/audio/test_startup_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc7ed2bdd05eac5786bc47c6f759b54a5da75060
--- /dev/null
+++ b/tests/audio/test_startup_config.py
@@ -0,0 +1,95 @@
+"""Tests for Reachy Mini audio startup configuration."""
+
+from __future__ import annotations
+from types import SimpleNamespace
+
+from peachy.audio.startup_config import (
+ AUDIO_STARTUP_CONFIG,
+ WRITE_SETTLE_SECONDS,
+ apply_audio_startup_config,
+)
+
+
+class FakeAudio:
+ """Fake SDK audio wrapper."""
+
+ def __init__(self, *, result: bool = True, error: Exception | None = None) -> None:
+ """Initialize the fake audio wrapper."""
+ self.result = result
+ self.error = error
+ self.calls: list[tuple[object, bool, float]] = []
+
+ def apply_audio_config(
+ self,
+ config: object,
+ *,
+ verify: bool = True,
+ write_settle_seconds: float = WRITE_SETTLE_SECONDS,
+ ) -> bool:
+ """Record SDK audio config calls."""
+ if self.error is not None:
+ raise self.error
+ self.calls.append((config, verify, write_settle_seconds))
+ return self.result
+
+
+def test_apply_audio_startup_config_uses_sdk_audio_config_api() -> None:
+ """Startup config should delegate writes and verification to the SDK audio API."""
+ audio = FakeAudio()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+
+ applied = apply_audio_startup_config(robot)
+
+ assert applied is True
+ assert audio.calls == [(AUDIO_STARTUP_CONFIG, True, WRITE_SETTLE_SECONDS)]
+
+
+def test_apply_audio_startup_config_forwards_sdk_options() -> None:
+ """SDK verification options should stay configurable for tests and callers."""
+ audio = FakeAudio()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+
+ applied = apply_audio_startup_config(robot, verify=False, write_settle_seconds=0)
+
+ assert applied is True
+ assert audio.calls == [(AUDIO_STARTUP_CONFIG, False, 0)]
+
+
+def test_apply_audio_startup_config_returns_false_without_audio() -> None:
+ """Startup should continue when the SDK audio object is unavailable."""
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None))
+
+ applied = apply_audio_startup_config(robot)
+
+ assert applied is False
+
+
+def test_apply_audio_startup_config_returns_false_without_sdk_api() -> None:
+ """Startup should continue when the installed SDK does not expose audio config helpers."""
+ robot = SimpleNamespace(media=SimpleNamespace(audio=object()))
+
+ applied = apply_audio_startup_config(robot)
+
+ assert applied is False
+
+
+def test_apply_audio_startup_config_returns_false_when_sdk_returns_false() -> None:
+ """SDK application failures should be reported without raising."""
+ audio = FakeAudio(result=False)
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+
+ applied = apply_audio_startup_config(robot)
+
+ assert applied is False
+ assert audio.calls == [(AUDIO_STARTUP_CONFIG, True, WRITE_SETTLE_SECONDS)]
+
+
+def test_apply_audio_startup_config_returns_false_when_sdk_raises() -> None:
+ """Unexpected SDK audio config errors should not prevent app startup."""
+ audio = FakeAudio(error=RuntimeError("audio board unavailable"))
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+
+ applied = apply_audio_startup_config(robot)
+
+ assert applied is False
+ assert audio.calls == []
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..735d2cc2b7d01d792d2d6d1507ddccbd1437b344
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,20 @@
+"""Pytest configuration for path setup."""
+
+import os
+import sys
+from pathlib import Path
+
+
+PROJECT_ROOT = Path(__file__).parents[1].resolve()
+SRC_PATH = PROJECT_ROOT / "src"
+if str(SRC_PATH) not in sys.path:
+ sys.path.insert(0, str(SRC_PATH))
+
+
+# Make tests reproducible by ignoring machine-specific profile/tool env config.
+# Without this, importing config during test collection can pick up a developer's
+# local .env and fail before tests run.
+os.environ["REACHY_MINI_SKIP_DOTENV"] = "1"
+os.environ.pop("REACHY_MINI_CUSTOM_PROFILE", None)
+os.environ.pop("REACHY_MINI_EXTERNAL_PROFILES_DIRECTORY", None)
+os.environ.pop("REACHY_MINI_EXTERNAL_TOOLS_DIRECTORY", None)
diff --git a/tests/fixtures/what_time_is_it.wav b/tests/fixtures/what_time_is_it.wav
new file mode 100644
index 0000000000000000000000000000000000000000..2b9fee23a4618ad97b3bd62dd974e25fbf3410ab
Binary files /dev/null and b/tests/fixtures/what_time_is_it.wav differ
diff --git a/tests/manual/__init__.py b/tests/manual/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5652c32c70e4cec725a68d515ddcbc4c0a5a4e4a
--- /dev/null
+++ b/tests/manual/__init__.py
@@ -0,0 +1 @@
+# Modified by Peachy contributors in 2026 for the guarded OpenAI Realtime smoke.
diff --git a/tests/manual/test_openai_realtime_live.py b/tests/manual/test_openai_realtime_live.py
new file mode 100644
index 0000000000000000000000000000000000000000..98554662f4e7fc8e256e233a669430439d1b3223
--- /dev/null
+++ b/tests/manual/test_openai_realtime_live.py
@@ -0,0 +1,389 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import wave
+from pathlib import Path
+from types import MethodType, SimpleNamespace
+from typing import Any, Final, Sequence
+from unittest.mock import MagicMock
+
+import certifi
+import numpy as np
+import pytest
+
+import peachy.console as console_mod
+import peachy.openai_realtime as openai_mod
+from peachy.console import LocalStream
+from peachy.openai_realtime import OpenAIRealtimeHandler
+from peachy.providers import get_provider_definition
+from peachy.tools.core_tools import ToolDependencies
+
+
+FIXTURE = Path(__file__).parents[1] / "fixtures" / "what_time_is_it.wav"
+MAX_OUTPUT_TOKENS: Final[int] = 64
+MAX_RESPONSES: Final[int] = 2
+MAX_TOTAL_OUTPUT_TOKENS: Final[int] = 128
+
+
+def _configure_certifi_ca() -> Path:
+ ca_bundle = Path(certifi.where()).resolve(strict=True)
+ os.environ["SSL_CERT_FILE"] = str(ca_bundle)
+ return ca_bundle
+
+
+def _install_console_resample_spy(
+ monkeypatch: pytest.MonkeyPatch,
+) -> list[tuple[int, int, int, int]]:
+ original_resample = console_mod.resample_audio
+ calls: list[tuple[int, int, int, int]] = []
+
+ def resample_spy(audio: np.ndarray, source_rate: int, target_rate: int) -> np.ndarray:
+ converted = original_resample(audio, source_rate, target_rate)
+ calls.append((source_rate, target_rate, audio.size, converted.size))
+ return converted
+
+ monkeypatch.setattr(console_mod, "resample_audio", resample_spy)
+ return calls
+
+
+def _load_fixture() -> tuple[int, np.ndarray]:
+ with wave.open(str(FIXTURE), "rb") as source:
+ assert source.getsampwidth() == 2
+ rate = source.getframerate()
+ channels = source.getnchannels()
+ audio = np.frombuffer(source.readframes(source.getnframes()), dtype=" 1:
+ audio = audio.reshape(-1, channels)
+ return rate, audio
+
+
+async def _wait_for_activity_reason(
+ activity_queue: asyncio.Queue[str],
+ target: str,
+ *,
+ timeout: float,
+) -> list[str]:
+ reasons: list[str] = []
+ try:
+ async with asyncio.timeout(timeout):
+ while target not in reasons:
+ reasons.append(await activity_queue.get())
+ except TimeoutError as exc:
+ raise AssertionError(f"Timed out waiting for {target!r}; observed activity: {reasons!r}") from exc
+ return reasons
+
+
+async def _run_single_realtime_session(handler: Any) -> None:
+ try:
+ handler.client = await handler._build_realtime_client()
+ await handler._run_realtime_session()
+ finally:
+ handler.connection = None
+ handler._connected_event.clear()
+
+
+def _event_response_id(event: object) -> str | None:
+ response_id = getattr(event, "response_id", None)
+ if isinstance(response_id, str) and response_id:
+ return response_id
+ response_id = getattr(getattr(event, "response", None), "id", None)
+ return response_id if isinstance(response_id, str) and response_id else None
+
+
+class _ResponseBudgetGuard:
+ def __init__(self) -> None:
+ self.response_count = 0
+ self.response_counts_by_id: dict[str, int] = {}
+ self.current_audio_response_count: int | None = None
+ self.emitted_audio_response_count: int | None = None
+
+ def __call__(self) -> int:
+ return self.response_count
+
+
+class _TaggedAudioFrame(tuple):
+ def __new__(cls, item: tuple[int, np.ndarray], response_count: int) -> _TaggedAudioFrame:
+ tagged = super().__new__(cls, item)
+ tagged.response_count = response_count
+ return tagged
+
+
+def _install_response_budget_guard(handler: Any) -> _ResponseBudgetGuard:
+ """Count response-created events before the bounded observer can drop them."""
+ original_handle_event = handler._handle_event
+ original_queue_put = handler.output_queue.put
+ original_emit = handler.emit
+ guard = _ResponseBudgetGuard()
+
+ async def tagged_queue_put(item: Any) -> None:
+ if isinstance(item, tuple) and guard.current_audio_response_count is not None:
+ item = _TaggedAudioFrame(item, guard.current_audio_response_count)
+ await original_queue_put(item)
+
+ async def tagged_emit(self: Any) -> Any:
+ output = await original_emit()
+ if isinstance(output, tuple):
+ guard.emitted_audio_response_count = getattr(output, "response_count", None)
+ else:
+ guard.emitted_audio_response_count = None
+ return output
+
+ async def guarded_handle_event(self: Any, event: object) -> None:
+ event_type = getattr(event, "type", None)
+ response_id = _event_response_id(event)
+ is_response_created = event_type == "response.created"
+ if is_response_created:
+ guard.response_count += 1
+ if response_id is not None:
+ guard.response_counts_by_id[response_id] = guard.response_count
+ if event_type == "response.output_audio.delta":
+ guard.current_audio_response_count = guard.response_counts_by_id.get(response_id, guard.response_count)
+ if response_id is not None:
+ guard.response_counts_by_id.setdefault(response_id, guard.current_audio_response_count)
+ try:
+ await original_handle_event(event)
+ finally:
+ guard.current_audio_response_count = None
+ if is_response_created and guard.response_count > MAX_RESPONSES:
+ await self._cancel_active_response_for_barge_in()
+ raise AssertionError(
+ f"Received a third response.created event; maximum is {MAX_RESPONSES} capped responses"
+ )
+
+ handler.output_queue.put = tagged_queue_put
+ handler.emit = MethodType(tagged_emit, handler)
+ handler._handle_event = MethodType(guarded_handle_event, handler)
+ return guard
+
+
+async def _cancel_tasks_and_raise_unexpected(tasks: Sequence[asyncio.Task[Any]]) -> None:
+ """Cancel requested tasks, preserving intentional cancellation but surfacing failures."""
+ for task in tasks:
+ if not task.done():
+ task.cancel()
+ results = await asyncio.gather(*tasks, return_exceptions=True)
+ unexpected = [
+ result
+ for result in results
+ if isinstance(result, BaseException) and not isinstance(result, asyncio.CancelledError)
+ ]
+ if unexpected:
+ failure = unexpected[0]
+ raise AssertionError(f"Unexpected live-smoke task failure: {failure}") from failure
+
+
+def _install_emit_gate(
+ handler: Any,
+ first_audio: asyncio.Event,
+) -> tuple[asyncio.Event, asyncio.Event]:
+ original_emit = handler.emit
+ gate_blocked = asyncio.Event()
+ release_gate = asyncio.Event()
+
+ async def gated_emit(self: Any) -> Any:
+ if first_audio.is_set() and not release_gate.is_set():
+ gate_blocked.set()
+ await release_gate.wait()
+ return await original_emit()
+
+ handler.emit = MethodType(gated_emit, handler)
+ return gate_blocked, release_gate
+
+
+def _queued_audio_count(output_queue: asyncio.Queue[Any]) -> int:
+ queued_items = tuple(getattr(output_queue, "_queue", ()))
+ return sum(isinstance(item, tuple) for item in queued_items)
+
+
+async def _wait_for_queued_audio(output_queue: asyncio.Queue[Any], *, timeout: float) -> int:
+ try:
+ async with asyncio.timeout(timeout):
+ while not (count := _queued_audio_count(output_queue)):
+ await asyncio.sleep(0.01)
+ return count
+ except TimeoutError as exc:
+ raise AssertionError("Timed out waiting for pending provider audio") from exc
+
+
+async def _feed_realtime(handler: OpenAIRealtimeHandler, rate: int, audio: np.ndarray) -> None:
+ chunk_samples = max(1, rate // 50)
+ for start in range(0, audio.shape[0], chunk_samples):
+ await handler.receive((rate, audio[start : start + chunk_samples]))
+ await asyncio.sleep(chunk_samples / rate)
+ silence = np.zeros(chunk_samples, dtype=np.int16)
+ for _ in range(30):
+ await handler.receive((rate, silence))
+ await asyncio.sleep(chunk_samples / rate)
+
+
+def _install_output_token_limit(handler: Any) -> None:
+ original_session_config = handler._get_session_config
+
+ def limited_session_config(self: OpenAIRealtimeHandler, specs: list[object]) -> dict[str, object]:
+ session = dict(original_session_config(specs))
+ session["max_output_tokens"] = MAX_OUTPUT_TOKENS
+ return session
+
+ handler._get_session_config = MethodType(limited_session_config, handler)
+
+
+def _assert_response_budget(response_count: int) -> int:
+ assert 1 <= response_count <= MAX_RESPONSES, (
+ f"Expected 1-{MAX_RESPONSES} capped responses; observed {response_count} responses"
+ )
+ assert response_count * MAX_OUTPUT_TOKENS <= MAX_TOTAL_OUTPUT_TOKENS
+ return response_count
+
+
+def _assert_no_cancelled_audio_replay(
+ playback_response_counts: Sequence[int],
+ *,
+ pushed_before_interrupt: int,
+ response_count_at_interrupt: int,
+) -> None:
+ post_interrupt_counts = playback_response_counts[pushed_before_interrupt:]
+ assert all(count > response_count_at_interrupt for count in post_interrupt_counts), (
+ "Cancelled response audio reached the playback sink after the interruption"
+ )
+
+
+@pytest.mark.live_openai
+@pytest.mark.asyncio
+async def test_real_sample_round_trip_and_barge_in(monkeypatch: pytest.MonkeyPatch) -> None:
+ if os.getenv("RUN_OPENAI_REALTIME") != "1":
+ pytest.skip("Set RUN_OPENAI_REALTIME=1 for the paid live smoke")
+ if os.getenv("PEACHY_LIVE_SPEND_APPROVED") != "0.10":
+ pytest.skip("Set PEACHY_LIVE_SPEND_APPROVED=0.10 after reviewing current pricing")
+ assert (os.getenv("OPENAI_API_KEY") or "").strip(), "OPENAI_API_KEY is required"
+ _configure_certifi_ca()
+
+ movement = MagicMock()
+ movement.is_idle.return_value = True
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement)
+ handler = OpenAIRealtimeHandler(deps, instance_path=None, startup_voice="marin")
+ handler._startup_greeting_sent = True
+ monkeypatch.setattr(openai_mod, "get_tool_specs", lambda: [])
+ _install_output_token_limit(handler)
+ resample_calls = _install_console_resample_spy(monkeypatch)
+ assert handler._startup_greeting_sent is True
+ assert openai_mod.get_tool_specs() == []
+ assert handler._get_session_config([])["max_output_tokens"] == MAX_OUTPUT_TOKENS
+ first_audio = asyncio.Event()
+ player_cleared = asyncio.Event()
+ pushed: list[tuple[int, np.ndarray]] = []
+ reasons: list[str] = []
+ response_guard: _ResponseBudgetGuard | None = None
+
+ class _AudioPlayer:
+ def __init__(self) -> None:
+ self.clear_calls = 0
+ self.pending: list[np.ndarray] = []
+
+ def clear_player(self) -> None:
+ self.clear_calls += 1
+ self.pending.clear()
+ player_cleared.set()
+
+ def push_audio(frame: np.ndarray) -> None:
+ copied = np.asarray(frame).copy()
+ assert response_guard is not None
+ response_count = response_guard.emitted_audio_response_count
+ assert response_count is not None, "Provider audio reached the sink without event/queue provenance"
+ pushed.append((response_count, copied))
+ audio_player.pending.append(copied)
+ first_audio.set()
+
+ audio_player = _AudioPlayer()
+ media = SimpleNamespace(
+ audio=audio_player,
+ get_output_audio_samplerate=lambda: 48_000,
+ push_audio_sample=push_audio,
+ )
+ stream = LocalStream(
+ handler,
+ SimpleNamespace(media=media),
+ provider_resolver=get_provider_definition,
+ )
+ response_count = _install_response_budget_guard(handler)
+ gate_blocked, release_playback = _install_emit_gate(handler, first_audio)
+ activity_queue, unsubscribe = stream._event_bus.subscribe()
+ startup_task = asyncio.create_task(
+ _run_single_realtime_session(handler),
+ name="live-openai-single-session",
+ )
+ play_task = asyncio.create_task(stream.play_loop(), name="live-playback-sink")
+ second_feed_task: asyncio.Task[None] | None = None
+ try:
+ await asyncio.wait_for(handler._connected_event.wait(), timeout=15.0)
+ rate, audio = _load_fixture()
+ await _feed_realtime(handler, rate, audio)
+ await asyncio.wait_for(first_audio.wait(), timeout=20.0)
+ await asyncio.wait_for(gate_blocked.wait(), timeout=2.0)
+
+ reasons.extend(
+ await _wait_for_activity_reason(
+ activity_queue,
+ "user_transcription_completed",
+ timeout=10.0,
+ )
+ )
+ assert "user_transcription_completed" in reasons
+ assert pushed
+ assert resample_calls
+ assert all(
+ source_rate == 24_000
+ and target_rate == 48_000
+ and output_samples == input_samples * 2
+ for source_rate, target_rate, input_samples, output_samples in resample_calls
+ )
+ assert pushed[0][1].dtype == np.float32
+ assert pushed[0][1].size == resample_calls[0][3]
+ assert audio_player.pending
+ pending_player_samples = sum(frame.size for frame in audio_player.pending)
+ assert pending_player_samples > 0
+ pending_queue_audio = await _wait_for_queued_audio(handler.output_queue, timeout=5.0)
+ assert pending_queue_audio > 0
+
+ clears_before_barge_in = audio_player.clear_calls
+ pushes_before_barge_in = len(pushed)
+ response_count_at_interrupt = response_count()
+ player_cleared.clear()
+ second_feed_task = asyncio.create_task(
+ _feed_realtime(handler, rate, audio),
+ name="live-openai-second-feed",
+ )
+ await asyncio.wait_for(player_cleared.wait(), timeout=10.0)
+ assert not second_feed_task.done()
+ assert audio_player.clear_calls == clears_before_barge_in + 1
+ assert audio_player.pending == []
+ assert handler.output_queue.empty()
+ assert _queued_audio_count(handler.output_queue) == 0
+
+ release_playback.set()
+ await asyncio.sleep(0.1)
+ assert not second_feed_task.done()
+ assert len(pushed) == pushes_before_barge_in
+ assert audio_player.pending == []
+ await second_feed_task
+ assert audio_player.clear_calls == clears_before_barge_in + 1
+ _assert_no_cancelled_audio_replay(
+ [observed_response_count for observed_response_count, _ in pushed],
+ pushed_before_interrupt=pushes_before_barge_in,
+ response_count_at_interrupt=response_count_at_interrupt,
+ )
+ finally:
+ stream._stop_event.set()
+ release_playback.set()
+ await handler.shutdown()
+ tasks = tuple(task for task in (second_feed_task, play_task, startup_task) if task is not None)
+ for task in tasks:
+ task.cancel()
+ await _cancel_tasks_and_raise_unexpected(tasks)
+ await asyncio.sleep(0)
+ while not activity_queue.empty():
+ reasons.append(activity_queue.get_nowait())
+ unsubscribe()
+ _assert_response_budget(response_count())
+ assert handler.connection is None
+ assert all(task.done() for task in handler.tool_manager._lifecycle_tasks)
diff --git a/tests/test_app_contract.py b/tests/test_app_contract.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c3ec5d4056e002a6840fb61b14a43a19a985511
--- /dev/null
+++ b/tests/test_app_contract.py
@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+import runpy
+import sys
+from pathlib import Path
+
+import pytest
+from reachy_mini import ReachyMiniApp
+
+
+PROJECT_ROOT = Path(__file__).parents[1]
+SOURCE_ROOT = PROJECT_ROOT / "src" / "peachy"
+UPSTREAM_SHA = "40ea94e49213f77ae83d21a81c1766b2e4f25e49"
+HF_CARD_COLORS = {"red", "yellow", "green", "blue", "indigo", "purple", "pink", "gray"}
+
+
+def test_upstream_provenance_is_exact() -> None:
+ text = (PROJECT_ROOT / "UPSTREAM.md").read_text(encoding="utf-8")
+ assert "v0.10.0" in text
+ assert UPSTREAM_SHA in text
+ assert (PROJECT_ROOT / "LICENSE").is_file()
+
+
+def test_checker_contract_is_present_in_source() -> None:
+ main_text = (SOURCE_ROOT / "main.py").read_text(encoding="utf-8")
+ pyproject = (PROJECT_ROOT / "pyproject.toml").read_text(encoding="utf-8")
+ readme = (PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+ assert "class Peachy(ReachyMiniApp)" in main_text
+ assert 'peachy = "peachy.main:Peachy"' in pyproject
+ assert 'peachy = "peachy.main:main"' in pyproject
+ assert "reachy_mini" in readme
+ assert "reachy_mini_python_app" in readme
+ assert (PROJECT_ROOT / "index.html").is_file()
+ assert (PROJECT_ROOT / "style.css").is_file()
+
+
+def test_hugging_face_card_uses_supported_colors() -> None:
+ readme = (PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+ frontmatter = readme.split("---", 2)[1]
+ metadata = {
+ key.strip(): value.strip()
+ for line in frontmatter.splitlines()
+ if ":" in line
+ for key, value in [line.split(":", 1)]
+ }
+
+ assert metadata["colorFrom"] in HF_CARD_COLORS
+ assert metadata["colorTo"] in HF_CARD_COLORS
+
+
+def test_old_application_namespace_is_absent_from_runtime_and_tests() -> None:
+ old_namespace = "reachy_mini_" + "conversation_app"
+ offenders: list[Path] = []
+ for root in (SOURCE_ROOT, PROJECT_ROOT / "tests"):
+ for path in root.rglob("*.py"):
+ if old_namespace in path.read_text(encoding="utf-8"):
+ offenders.append(path.relative_to(PROJECT_ROOT))
+ assert offenders == []
+
+
+def test_fork_documentation_maps_inputs_and_uses_peachy_commands() -> None:
+ upstream = (PROJECT_ROOT / "UPSTREAM.md").read_text(encoding="utf-8")
+ readme = (PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+ old_namespace = "reachy_mini_" + "conversation_app"
+
+ expected_mappings = (
+ f"src/{old_namespace}/** -> onrobot/src/peachy/**",
+ "tests/** -> onrobot/tests/**",
+ "profiles/** -> onrobot/src/peachy/profiles/**",
+ ".env.example -> onrobot/.env.example",
+ ".env.example -> onrobot/src/peachy/.env.example",
+ "LICENSE -> onrobot/LICENSE",
+ "index.html -> onrobot/index.html",
+ "style.css -> onrobot/style.css",
+ "docs/assets/conversation_app_arch.svg -> onrobot/docs/assets/conversation_app_arch.svg",
+ "docs/assets/reachy_mini_dance.gif -> onrobot/docs/assets/reachy_mini_dance.gif",
+ )
+ assert all(mapping in upstream for mapping in expected_mappings)
+ assert "reachy-mini-conversation-app" not in readme
+ assert old_namespace not in readme
+ assert "pip install -e .[dev]" not in readme
+ assert "uv sync --group dev" in readme
+ assert "peachy tool-spaces" in readme
+
+
+def test_readme_describes_package_local_profile_storage() -> None:
+ readme = (PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+
+ required_phrases = (
+ "selects a named built-in package profile unless an external profiles directory is configured",
+ "Peachy's package-local default profile",
+ "package-local built-ins plus instance-directory user personalities",
+ "src/peachy/profiles/",
+ "installed built-ins are read-only package data",
+ "durable profiles through the UI or an external profiles directory",
+ "built-in package-local default tools",
+ "uv sync --group dev",
+ "pytest",
+ "ruff",
+ "mypy",
+ )
+ stale_phrases = (
+ "profiles//",
+ "profiles/default/",
+ "folders under `profiles/`",
+ "Core profiles are under `profiles/`",
+ "CONTRIBUTING.md",
+ "AGENTS.md",
+ )
+
+ assert all(phrase in readme for phrase in required_phrases)
+ assert all(phrase not in readme for phrase in stale_phrases)
+
+
+def test_readme_qualifies_hugging_face_connection_default() -> None:
+ readme = (PROJECT_ROOT / "README.md").read_text(encoding="utf-8")
+
+ assert "After selecting the Hugging Face provider" in readme
+ assert "This is the default Hugging Face connection mode" in readme
+ assert "This is the default for a new install" not in readme
+
+
+def test_python_module_mode_constructs_peachy_and_calls_wrapped_run(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ calls: list[str] = []
+ monkeypatch.setattr(
+ ReachyMiniApp,
+ "wrapped_run",
+ lambda self: calls.append(type(self).__name__),
+ )
+ monkeypatch.delitem(sys.modules, "peachy.main", raising=False)
+
+ runpy.run_module("peachy.main", run_name="__main__")
+
+ assert calls == ["Peachy"]
+
+
+def test_python_module_mode_stops_cleanly_on_keyboard_interrupt(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ stopped: list[str] = []
+
+ def interrupt(_self: ReachyMiniApp) -> None:
+ raise KeyboardInterrupt
+
+ monkeypatch.setattr(ReachyMiniApp, "wrapped_run", interrupt)
+ monkeypatch.setattr(ReachyMiniApp, "stop", lambda self: stopped.append(type(self).__name__))
+ monkeypatch.delitem(sys.modules, "peachy.main", raising=False)
+
+ runpy.run_module("peachy.main", run_name="__main__")
+
+ assert stopped == ["Peachy"]
diff --git a/tests/test_app_lifecycle.py b/tests/test_app_lifecycle.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c857d0b7c720bf6e7ca410923228cb8e898677a
--- /dev/null
+++ b/tests/test_app_lifecycle.py
@@ -0,0 +1,71 @@
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+
+from reachy_mini.reachy_mini import SLEEP_HEAD_POSE
+from peachy import app_lifecycle
+from peachy.tools.core_tools import ToolDependencies
+
+
+def test_request_stop_current_app_posts_to_daemon(monkeypatch) -> None:
+ """The app stop request should call the connected Reachy daemon endpoint."""
+
+ class FakeResponse:
+ def __enter__(self) -> "FakeResponse":
+ return self
+
+ def __exit__(self, *_args: object) -> None:
+ pass
+
+ def read(self) -> bytes:
+ return b"{}"
+
+ def fake_urlopen(request, timeout):
+ assert request.full_url == "http://192.168.1.42:8000/api/apps/stop-current-app"
+ assert request.get_method() == "POST"
+ assert timeout == 2.0
+ return FakeResponse()
+
+ monkeypatch.setattr(app_lifecycle.urllib.request, "urlopen", fake_urlopen)
+ robot = SimpleNamespace(client=SimpleNamespace(host="192.168.1.42", port=8000))
+
+ assert app_lifecycle.request_stop_current_app(robot, MagicMock())
+
+
+def test_wake_up_if_sleeping_runs_wake_up_from_sleep_head_pose() -> None:
+ """Startup should play the wake-up movement when the robot head is sleeping."""
+ robot = MagicMock()
+ robot.get_current_head_pose.return_value = SLEEP_HEAD_POSE.copy()
+
+ assert app_lifecycle.wake_up_if_sleeping(robot, MagicMock())
+
+ robot.get_current_joint_positions.assert_not_called()
+ robot.wake_up.assert_called_once_with()
+
+
+def test_wake_up_if_sleeping_skips_non_sleep_head_pose() -> None:
+ """Startup should leave an already-awake robot alone."""
+ robot = MagicMock()
+ robot.get_current_head_pose.return_value = np.eye(4)
+
+ assert not app_lifecycle.wake_up_if_sleeping(robot, MagicMock())
+
+ robot.get_current_joint_positions.assert_not_called()
+ robot.wake_up.assert_not_called()
+
+
+def test_run_go_to_sleep_tool_uses_runtime_callback() -> None:
+ """Synchronous lifecycle paths should enter through the go_to_sleep tool."""
+ expected = {"status": "sleeping"}
+ go_to_sleep = MagicMock(return_value=expected)
+ deps = ToolDependencies(
+ reachy_mini=MagicMock(),
+ movement_manager=MagicMock(),
+ go_to_sleep=go_to_sleep,
+ )
+
+ result = app_lifecycle.run_go_to_sleep_tool(deps, MagicMock())
+
+ assert result == expected
+ go_to_sleep.assert_called_once_with()
diff --git a/tests/test_config.py b/tests/test_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..adec0087e0e36c6aeeab817ae5713829d6e69f4d
--- /dev/null
+++ b/tests/test_config.py
@@ -0,0 +1,22 @@
+"""Tests for configuration helpers."""
+
+import pytest
+
+from peachy import config
+
+
+@pytest.mark.parametrize(
+ "raw_value, expected",
+ [
+ ("45", 45.0),
+ ("", config.DEFAULT_APP_TIMEOUT_MINUTES), # unset/blank falls back to the default
+ ("soon", config.DEFAULT_APP_TIMEOUT_MINUTES), # unparseable falls back to the default
+ ("0", None), # non-positive disables the watchdog
+ ("-1", None),
+ ],
+)
+def test_resolve_app_timeout_minutes(monkeypatch, raw_value, expected) -> None:
+ """The env timeout parses to minutes, falls back to the default, or disables on non-positive."""
+ monkeypatch.setenv(config.APP_TIMEOUT_MINUTES_ENV, raw_value)
+
+ assert config.resolve_app_timeout_minutes() == expected
diff --git a/tests/test_config_name_collisions.py b/tests/test_config_name_collisions.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2acf38300ac56b4194f64909744140213b94fbe
--- /dev/null
+++ b/tests/test_config_name_collisions.py
@@ -0,0 +1,133 @@
+from pathlib import Path
+
+import pytest
+
+import peachy.config as config_mod
+
+
+def test_config_raises_on_external_profile_name_collision(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Config should fail fast when external/built-in profile names collide."""
+ external_profiles = tmp_path / "external_profiles"
+ external_profiles.mkdir(parents=True)
+ (external_profiles / "default").mkdir()
+
+ monkeypatch.setattr(config_mod.Config, "PROFILES_DIRECTORY", external_profiles)
+ monkeypatch.setattr(config_mod.Config, "TOOLS_DIRECTORY", None)
+
+ with pytest.raises(RuntimeError, match="Ambiguous profile names"):
+ config_mod.Config()
+
+
+def test_config_raises_on_external_profile_name_collision_with_builtin_alias(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ """Config should treat compact built-in profile names as reserved."""
+ external_profiles = tmp_path / "external_profiles"
+ external_profiles.mkdir(parents=True)
+ (external_profiles / "mad_scientist_assistant").mkdir()
+
+ monkeypatch.setattr(config_mod.Config, "PROFILES_DIRECTORY", external_profiles)
+ monkeypatch.setattr(config_mod.Config, "TOOLS_DIRECTORY", None)
+
+ with pytest.raises(RuntimeError, match="Ambiguous profile names"):
+ config_mod.Config()
+
+
+def test_config_raises_on_external_tool_name_collision(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Config should fail fast when external/built-in tool names collide."""
+ external_tools = tmp_path / "external_tools"
+ external_tools.mkdir(parents=True)
+ (external_tools / "dance.py").write_text("# collision with built-in dance tool\n", encoding="utf-8")
+
+ monkeypatch.setattr(config_mod.Config, "PROFILES_DIRECTORY", config_mod.DEFAULT_PROFILES_DIRECTORY)
+ monkeypatch.setattr(config_mod.Config, "TOOLS_DIRECTORY", external_tools)
+
+ with pytest.raises(RuntimeError, match="Ambiguous tool names"):
+ config_mod.Config()
+
+
+def test_config_raises_when_selected_external_profile_is_missing(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ """Config should fail fast when selected profile is absent from external root."""
+ external_profiles = tmp_path / "external_profiles"
+ external_profiles.mkdir(parents=True)
+
+ monkeypatch.setattr(config_mod.Config, "REACHY_MINI_CUSTOM_PROFILE", "missing_profile")
+ monkeypatch.setattr(config_mod.Config, "PROFILES_DIRECTORY", external_profiles)
+ monkeypatch.setattr(config_mod.Config, "TOOLS_DIRECTORY", None)
+
+ with pytest.raises(RuntimeError, match="Selected profile 'missing_profile' was not found"):
+ config_mod.Config()
+
+
+def test_obsolete_backend_env_is_ignored_with_warning(
+ monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture
+) -> None:
+ """Stale multi-backend selectors should be ignored with a warning, not change behaviour."""
+ monkeypatch.setenv("BACKEND_PROVIDER", "openai")
+ monkeypatch.setenv("MODEL_NAME", "gpt-realtime-2")
+
+ with caplog.at_level("WARNING"):
+ config_mod.refresh_runtime_config_from_env()
+
+ assert "BACKEND_PROVIDER" in caplog.text
+ assert "MODEL_NAME" in caplog.text
+ assert "Hugging Face backend only" in caplog.text
+
+
+def test_hf_default_session_url_uses_stable_space_proxy() -> None:
+ """The app should not embed the raw, replaceable Inference Endpoint allocator URL."""
+ assert config_mod.HF_DEFAULTS.session_url == "https://pollen-robotics-reachy-mini-realtime-url.hf.space/session"
+ assert ".aws.endpoints.huggingface.cloud" not in config_mod.HF_DEFAULTS.session_url
+
+
+def test_refresh_runtime_config_reloads_hf_runtime_fields(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Instance-local .env reloads should update every env-backed Hugging Face runtime field."""
+ monkeypatch.setenv("HF_TOKEN", "hf-runtime-token")
+
+ monkeypatch.setattr(config_mod.config, "HF_TOKEN", None)
+
+ config_mod.refresh_runtime_config_from_env()
+
+ assert config_mod.config.HF_TOKEN == "hf-runtime-token"
+
+
+@pytest.mark.parametrize(
+ ("configured_mode", "session_url", "direct_ws_url", "expected_mode", "expected_has_target"),
+ [
+ ("local", "https://hf.example.test/session", None, "local", False),
+ ("deployed", "https://hf.example.test/session", "ws://127.0.0.1:8765/v1/realtime", "deployed", True),
+ ("local", None, "ws://127.0.0.1:8765/v1/realtime", "local", True),
+ ("deployed", None, "ws://127.0.0.1:8765/v1/realtime", "deployed", False),
+ ],
+)
+def test_hf_connection_selection_uses_explicit_mode_for_target(
+ monkeypatch: pytest.MonkeyPatch,
+ configured_mode: str | None,
+ session_url: str | None,
+ direct_ws_url: str | None,
+ expected_mode: str,
+ expected_has_target: bool,
+) -> None:
+ """Hugging Face selection should use the configured mode without inferring from URLs."""
+ monkeypatch.setattr(config_mod.config, "HF_REALTIME_CONNECTION_MODE", configured_mode)
+ monkeypatch.setattr(config_mod.config, "HF_REALTIME_SESSION_URL", session_url)
+ monkeypatch.setattr(config_mod.config, "HF_REALTIME_WS_URL", direct_ws_url)
+
+ selection = config_mod.get_hf_connection_selection()
+
+ assert selection.mode == expected_mode
+ assert selection.has_target is expected_has_target
+ assert selection.session_url == session_url
+ assert selection.direct_ws_url == direct_ws_url
+
+
+def test_hf_connection_selection_requires_mode(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Hugging Face selection should fail instead of inferring a missing mode."""
+ monkeypatch.setattr(config_mod.config, "HF_REALTIME_CONNECTION_MODE", None)
+ monkeypatch.setattr(config_mod.config, "HF_REALTIME_SESSION_URL", "https://hf.example.test/session")
+ monkeypatch.setattr(config_mod.config, "HF_REALTIME_WS_URL", "ws://127.0.0.1:8765/v1/realtime")
+
+ with pytest.raises(RuntimeError, match="HF_REALTIME_CONNECTION_MODE must be set"):
+ config_mod.get_hf_connection_selection()
diff --git a/tests/test_console.py b/tests/test_console.py
new file mode 100644
index 0000000000000000000000000000000000000000..8fffa80268d1d1d79a39d5f10b674b170810502c
--- /dev/null
+++ b/tests/test_console.py
@@ -0,0 +1,1389 @@
+"""Tests for the headless console stream."""
+
+import asyncio
+import logging
+import os
+import threading
+from types import SimpleNamespace
+from typing import Any
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock
+
+import numpy as np
+import pytest
+from fastapi import FastAPI, HTTPException
+from fastapi.testclient import TestClient
+
+from peachy.config import HF_AVAILABLE_VOICES, config
+from peachy.console import LocalStream
+from peachy.openai_realtime import OPENAI_VOICES, RetryExhaustedError
+from peachy.providers import (
+ ProviderDefinition,
+ ProviderReadiness,
+ get_provider_definition,
+)
+from peachy.startup_settings import (
+ StartupSettings,
+ load_startup_settings_into_runtime,
+)
+from peachy.personality_routes import mount_personality_routes
+
+
+async def _wait_until(predicate: Any, timeout: float = 1.0) -> None:
+ """Wait until a test predicate becomes true."""
+ deadline = asyncio.get_running_loop().time() + timeout
+ while asyncio.get_running_loop().time() < deadline:
+ if predicate():
+ return
+ await asyncio.sleep(0.01)
+ raise AssertionError("Timed out waiting for condition")
+
+
+def test_clear_audio_queue_prefers_clear_player() -> None:
+ """clear_player() is the canonical flush and is used whenever available."""
+ handler = MagicMock()
+ handler.output_queue = asyncio.Queue()
+ handler.output_queue.put_nowait((24000, np.zeros(4, dtype=np.int16)))
+ audio = SimpleNamespace(
+ clear_player=MagicMock(),
+ clear_output_buffer=MagicMock(),
+ )
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+ stream = LocalStream(handler, robot)
+
+ stream.clear_audio_queue()
+
+ audio.clear_player.assert_called_once()
+ audio.clear_output_buffer.assert_not_called()
+ assert handler.output_queue.empty()
+
+
+def test_clear_audio_queue_falls_back_to_output_buffer() -> None:
+ """Older SDKs without clear_player() still flush via clear_output_buffer()."""
+ handler = MagicMock()
+ handler.output_queue = asyncio.Queue()
+ audio = SimpleNamespace(clear_output_buffer=MagicMock()) # no clear_player
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+ stream = LocalStream(handler, robot)
+
+ stream.clear_audio_queue()
+
+ audio.clear_output_buffer.assert_called_once()
+ assert handler.output_queue.empty()
+
+
+def test_clear_audio_queue_drains_queue_in_place() -> None:
+ """The output queue is drained in place, not replaced with a new object."""
+ handler = MagicMock()
+ queue: asyncio.Queue[Any] = asyncio.Queue()
+ queue.put_nowait((24000, np.zeros(4, dtype=np.int16)))
+ queue.put_nowait((24000, np.zeros(4, dtype=np.int16)))
+ handler.output_queue = queue
+ audio = SimpleNamespace(clear_player=MagicMock())
+ robot = SimpleNamespace(media=SimpleNamespace(audio=audio))
+ stream = LocalStream(handler, robot)
+
+ stream.clear_audio_queue()
+
+ assert handler.output_queue is queue # same object, not replaced
+ assert queue.empty()
+
+
+def test_mic_endpoints_report_and_toggle_mute_state() -> None:
+ """The mic starts live; the settings API exposes and flips the pause state."""
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app)
+ stream._init_settings_ui_if_needed()
+ client = TestClient(app)
+
+ assert client.get("/api/v1/mic").json() == {"muted": False}
+
+ assert client.post("/api/v1/mic", json={"muted": True}).json() == {"muted": True}
+ assert stream._mic_muted is True
+
+ assert client.post("/api/v1/mic", json={"muted": False}).json() == {"muted": False}
+ assert stream._mic_muted is False
+
+ # headless streams keep the mic live
+ assert LocalStream(MagicMock(), robot)._mic_muted is False
+
+
+def test_settings_api_uses_versioned_routes_only() -> None:
+ """Settings clients should use the versioned API paths."""
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app)
+ stream._init_settings_ui_if_needed()
+ client = TestClient(app)
+
+ assert client.get("/api/v1/mic").json() == {"muted": False}
+
+ response = client.post("/api/v1/mic", json={"muted": True})
+
+ assert response.status_code == 200
+ assert response.json() == {"muted": True}
+ assert stream._mic_muted is True
+ assert client.get("/api/v1/status").json()["provider"]
+ assert client.get("/api/v1/ready").status_code == 404
+ assert client.get("/status").status_code == 404
+ assert client.get("/ready").status_code == 404
+ assert client.post("/backend_config", json={"backend": "openai"}).status_code == 404
+ assert client.get("/mic").status_code == 404
+ assert client.post("/mic", json={"muted": False}).status_code == 404
+ assert client.get("/conversation_events").status_code == 404
+
+
+def test_settings_ui_detaches_framework_catch_all_before_api_routes() -> None:
+ """Framework fallback routes should not shadow the settings API."""
+ app = FastAPI()
+
+ @app.get("/{path:path}")
+ def _framework_fallback(path: str) -> None:
+ raise HTTPException(status_code=404)
+
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app)
+ stream._init_settings_ui_if_needed()
+ client = TestClient(app)
+
+ assert client.get("/").status_code == 200
+ assert client.get("/static/js/api.js").status_code == 200
+ assert client.get("/api/v1/mic").status_code == 200
+ assert client.get("/api/v1/personalities").status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_conversation_events_survive_handler_rebuild() -> None:
+ """Activity from a rebuilt handler must reach subscribers of the original event bus."""
+
+ class FakeHandler:
+ def __init__(self) -> None:
+ self.observer = None
+
+ def set_activity_observer(self, observer: Any) -> None:
+ self.observer = observer
+
+ rebuilt = FakeHandler()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(FakeHandler(), robot, settings_app=FastAPI(), handler_factory=lambda voice: rebuilt)
+
+ queue, unsubscribe = stream._event_bus.subscribe()
+ stream._build_handler_for_current_backend()
+ rebuilt.observer("assistant_audio_delta")
+
+ assert await asyncio.wait_for(queue.get(), timeout=1.0) == "assistant_audio_delta"
+ unsubscribe()
+
+
+def test_backend_config_requests_in_process_restart_with_handler_factory(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A rebuild-capable LocalStream should reconnect in process after a connection change."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "deployed")
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", None)
+ monkeypatch.delenv("HF_REALTIME_CONNECTION_MODE", raising=False)
+ monkeypatch.delenv("HF_REALTIME_WS_URL", raising=False)
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.shutdown = AsyncMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(
+ handler,
+ robot,
+ settings_app=app,
+ instance_path=str(tmp_path),
+ handler_factory=lambda _voice: handler,
+ )
+ stream._init_settings_ui_if_needed()
+
+ response = TestClient(app).post(
+ "/api/v1/backend_config",
+ json={
+ "provider": "huggingface",
+ "hf_mode": "local",
+ "hf_host": "localhost",
+ "hf_port": 8765,
+ },
+ )
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["ok"] is True
+ assert data["message"] == "Connection saved. Reconnecting backend."
+ assert data["provider"] == "huggingface"
+ assert data["requires_restart"] is False
+ assert data["can_proceed"] is True
+ assert data["backend_connection_state"] == "connecting"
+ assert stream._restart_requested.is_set()
+
+
+def test_backend_config_persists_local_hf_selection_and_status(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Settings API should persist a direct Hugging Face websocket target."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "deployed")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", None)
+ monkeypatch.delenv("HF_REALTIME_CONNECTION_MODE", raising=False)
+ monkeypatch.delenv("HF_REALTIME_SESSION_URL", raising=False)
+ monkeypatch.delenv("HF_REALTIME_WS_URL", raising=False)
+
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app, instance_path=str(tmp_path))
+ stream._init_settings_ui_if_needed()
+
+ client = TestClient(app)
+ response = client.post(
+ "/api/v1/backend_config",
+ json={
+ "provider": "huggingface",
+ "hf_mode": "local",
+ "hf_host": "localhost",
+ "hf_port": 8765,
+ },
+ )
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["ok"] is True
+ assert data["provider"] == "huggingface"
+ assert data["has_hf_ws_url"] is True
+ assert data["has_hf_connection"] is True
+ assert data["hf_connection_mode"] == "local"
+ assert data["hf_direct_host"] == "localhost"
+ assert data["hf_direct_port"] == 8765
+
+ env_text = (tmp_path / ".env").read_text(encoding="utf-8")
+ assert "HF_REALTIME_CONNECTION_MODE=local" in env_text
+ assert "HF_REALTIME_WS_URL=ws://localhost:8765/v1/realtime" in env_text
+
+
+def test_backend_config_persists_deployed_mode_without_clearing_local_hf_ws_url(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Saving deployed mode should make env selection explicit and remove stale allocator URLs."""
+ env_path = tmp_path / ".env"
+ env_path.write_text(
+ "HF_REALTIME_SESSION_URL=https://lb.example.test/session\n"
+ "HF_REALTIME_WS_URL=ws://localhost:8765/v1/realtime\n",
+ encoding="utf-8",
+ )
+
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "deployed")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://localhost:8765/v1/realtime")
+ monkeypatch.delenv("HF_REALTIME_CONNECTION_MODE", raising=False)
+ monkeypatch.setenv("HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+ monkeypatch.setenv("HF_REALTIME_WS_URL", "ws://localhost:8765/v1/realtime")
+
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app, instance_path=str(tmp_path))
+ stream._init_settings_ui_if_needed()
+
+ client = TestClient(app)
+ response = client.post(
+ "/api/v1/backend_config",
+ json={
+ "provider": "huggingface",
+ "hf_mode": "deployed",
+ },
+ )
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["ok"] is True
+ assert data["has_hf_session_url"] is True
+ assert data["has_hf_ws_url"] is True
+ assert data["hf_connection_mode"] == "deployed"
+
+ env_text = env_path.read_text(encoding="utf-8")
+ assert "HF_REALTIME_CONNECTION_MODE=deployed" in env_text
+ assert "HF_REALTIME_SESSION_URL=" not in env_text
+ assert "HF_REALTIME_WS_URL=ws://localhost:8765/v1/realtime" in env_text
+
+
+def test_deployed_hf_cleanup_failure_is_transactional(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A failed stale-session cleanup must not commit any provider change."""
+ original_env_text = (
+ "PEACHY_REALTIME_PROVIDER=openai\n"
+ "HF_REALTIME_CONNECTION_MODE=local\n"
+ "HF_REALTIME_SESSION_URL=https://lb.example.test/session\n"
+ "HF_REALTIME_WS_URL=ws://localhost:8765/v1/realtime\n"
+ )
+ env_path = tmp_path / ".env"
+ env_path.write_text(original_env_text, encoding="utf-8")
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://localhost:8765/v1/realtime")
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "openai")
+ monkeypatch.setenv("HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setenv("HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+ monkeypatch.setenv("HF_REALTIME_WS_URL", "ws://localhost:8765/v1/realtime")
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.shutdown = AsyncMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(
+ handler,
+ robot,
+ settings_app=app,
+ instance_path=str(tmp_path),
+ handler_factory=lambda _voice: handler,
+ )
+ stream._init_settings_ui_if_needed()
+
+ real_write_text = Path.write_text
+
+ def fail_cleanup_write(path: Path, text: str, *args: Any, **kwargs: Any) -> int:
+ if "HF_REALTIME_SESSION_URL=" not in text:
+ raise OSError("simulated cleanup-only disk failure")
+ return real_write_text(path, text, *args, **kwargs)
+
+ monkeypatch.setattr(Path, "write_text", fail_cleanup_write)
+
+ response = TestClient(app).post(
+ "/api/v1/backend_config",
+ json={"provider": "huggingface", "hf_mode": "deployed"},
+ )
+
+ assert response.status_code == 500
+ assert response.json() == {"ok": False, "error": "persistence_failed"}
+ assert os.environ["PEACHY_REALTIME_PROVIDER"] == "openai"
+ assert os.environ["HF_REALTIME_CONNECTION_MODE"] == "local"
+ assert os.environ["HF_REALTIME_SESSION_URL"] == "https://lb.example.test/session"
+ assert os.environ["HF_REALTIME_WS_URL"] == "ws://localhost:8765/v1/realtime"
+ assert env_path.read_text(encoding="utf-8") == original_env_text
+ assert list(tmp_path.glob(".env.*.tmp")) == []
+ assert not stream._restart_requested.is_set()
+
+
+def test_backend_config_switches_to_saved_local_hf_connection_without_payload_target(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Switching back to a saved local Hugging Face backend should reuse the persisted target."""
+ env_path = tmp_path / ".env"
+ env_path.write_text(
+ "HF_REALTIME_CONNECTION_MODE=local\nHF_REALTIME_WS_URL=ws://192.168.1.42:8766/v1/realtime\n",
+ encoding="utf-8",
+ )
+
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://192.168.1.42:8766/v1/realtime")
+ monkeypatch.setenv("HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setenv("HF_REALTIME_WS_URL", "ws://192.168.1.42:8766/v1/realtime")
+
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app, instance_path=str(tmp_path))
+ stream._init_settings_ui_if_needed()
+
+ client = TestClient(app)
+ response = client.post(
+ "/api/v1/backend_config",
+ json={"provider": "huggingface"},
+ )
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["ok"] is True
+ assert data["provider"] == "huggingface"
+ assert data["hf_connection_mode"] == "local"
+ assert data["hf_direct_host"] == "192.168.1.42"
+ assert data["hf_direct_port"] == 8766
+
+ env_text = env_path.read_text(encoding="utf-8")
+ assert "HF_REALTIME_CONNECTION_MODE=local" in env_text
+ assert "HF_REALTIME_WS_URL=ws://192.168.1.42:8766/v1/realtime" in env_text
+
+
+def test_backend_config_rejects_invalid_hf_port_zero(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Settings API should reject invalid local Hugging Face ports from direct callers."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "deployed")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", None)
+
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app, instance_path=str(tmp_path))
+ stream._init_settings_ui_if_needed()
+
+ client = TestClient(app)
+ response = client.post(
+ "/api/v1/backend_config",
+ json={
+ "provider": "huggingface",
+ "hf_mode": "local",
+ "hf_host": "localhost",
+ "hf_port": 0,
+ },
+ )
+
+ assert response.status_code == 400
+ assert response.json()["error"] == "invalid_hf_port"
+
+
+def test_status_reports_direct_hf_ws_url_as_ready(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Settings API should treat a direct Hugging Face websocket as a valid configuration."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://127.0.0.1:8765/v1/realtime")
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(MagicMock(), robot, settings_app=app, instance_path=str(tmp_path))
+ stream._init_settings_ui_if_needed()
+
+ client = TestClient(app)
+ response = client.get("/api/v1/status")
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["provider"] == "huggingface"
+ assert data["has_hf_session_url"] is False
+ assert data["has_hf_ws_url"] is True
+ assert data["has_hf_connection"] is True
+ assert data["hf_connection_mode"] == "local"
+ assert data["provider_state"] == "ready"
+ assert data["can_proceed"] is True
+
+
+def test_status_reports_backend_connection_failure(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Settings API should expose backend connection failures without hiding controls."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://127.0.0.1:8765/v1/realtime")
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.connection = None
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, settings_app=app, instance_path=str(tmp_path))
+ stream._set_backend_connection_state("disconnected", RuntimeError("connect failed"))
+ stream._init_settings_ui_if_needed()
+
+ client = TestClient(app)
+ response = client.get("/api/v1/status")
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["provider"] == "huggingface"
+ assert data["backend_connected"] is False
+ assert data["backend_connection_state"] == "disconnected"
+ assert data["backend_error"] == "RuntimeError: connect failed"
+ assert data["can_proceed"] is True
+ assert data["provider_state"] == "ready"
+ assert data["can_proceed"] is True
+
+
+def test_status_redacts_configured_openai_key_from_backend_error(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-status-must-be-redacted"
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "openai")
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.connection = None
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, settings_app=app)
+ stream._set_backend_connection_state(
+ "disconnected",
+ RuntimeError(f"authentication failed for {secret}"),
+ )
+ stream._init_settings_ui_if_needed()
+
+ response = TestClient(app).get("/api/v1/status")
+
+ assert response.status_code == 200
+ assert secret not in response.text
+ assert response.json()["backend_error"] == "RuntimeError: authentication failed for [redacted]"
+
+
+@pytest.mark.asyncio
+async def test_startup_warning_redacts_configured_openai_key(
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "sk-test-log-must-be-redacted"
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "openai")
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+
+ handler = MagicMock()
+ handler.connection = None
+ handler.shutdown = AsyncMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot)
+ stream._backend_retry_delay = 0
+
+ async def fail_and_stop() -> None:
+ stream._stop_event.set()
+ raise RuntimeError(f"authentication failed for {secret}")
+
+ handler.start_up = AsyncMock(side_effect=fail_and_stop)
+ caplog.set_level(logging.WARNING, logger="peachy.console")
+
+ await stream._run_handler_startup_loop()
+
+ assert secret not in caplog.text
+ assert "authentication failed for [redacted]" in caplog.text
+ assert secret not in (stream._backend_error or "")
+
+
+def test_voice_apply_redacts_configured_openai_key_from_http_and_logs(
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "sk-test-voice-apply-must-be-redacted"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.change_voice = AsyncMock(side_effect=RuntimeError(f"voice update rejected for {secret}"))
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, settings_app=app)
+ stream._init_settings_ui_if_needed()
+
+ loop = asyncio.new_event_loop()
+ started = threading.Event()
+
+ def _run_loop() -> None:
+ asyncio.set_event_loop(loop)
+ started.set()
+ loop.run_forever()
+
+ thread = threading.Thread(target=_run_loop, daemon=True)
+ thread.start()
+ started.wait(timeout=1.0)
+ stream._asyncio_loop = loop
+ caplog.set_level(logging.ERROR, logger="peachy.console")
+
+ try:
+ response = TestClient(app).post("/api/v1/voices/apply?voice=marin")
+ finally:
+ loop.call_soon_threadsafe(loop.stop)
+ thread.join(timeout=1.0)
+ loop.close()
+
+ assert response.status_code == 200
+ assert response.json() == {
+ "ok": True,
+ "status": "Failed to change voice: voice update rejected for [redacted]",
+ }
+ assert secret not in response.text
+ assert secret not in caplog.text
+ assert "voice update rejected for [redacted]" in caplog.text
+
+
+def test_personality_validation_redacts_openai_key_from_http_and_logs(
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "sk-test-personality-validation-redaction"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ monkeypatch.setattr("peachy.config.set_custom_profile", lambda _profile: None)
+
+ def reject_instructions(*_args: Any, **_kwargs: Any) -> str:
+ raise RuntimeError("personality rejected " + secret)
+
+ monkeypatch.setattr("peachy.prompts.get_session_instructions", reject_instructions)
+ app = FastAPI()
+ handler = MagicMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, settings_app=app)
+ stream._init_settings_ui_if_needed()
+ loop = asyncio.new_event_loop()
+ started = threading.Event()
+
+ def _run_loop() -> None:
+ asyncio.set_event_loop(loop)
+ started.set()
+ loop.run_forever()
+
+ thread = threading.Thread(target=_run_loop, daemon=True)
+ thread.start()
+ started.wait(timeout=1.0)
+ stream._asyncio_loop = loop
+ caplog.set_level(logging.ERROR, logger="peachy.console")
+ try:
+ response = TestClient(app).post(
+ "/api/v1/personalities/apply",
+ json={"name": "sorry_bro"},
+ )
+ finally:
+ loop.call_soon_threadsafe(loop.stop)
+ thread.join(timeout=1.0)
+ loop.close()
+
+ assert response.status_code == 200
+ assert secret not in response.text
+ assert secret not in caplog.text
+ assert response.json()["status"] == "Failed to apply personality: personality rejected [redacted]"
+ assert "personality rejected [redacted]" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_handler_shutdown_log_redacts_configured_openai_key(
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "sk-test-shutdown-must-be-redacted"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+
+ handler = MagicMock()
+ handler.shutdown = AsyncMock(side_effect=RuntimeError(f"shutdown rejected for {secret}"))
+ stream = LocalStream(handler, MagicMock())
+ caplog.set_level(logging.DEBUG, logger="peachy.console")
+
+ await stream._shutdown_active_handler()
+
+ assert secret not in caplog.text
+ assert "shutdown rejected for [redacted]" in caplog.text
+
+
+def test_backend_startup_failure_is_recorded_without_raising(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Backend startup failures should become status state instead of killing LocalStream."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://127.0.0.1:8765/v1/realtime")
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.connection = None
+ handler.shutdown = AsyncMock()
+ media = SimpleNamespace(
+ audio=None,
+ backend=None,
+ start_recording=MagicMock(),
+ start_playing=MagicMock(),
+ )
+ robot = SimpleNamespace(media=media)
+ stream = LocalStream(handler, robot, settings_app=app, instance_path=str(tmp_path))
+ stream._backend_retry_delay = 0
+ stream.record_loop = AsyncMock(return_value=None) # type: ignore[method-assign]
+ stream.play_loop = AsyncMock(return_value=None) # type: ignore[method-assign]
+ monkeypatch.setattr("peachy.console.apply_audio_startup_config", MagicMock())
+
+ async def fail_and_stop() -> None:
+ stream._stop_event.set()
+ raise RuntimeError("local server unavailable")
+
+ handler.start_up = AsyncMock(side_effect=fail_and_stop)
+
+ try:
+ stream.launch()
+ finally:
+ asyncio.set_event_loop(asyncio.new_event_loop())
+
+ handler.start_up.assert_awaited_once()
+ client = TestClient(app)
+ response = client.get("/api/v1/status")
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["backend_connected"] is False
+ assert data["backend_connection_state"] == "disconnected"
+ assert data["backend_error"] == "RuntimeError: local server unavailable"
+
+
+@pytest.mark.asyncio
+async def test_startup_loop_rebuilds_handler_on_restart_request(monkeypatch: pytest.MonkeyPatch) -> None:
+ """LocalStream should shut down and rebuild the handler when a restart is requested."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://127.0.0.1:8765/v1/realtime")
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+
+ class FakeHandler:
+ def __init__(self) -> None:
+ self.connection = None
+ self.output_queue = asyncio.Queue()
+ self.started = asyncio.Event()
+ self.stopped = asyncio.Event()
+ self.shutdown_calls = 0
+
+ async def start_up(self) -> None:
+ self.connection = object()
+ self.started.set()
+ await self.stopped.wait()
+ self.connection = None
+
+ async def shutdown(self) -> None:
+ self.shutdown_calls += 1
+ self.stopped.set()
+
+ async def receive(self, _frame: Any) -> None:
+ return None
+
+ async def emit(self) -> None:
+ return None
+
+ handlers: list[FakeHandler] = []
+
+ def handler_factory(_voice: str | None) -> FakeHandler:
+ handler = FakeHandler()
+ handlers.append(handler)
+ return handler
+
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ initial_handler = handler_factory(None)
+ stream = LocalStream(initial_handler, robot, handler_factory=handler_factory)
+ stream._backend_retry_delay = 0.01
+
+ startup_task = asyncio.create_task(stream._run_handler_startup_loop())
+ try:
+ await _wait_until(lambda: initial_handler.started.is_set())
+
+ await stream.request_backend_restart("backend_config_changed")
+
+ await _wait_until(lambda: len(handlers) == 2 and handlers[1].started.is_set())
+
+ assert initial_handler.shutdown_calls >= 1
+ assert stream.handler is handlers[1]
+ assert stream._backend_connected() is True
+ finally:
+ stream._stop_event.set()
+ await stream._shutdown_active_handler()
+ startup_task.cancel()
+ try:
+ await startup_task
+ except asyncio.CancelledError:
+ pass
+
+
+def test_personality_routes_return_hf_voices() -> None:
+ """Headless personality UI should expose the Hugging Face voices."""
+ app = FastAPI()
+ handler = MagicMock()
+ mount_personality_routes(app, handler, lambda: None)
+
+ client = TestClient(app)
+ response = client.get("/voices")
+
+ assert response.status_code == 200
+ assert response.json() == HF_AVAILABLE_VOICES
+
+
+def test_personality_routes_mount_versioned_paths() -> None:
+ """Personality and voice endpoints should use the configured API prefix."""
+ app = FastAPI()
+ handler = MagicMock()
+
+ mount_personality_routes(
+ app,
+ handler,
+ lambda: None,
+ api_prefix="/api/v1",
+ )
+
+ client = TestClient(app)
+ response = client.get("/api/v1/voices")
+ delete_response = client.delete("/api/v1/personalities", params={"name": "mad_scientist_assistant"})
+
+ assert response.status_code == 200
+ assert delete_response.status_code == 404
+ assert delete_response.json()["error"] == "not_deletable"
+ assert client.get("/personalities").status_code == 404
+ assert client.get("/voices").status_code == 404
+ assert client.delete("/personalities", params={"name": "mad_scientist_assistant"}).status_code == 404
+ assert client.post("/voices/apply?voice=cedar").status_code == 404
+
+
+def test_personality_routes_load_builtin_default_tools() -> None:
+ """Headless personality UI should expose built-in default tools on initial load."""
+ app = FastAPI()
+ handler = MagicMock()
+ mount_personality_routes(app, handler, lambda: None)
+
+ client = TestClient(app)
+ response = client.get("/personalities/load", params={"name": "(built-in default)"})
+
+ assert response.status_code == 200
+ data = response.json()
+ assert data["tools_text"]
+ assert "dance" in data["enabled_tools"]
+ assert "camera" in data["enabled_tools"]
+
+
+def test_personality_routes_apply_voice_accepts_query_param() -> None:
+ """Headless personality UI should apply a voice change from a POST query param."""
+ app = FastAPI()
+ handler = MagicMock()
+ handler.change_voice = AsyncMock(return_value="Voice changed to cedar.")
+
+ loop = asyncio.new_event_loop()
+ started = threading.Event()
+
+ def _run_loop() -> None:
+ asyncio.set_event_loop(loop)
+ started.set()
+ loop.run_forever()
+
+ thread = threading.Thread(target=_run_loop, daemon=True)
+ thread.start()
+ started.wait(timeout=1.0)
+
+ try:
+ mount_personality_routes(app, handler, lambda: loop, api_prefix="/api/v1")
+
+ client = TestClient(app)
+ response = client.post("/api/v1/voices/apply?voice=cedar")
+
+ assert response.status_code == 200
+ assert response.json() == {"ok": True, "status": "Voice changed to cedar."}
+ handler.change_voice.assert_awaited_once_with("cedar")
+ finally:
+ loop.call_soon_threadsafe(loop.stop)
+ thread.join(timeout=1.0)
+ loop.close()
+
+
+def test_personality_routes_persist_startup_with_voice_override() -> None:
+ """Saving a startup personality should persist the active manual voice override."""
+ app = FastAPI()
+ handler = MagicMock()
+ handler.apply_personality = AsyncMock(return_value="Applied personality and restarted realtime session.")
+ handler.get_current_voice = MagicMock(return_value="shimmer")
+ persist_personality = MagicMock()
+
+ loop = asyncio.new_event_loop()
+ started = threading.Event()
+
+ def _run_loop() -> None:
+ asyncio.set_event_loop(loop)
+ started.set()
+ loop.run_forever()
+
+ thread = threading.Thread(target=_run_loop, daemon=True)
+ thread.start()
+ started.wait(timeout=1.0)
+
+ try:
+ mount_personality_routes(app, handler, lambda: loop, persist_personality=persist_personality)
+
+ client = TestClient(app)
+ response = client.post("/personalities/apply", json={"name": "sorry_bro", "persist": True})
+
+ assert response.status_code == 200
+ assert response.json()["ok"] is True
+ handler.apply_personality.assert_awaited_once_with("sorry_bro")
+ persist_personality.assert_called_once_with("sorry_bro", "shimmer")
+ finally:
+ loop.call_soon_threadsafe(loop.stop)
+ thread.join(timeout=1.0)
+ loop.close()
+
+
+def test_personality_routes_apply_same_profile_does_not_restart(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Re-applying the active personality should be a no-op for the realtime handler."""
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "sorry_bro")
+ app = FastAPI()
+ handler = MagicMock()
+ handler.apply_personality = AsyncMock(return_value="should not be called")
+ handler.get_current_voice = MagicMock(return_value="shimmer")
+ mount_personality_routes(app, handler, lambda: None)
+
+ response = TestClient(app).post("/personalities/apply", json={"name": "sorry_bro"})
+
+ assert response.status_code == 200
+ assert response.json()["status"] == "Personality unchanged."
+ handler.apply_personality.assert_not_awaited()
+ handler.get_current_voice.assert_not_called()
+
+
+def test_personality_routes_startup_choice_survives_runtime_profile_change(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Runtime profile switching should not redefine the saved startup personality."""
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "captain_circuit")
+ app = FastAPI()
+ handler = MagicMock()
+ mount_personality_routes(app, handler, lambda: None)
+ client = TestClient(app)
+
+ initial_response = client.get("/personalities")
+ assert initial_response.status_code == 200
+ assert initial_response.json()["current"] == "captain_circuit"
+ assert initial_response.json()["startup"] == "captain_circuit"
+
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "chess_coach")
+
+ switched_response = client.get("/personalities")
+ assert switched_response.status_code == 200
+ assert switched_response.json()["current"] == "chess_coach"
+ assert switched_response.json()["startup"] == "captain_circuit"
+
+
+def test_headless_personality_routes_can_use_stream_callbacks() -> None:
+ """Headless personality routes can delegate apply/restart ownership to LocalStream."""
+ app = FastAPI()
+ handler = MagicMock()
+ handler.apply_personality = AsyncMock(return_value="handler should not be called")
+ apply_personality = AsyncMock(return_value="Applied personality and restarting backend.")
+ get_current_voice = MagicMock(return_value="cedar")
+
+ loop = asyncio.new_event_loop()
+ started = threading.Event()
+
+ def _run_loop() -> None:
+ asyncio.set_event_loop(loop)
+ started.set()
+ loop.run_forever()
+
+ thread = threading.Thread(target=_run_loop, daemon=True)
+ thread.start()
+ started.wait(timeout=1.0)
+
+ try:
+ mount_personality_routes(
+ app,
+ handler,
+ lambda: loop,
+ apply_personality=apply_personality,
+ get_current_voice=get_current_voice,
+ )
+
+ response = TestClient(app).post("/personalities/apply", json={"name": "sorry_bro"})
+
+ assert response.status_code == 200
+ assert response.json()["status"] == "Applied personality and restarting backend."
+ apply_personality.assert_awaited_once_with("sorry_bro")
+ handler.apply_personality.assert_not_awaited()
+ finally:
+ loop.call_soon_threadsafe(loop.stop)
+ thread.join(timeout=1.0)
+ loop.close()
+
+
+@pytest.mark.asyncio
+async def test_apply_personality_propagates_restart_cancellation(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Cancellation during backend restart should not be converted into a status string."""
+ monkeypatch.setattr("peachy.config.set_custom_profile", lambda _profile: None)
+ monkeypatch.setattr(
+ "peachy.prompts.get_session_instructions", lambda _instance_path=None: "instructions"
+ )
+ monkeypatch.setattr("peachy.prompts.get_session_voice", lambda default: default)
+
+ stream = LocalStream(MagicMock(), MagicMock())
+
+ async def cancel_restart(_reason: str) -> None:
+ raise asyncio.CancelledError
+
+ monkeypatch.setattr(stream, "request_backend_restart", cancel_restart)
+
+ with pytest.raises(asyncio.CancelledError):
+ await stream.apply_personality("sorry_bro")
+
+
+@pytest.mark.asyncio
+async def test_local_stream_change_voice_delegates_without_backend_restart() -> None:
+ """LocalStream voice changes should update the active handler without rebuilding it."""
+ handler = MagicMock()
+ handler.change_voice = AsyncMock(return_value="Voice changed to Serena.")
+ handler.get_current_voice = MagicMock(return_value="Serena")
+ stream = LocalStream(handler, MagicMock())
+
+ status = await stream.change_voice("Serena")
+
+ assert status == "Voice changed to Serena."
+ handler.change_voice.assert_awaited_once_with("Serena")
+ assert stream._voice_override == "Serena"
+ assert not stream._restart_requested.is_set()
+
+
+@pytest.mark.asyncio
+async def test_post_change_voice_sync_log_redacts_configured_openai_key(
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "sk-test-voice-sync-must-be-redacted"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ handler = MagicMock()
+ handler.change_voice = AsyncMock(return_value="Voice changed to marin.")
+ handler.get_current_voice = MagicMock(
+ side_effect=RuntimeError(f"voice sync rejected for {secret}")
+ )
+ stream = LocalStream(handler, MagicMock())
+ caplog.set_level(logging.DEBUG, logger="peachy.console")
+
+ status = await stream.change_voice("marin")
+
+ assert status == "Voice changed to marin."
+ assert secret not in caplog.text
+ assert "voice sync rejected for [redacted]" in caplog.text
+
+
+@pytest.mark.parametrize(
+ ("voices", "current_voice"),
+ [
+ (list(OPENAI_VOICES), "marin"),
+ (HF_AVAILABLE_VOICES, "Aiden"),
+ ],
+ ids=("openai", "huggingface"),
+)
+@pytest.mark.asyncio
+async def test_local_stream_voice_reads_delegate_to_active_provider(
+ voices: list[str],
+ current_voice: str,
+) -> None:
+ handler = MagicMock()
+ handler.get_available_voices = AsyncMock(return_value=voices)
+ handler.get_current_voice = MagicMock(return_value=current_voice)
+ stream = LocalStream(handler, MagicMock(), startup_voice="stale-local-override")
+
+ assert await stream.get_available_voices() == voices
+ assert stream.get_current_voice() == current_voice
+ handler.get_available_voices.assert_awaited_once_with()
+ handler.get_current_voice.assert_called_once_with()
+
+
+def test_local_stream_persist_personality_stores_voice_override(tmp_path) -> None:
+ """Persisting startup settings should write both profile and voice override."""
+ stream = LocalStream(MagicMock(), MagicMock(), instance_path=str(tmp_path))
+
+ stream._persist_personality("sorry_bro", "shimmer")
+
+ settings_path = tmp_path / "startup_settings.json"
+ assert settings_path.exists()
+ assert settings_path.read_text(encoding="utf-8") == '{\n "profile": "sorry_bro",\n "voice": "shimmer"\n}\n'
+ assert stream._read_persisted_personality() == "sorry_bro"
+
+
+def test_local_stream_persist_personality_clears_legacy_startup_env_overrides(tmp_path, monkeypatch) -> None:
+ """Saving startup settings should remove legacy `.env` profile and voice overrides."""
+ env_path = tmp_path / ".env"
+ env_path.write_text(
+ "HF_TOKEN=test-token\n"
+ "REACHY_MINI_CUSTOM_PROFILE=mad_scientist_assistant\n"
+ "REACHY_MINI_VOICE_OVERRIDE=shimmer\n",
+ encoding="utf-8",
+ )
+ stream = LocalStream(MagicMock(), MagicMock(), instance_path=str(tmp_path))
+
+ stream._persist_personality(None, "Aiden")
+
+ env_text = env_path.read_text(encoding="utf-8")
+ assert "HF_TOKEN=test-token" in env_text
+ assert "REACHY_MINI_CUSTOM_PROFILE=" not in env_text
+ assert "REACHY_MINI_VOICE_OVERRIDE=" not in env_text
+
+ applied_profiles: list[str | None] = []
+ monkeypatch.delenv("REACHY_MINI_CUSTOM_PROFILE", raising=False)
+ monkeypatch.setattr(
+ "peachy.config.set_custom_profile",
+ lambda profile: applied_profiles.append(profile),
+ )
+
+ settings = load_startup_settings_into_runtime(tmp_path)
+
+ assert settings == StartupSettings(voice="Aiden")
+ assert applied_profiles == [None]
+
+
+def test_local_stream_launch_starts_media_while_provider_waits_for_config(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Startup should keep media and settings live while provider configuration is missing."""
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", None)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", None)
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+
+ media = SimpleNamespace(
+ start_recording=MagicMock(),
+ start_playing=MagicMock(),
+ )
+ robot = SimpleNamespace(media=media)
+ handler = MagicMock()
+ handler.shutdown = AsyncMock()
+ stream = LocalStream(handler, robot, settings_app=FastAPI(), instance_path=str(tmp_path))
+
+ init_settings_ui = MagicMock()
+ monkeypatch.setattr(stream, "_init_settings_ui_if_needed", init_settings_ui)
+ monkeypatch.setattr(stream, "_run_handler_startup_loop", AsyncMock(return_value=None))
+ monkeypatch.setattr(stream, "record_loop", AsyncMock(return_value=None))
+ monkeypatch.setattr(stream, "play_loop", AsyncMock(return_value=None))
+ monkeypatch.setattr("peachy.console.apply_audio_startup_config", MagicMock())
+
+ try:
+ stream.launch()
+ finally:
+ asyncio.set_event_loop(asyncio.new_event_loop())
+
+ init_settings_ui.assert_called_once()
+ media.start_recording.assert_called_once()
+ media.start_playing.assert_called_once()
+ handler.start_up.assert_not_called()
+
+
+def test_settings_status_and_save_select_openai_without_echoing_key(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-settings-secret"
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+ app = FastAPI()
+ handler = MagicMock()
+ handler.shutdown = AsyncMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(
+ handler,
+ robot,
+ settings_app=app,
+ instance_path=str(tmp_path),
+ handler_factory=lambda _voice: handler,
+ provider_resolver=get_provider_definition,
+ )
+ stream._init_settings_ui_if_needed()
+ client = TestClient(app)
+
+ response = client.post(
+ "/api/v1/backend_config",
+ json={
+ "provider": "openai",
+ "openai_api_key": secret,
+ "openai_model": "gpt-realtime",
+ },
+ )
+
+ assert response.status_code == 200
+ body = response.json()
+ assert body["provider"] == "openai"
+ assert body["provider_state"] == "ready"
+ assert body["has_openai_api_key"] is True
+ assert secret not in response.text
+ assert stream._restart_requested.is_set()
+ env_text = (tmp_path / ".env").read_text(encoding="utf-8")
+ assert "PEACHY_REALTIME_PROVIDER=openai" in env_text
+ assert "OPENAI_REALTIME_MODEL=gpt-realtime" in env_text
+ assert secret in env_text
+
+
+def test_backend_config_persistence_failure_is_transactional(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ original_env_text = (
+ "PEACHY_REALTIME_PROVIDER=huggingface\n"
+ "OPENAI_API_KEY=sk-test-original-key\n"
+ "OPENAI_REALTIME_MODEL=gpt-realtime-original\n"
+ )
+ env_path = tmp_path / ".env"
+ env_path.write_text(original_env_text, encoding="utf-8")
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-original-key")
+ monkeypatch.setenv("OPENAI_REALTIME_MODEL", "gpt-realtime-original")
+
+ app = FastAPI()
+ handler = MagicMock()
+ handler.shutdown = AsyncMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(
+ handler,
+ robot,
+ settings_app=app,
+ instance_path=str(tmp_path),
+ handler_factory=lambda _voice: handler,
+ provider_resolver=get_provider_definition,
+ )
+ stream._init_settings_ui_if_needed()
+
+ def fail_write_text(*_args: Any, **_kwargs: Any) -> int:
+ raise OSError("simulated full disk")
+
+ monkeypatch.setattr(Path, "write_text", fail_write_text)
+
+ response = TestClient(app).post(
+ "/api/v1/backend_config",
+ json={
+ "provider": "openai",
+ "openai_api_key": "sk-test-rejected-key",
+ "openai_model": "gpt-realtime-rejected",
+ },
+ )
+
+ assert response.status_code == 500
+ assert response.json() == {"ok": False, "error": "persistence_failed"}
+ assert os.environ["PEACHY_REALTIME_PROVIDER"] == "huggingface"
+ assert os.environ["OPENAI_API_KEY"] == "sk-test-original-key"
+ assert os.environ["OPENAI_REALTIME_MODEL"] == "gpt-realtime-original"
+ assert env_path.read_text(encoding="utf-8") == original_env_text
+ assert list(tmp_path.glob(".env.*.tmp")) == []
+ assert not stream._restart_requested.is_set()
+
+
+def test_settings_reject_unknown_provider_without_mutating_selection(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "openai")
+ app = FastAPI()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(
+ MagicMock(),
+ robot,
+ settings_app=app,
+ instance_path=str(tmp_path),
+ provider_resolver=get_provider_definition,
+ )
+ stream._init_settings_ui_if_needed()
+
+ response = TestClient(app).post("/api/v1/backend_config", json={"provider": "mystery"})
+
+ assert response.status_code == 400
+ assert response.json()["error"] == "invalid_provider"
+ assert os.environ["PEACHY_REALTIME_PROVIDER"] == "openai"
+
+
+def test_packaged_settings_assets_have_provider_specific_controls() -> None:
+ static_root = Path(__file__).parents[1] / "src" / "peachy" / "static" / "js"
+ settings_js = (static_root / "views" / "settings.js").read_text(encoding="utf-8")
+ api_js = (static_root / "api.js").read_text(encoding="utf-8")
+ assert 'name: "provider"' in settings_js
+ assert 'name: "openai_api_key"' in settings_js
+ assert 'name: "openai_model"' in settings_js
+ assert "huggingface" in settings_js
+ assert "backend_config" in api_js
+ assert "persistence_failed" in api_js
+ assert "reconnectBackend" in api_js
+ assert 'role: "status"' in settings_js
+ assert '"Reconnect"' in settings_js
+
+
+@pytest.mark.asyncio
+async def test_openai_exhaustion_waits_for_explicit_restart(monkeypatch: pytest.MonkeyPatch) -> None:
+ secret = "sk-test-do-not-log"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ handler = MagicMock()
+ handler.start_up = AsyncMock(side_effect=RetryExhaustedError("failed 3 attempts " + secret))
+ handler.shutdown = AsyncMock()
+ handler.output_queue = asyncio.Queue()
+ handler.last_activity_time = 0.0
+ definition = ProviderDefinition(
+ name="openai",
+ readiness=lambda: ProviderReadiness("ready"),
+ redacted_status=lambda: {"has_openai_api_key": True},
+ build_handler=lambda _deps, _path, _voice: handler,
+ auto_reconnect=False,
+ )
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, provider_resolver=lambda: definition)
+
+ task = asyncio.create_task(stream._run_handler_startup_loop())
+ await _wait_until(lambda: stream._backend_connection_state == "disconnected")
+ await asyncio.sleep(0.05)
+ assert handler.start_up.await_count == 1
+ assert secret not in (stream._backend_error or "")
+ stream._stop_event.set()
+ stream._restart_requested.set()
+ await asyncio.wait_for(task, timeout=1.0)
+
+
+def test_manual_reconnect_endpoint_requests_restart() -> None:
+ app = FastAPI()
+ handler = MagicMock()
+ handler.shutdown = AsyncMock()
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, settings_app=app, provider_resolver=get_provider_definition)
+ stream._init_settings_ui_if_needed()
+
+ response = TestClient(app).post("/api/v1/reconnect")
+
+ assert response.status_code == 200
+ assert response.json()["ok"] is True
+ assert stream._restart_requested.is_set()
+
+
+@pytest.mark.asyncio
+async def test_status_and_logs_never_contain_openai_key(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-redaction-canary"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ handler = MagicMock()
+ handler.start_up = AsyncMock(side_effect=RetryExhaustedError("rejected " + secret))
+ handler.shutdown = AsyncMock()
+ handler.output_queue = asyncio.Queue()
+ handler.last_activity_time = 0.0
+ definition = ProviderDefinition(
+ name="openai",
+ readiness=lambda: ProviderReadiness("ready"),
+ redacted_status=lambda: {"has_openai_api_key": True},
+ build_handler=lambda _deps, _path, _voice: handler,
+ auto_reconnect=False,
+ )
+ stream = LocalStream(
+ handler,
+ SimpleNamespace(media=SimpleNamespace(audio=None, backend=None)),
+ settings_app=FastAPI(),
+ provider_resolver=lambda: definition,
+ )
+ stream._init_settings_ui_if_needed()
+ task = asyncio.create_task(stream._run_handler_startup_loop())
+ await _wait_until(lambda: stream._backend_connection_state == "disconnected")
+ response = TestClient(stream._settings_app).get("/api/v1/status")
+ stream._stop_event.set()
+ stream._restart_requested.set()
+ await asyncio.wait_for(task, timeout=1.0)
+
+ assert secret not in response.text
+ assert secret not in caplog.text
+ assert secret not in (stream._backend_error or "")
+
+
+def test_provider_status_redacts_string_values_before_http_response(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-provider-status-boundary"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ definition = ProviderDefinition(
+ name="openai",
+ readiness=lambda: ProviderReadiness("ready"),
+ redacted_status=lambda: {"openai_model": "model-" + secret},
+ build_handler=MagicMock(),
+ auto_reconnect=False,
+ )
+ stream = LocalStream(
+ MagicMock(),
+ SimpleNamespace(media=SimpleNamespace(audio=None, backend=None)),
+ settings_app=FastAPI(),
+ provider_resolver=lambda: definition,
+ )
+ stream._init_settings_ui_if_needed()
+
+ response = TestClient(stream._settings_app).get("/api/v1/status")
+
+ assert response.status_code == 200
+ assert secret not in response.text
+ assert response.json()["openai_model"] == "model-[redacted]"
diff --git a/tests/test_console_audio.py b/tests/test_console_audio.py
new file mode 100644
index 0000000000000000000000000000000000000000..097806d3393c8729a9adf3e23a79499349bf09c6
--- /dev/null
+++ b/tests/test_console_audio.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import asyncio
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import numpy as np
+import pytest
+
+from peachy.console import LocalStream
+
+
+class _Handler:
+ def __init__(self, output: tuple[int, np.ndarray]) -> None:
+ self.output = output
+ self.output_queue: asyncio.Queue[object] = asyncio.Queue()
+ self.last_activity_time = 0.0
+
+ def set_activity_observer(self, _observer: object) -> None:
+ pass
+
+ async def emit(self) -> tuple[int, np.ndarray]:
+ return self.output
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("provider_rate", "source_samples"), [(16_000, 160), (24_000, 240)])
+async def test_play_loop_resamples_provider_audio_to_robot_rate(
+ provider_rate: int,
+ source_samples: int,
+) -> None:
+ pushed: list[np.ndarray] = []
+ media = SimpleNamespace(
+ audio=None,
+ get_output_audio_samplerate=lambda: 48_000,
+ push_audio_sample=lambda frame: pushed.append(np.asarray(frame)),
+ )
+ stream = LocalStream(
+ _Handler((provider_rate, np.ones((1, source_samples), dtype=np.int16))),
+ SimpleNamespace(media=media),
+ )
+
+ media.push_audio_sample = lambda frame: (
+ pushed.append(np.asarray(frame)),
+ stream._stop_event.set(),
+ )
+ await stream.play_loop()
+
+ assert len(pushed) == 1
+ assert pushed[0].dtype == np.float32
+ assert pushed[0].shape == (480,)
+
+
+@pytest.mark.asyncio
+async def test_play_loop_uses_the_rate_from_each_tuple() -> None:
+ media = SimpleNamespace(
+ audio=None,
+ get_output_audio_samplerate=MagicMock(return_value=24_000),
+ push_audio_sample=MagicMock(),
+ )
+ stream = LocalStream(
+ _Handler((48_000, np.ones(480, dtype=np.int16))),
+ SimpleNamespace(media=media),
+ )
+ media.push_audio_sample.side_effect = lambda _frame: stream._stop_event.set()
+
+ await stream.play_loop()
+
+ pushed = media.push_audio_sample.call_args.args[0]
+ assert pushed.shape == (240,)
+ media.get_output_audio_samplerate.assert_called_once_with()
diff --git a/tests/test_external_loading.py b/tests/test_external_loading.py
new file mode 100644
index 0000000000000000000000000000000000000000..78ace59abfd9b5b008ac4d629815a0efbb1ac7fb
--- /dev/null
+++ b/tests/test_external_loading.py
@@ -0,0 +1,165 @@
+import sys
+import importlib
+from types import ModuleType
+from pathlib import Path
+
+import pytest
+
+import peachy.config as config_mod
+
+
+def _reload_core_tools() -> ModuleType:
+ """Reload core_tools after config object has been patched."""
+ for module_name in list(sys.modules):
+ if module_name.startswith("peachy.tools."):
+ sys.modules.pop(module_name, None)
+ # External file-loaded modules are registered by bare tool name.
+ sys.modules.pop("ext_ping", None)
+ sys.modules.pop("sweep_look", None)
+ sys.modules.pop("ext_dup_a", None)
+ sys.modules.pop("ext_dup_b", None)
+
+ sys.modules.pop("peachy.tools.core_tools", None)
+ core_tools_mod = importlib.import_module("peachy.tools.core_tools")
+ core_tools_mod.initialize_tools()
+ return core_tools_mod
+
+
+def test_external_profile_can_use_builtin_tools(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """External profile tools.txt can reference built-in src tools."""
+ profile_name = "ext_profile_test"
+ external_profiles_root = tmp_path / "external_profiles"
+ profile_dir = external_profiles_root / profile_name
+ profile_dir.mkdir(parents=True)
+ (profile_dir / "instructions.txt").write_text("hello\n", encoding="utf-8")
+ (profile_dir / "tools.txt").write_text("dance\n", encoding="utf-8")
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", profile_name)
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles_root)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ core_tools_mod = _reload_core_tools()
+
+ assert "dance" in core_tools_mod.ALL_TOOLS
+ assert "dance" not in sys.modules
+
+
+def test_external_tools_can_be_loaded_without_external_profile(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ """External tools can be loaded with built-in profile via autoload mode."""
+ external_tools_root = tmp_path / "external_tools"
+ external_tools_root.mkdir(parents=True)
+
+ (external_tools_root / "ext_ping.py").write_text(
+ "\n".join(
+ [
+ "from typing import Any, Dict",
+ "from peachy.tools.core_tools import Tool, ToolDependencies",
+ "",
+ "class ExtPingTool(Tool):",
+ ' name = "ext_ping"',
+ ' description = "External ping tool"',
+ ' parameters_schema = {"type": "object", "properties": {}, "required": []}',
+ "",
+ " async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:",
+ ' return {"status": "ok"}',
+ "",
+ ]
+ ),
+ encoding="utf-8",
+ )
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", config_mod.DEFAULT_PROFILES_DIRECTORY)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", external_tools_root)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", True)
+
+ core_tools_mod = _reload_core_tools()
+
+ assert "ext_ping" in core_tools_mod.ALL_TOOLS
+
+
+def test_external_tools_fail_on_duplicate_tool_names(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Loading must fail if multiple tools declare the same Tool.name."""
+ external_tools_root = tmp_path / "external_tools"
+ external_tools_root.mkdir(parents=True)
+
+ duplicate_tool_source = "\n".join(
+ [
+ "from typing import Any, Dict",
+ "from peachy.tools.core_tools import Tool, ToolDependencies",
+ "",
+ "class DupTool(Tool):",
+ ' name = "dup_tool"',
+ ' description = "Duplicate tool name"',
+ ' parameters_schema = {"type": "object", "properties": {}, "required": []}',
+ "",
+ " async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> Dict[str, Any]:",
+ ' return {"status": "ok"}',
+ "",
+ ]
+ )
+ (external_tools_root / "ext_dup_a.py").write_text(duplicate_tool_source, encoding="utf-8")
+ (external_tools_root / "ext_dup_b.py").write_text(duplicate_tool_source, encoding="utf-8")
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", config_mod.DEFAULT_PROFILES_DIRECTORY)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", external_tools_root)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", True)
+
+ with pytest.raises(RuntimeError, match="Duplicate Tool.name values detected"):
+ _reload_core_tools()
+
+
+def test_builtin_profile_can_load_profile_local_tools(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Built-in profile-local tools should load from the packaged profiles root."""
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", config_mod.DEFAULT_PROFILES_DIRECTORY)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ core_tools_mod = _reload_core_tools()
+
+ assert "sweep_look" in core_tools_mod.ALL_TOOLS
+
+
+def test_tool_registry_reloads_when_profile_changes(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Runtime profile changes should refresh enabled tools without restarting Python."""
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", config_mod.DEFAULT_PROFILES_DIRECTORY)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ core_tools_mod = _reload_core_tools()
+
+ initial_tool_names = {spec["name"] for spec in core_tools_mod.get_tool_specs()}
+ assert "sweep_look" in initial_tool_names
+ assert "camera" in initial_tool_names
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "mars_rover")
+
+ reloaded_tool_names = {spec["name"] for spec in core_tools_mod.get_tool_specs()}
+ assert "camera" in reloaded_tool_names
+ assert "move_head" in reloaded_tool_names
+ assert "sweep_look" not in reloaded_tool_names
+ assert "camera" in core_tools_mod.ALL_TOOLS
+ assert "sweep_look" not in core_tools_mod.ALL_TOOLS
+
+
+def test_forced_tool_registry_reload_does_not_duplicate_profile_local_tool(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Reloading a profile-local tool should ignore stale class objects from the previous load."""
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", config_mod.DEFAULT_PROFILES_DIRECTORY)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ core_tools_mod = _reload_core_tools()
+ core_tools_mod.initialize_tools(force=True)
+
+ assert "sweep_look" in core_tools_mod.ALL_TOOLS
diff --git a/tests/test_huggingface_realtime.py b/tests/test_huggingface_realtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc06abef5c3f55b64a12d262919a0da2ca1ccd3a
--- /dev/null
+++ b/tests/test_huggingface_realtime.py
@@ -0,0 +1,581 @@
+import time
+import asyncio
+import gc
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+import peachy.conversation_handler as conv_mod
+import peachy.huggingface_realtime as hf_mod
+from peachy.config import config, get_default_voice
+from peachy.tools.core_tools import ToolDependencies
+from peachy.huggingface_realtime import HuggingFaceRealtimeHandler
+from peachy.tools.background_tool_manager import ToolState, ToolNotification
+
+
+HF_DEFAULT_VOICE = get_default_voice()
+
+
+class _FakeEvent:
+ """A minimal realtime event: a `type` plus arbitrary attributes."""
+
+ def __init__(self, event_type: str, **fields: Any) -> None:
+ """Store the event type and any extra attributes."""
+ self.type = event_type
+ self.__dict__.update(fields)
+
+
+def _make_fake_realtime_client(
+ *,
+ events: tuple[_FakeEvent, ...] = (),
+ captured_update: dict[str, Any] | None = None,
+ captured_connect: dict[str, Any] | None = None,
+) -> Any:
+ """Build a fake AsyncOpenAI-shaped client whose realtime session yields `events`.
+
+ When given, `captured_update`/`captured_connect` record the kwargs passed to
+ `session.update(...)` / `realtime.connect(...)`.
+ """
+
+ class FakeSession:
+ async def update(self, **kwargs: Any) -> None:
+ if captured_update is not None:
+ captured_update.update(kwargs)
+
+ class FakeNoop:
+ async def append(self, **_kw: Any) -> None:
+ pass
+
+ async def create(self, **_kw: Any) -> None:
+ pass
+
+ async def cancel(self, **_kw: Any) -> None:
+ pass
+
+ class FakeConversation:
+ item = FakeNoop()
+
+ class FakeConn:
+ session = FakeSession()
+ input_audio_buffer = FakeNoop()
+ conversation = FakeConversation()
+ response = FakeNoop()
+
+ def __init__(self) -> None:
+ self._events = iter(events)
+
+ async def __aenter__(self) -> "FakeConn":
+ return self
+
+ async def __aexit__(self, *_args: Any) -> bool:
+ return False
+
+ async def close(self) -> None:
+ pass
+
+ def __aiter__(self) -> "FakeConn":
+ return self
+
+ async def __anext__(self) -> _FakeEvent:
+ try:
+ return next(self._events)
+ except StopIteration:
+ raise StopAsyncIteration
+
+ class FakeRealtime:
+ def connect(self, **kwargs: Any) -> FakeConn:
+ if captured_connect is not None:
+ captured_connect.update(kwargs)
+ return FakeConn()
+
+ class FakeClient:
+ realtime = FakeRealtime()
+
+ return FakeClient()
+
+
+def _fake_openai_client(captured_kwargs: dict[str, Any]) -> type:
+ """Return a fake AsyncOpenAI class that records its constructor kwargs."""
+
+ class FakeClient:
+ def __init__(self, **kwargs: Any) -> None:
+ captured_kwargs.update(kwargs)
+
+ return FakeClient
+
+
+def _fake_allocator(connect_url: str, posts: list[tuple[str, dict[str, str] | None]]) -> type:
+ """Return a fake httpx.AsyncClient whose POST records (url, headers) and returns `connect_url`."""
+
+ class FakeResponse:
+ def raise_for_status(self) -> None:
+ pass
+
+ def json(self) -> dict[str, str]:
+ return {"session_id": "session-123", "connect_url": connect_url}
+
+ class FakeAsyncClient:
+ def __init__(self, **_kw: Any) -> None:
+ pass
+
+ async def __aenter__(self) -> "FakeAsyncClient":
+ return self
+
+ async def __aexit__(self, *_a: Any) -> bool:
+ return False
+
+ async def post(self, url: str, headers: dict[str, str] | None = None) -> FakeResponse:
+ posts.append((url, headers))
+ return FakeResponse()
+
+ return FakeAsyncClient
+
+
+@pytest.mark.asyncio
+async def test_partial_transcription_uses_latest_snapshot(monkeypatch: Any) -> None:
+ """Partial transcription snapshots should replace older snapshots for the same item."""
+ monkeypatch.setattr(hf_mod, "get_session_instructions", lambda _instance_path=None: "test")
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: "Aiden")
+ monkeypatch.setattr(hf_mod, "get_tool_specs", lambda: [])
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+ handler.client = _make_fake_realtime_client(
+ events=(
+ _FakeEvent("conversation.item.input_audio_transcription.delta", item_id="item-1", delta="Hey"),
+ _FakeEvent(
+ "conversation.item.input_audio_transcription.delta", item_id="item-1", delta="Hey, how are you?"
+ ),
+ )
+ )
+ monkeypatch.setattr(type(handler.tool_manager), "start_up", MagicMock())
+ monkeypatch.setattr(type(handler.tool_manager), "shutdown", AsyncMock())
+
+ await handler._run_realtime_session()
+
+ assert handler.input_transcript_chunks_by_item.item_id == "item-1"
+ assert handler.input_transcript_chunks_by_item.deltas == ["Hey, how are you?"]
+
+
+@pytest.mark.asyncio
+async def test_emit_skips_idle_signal_while_response_active(monkeypatch: Any) -> None:
+ """Idle tools should not trigger while a response is still active."""
+ movement_manager = MagicMock()
+ movement_manager.is_idle.return_value = True
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement_manager)
+ handler = HuggingFaceRealtimeHandler(deps)
+ handler.last_activity_time = time.monotonic() - (handler.IDLE_BEHAVIOR_THRESHOLD_S + 10.0)
+ handler._response_done_event.clear()
+
+ send_idle_signal = AsyncMock()
+ monkeypatch.setattr(handler, "send_idle_signal", send_idle_signal)
+ monkeypatch.setattr(conv_mod, "wait_for_item", AsyncMock(return_value=None))
+
+ result = await handler.emit()
+
+ assert result is None
+ send_idle_signal.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_parallel_tool_calls_trigger_single_response(monkeypatch: Any) -> None:
+ """Parallel tool calls in one turn should yield one response, not one per completed tool."""
+ monkeypatch.setattr(hf_mod, "get_session_instructions", lambda _instance_path=None: "test")
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: "Aiden")
+ monkeypatch.setattr(hf_mod, "get_tool_specs", lambda: [])
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+ handler.connection = AsyncMock()
+ handler.output_queue = asyncio.Queue()
+ monkeypatch.setattr(handler, "_wait_for_response_done_before_tool_result", AsyncMock(return_value=True))
+ create = AsyncMock()
+ monkeypatch.setattr(handler, "_safe_response_create", create)
+
+ handler._in_flight_tool_calls = {"call_a", "call_b"}
+
+ def _completed(call_id: str) -> ToolNotification:
+ return ToolNotification(
+ id=call_id,
+ tool_name="test__parallel_probe",
+ is_idle_tool_call=False,
+ status=ToolState.COMPLETED,
+ result={"ok": True},
+ )
+
+ await handler._handle_tool_result(_completed("call_a"))
+ assert create.await_count == 0
+
+ await handler._handle_tool_result(_completed("call_b"))
+ assert create.await_count == 1
+
+
+def test_handler_uses_hf_startup_voice_at_startup(monkeypatch: Any) -> None:
+ """Hugging Face startup should restore persisted HF voices."""
+ handler = HuggingFaceRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()),
+ startup_voice="Aiden",
+ )
+
+ assert handler.get_current_voice() == "Aiden"
+
+
+def test_handler_ignores_unsupported_hf_profile_voice(monkeypatch: Any) -> None:
+ """Unsupported profile voices should not be sent to the Hugging Face backend."""
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: "cedar")
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+
+ assert handler.get_current_voice() == HF_DEFAULT_VOICE
+ session = handler._get_session_config([])
+ assert session["audio"]["output"]["voice"] == HF_DEFAULT_VOICE
+
+
+def test_handler_normalizes_hf_voice_case(monkeypatch: Any) -> None:
+ """Lowercase Hugging Face speaker names should resolve to the curated UI value."""
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: "serena")
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+
+ assert handler.get_current_voice() == "Serena"
+
+
+@pytest.mark.asyncio
+async def test_run_realtime_session_uses_default_voice_for_lb_allocated_sessions(monkeypatch: Any) -> None:
+ """Use the backend default speaker when no profile voice is selected for the hf LB."""
+ monkeypatch.setattr(hf_mod, "get_session_instructions", lambda _instance_path=None: "test")
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: default)
+ monkeypatch.setattr(hf_mod, "get_tool_specs", lambda: [])
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+
+ captured_update: dict[str, Any] = {}
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+ handler.client = _make_fake_realtime_client(captured_update=captured_update)
+
+ await handler._run_realtime_session()
+
+ session = captured_update["session"]
+ # HF at 16 kHz passes None so the backend uses its optimal default (16 kHz).
+ assert session["audio"]["input"]["format"]["rate"] is None
+ assert session["audio"]["output"]["format"]["rate"] is None
+ assert session["audio"]["input"]["transcription"]["language"] == "en"
+ assert session["audio"]["output"]["voice"] == HF_DEFAULT_VOICE
+
+
+def test_huggingface_session_uses_configured_transcription_language(monkeypatch: Any) -> None:
+ """Hugging Face realtime sessions should forward the configured transcription language."""
+ monkeypatch.setattr(config, "REALTIME_TRANSCRIPTION_LANGUAGE", "zh")
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+
+ session = handler._get_session_config([])
+
+ assert session["audio"]["input"]["transcription"]["language"] == "zh"
+
+
+@pytest.mark.asyncio
+async def test_run_realtime_session_passes_allocated_session_query(monkeypatch: Any) -> None:
+ """Hugging Face sessions must forward the allocated session token to the websocket connect call."""
+ monkeypatch.setattr(hf_mod, "get_session_instructions", lambda _instance_path=None: "test")
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: default)
+ monkeypatch.setattr(hf_mod, "get_tool_specs", lambda: [])
+
+ captured_connect: dict[str, Any] = {}
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+ handler.client = _make_fake_realtime_client(captured_connect=captured_connect)
+ handler._realtime_connect_query = {"session_token": "abc123"}
+
+ await handler._run_realtime_session()
+
+ assert "model" not in captured_connect
+ assert captured_connect["extra_query"] == {"session_token": "abc123"}
+
+
+@pytest.mark.asyncio
+async def test_build_realtime_client_uses_direct_hf_ws_url(monkeypatch: Any) -> None:
+ """Hugging Face direct websocket mode should bypass the session allocator."""
+ client_kwargs: dict[str, Any] = {}
+
+ def _no_allocator(*_args: Any, **_kwargs: Any) -> Any:
+ raise AssertionError("session allocator should not be called in direct websocket mode")
+
+ monkeypatch.setattr(hf_mod, "AsyncOpenAI", _fake_openai_client(client_kwargs))
+ monkeypatch.setattr(hf_mod.httpx, "AsyncClient", _no_allocator)
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+ monkeypatch.setattr(config, "HF_TOKEN", None)
+ monkeypatch.setattr(
+ config,
+ "HF_REALTIME_WS_URL",
+ "ws://127.0.0.1:8765/v1/realtime?session_token=abc123&model=ignored-by-sdk",
+ )
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+
+ client = await handler._build_realtime_client()
+
+ assert client is not None
+ assert client_kwargs["api_key"] == "DUMMY"
+ assert client_kwargs["base_url"] == "http://127.0.0.1:8765/v1"
+ assert client_kwargs["websocket_base_url"] == "ws://127.0.0.1:8765/v1"
+ assert handler._realtime_connect_query == {"session_token": "abc123"}
+
+
+@pytest.mark.asyncio
+async def test_direct_hf_endpoint_log_omits_credentials_query_and_fragment(
+ monkeypatch: Any,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ secret = "hf_test_direct_endpoint_log_redaction"
+ direct_url = (
+ f"wss://operator:password@hf.example.test:9443/v1/{secret}/realtime"
+ f"?session_token={secret}&model=ignored-by-sdk#private-fragment"
+ )
+ client_kwargs: dict[str, Any] = {}
+ monkeypatch.setenv("HF_TOKEN", secret)
+ monkeypatch.setattr(hf_mod, "AsyncOpenAI", _fake_openai_client(client_kwargs))
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "local")
+ monkeypatch.setattr(config, "HF_TOKEN", secret)
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", direct_url)
+ caplog.set_level("INFO", logger="peachy.huggingface_realtime")
+ handler = HuggingFaceRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+ )
+
+ await handler._build_realtime_client()
+
+ assert handler._realtime_connect_query == {"session_token": secret}
+ assert client_kwargs["websocket_base_url"] == (
+ f"wss://operator:password@hf.example.test:9443/v1/{secret}"
+ )
+ assert "wss://hf.example.test:9443/v1/[redacted]/realtime" in caplog.text
+ assert secret not in caplog.text
+ assert "session_token" not in caplog.text
+ assert "private-fragment" not in caplog.text
+ assert "operator:password" not in caplog.text
+
+
+@pytest.mark.parametrize(
+ ("hf_token", "expected_header", "expected_api_key"),
+ [
+ ("hf-secret", {"Authorization": "Bearer hf-secret"}, "hf-secret"),
+ (None, None, "DUMMY"),
+ ],
+)
+@pytest.mark.asyncio
+async def test_build_realtime_client_deployed_allocates_with_hf_token_only(
+ monkeypatch: Any,
+ hf_token: str | None,
+ expected_header: dict[str, str] | None,
+ expected_api_key: str,
+) -> None:
+ """Deployed mode allocates via the session URL, authenticating with HF_TOKEN only (never an OpenAI key)."""
+ client_kwargs: dict[str, Any] = {}
+ posts: list[tuple[str, dict[str, str] | None]] = []
+ connect_url = "wss://hf.example.test/v1/realtime?session_token=allocated"
+ monkeypatch.setattr(hf_mod, "AsyncOpenAI", _fake_openai_client(client_kwargs))
+ monkeypatch.setattr(hf_mod.httpx, "AsyncClient", _fake_allocator(connect_url, posts))
+ monkeypatch.setattr(config, "HF_REALTIME_CONNECTION_MODE", "deployed")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+ # A stale local URL must be ignored in deployed mode.
+ monkeypatch.setattr(config, "HF_REALTIME_WS_URL", "ws://127.0.0.1:8765/v1/realtime")
+ monkeypatch.setattr(config, "HF_TOKEN", hf_token)
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+
+ client = await handler._build_realtime_client()
+
+ assert client is not None
+ assert posts == [("https://lb.example.test/session", expected_header)]
+ assert client_kwargs["api_key"] == expected_api_key
+ assert client_kwargs["base_url"] == "https://hf.example.test/v1"
+ assert client_kwargs["websocket_base_url"] == "wss://hf.example.test/v1"
+ assert handler._realtime_connect_query == {"session_token": "allocated"}
+
+
+@pytest.mark.asyncio
+async def test_apply_personality_uses_selected_voice_for_lb_allocated_sessions(monkeypatch: Any) -> None:
+ """Live personality updates should honor the selected Qwen CustomVoice speaker."""
+ monkeypatch.setattr(hf_mod, "get_session_instructions", lambda _instance_path=None: "new instructions")
+ monkeypatch.setattr(hf_mod, "get_session_voice", lambda default=HF_DEFAULT_VOICE: "Serena")
+ monkeypatch.setattr(config, "HF_REALTIME_SESSION_URL", "https://lb.example.test/session")
+
+ captured_update: dict[str, Any] = {}
+
+ class FakeSession:
+ async def update(self, **kwargs: Any) -> None:
+ captured_update.update(kwargs)
+
+ class FakeConnection:
+ session = FakeSession()
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+ handler.connection = FakeConnection()
+ monkeypatch.setattr(handler, "_restart_session", AsyncMock(return_value=None))
+
+ result = await handler.apply_personality("mars_rover")
+
+ assert "restarted realtime session" in result.lower()
+ session = captured_update["session"]
+ assert session["instructions"] == "new instructions"
+ assert session["audio"]["output"]["voice"] == "Serena"
+
+
+@pytest.mark.asyncio
+async def test_change_voice_updates_live_hf_session_without_restart(monkeypatch: Any) -> None:
+ """Changing Hugging Face voice should update the active session in place."""
+ captured_update: dict[str, Any] = {}
+
+ class FakeSession:
+ async def update(self, **kwargs: Any) -> None:
+ captured_update.update(kwargs)
+
+ class FakeConnection:
+ session = FakeSession()
+
+ handler = HuggingFaceRealtimeHandler(ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock()))
+ handler.connection = FakeConnection()
+ restart = AsyncMock(return_value=None)
+ monkeypatch.setattr(handler, "_restart_session", restart)
+
+ result = await handler.change_voice("Serena")
+
+ assert result == "Voice changed to Serena."
+ assert handler.get_current_voice() == "Serena"
+ restart.assert_not_awaited()
+ session = captured_update["session"]
+ assert session["audio"]["output"]["voice"] == "Serena"
+
+
+@pytest.mark.asyncio
+async def test_hf_session_update_failure_redacts_token_without_traceback(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: Any,
+) -> None:
+ secret = "hf_test_session_update_redaction"
+ monkeypatch.setenv("HF_TOKEN", secret)
+ monkeypatch.setattr(config, "HF_TOKEN", secret)
+ monkeypatch.setattr(hf_mod, "get_session_instructions", lambda _path=None: "test")
+ monkeypatch.setattr(hf_mod, "get_tool_specs", lambda: [])
+ update = AsyncMock(side_effect=RuntimeError("session rejected " + secret))
+
+ class FakeConnection:
+ session = SimpleNamespace(update=update)
+
+ async def __aenter__(self) -> "FakeConnection":
+ return self
+
+ async def __aexit__(self, *_args: Any) -> bool:
+ return False
+
+ handler = HuggingFaceRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+ )
+ handler.client = SimpleNamespace(
+ realtime=SimpleNamespace(connect=lambda **_kwargs: FakeConnection()),
+ )
+
+ with pytest.raises(RuntimeError):
+ await handler._run_realtime_session()
+
+ assert secret not in caplog.text
+ assert "session rejected [redacted]" in caplog.text
+ assert all(record.exc_info is None for record in caplog.records)
+
+
+@pytest.mark.asyncio
+async def test_hf_caught_provider_errors_redact_token(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: Any,
+) -> None:
+ secret = "hf_test_caught_boundary_redaction"
+ monkeypatch.setenv("HF_TOKEN", secret)
+ monkeypatch.setattr(config, "HF_TOKEN", secret)
+ caplog.set_level("DEBUG", logger="peachy.huggingface_realtime")
+ handler = HuggingFaceRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+ )
+ handler.connection = SimpleNamespace(
+ session=SimpleNamespace(update=AsyncMock(side_effect=RuntimeError("voice rejected " + secret))),
+ )
+
+ result = await handler.change_voice("Serena")
+
+ handler.connection = SimpleNamespace(close=AsyncMock(side_effect=RuntimeError("close rejected " + secret)))
+ await handler.shutdown()
+
+ assert result == "Voice change failed. Will take effect on next connection."
+ assert secret not in caplog.text
+ assert "voice rejected [redacted]" in caplog.text
+ assert "close rejected [redacted]" in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_hf_restart_task_failure_is_retrieved_and_redacted(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: Any,
+) -> None:
+ secret = "hf_test_restart_task_redaction"
+ monkeypatch.setenv("HF_TOKEN", secret)
+ monkeypatch.setattr(config, "HF_TOKEN", secret)
+ handler = HuggingFaceRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+ )
+ handler.client = MagicMock()
+ handler._connected_event = SimpleNamespace(clear=MagicMock(), wait=AsyncMock())
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=MagicMock()))
+ monkeypatch.setattr(
+ handler,
+ "_run_realtime_session",
+ AsyncMock(side_effect=RuntimeError("restart failed " + secret)),
+ )
+ loop = asyncio.get_running_loop()
+ previous_handler = loop.get_exception_handler()
+ unhandled_contexts: list[dict[str, Any]] = []
+ loop.set_exception_handler(lambda _loop, context: unhandled_contexts.append(context))
+ try:
+ await handler._restart_session()
+ await asyncio.sleep(0)
+ gc.collect()
+ await asyncio.sleep(0)
+ finally:
+ loop.set_exception_handler(previous_handler)
+
+ assert unhandled_contexts == []
+ assert secret not in caplog.text
+ assert "restart failed [redacted]" in caplog.text
+ assert all(record.exc_info is None for record in caplog.records)
+
+
+@pytest.mark.asyncio
+async def test_hf_shutdown_fences_restart_during_client_construction(monkeypatch: Any) -> None:
+ handler = HuggingFaceRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+ )
+ handler.client = MagicMock()
+ build_started = asyncio.Event()
+ release_build = asyncio.Event()
+ session_started = asyncio.Event()
+
+ async def build_client() -> MagicMock:
+ build_started.set()
+ await release_build.wait()
+ return MagicMock()
+
+ async def run_session() -> None:
+ session_started.set()
+ handler._connected_event.set()
+
+ monkeypatch.setattr(handler, "_build_realtime_client", build_client)
+ monkeypatch.setattr(handler, "_run_realtime_session", run_session)
+
+ restart_call = asyncio.create_task(handler._restart_session())
+ await asyncio.wait_for(build_started.wait(), timeout=1.0)
+ shutdown_call = asyncio.create_task(handler.shutdown())
+ await asyncio.sleep(0)
+ release_build.set()
+
+ await asyncio.wait_for(asyncio.gather(restart_call, shutdown_call), timeout=1.0)
+ await handler.shutdown()
+
+ assert not session_started.is_set()
+ assert handler._restart_tasks == set()
diff --git a/tests/test_idle_policy.py b/tests/test_idle_policy.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5a678cd5c2c71798d8ce0af514eb9debe310c00
--- /dev/null
+++ b/tests/test_idle_policy.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+from typing import Any
+
+import peachy.idle_policy as idle_policy_mod
+from peachy.tools.move_head import MoveHead
+from peachy.tools.core_tools import Tool, ToolDependencies
+from peachy.tools.idle_do_nothing import IdleDoNothing
+
+
+class FakeIdleTool(Tool):
+ """Tool with an idle tool name but not the idle tool class."""
+
+ _auto_register = False
+ name = "idle_do_nothing"
+ description = "Fake idle tool with the same public name."
+ parameters_schema: dict[str, Any] = {"type": "object", "properties": {}, "required": []}
+
+ async def __call__(self, deps: ToolDependencies, **kwargs: Any) -> dict[str, Any]:
+ """Return a fake result."""
+ return {"status": "fake"}
+
+
+def test_choose_idle_tool_call_uses_registered_name_for_matching_class() -> None:
+ """A matching idle class should use the registered tool instance name."""
+ tool = IdleDoNothing()
+ tool.name = "profile_idle_do_nothing"
+
+ selected = idle_policy_mod.choose_idle_tool_call(
+ ["profile_idle_do_nothing"],
+ tool_registry={"profile_idle_do_nothing": tool},
+ )
+
+ assert selected == ("profile_idle_do_nothing", {"reason": "random idle policy selected stillness"})
+
+
+def test_choose_idle_tool_call_rejects_same_name_with_unmatched_class() -> None:
+ """A matching public name alone should not make a tool eligible."""
+ selected = idle_policy_mod.choose_idle_tool_call(
+ ["idle_do_nothing"],
+ tool_registry={"idle_do_nothing": FakeIdleTool()},
+ )
+
+ assert selected is None
+
+
+def test_choose_idle_tool_call_keeps_args_with_weighted_candidate(monkeypatch) -> None:
+ """Argument generation should stay attached to the weighted candidate."""
+ monkeypatch.setattr(idle_policy_mod.random, "choice", lambda _choices: "right")
+
+ selected = idle_policy_mod.choose_idle_tool_call(
+ ["move_head"],
+ tool_registry={"move_head": MoveHead()},
+ )
+
+ assert selected == ("move_head", {"direction": "right"})
diff --git a/tests/test_main.py b/tests/test_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..cf927849b854364888c936a39c08c420abd253d2
--- /dev/null
+++ b/tests/test_main.py
@@ -0,0 +1,60 @@
+"""Tests for app-level runtime behavior."""
+
+import threading
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+import peachy.main as main_mod
+
+
+def test_inactivity_timeout_thread_goes_to_sleep() -> None:
+ """The watchdog should use the shared sleep shutdown path once activity is too old."""
+ stream_manager = SimpleNamespace(seconds_since_activity=lambda: 10.0, close=MagicMock())
+ go_to_sleep = MagicMock(return_value={"status": "sleeping"})
+
+ thread = main_mod._start_inactivity_timeout_thread(
+ timeout_minutes=0.0001,
+ stream_manager=stream_manager,
+ logger=MagicMock(),
+ app_stop_event=threading.Event(),
+ go_to_sleep=go_to_sleep,
+ )
+
+ thread.join(timeout=1.0)
+ assert not thread.is_alive()
+ go_to_sleep.assert_called_once_with()
+ stream_manager.close.assert_not_called()
+
+
+def test_inactivity_timeout_thread_closes_stream_manager_without_sleep_callback() -> None:
+ """The watchdog should still close the stream when no sleep callback is available."""
+ stream_manager = SimpleNamespace(seconds_since_activity=lambda: 10.0, close=MagicMock())
+
+ thread = main_mod._start_inactivity_timeout_thread(
+ timeout_minutes=0.0001,
+ stream_manager=stream_manager,
+ logger=MagicMock(),
+ app_stop_event=threading.Event(),
+ )
+
+ thread.join(timeout=1.0)
+ assert not thread.is_alive()
+ stream_manager.close.assert_called_once_with()
+
+
+def test_build_selected_handler_uses_provider_registry(monkeypatch: pytest.MonkeyPatch) -> None:
+ import peachy.providers as providers_mod
+
+ deps = MagicMock()
+ handler = MagicMock()
+ build_handler = MagicMock(return_value=handler)
+ definition = SimpleNamespace(name="openai", build_handler=build_handler)
+ monkeypatch.setattr(providers_mod, "get_provider_definition", lambda: definition)
+
+ selected, result = main_mod._build_selected_handler(deps, "/tmp/state", "marin")
+
+ assert selected is definition
+ assert result is handler
+ build_handler.assert_called_once_with(deps, "/tmp/state", "marin")
diff --git a/tests/test_mcp_client.py b/tests/test_mcp_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..98b7b8ecd77288702ff336e3b3baa237d719ed39
--- /dev/null
+++ b/tests/test_mcp_client.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import pytest
+
+
+pytest.importorskip("mcp.types")
+
+from mcp.types import Tool, TextContent, CallToolResult
+
+from peachy.mcp_client import (
+ RemoteToolSpec,
+ RemoteToolCallResponse,
+ validate_http_mcp_url,
+ build_namespaced_tool_name,
+)
+
+
+def test_validate_http_mcp_url_rejects_non_http_scheme() -> None:
+ """Only HTTP(S) MCP endpoints are supported."""
+ with pytest.raises(ValueError, match="Unsupported MCP URL scheme"):
+ validate_http_mcp_url("stdio://local-server")
+
+
+def test_validate_http_mcp_url_rejects_non_local_plain_http() -> None:
+ """Remote servers must use HTTPS unless they are local development endpoints."""
+ with pytest.raises(ValueError, match="must use HTTPS"):
+ validate_http_mcp_url("http://example.com/mcp")
+
+
+def test_build_namespaced_tool_name_normalizes_tool_segment() -> None:
+ """Remote tool names are normalized into app-safe tool IDs."""
+ assert build_namespaced_tool_name("gradio_docs", "search-docs") == "gradio_docs__search_docs"
+
+
+def test_remote_tool_spec_translates_to_function_spec() -> None:
+ """Discovered MCP tools should translate into app function specs."""
+ tool = Tool(
+ name="search-docs",
+ description="Search the docs",
+ inputSchema={
+ "type": "object",
+ "properties": {"query": {"type": "string"}},
+ "required": ["query"],
+ },
+ )
+
+ spec = RemoteToolSpec.from_mcp_tool("gradio_docs", tool)
+
+ assert spec.remote_name == "search-docs"
+ assert spec.namespaced_name == "gradio_docs__search_docs"
+ assert spec.to_function_spec() == {
+ "type": "function",
+ "name": "gradio_docs__search_docs",
+ "description": "Search the docs",
+ "parameters": {
+ "type": "object",
+ "properties": {"query": {"type": "string"}},
+ "required": ["query"],
+ },
+ }
+
+
+def test_remote_tool_error_result_maps_to_app_payload() -> None:
+ """Remote tool errors should remain visible after response mapping."""
+ result = CallToolResult(
+ content=[TextContent(type="text", text="Search backend unavailable")],
+ structuredContent=None,
+ isError=True,
+ )
+
+ payload = RemoteToolCallResponse.from_call_tool_result(
+ server_alias="gradio_docs",
+ remote_tool_name="search-docs",
+ result=result,
+ ).to_tool_result()
+
+ assert payload["status"] == "error"
+ assert payload["namespaced_tool_name"] == "gradio_docs__search_docs"
+ assert payload["text"] == "Search backend unavailable"
diff --git a/tests/test_mcp_client_integration.py b/tests/test_mcp_client_integration.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fefe2a608420a00f7f19b1b6287ea4e332f0dc1
--- /dev/null
+++ b/tests/test_mcp_client_integration.py
@@ -0,0 +1,203 @@
+from __future__ import annotations
+import asyncio
+from contextlib import asynccontextmanager
+from collections.abc import AsyncIterator
+
+import pytest
+import uvicorn
+import pytest_asyncio
+from starlette.routing import Mount
+from starlette.responses import PlainTextResponse
+from starlette.applications import Starlette
+
+
+pytest.importorskip("mcp.server.fastmcp")
+
+from mcp.server.fastmcp import FastMCP
+
+from peachy.mcp_client import (
+ RemoteToolSpec,
+ McpTransportError,
+ McpToolTimeoutError,
+ RemoteMcpToolClient,
+ RemoteMcpServerConfig,
+)
+
+
+class _BearerAuthMiddleware:
+ def __init__(self, app: object, token: str) -> None:
+ self.app = app
+ self.token = token
+
+ async def __call__(self, scope: dict, receive: object, send: object) -> None:
+ if scope["type"] == "http" and scope["path"].startswith("/mcp"):
+ headers = {key.decode("latin-1"): value.decode("latin-1") for key, value in scope.get("headers", [])}
+ if headers.get("authorization") != f"Bearer {self.token}":
+ response = PlainTextResponse("Unauthorized", status_code=401)
+ await response(scope, receive, send)
+ return
+
+ await self.app(scope, receive, send)
+
+
+def _build_local_mcp_app(required_token: str) -> object:
+ mcp_server = FastMCP("Reachy Test MCP", stateless_http=True, json_response=True)
+
+ @mcp_server.tool()
+ def echo_text(message: str) -> dict[str, str]:
+ """Echo text as structured JSON."""
+ return {"echo": message}
+
+ @mcp_server.tool()
+ async def slow_echo(message: str, delay_s: float = 0.2) -> dict[str, str]:
+ """Delay, then echo text as structured JSON."""
+ await asyncio.sleep(delay_s)
+ return {"echo": message}
+
+ mcp_app = mcp_server.streamable_http_app()
+
+ @asynccontextmanager
+ async def lifespan(_: Starlette) -> AsyncIterator[None]:
+ async with mcp_server.session_manager.run():
+ yield
+
+ app = Starlette(routes=[Mount("/", app=mcp_app)], lifespan=lifespan)
+ return _BearerAuthMiddleware(app, required_token)
+
+
+async def _wait_for_server(host: str, port: int) -> None:
+ deadline = asyncio.get_running_loop().time() + 5
+ while asyncio.get_running_loop().time() < deadline:
+ try:
+ reader, writer = await asyncio.open_connection(host, port)
+ except OSError:
+ await asyncio.sleep(0.05)
+ continue
+
+ writer.close()
+ await writer.wait_closed()
+ return
+
+ raise RuntimeError(f"Timed out waiting for local MCP server on {host}:{port}")
+
+
+@pytest_asyncio.fixture
+async def local_mcp_server(unused_tcp_port: int) -> AsyncIterator[tuple[str, str]]:
+ """Run a local HTTP MCP server that requires a bearer token."""
+ token = "local-test-token"
+ app = _build_local_mcp_app(token)
+ server = uvicorn.Server(
+ uvicorn.Config(
+ app,
+ host="127.0.0.1",
+ port=unused_tcp_port,
+ log_level="error",
+ access_log=False,
+ ws="none",
+ )
+ )
+
+ task = asyncio.create_task(server.serve())
+ await _wait_for_server("127.0.0.1", unused_tcp_port)
+
+ try:
+ yield (f"http://127.0.0.1:{unused_tcp_port}/mcp", token)
+ finally:
+ server.should_exit = True
+ await task
+
+
+@pytest.mark.asyncio
+async def test_remote_mcp_tool_client_calls_known_tool_without_discovery(
+ local_mcp_server: tuple[str, str],
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A cached tool spec should let the first call skip remote discovery."""
+ server_url, token = local_mcp_server
+ client = RemoteMcpToolClient(
+ RemoteMcpServerConfig(
+ alias="gradio_docs",
+ url=server_url,
+ headers={"Authorization": f"Bearer {token}"},
+ request_timeout_s=2.0,
+ tool_timeout_s=1.0,
+ ),
+ known_tools=[
+ RemoteToolSpec(
+ server_alias="gradio_docs",
+ remote_name="echo_text",
+ namespaced_name="gradio_docs__echo_text",
+ description="Echo text",
+ parameters_schema={
+ "type": "object",
+ "properties": {"message": {"type": "string"}},
+ "required": ["message"],
+ },
+ )
+ ],
+ )
+
+ async def _fail_list_tool_specs() -> list[RemoteToolSpec]:
+ raise AssertionError("discovery should not run")
+
+ monkeypatch.setattr(client, "list_tool_specs", _fail_list_tool_specs)
+
+ result = await client.call_tool("gradio_docs__echo_text", {"message": "hello"})
+
+ assert result["status"] == "ok"
+ assert result["structured_content"] == {"echo": "hello"}
+
+
+@pytest.mark.asyncio
+async def test_remote_mcp_tool_client_discovers_calls_and_handles_timeout(
+ local_mcp_server: tuple[str, str],
+) -> None:
+ """The client should discover tools, map schemas, invoke tools, and handle timeouts/auth."""
+ server_url, token = local_mcp_server
+ client = RemoteMcpToolClient(
+ RemoteMcpServerConfig(
+ alias="gradio_docs",
+ url=server_url,
+ headers={"Authorization": f"Bearer {token}"},
+ request_timeout_s=2.0,
+ tool_timeout_s=1.0,
+ )
+ )
+
+ function_specs = await client.list_function_specs()
+ function_names = sorted(spec["name"] for spec in function_specs)
+ assert function_names == ["gradio_docs__echo_text", "gradio_docs__slow_echo"]
+
+ echo_spec = next(spec for spec in function_specs if spec["name"] == "gradio_docs__echo_text")
+ assert echo_spec["parameters"]["properties"]["message"]["type"] == "string"
+
+ result = await client.call_tool("gradio_docs__echo_text", {"message": "hello"})
+ assert result["status"] == "ok"
+ assert result["structured_content"] == {"echo": "hello"}
+ assert result["namespaced_tool_name"] == "gradio_docs__echo_text"
+
+ timeout_client = RemoteMcpToolClient(
+ RemoteMcpServerConfig(
+ alias="gradio_docs",
+ url=server_url,
+ headers={"Authorization": f"Bearer {token}"},
+ request_timeout_s=2.0,
+ tool_timeout_s=0.05,
+ )
+ )
+ with pytest.raises(McpToolTimeoutError, match="Timed out calling MCP tool"):
+ await timeout_client.call_tool(
+ "gradio_docs__slow_echo",
+ {"message": "hello", "delay_s": 0.2},
+ )
+
+ unauthorized_client = RemoteMcpToolClient(
+ RemoteMcpServerConfig(
+ alias="gradio_docs",
+ url=server_url,
+ request_timeout_s=2.0,
+ tool_timeout_s=1.0,
+ )
+ )
+ with pytest.raises(McpTransportError, match="Failed to discover MCP tools"):
+ await unauthorized_client.list_tool_specs()
diff --git a/tests/test_memory.py b/tests/test_memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..7a182efb6060f7e33e8e59d9dfa32aedec55f37b
--- /dev/null
+++ b/tests/test_memory.py
@@ -0,0 +1,105 @@
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+import peachy.prompts as prompts_mod
+from peachy.config import config
+from peachy.memory import (
+ MAX_FACTS,
+ MAX_FACT_CHARS,
+ MemoryFact,
+ add_memory_fact,
+ list_memory_facts,
+ clear_memory_facts,
+ forget_memory_fact,
+ format_memory_for_prompt,
+ memory_path_for_instance,
+)
+from peachy.tools.forget import Forget
+from peachy.tools.remember import Remember
+from peachy.tools.core_tools import ToolDependencies
+
+
+def test_memory_store_adds_dedupes_caps_and_formats(tmp_path: Path) -> None:
+ """Memory facts should be normalized, deduplicated, capped, and prompt-formatted."""
+ first = add_memory_fact(tmp_path, " Likes jazz ")
+ duplicate = add_memory_fact(tmp_path, "likes jazz")
+
+ assert first is not None
+ assert duplicate == first
+ assert [fact.text for fact in list_memory_facts(tmp_path)] == ["Likes jazz"]
+
+ long_text = "x" * (MAX_FACT_CHARS + 20)
+ stored_long = add_memory_fact(tmp_path, long_text)
+
+ assert stored_long is not None
+ assert len(stored_long.text) == MAX_FACT_CHARS
+ assert stored_long.text.endswith("...")
+
+ for index in range(MAX_FACTS + 5):
+ add_memory_fact(tmp_path, f"Fact {index}")
+
+ facts = list_memory_facts(tmp_path)
+ assert len(facts) == MAX_FACTS
+ assert facts[0].text == f"Fact {MAX_FACTS + 4}"
+ assert "Likes jazz" not in [fact.text for fact in facts]
+
+ prompt = format_memory_for_prompt(tmp_path)
+ assert prompt.startswith("Things you remember about the user")
+ assert f"- Fact {MAX_FACTS + 4}" in prompt
+
+
+def test_memory_store_reads_mobile_json_shape_and_forgets_by_query(tmp_path: Path) -> None:
+ """The Python store should preserve the mobile app JSON envelope shape."""
+ path = memory_path_for_instance(tmp_path)
+ path.write_text(
+ json.dumps(
+ {
+ "version": 1,
+ "facts": [
+ {"id": "m_1", "text": "Likes jazz", "createdAt": 1000},
+ {"id": "m_2", "text": "Likes jazz piano", "createdAt": 900},
+ {"id": "bad"},
+ ],
+ }
+ ),
+ encoding="utf-8",
+ )
+
+ result = forget_memory_fact(tmp_path, query="jazz")
+
+ assert result.removed == MemoryFact(id="m_1", text="Likes jazz", created_at=1000)
+ assert [candidate.text for candidate in result.candidates] == ["Likes jazz", "Likes jazz piano"]
+ assert [fact.text for fact in list_memory_facts(tmp_path)] == ["Likes jazz piano"]
+
+
+@pytest.mark.asyncio
+async def test_memory_tools_use_instance_storage(tmp_path: Path) -> None:
+ """Remember and forget tools should read/write through ToolDependencies.instance_path."""
+ deps = ToolDependencies(
+ reachy_mini=MagicMock(),
+ movement_manager=MagicMock(),
+ instance_path=tmp_path,
+ )
+
+ remember_result = await Remember()(deps, fact="Has a dog named Mochi")
+ forget_result = await Forget()(deps, query="Mochi")
+
+ assert remember_result["saved"] == "Has a dog named Mochi"
+ assert forget_result["removed"] == "Has a dog named Mochi"
+ assert list_memory_facts(tmp_path) == []
+
+
+def test_prompt_includes_memory_fragment(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Session instructions should prepend saved memories for the active app instance."""
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ clear_memory_facts(tmp_path)
+ add_memory_fact(tmp_path, "Prefers concise answers")
+
+ instructions = prompts_mod.get_session_instructions(instance_path=tmp_path)
+
+ assert instructions.startswith("Things you remember about the user")
+ assert "- Prefers concise answers" in instructions
+ assert "## IDENTITY" in instructions
diff --git a/tests/test_moves.py b/tests/test_moves.py
new file mode 100644
index 0000000000000000000000000000000000000000..e8103da232f0aa65b43b917b88cd82c5a84d9df6
--- /dev/null
+++ b/tests/test_moves.py
@@ -0,0 +1,111 @@
+import time
+import threading
+from unittest.mock import MagicMock, call
+from collections.abc import Callable
+
+import numpy as np
+import pytest
+
+from reachy_mini.utils import create_head_pose
+from reachy_mini.utils.interpolation import compose_world_offset
+from peachy.moves import MovementManager
+from peachy.dance_emotion_moves import EmotionQueueMove
+
+
+class _FakeMove:
+ """Minimal non-emotion Move stub returning a fixed head pose."""
+
+ def __init__(self, head: np.ndarray) -> None:
+ self._head = head
+ self.duration = 10.0
+
+ def evaluate(self, t: float):
+ return (self._head, np.array([0.0, 0.0]), 0.0)
+
+
+def _wait_for(predicate: Callable[[], bool], timeout: float = 1.0) -> bool:
+ deadline = time.monotonic() + timeout
+ while time.monotonic() < deadline:
+ if predicate():
+ return True
+ time.sleep(0.005)
+ return False
+
+
+def test_stop_can_skip_neutral_reset(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Sleep shutdown should stop the movement loop without undoing the sleep pose."""
+ robot = MagicMock()
+ manager = MovementManager(robot)
+ started = threading.Event()
+
+ def fake_working_loop() -> None:
+ started.set()
+ while not manager._stop_event.is_set():
+ time.sleep(0.001)
+
+ monkeypatch.setattr(manager, "working_loop", fake_working_loop)
+
+ manager.start()
+ assert started.wait(timeout=1.0)
+
+ manager.stop(reset_to_neutral=False)
+
+ assert manager._thread is None
+ robot.goto_target.assert_not_called()
+
+
+def test_head_tracking_follows_speaking() -> None:
+ """Once enabled, tracking owns the head when idle and releases it while the assistant speaks."""
+ robot = MagicMock()
+ robot.get_current_head_pose.return_value = np.eye(4)
+ robot.get_current_joint_positions.return_value = ([0.0] * 6, [0.0, 0.0])
+ manager = MovementManager(robot)
+ manager.start()
+ try:
+ # The head_tracking tool enables tracking with full weight.
+ manager.set_head_tracking(True)
+ assert _wait_for(lambda: call(weight=1.0) in robot.start_head_tracking.call_args_list)
+
+ # Speaking with a locked face captures the anchor and releases the head.
+ manager.set_speaking(True)
+ assert _wait_for(lambda: call(weight=0.0) in robot.start_head_tracking.call_args_list)
+ assert _wait_for(lambda: manager._track_anchor is not None)
+
+ # Done speaking hands the head back to tracking.
+ robot.start_head_tracking.reset_mock()
+ manager.set_speaking(False)
+ assert _wait_for(lambda: call(weight=1.0) in robot.start_head_tracking.call_args_list)
+ assert _wait_for(lambda: manager._track_anchor is None)
+ finally:
+ manager.stop(reset_to_neutral=False)
+
+ robot.stop_head_tracking.assert_called_once()
+
+
+def test_speaking_anchor_composes_emotions_and_holds_dances_from_neutral() -> None:
+ """While speaking: hold the anchor, compose emotions onto it, play dances from neutral."""
+ robot = MagicMock()
+ manager = MovementManager(robot)
+ anchor = create_head_pose(0, 0, 0, 0, 0, 20, degrees=True)
+ manager._track_anchor = anchor
+
+ # No move: the head holds the captured look-at anchor.
+ manager.state.current_move = None
+ head, _, _ = manager._get_primary_pose(manager._now())
+ assert np.allclose(head, anchor)
+
+ # Emotion: composed onto the anchor exactly like the daemon wobble.
+ emotion_head = create_head_pose(0, 0, 0, 0, 0, 15, degrees=True)
+ recorded = MagicMock()
+ recorded.get.return_value = _FakeMove(emotion_head)
+ manager.state.current_move = EmotionQueueMove("happy", recorded)
+ manager.state.move_start_time = manager._now()
+ head, _, _ = manager._get_primary_pose(manager._now())
+ assert np.allclose(head, compose_world_offset(anchor, emotion_head))
+
+ # Any other move (e.g. a dance) plays from its own neutral base, ignoring the anchor.
+ dance_head = create_head_pose(0, 0, 0, 0, 25, 0, degrees=True)
+ manager.state.current_move = _FakeMove(dance_head)
+ manager.state.move_start_time = manager._now()
+ head, _, _ = manager._get_primary_pose(manager._now())
+ assert np.allclose(head, dance_head)
diff --git a/tests/test_openai_realtime.py b/tests/test_openai_realtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ae58a90e612abd00c6701cc919f1964e2b12f6f
--- /dev/null
+++ b/tests/test_openai_realtime.py
@@ -0,0 +1,854 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import gc
+from types import SimpleNamespace
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import numpy as np
+import pytest
+
+import peachy.config as config_mod
+import peachy.openai_realtime as openai_mod
+from peachy.openai_realtime import OpenAIRealtimeHandler
+from peachy.streaming import AdditionalOutputs
+from peachy.tools.core_tools import ToolDependencies
+
+
+def _deps() -> ToolDependencies:
+ movement = MagicMock()
+ movement.is_idle.return_value = True
+ return ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement)
+
+
+class _Event:
+ def __init__(self, event_type: str, **fields: Any) -> None:
+ self.type = event_type
+ self.__dict__.update(fields)
+
+
+def test_openai_handler_satisfies_the_conversation_contract(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-contract")
+ handler = OpenAIRealtimeHandler(_deps())
+ assert handler.SAMPLE_RATE == 24_000
+ assert handler.get_current_voice() == "marin"
+ assert handler._is_connected() is False
+ assert callable(handler.start_up)
+ assert callable(handler.shutdown)
+ assert callable(handler.receive)
+
+
+@pytest.mark.asyncio
+async def test_build_client_and_connect_use_key_and_selected_model(monkeypatch: pytest.MonkeyPatch) -> None:
+ captured_client: dict[str, Any] = {}
+ captured_connect: dict[str, Any] = {}
+
+ class _Realtime:
+ def connect(self, **kwargs: Any) -> object:
+ captured_connect.update(kwargs)
+ raise RuntimeError("stop after connect arguments")
+
+ class _Client:
+ realtime = _Realtime()
+
+ def __init__(self, **kwargs: Any) -> None:
+ captured_client.update(kwargs)
+
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-client")
+ monkeypatch.setenv("OPENAI_REALTIME_MODEL", "gpt-realtime-test")
+ monkeypatch.setattr(openai_mod, "AsyncOpenAI", _Client)
+ monkeypatch.setattr(openai_mod, "get_tool_specs", lambda: [])
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.client = await handler._build_realtime_client()
+
+ with pytest.raises(RuntimeError, match="stop after connect"):
+ await handler._run_realtime_session()
+
+ assert captured_client == {"api_key": "sk-test-client"}
+ assert captured_connect == {"model": "gpt-realtime-test"}
+
+
+def test_session_config_uses_24k_vad_instructions_voice_and_filters_camera(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-session")
+ monkeypatch.setattr(openai_mod, "get_session_instructions", lambda _path=None: "You are Peachy")
+ handler = OpenAIRealtimeHandler(_deps(), startup_voice="cedar")
+ tools = [
+ {"name": "camera", "description": "camera", "parameters": {"type": "object"}},
+ {"name": "get_time", "description": "time", "parameters": {"type": "object"}},
+ ]
+
+ session = handler._get_session_config(tools)
+
+ assert session["instructions"] == "You are Peachy"
+ assert session["audio"]["input"]["format"] == {"type": "audio/pcm", "rate": 24_000}
+ assert session["audio"]["output"]["format"] == {"type": "audio/pcm", "rate": 24_000}
+ assert session["audio"]["input"]["turn_detection"]["interrupt_response"] is True
+ assert session["audio"]["output"]["voice"] == "cedar"
+ assert [tool["name"] for tool in session["tools"]] == ["get_time"]
+
+
+@pytest.mark.asyncio
+async def test_run_realtime_session_manages_full_offline_lifecycle(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.delenv("OPENAI_REALTIME_MODEL", raising=False)
+ monkeypatch.setattr(openai_mod, "get_session_instructions", lambda _path=None: "Lifecycle instructions")
+ monkeypatch.setattr(openai_mod, "get_session_greeting_prompt", lambda: "Open with a greeting.")
+ monkeypatch.setattr(
+ openai_mod,
+ "get_tool_specs",
+ lambda: [
+ {"name": "camera", "description": "camera", "parameters": {"type": "object"}},
+ {"name": "get_time", "description": "time", "parameters": {"type": "object"}},
+ ],
+ )
+ handler = OpenAIRealtimeHandler(_deps())
+ session_update = AsyncMock()
+ conversation_item_create = AsyncMock()
+ worker_started = asyncio.Event()
+ worker_cancelled = asyncio.Event()
+ worker_tasks: list[asyncio.Task[None]] = []
+ lifecycle_states: list[tuple[bool, bool]] = []
+ captured_connect: dict[str, Any] = {}
+
+ async def _response_sender_worker() -> None:
+ task = asyncio.current_task()
+ assert task is not None
+ worker_tasks.append(task)
+ worker_started.set()
+ try:
+ await asyncio.Event().wait()
+ except asyncio.CancelledError:
+ worker_cancelled.set()
+ raise
+
+ monkeypatch.setattr(handler, "_response_sender_loop", _response_sender_worker)
+ tool_start = MagicMock()
+ tool_shutdown = AsyncMock()
+ monkeypatch.setattr(type(handler.tool_manager), "start_up", tool_start)
+ monkeypatch.setattr(type(handler.tool_manager), "shutdown", tool_shutdown)
+
+ class _Connection:
+ session = SimpleNamespace(update=session_update)
+ conversation = SimpleNamespace(item=SimpleNamespace(create=conversation_item_create))
+
+ def __init__(self) -> None:
+ self._visited = False
+
+ async def __aenter__(self) -> _Connection:
+ return self
+
+ async def __aexit__(self, *_args: Any) -> bool:
+ return False
+
+ def __aiter__(self) -> _Connection:
+ return self
+
+ async def __anext__(self) -> _Event:
+ if self._visited:
+ raise StopAsyncIteration
+ self._visited = True
+ await asyncio.wait_for(worker_started.wait(), timeout=1.0)
+ lifecycle_states.append((handler.connection is self, handler._connected_event.is_set()))
+ raise StopAsyncIteration
+
+ connection = _Connection()
+
+ class _Realtime:
+ def connect(self, **kwargs: Any) -> _Connection:
+ captured_connect.update(kwargs)
+ return connection
+
+ handler.client = SimpleNamespace(realtime=_Realtime())
+
+ await handler._run_realtime_session()
+
+ assert captured_connect == {"model": "gpt-realtime"}
+ session_update.assert_awaited_once()
+ session = session_update.await_args.kwargs["session"]
+ assert session["audio"]["input"]["format"] == {"type": "audio/pcm", "rate": 24_000}
+ assert session["audio"]["output"]["format"] == {"type": "audio/pcm", "rate": 24_000}
+ assert [tool["name"] for tool in session["tools"]] == ["get_time"]
+ assert lifecycle_states == [(True, True)]
+ tool_start.assert_called_once()
+ callbacks = tool_start.call_args.kwargs["tool_callbacks"]
+ assert len(callbacks) == 1
+ assert callbacks[0].__self__ is handler
+ tool_shutdown.assert_awaited_once_with()
+ conversation_item_create.assert_awaited_once_with(
+ item={
+ "type": "message",
+ "role": "user",
+ "content": [{"type": "input_text", "text": "Open with a greeting."}],
+ }
+ )
+ assert handler._startup_greeting_sent is True
+ assert handler._pending_responses.get_nowait() == {}
+ assert len(worker_tasks) == 1
+ assert worker_tasks[0].get_name() == "response-sender"
+ assert worker_tasks[0].done()
+ assert worker_tasks[0].cancelled()
+ assert worker_cancelled.is_set()
+ assert handler.connection is None
+ assert not handler._connected_event.is_set()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(("source_rate", "shape"), [(16_000, (160,)), (48_000, (2, 480))])
+async def test_receive_sends_mono_24k_pcm16(
+ monkeypatch: pytest.MonkeyPatch,
+ source_rate: int,
+ shape: tuple[int, ...],
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-audio")
+ handler = OpenAIRealtimeHandler(_deps())
+ append = AsyncMock()
+ handler.connection = SimpleNamespace(input_audio_buffer=SimpleNamespace(append=append))
+ source = np.full(shape, 0.25, dtype=np.float32)
+
+ await handler.receive((source_rate, source))
+
+ encoded = append.await_args.kwargs["audio"]
+ decoded = np.frombuffer(base64.b64decode(encoded), dtype=" 0)
+
+
+@pytest.mark.asyncio
+async def test_receive_drops_empty_connected_audio(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-empty")
+ handler = OpenAIRealtimeHandler(_deps())
+ append = AsyncMock()
+ handler.connection = SimpleNamespace(input_audio_buffer=SimpleNamespace(append=append))
+
+ await handler.receive((16_000, np.array([], dtype=np.int16)))
+
+ append.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_receive_drops_disconnected_audio(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-disconnected")
+ handler = OpenAIRealtimeHandler(_deps())
+
+ await handler.receive((16_000, np.ones(160, dtype=np.int16)))
+
+
+@pytest.mark.asyncio
+async def test_output_audio_delta_enqueues_rate_tagged_pcm(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-output")
+ handler = OpenAIRealtimeHandler(_deps())
+ pcm = np.array([-100, 0, 100], dtype=" None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-transcript")
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.partial_debounce_delay = 0
+
+ await handler._handle_event(
+ _Event("conversation.item.input_audio_transcription.delta", item_id="item-1", delta="Hello")
+ )
+ assert handler.partial_transcript_task is not None
+ await handler.partial_transcript_task
+ await handler._handle_event(
+ _Event("conversation.item.input_audio_transcription.completed", item_id="item-1", transcript=" Hello ")
+ )
+
+ partial = handler.output_queue.get_nowait()
+ completed = handler.output_queue.get_nowait()
+ assert isinstance(partial, AdditionalOutputs)
+ assert partial.args == ({"role": "user_partial", "content": "Hello"},)
+ assert isinstance(completed, AdditionalOutputs)
+ assert completed.args == ({"role": "user", "content": "Hello"},)
+ assert handler.input_transcript_chunks_by_item.item_id == "item-1"
+ assert handler.input_transcript_chunks_by_item.deltas == ["Hello"]
+ handler.deps.movement_manager.set_listening.assert_called_with(False)
+
+
+@pytest.mark.asyncio
+async def test_response_created_and_done_update_speaking_and_response_state(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-response-state")
+ handler = OpenAIRealtimeHandler(_deps())
+
+ await handler._handle_event(_Event("response.created"))
+
+ handler.deps.movement_manager.set_speaking.assert_called_with(True)
+ assert not handler._response_done_event.is_set()
+ assert handler._response_started_or_rejected_event.is_set()
+
+ await handler._handle_event(_Event("response.done"))
+
+ handler.deps.movement_manager.set_speaking.assert_called_with(False)
+ assert handler._response_done_event.is_set()
+ assert handler._response_started_or_rejected_event.is_set()
+
+
+@pytest.mark.asyncio
+async def test_function_call_event_dispatches_background_tool(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-tool-event")
+ handler = OpenAIRealtimeHandler(_deps())
+ start_tool = AsyncMock(return_value=SimpleNamespace(tool_id="tool-1"))
+ monkeypatch.setattr(type(handler.tool_manager), "start_tool", start_tool)
+
+ await handler._handle_event(
+ _Event(
+ "response.function_call_arguments.done",
+ name="get_time",
+ arguments='{"timezone":"UTC"}',
+ call_id="call-1",
+ )
+ )
+
+ start_tool.assert_awaited_once()
+ kwargs = start_tool.await_args.kwargs
+ routine = kwargs["tool_call_routine"]
+ assert kwargs["call_id"] == "call-1"
+ assert kwargs["is_idle_tool_call"] is False
+ assert routine.tool_name == "get_time"
+ assert routine.args_json_str == '{"timezone":"UTC"}'
+ assert routine.deps is handler.deps
+ assert handler._in_flight_tool_calls == {"call-1"}
+ emitted = handler.output_queue.get_nowait()
+ assert isinstance(emitted, AdditionalOutputs)
+ assert "Used tool get_time" in emitted.args[0]["content"]
+
+
+@pytest.mark.asyncio
+async def test_error_events_separate_response_rejection_from_user_facing_errors(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-errors")
+ handler = OpenAIRealtimeHandler(_deps())
+
+ await handler._handle_event(
+ _Event(
+ "error",
+ error=SimpleNamespace(
+ code="conversation_already_has_active_response",
+ message="response already active",
+ ),
+ )
+ )
+
+ assert handler._last_response_rejected is True
+ assert handler._response_started_or_rejected_event.is_set()
+ assert handler.output_queue.empty()
+
+ handler._response_started_or_rejected_event.clear()
+ with pytest.raises(openai_mod.RealtimeProtocolError, match="Invalid request"):
+ await handler._handle_event(
+ _Event("error", error=SimpleNamespace(code="bad_request", message="Invalid request"))
+ )
+
+ assert handler._response_started_or_rejected_event.is_set()
+ assert handler.output_queue.empty()
+
+
+@pytest.mark.asyncio
+async def test_change_voice_updates_live_session_case_insensitively(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-live-voice")
+ handler = OpenAIRealtimeHandler(_deps())
+ session_update = AsyncMock()
+ handler.connection = SimpleNamespace(session=SimpleNamespace(update=session_update))
+
+ result = await handler.change_voice("CEDAR")
+
+ assert result == "Voice changed to cedar."
+ assert handler.get_current_voice() == "cedar"
+ session_update.assert_awaited_once()
+ session = session_update.await_args.kwargs["session"]
+ assert session["audio"]["output"]["voice"] == "cedar"
+
+
+@pytest.mark.asyncio
+async def test_apply_personality_updates_live_session_and_restarts(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-personality")
+ monkeypatch.setattr(openai_mod, "get_session_instructions", lambda _path=None: "New personality")
+ set_custom_profile = MagicMock()
+ initialize_tools = MagicMock()
+ monkeypatch.setattr(config_mod, "set_custom_profile", set_custom_profile)
+ monkeypatch.setattr(openai_mod.core_tools, "initialize_tools", initialize_tools)
+ handler = OpenAIRealtimeHandler(_deps(), startup_voice="cedar")
+ session_update = AsyncMock()
+ handler.connection = SimpleNamespace(session=SimpleNamespace(update=session_update))
+ restart_session = AsyncMock()
+ monkeypatch.setattr(handler, "_restart_session", restart_session)
+
+ result = await handler.apply_personality("mars_rover")
+
+ assert result == "Applied personality and restarted realtime session."
+ set_custom_profile.assert_called_once_with("mars_rover")
+ initialize_tools.assert_called_once_with(force=True)
+ session_update.assert_awaited_once()
+ session = session_update.await_args.kwargs["session"]
+ assert session["instructions"] == "New personality"
+ assert session["audio"]["output"]["voice"] == "cedar"
+ restart_session.assert_awaited_once_with()
+
+
+@pytest.mark.asyncio
+async def test_speech_started_cancels_active_response_and_clears_once(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-barge")
+ handler = OpenAIRealtimeHandler(_deps())
+ cancel = AsyncMock()
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=cancel))
+
+ def drain_output_queue() -> None:
+ while not handler.output_queue.empty():
+ handler.output_queue.get_nowait()
+
+ clear = MagicMock(side_effect=drain_output_queue)
+ handler._clear_queue = clear
+ await handler.output_queue.put((24_000, np.ones((1, 8), dtype=np.int16)))
+ await handler._handle_event(_Event("response.created", response=SimpleNamespace(id="response-old")))
+
+ await handler._handle_event(_Event("input_audio_buffer.speech_started"))
+
+ cancel.assert_awaited_once()
+ cancel_kwargs = cancel.await_args.kwargs
+ assert cancel_kwargs["response_id"] == "response-old"
+ assert cancel_kwargs["event_id"].startswith("peachy-cancel-")
+ assert cancel_kwargs["event_id"] in handler._pending_cancel_event_ids
+ clear.assert_called_once_with()
+ assert handler.output_queue.empty()
+ assert "response-old" in handler._cancelled_response_ids
+
+
+@pytest.mark.asyncio
+async def test_speech_started_after_response_done_is_a_harmless_clear(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-finished")
+ handler = OpenAIRealtimeHandler(_deps())
+ cancel = AsyncMock()
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=cancel))
+ handler._clear_queue = MagicMock()
+ await handler._handle_event(_Event("response.created", response=SimpleNamespace(id="response-done")))
+ await handler._handle_event(_Event("response.done", response=SimpleNamespace(id="response-done")))
+
+ await handler._handle_event(_Event("input_audio_buffer.speech_started"))
+
+ cancel.assert_not_awaited()
+ handler._clear_queue.assert_called_once_with()
+
+
+@pytest.mark.asyncio
+async def test_late_delta_from_cancelled_response_is_suppressed_until_terminal_event(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-late")
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=AsyncMock()))
+ handler._clear_queue = MagicMock()
+ pcm = base64.b64encode(np.ones(4, dtype=" None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-generation")
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=AsyncMock()))
+ handler._clear_queue = MagicMock()
+ pcm = base64.b64encode(np.ones(4, dtype=" None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-tool")
+ handler = OpenAIRealtimeHandler(_deps())
+ create_item = AsyncMock()
+ handler.connection = SimpleNamespace(
+ conversation=SimpleNamespace(item=SimpleNamespace(create=create_item)),
+ response=SimpleNamespace(create=AsyncMock()),
+ )
+
+ class _DoubleTool(openai_mod.core_tools.Tool):
+ name = "double_value"
+ description = "Double an integer"
+ parameters_schema = {
+ "type": "object",
+ "properties": {"value": {"type": "integer"}},
+ "required": ["value"],
+ }
+ needs_response = True
+
+ async def __call__(self, _deps: ToolDependencies, value: int) -> dict[str, int]:
+ return {"doubled": value * 2}
+
+ monkeypatch.setattr(openai_mod.core_tools, "ALL_TOOLS", {"double_value": _DoubleTool()})
+ monkeypatch.setattr(openai_mod.core_tools, "initialize_tools", lambda *args, **kwargs: None)
+ handler.tool_manager.start_up(tool_callbacks=[handler._handle_tool_result])
+ try:
+ await handler._handle_event(
+ _Event(
+ "response.function_call_arguments.done",
+ name="double_value",
+ arguments='{"value": 21}',
+ call_id="call-42",
+ )
+ )
+ deadline = asyncio.get_running_loop().time() + 1.0
+ while create_item.await_count == 0 and asyncio.get_running_loop().time() < deadline:
+ await asyncio.sleep(0.01)
+ finally:
+ await handler.tool_manager.shutdown()
+
+ sent = create_item.await_args.kwargs["item"]
+ assert sent["type"] == "function_call_output"
+ assert sent["call_id"] == "call-42"
+ assert '"doubled": 42' in sent["output"]
+ assert handler._pending_responses.qsize() == 1
+
+
+class _ProviderFailure(RuntimeError):
+ def __init__(
+ self,
+ message: str,
+ *,
+ status_code: int | None = None,
+ code: str | None = None,
+ ) -> None:
+ super().__init__(message)
+ self.status_code = status_code
+ self.code = code
+
+
+@pytest.mark.parametrize(
+ "error",
+ [
+ _ProviderFailure("invalid key", status_code=401),
+ _ProviderFailure("forbidden", status_code=403),
+ _ProviderFailure("bad session", status_code=400),
+ _ProviderFailure("quota", status_code=429, code="insufficient_quota"),
+ _ProviderFailure("unknown provider failure"),
+ ],
+)
+def test_terminal_provider_errors_are_classified_without_retry(error: BaseException) -> None:
+ assert openai_mod.classify_openai_error(error) == "terminal"
+
+
+@pytest.mark.parametrize(
+ "error",
+ [
+ ConnectionError("socket closed"),
+ TimeoutError("timed out"),
+ _ProviderFailure("server unavailable", status_code=503),
+ _ProviderFailure("rate limited", status_code=429, code="rate_limit_exceeded"),
+ ],
+)
+def test_transient_provider_errors_are_retryable(error: BaseException) -> None:
+ assert openai_mod.classify_openai_error(error) == "transient"
+
+
+@pytest.mark.asyncio
+async def test_terminal_realtime_error_event_stops_activation_after_one_attempt(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-protocol-terminal")
+ handler = OpenAIRealtimeHandler(_deps())
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=MagicMock()))
+ attempts = 0
+
+ async def run_session() -> None:
+ nonlocal attempts
+ attempts += 1
+ await handler._handle_event(
+ _Event(
+ "error",
+ error=SimpleNamespace(
+ code="invalid_api_key",
+ type="invalid_request_error",
+ message="invalid key",
+ ),
+ )
+ )
+
+ monkeypatch.setattr(handler, "_run_realtime_session", run_session)
+
+ with pytest.raises(openai_mod.TerminalProviderError, match="invalid key"):
+ await handler.start_up()
+
+ assert attempts == 1
+
+
+@pytest.mark.asyncio
+async def test_active_response_rejection_event_remains_internal() -> None:
+ handler = OpenAIRealtimeHandler(_deps())
+ handler._response_started_or_rejected_event.clear()
+
+ await handler._handle_event(
+ _Event(
+ "error",
+ error=SimpleNamespace(
+ code="conversation_already_has_active_response",
+ message="response already active",
+ ),
+ )
+ )
+
+ assert handler._last_response_rejected is True
+ assert handler._response_started_or_rejected_event.is_set()
+
+
+@pytest.mark.asyncio
+async def test_correlated_cancel_race_error_remains_internal() -> None:
+ handler = OpenAIRealtimeHandler(_deps())
+ cancel = AsyncMock()
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=cancel))
+ handler._clear_queue = MagicMock()
+ await handler._handle_event(_Event("response.created", response=SimpleNamespace(id="response-race")))
+ await handler._handle_event(_Event("input_audio_buffer.speech_started"))
+ cancel_event_id = cancel.await_args.kwargs["event_id"]
+ await handler._handle_event(_Event("response.done", response=SimpleNamespace(id="response-race")))
+
+ await handler._handle_event(
+ _Event(
+ "error",
+ error=SimpleNamespace(
+ code="response_cancel_not_active",
+ type="invalid_request_error",
+ message="there is no active response to cancel",
+ event_id=cancel_event_id,
+ ),
+ )
+ )
+
+ assert cancel_event_id not in handler._pending_cancel_event_ids
+ assert handler.connection is not None
+
+
+@pytest.mark.asyncio
+async def test_terminal_error_stops_after_one_attempt(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-terminal")
+ handler = OpenAIRealtimeHandler(_deps())
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=MagicMock()))
+ run_session = AsyncMock(side_effect=_ProviderFailure("denied", status_code=401))
+ monkeypatch.setattr(handler, "_run_realtime_session", run_session)
+
+ with pytest.raises(openai_mod.TerminalProviderError, match="denied"):
+ await handler.start_up()
+
+ assert run_session.await_count == 1
+
+
+@pytest.mark.asyncio
+async def test_transient_error_uses_exactly_three_attempts(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-transient")
+ handler = OpenAIRealtimeHandler(_deps())
+ build_client = AsyncMock(side_effect=[MagicMock(), MagicMock(), MagicMock()])
+ run_session = AsyncMock(side_effect=ConnectionError("socket closed"))
+ sleep = AsyncMock()
+ jitter = MagicMock(return_value=0.0)
+ monkeypatch.setattr(handler, "_build_realtime_client", build_client)
+ monkeypatch.setattr(handler, "_run_realtime_session", run_session)
+ monkeypatch.setattr(openai_mod.random, "uniform", jitter)
+ monkeypatch.setattr(openai_mod.asyncio, "sleep", sleep)
+
+ with pytest.raises(openai_mod.RetryExhaustedError, match="3 attempts"):
+ await handler.start_up()
+
+ assert run_session.await_count == 3
+ assert build_client.await_count == 3
+ assert [call.args[0] for call in sleep.await_args_list] == [1.0, 2.0]
+ assert [call.args for call in jitter.call_args_list] == [(0.0, 0.5), (0.0, 0.5)]
+
+
+@pytest.mark.asyncio
+async def test_openai_activation_log_redacts_key(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-handler-redaction"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ handler = OpenAIRealtimeHandler(_deps())
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=MagicMock()))
+ monkeypatch.setattr(
+ handler,
+ "_run_realtime_session",
+ AsyncMock(side_effect=_ProviderFailure("rejected " + secret, status_code=401)),
+ )
+
+ with pytest.raises(openai_mod.TerminalProviderError):
+ await handler.start_up()
+
+ assert secret not in caplog.text
+
+
+@pytest.mark.asyncio
+async def test_session_update_exception_is_redacted_without_traceback(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-session-update-redaction"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ monkeypatch.setattr(openai_mod, "get_tool_specs", lambda: [])
+ update = AsyncMock(side_effect=RuntimeError("session rejected " + secret))
+
+ class _Connection:
+ session = SimpleNamespace(update=update)
+
+ async def __aenter__(self) -> _Connection:
+ return self
+
+ async def __aexit__(self, *_args: Any) -> bool:
+ return False
+
+ client = SimpleNamespace(
+ realtime=SimpleNamespace(connect=lambda **_kwargs: _Connection()),
+ )
+ handler = OpenAIRealtimeHandler(_deps())
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=client))
+
+ with pytest.raises(openai_mod.TerminalProviderError):
+ await handler.start_up()
+
+ assert secret not in caplog.text
+ assert all(record.exc_info is None for record in caplog.records)
+
+
+@pytest.mark.asyncio
+async def test_restart_task_failure_is_retrieved_and_redacted(
+ caplog: pytest.LogCaptureFixture,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ secret = "sk-test-restart-task-redaction"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.client = MagicMock()
+ handler._connected_event = SimpleNamespace(clear=MagicMock(), wait=AsyncMock())
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=MagicMock()))
+ monkeypatch.setattr(
+ handler,
+ "_run_realtime_session",
+ AsyncMock(side_effect=RuntimeError("restart failed " + secret)),
+ )
+ loop = asyncio.get_running_loop()
+ previous_handler = loop.get_exception_handler()
+ unhandled_contexts: list[dict[str, Any]] = []
+ loop.set_exception_handler(lambda _loop, context: unhandled_contexts.append(context))
+ try:
+ await handler._restart_session()
+ await asyncio.sleep(0)
+ gc.collect()
+ await asyncio.sleep(0)
+ finally:
+ loop.set_exception_handler(previous_handler)
+
+ assert unhandled_contexts == []
+ assert secret not in caplog.text
+ assert "restart failed [redacted]" in caplog.text
+ assert all(record.exc_info is None for record in caplog.records)
+
+
+@pytest.mark.asyncio
+async def test_shutdown_cancels_tracked_restart_task(monkeypatch: pytest.MonkeyPatch) -> None:
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.client = MagicMock()
+ handler._connected_event = SimpleNamespace(
+ clear=MagicMock(),
+ set=MagicMock(),
+ wait=AsyncMock(),
+ )
+ started = asyncio.Event()
+ cancelled = asyncio.Event()
+
+ async def run_until_cancelled() -> None:
+ started.set()
+ try:
+ await asyncio.Event().wait()
+ except asyncio.CancelledError:
+ cancelled.set()
+ raise
+
+ monkeypatch.setattr(handler, "_build_realtime_client", AsyncMock(return_value=MagicMock()))
+ monkeypatch.setattr(handler, "_run_realtime_session", run_until_cancelled)
+
+ await handler._restart_session()
+ await asyncio.wait_for(started.wait(), timeout=1.0)
+ restart_tasks = tuple(handler._restart_tasks)
+ await handler.shutdown()
+
+ assert len(restart_tasks) == 1
+ assert restart_tasks[0].cancelled()
+ assert cancelled.is_set()
+ assert handler._restart_tasks == set()
+
+
+@pytest.mark.asyncio
+async def test_shutdown_fences_restart_during_client_construction(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ handler = OpenAIRealtimeHandler(_deps())
+ handler.client = MagicMock()
+ build_started = asyncio.Event()
+ release_build = asyncio.Event()
+ session_started = asyncio.Event()
+
+ async def build_client() -> MagicMock:
+ build_started.set()
+ await release_build.wait()
+ return MagicMock()
+
+ async def run_session() -> None:
+ session_started.set()
+ handler._connected_event.set()
+
+ monkeypatch.setattr(handler, "_build_realtime_client", build_client)
+ monkeypatch.setattr(handler, "_run_realtime_session", run_session)
+
+ restart_call = asyncio.create_task(handler._restart_session())
+ await asyncio.wait_for(build_started.wait(), timeout=1.0)
+ shutdown_call = asyncio.create_task(handler.shutdown())
+ await asyncio.sleep(0)
+ release_build.set()
+
+ await asyncio.wait_for(asyncio.gather(restart_call, shutdown_call), timeout=1.0)
+ await handler.shutdown()
+
+ assert not session_started.is_set()
+ assert handler._restart_tasks == set()
diff --git a/tests/test_openai_realtime_live_contract.py b/tests/test_openai_realtime_live_contract.py
new file mode 100644
index 0000000000000000000000000000000000000000..17d17ee68b8ddc578921c2fc1122f4b13a5cba1a
--- /dev/null
+++ b/tests/test_openai_realtime_live_contract.py
@@ -0,0 +1,558 @@
+from __future__ import annotations
+
+import asyncio
+import ast
+import base64
+import importlib.util
+import inspect
+import os
+import socket
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import numpy as np
+import pytest
+import certifi
+
+from peachy.console import LocalStream
+from peachy.openai_realtime import OpenAIRealtimeHandler
+from peachy.tools.core_tools import ToolDependencies
+
+
+PROJECT_ROOT = Path(__file__).parents[1]
+LIVE_TEST = PROJECT_ROOT / "tests" / "manual" / "test_openai_realtime_live.py"
+
+
+def _offline_subprocess_env(tmp_path: Path) -> dict[str, str]:
+ sitecustomize = textwrap.dedent(
+ """
+ import os
+ import socket
+
+ _original_getenv = os.getenv
+
+ def _guarded_getenv(key, default=None):
+ if key == "OPENAI_API_KEY":
+ raise AssertionError("OPENAI_API_KEY access is forbidden in guard tests")
+ return _original_getenv(key, default)
+
+ def _forbidden_network(*_args, **_kwargs):
+ raise AssertionError("network access is forbidden in guard tests")
+
+ os.getenv = _guarded_getenv
+ socket.create_connection = _forbidden_network
+ socket.getaddrinfo = _forbidden_network
+ socket.socket.connect = _forbidden_network
+ socket.socket.connect_ex = _forbidden_network
+ """
+ )
+ (tmp_path / "sitecustomize.py").write_text(sitecustomize, encoding="utf-8")
+ env = os.environ.copy()
+ env.pop("OPENAI_API_KEY", None)
+ env.pop("RUN_OPENAI_REALTIME", None)
+ env.pop("PEACHY_LIVE_SPEND_APPROVED", None)
+ # GStreamer's .pth mutates this in the parent interpreter. A child must
+ # derive its own prefix-local value or it receives invalid joined paths.
+ env.pop("GST_PYTHONPATH_1_0", None)
+ env["PYTHONPATH"] = str(tmp_path)
+ return env
+
+
+def _run_live_pytest(tmp_path: Path, *args: str) -> subprocess.CompletedProcess[str]:
+ return subprocess.run(
+ [sys.executable, "-m", "pytest", *args, str(LIVE_TEST), "-q"],
+ cwd=PROJECT_ROOT,
+ env=_offline_subprocess_env(tmp_path),
+ capture_output=True,
+ text=True,
+ timeout=20,
+ check=False,
+ )
+
+
+def test_default_pytest_selection_deselects_live_test_without_key_or_network(tmp_path: Path) -> None:
+ result = _run_live_pytest(tmp_path)
+
+ output = result.stdout + result.stderr
+ assert result.returncode == 5, output
+ assert "1 deselected" in output
+ assert "ERROR collecting" not in output
+ assert "errors during collection" not in output
+ assert "OPENAI_API_KEY access is forbidden" not in output
+ assert "network access is forbidden" not in output
+
+
+def test_explicit_live_marker_skips_before_key_or_network_access(tmp_path: Path) -> None:
+ result = _run_live_pytest(tmp_path, "-o", "addopts=", "-m", "live_openai")
+
+ output = result.stdout + result.stderr
+ assert result.returncode == 0, output
+ assert "1 skipped" in output
+ assert "OPENAI_API_KEY access is forbidden" not in output
+ assert "network access is forbidden" not in output
+
+
+def _live_module() -> object:
+ spec = importlib.util.spec_from_file_location("peachy_live_test_contract_target", LIVE_TEST)
+ assert spec is not None and spec.loader is not None
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ return module
+
+
+def test_checked_in_fixture_loads_as_mono_pcm16_at_24khz() -> None:
+ live = _live_module()
+
+ rate, audio = live._load_fixture()
+
+ assert rate == 24_000
+ assert audio.dtype == np.dtype(" 0
+
+
+def test_certifi_ca_setup_is_offline_and_does_not_read_the_api_key(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ live = _live_module()
+ monkeypatch.delenv("SSL_CERT_FILE", raising=False)
+ original_getenv = os.getenv
+
+ def guarded_getenv(key: str, default: str | None = None) -> str | None:
+ if key == "OPENAI_API_KEY":
+ raise AssertionError("OPENAI_API_KEY access is forbidden in CA setup")
+ return original_getenv(key, default)
+
+ def forbidden_network(*_args: object, **_kwargs: object) -> None:
+ raise AssertionError("network access is forbidden in CA setup")
+
+ monkeypatch.setattr(os, "getenv", guarded_getenv)
+ monkeypatch.setattr(socket, "create_connection", forbidden_network)
+ monkeypatch.setattr(socket, "getaddrinfo", forbidden_network)
+ monkeypatch.setattr(socket.socket, "connect", forbidden_network)
+ monkeypatch.setattr(socket.socket, "connect_ex", forbidden_network)
+
+ ca_bundle = live._configure_certifi_ca()
+
+ assert ca_bundle == Path(certifi.where()).resolve()
+ assert ca_bundle.is_file()
+ assert os.environ["SSL_CERT_FILE"] == str(ca_bundle)
+
+
+@pytest.mark.asyncio
+async def test_single_realtime_activation_runs_one_session_and_always_cleans_up() -> None:
+ live = _live_module()
+ calls: list[str] = []
+ connected = asyncio.Event()
+ client = object()
+
+ class _Handler:
+ def __init__(self) -> None:
+ self.client: object | None = None
+ self.connection: object | None = None
+ self._connected_event = connected
+
+ async def _build_realtime_client(self) -> object:
+ calls.append("build")
+ return client
+
+ async def _run_realtime_session(self) -> None:
+ calls.append("session")
+ self.connection = object()
+ self._connected_event.set()
+ raise RuntimeError("one fake session failure")
+
+ handler = _Handler()
+
+ with pytest.raises(RuntimeError, match="one fake session failure"):
+ await live._run_single_realtime_session(handler)
+
+ assert calls == ["build", "session"]
+ assert handler.client is client
+ assert handler.connection is None
+ assert not handler._connected_event.is_set()
+
+
+@pytest.mark.asyncio
+async def test_activity_wait_handles_first_audio_before_transcription_completion() -> None:
+ live = _live_module()
+ activity_queue: asyncio.Queue[str] = asyncio.Queue()
+ first_audio = asyncio.Event()
+ release_completion = asyncio.Event()
+ expected = [
+ "user_speech_started",
+ "user_speech_stopped",
+ "response_created",
+ "user_transcription_delta",
+ "user_transcription_delta",
+ "user_transcription_completed",
+ ]
+
+ async def publish_live_order() -> None:
+ for reason in expected[:-1]:
+ await activity_queue.put(reason)
+ first_audio.set()
+ await release_completion.wait()
+ await activity_queue.put(expected[-1])
+
+ publisher = asyncio.create_task(publish_live_order())
+ await first_audio.wait()
+ waiter = asyncio.create_task(
+ live._wait_for_activity_reason(
+ activity_queue,
+ "user_transcription_completed",
+ timeout=0.5,
+ )
+ )
+ await asyncio.sleep(0)
+
+ assert not waiter.done()
+ release_completion.set()
+ reasons = await waiter
+ await publisher
+
+ assert reasons == expected
+
+
+@pytest.mark.asyncio
+async def test_activity_wait_reports_observed_reasons_when_completion_is_absent() -> None:
+ live = _live_module()
+ activity_queue: asyncio.Queue[str] = asyncio.Queue()
+ await activity_queue.put("user_speech_started")
+ await activity_queue.put("response_created")
+
+ with pytest.raises(AssertionError) as exc_info:
+ await live._wait_for_activity_reason(
+ activity_queue,
+ "user_transcription_completed",
+ timeout=0.01,
+ )
+
+ message = str(exc_info.value)
+ assert "user_transcription_completed" in message
+ assert "user_speech_started" in message
+ assert "response_created" in message
+
+
+@pytest.mark.asyncio
+async def test_fixture_feeder_uses_20ms_chunks_and_trailing_silence(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ live = _live_module()
+ receives: list[tuple[int, np.ndarray]] = []
+
+ class _Handler:
+ async def receive(self, frame: tuple[int, np.ndarray]) -> None:
+ receives.append(frame)
+
+ sleep = AsyncMock()
+ monkeypatch.setattr(live.asyncio, "sleep", sleep)
+ source = np.arange(961, dtype=np.int16)
+
+ await live._feed_realtime(_Handler(), 24_000, source)
+
+ assert [frame.shape[0] for _, frame in receives[:3]] == [480, 480, 1]
+ assert len(receives) == 33
+ assert all(rate == 24_000 for rate, _ in receives)
+ assert all(frame.shape == (480,) and not frame.any() for _, frame in receives[-30:])
+ assert [call.args[0] for call in sleep.await_args_list] == [0.02] * 33
+
+
+def test_session_override_caps_output_at_64_tokens() -> None:
+ live = _live_module()
+
+ class _Handler:
+ def _get_session_config(self, _specs: list[object]) -> dict[str, object]:
+ return {"type": "realtime", "instructions": "fixture"}
+
+ handler = _Handler()
+ live._install_output_token_limit(handler)
+
+ assert handler._get_session_config([]) == {
+ "type": "realtime",
+ "instructions": "fixture",
+ "max_output_tokens": 64,
+ }
+
+
+def test_response_budget_rejects_more_than_two_capped_responses() -> None:
+ live = _live_module()
+
+ assert live._assert_response_budget(2) == 2
+
+ with pytest.raises(AssertionError, match="observed 3 responses"):
+ live._assert_response_budget(3)
+
+
+@pytest.mark.asyncio
+async def test_response_budget_guard_counts_real_events_and_cancels_the_third_response() -> None:
+ live = _live_module()
+ movement = MagicMock()
+ movement.is_idle.return_value = True
+ handler = OpenAIRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement),
+ startup_voice="marin",
+ )
+ cancel = AsyncMock()
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=cancel))
+ response_count = live._install_response_budget_guard(handler)
+
+ def event(response_id: str) -> SimpleNamespace:
+ return SimpleNamespace(type="response.created", response=SimpleNamespace(id=response_id))
+
+ await handler._handle_event(event("response-one"))
+ await handler._handle_event(event("response-two"))
+
+ with pytest.raises(AssertionError, match="third response.created"):
+ await handler._handle_event(event("response-three"))
+
+ assert response_count() == 3
+ assert cancel.await_count == 1
+ assert cancel.await_args.kwargs["response_id"] == "response-three"
+ await handler.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_response_budget_guard_preserves_delayed_audio_response_provenance() -> None:
+ live = _live_module()
+ movement = MagicMock()
+ movement.is_idle.return_value = True
+ handler = OpenAIRealtimeHandler(
+ ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement),
+ startup_voice="marin",
+ )
+ response_guard = live._install_response_budget_guard(handler)
+ pcm = base64.b64encode(np.ones(8, dtype=" SimpleNamespace:
+ return SimpleNamespace(type=event_type, **fields)
+
+ await handler._handle_event(event("response.created", response=SimpleNamespace(id="response-one")))
+ await handler._handle_event(
+ event("response.output_audio.delta", response_id="response-one", delta=pcm)
+ )
+ delayed_response_one_frame = handler.output_queue.get_nowait()
+ await handler._handle_event(event("response.created", response=SimpleNamespace(id="response-two")))
+ await handler.output_queue.put(delayed_response_one_frame)
+
+ emitted = await handler.emit()
+
+ assert emitted is delayed_response_one_frame
+ assert response_guard.emitted_audio_response_count == 1
+ with pytest.raises(AssertionError, match="Cancelled response audio"):
+ live._assert_no_cancelled_audio_replay(
+ [1, response_guard.emitted_audio_response_count],
+ pushed_before_interrupt=1,
+ response_count_at_interrupt=1,
+ )
+ await handler.shutdown()
+
+
+@pytest.mark.asyncio
+async def test_teardown_task_check_allows_cancellation_but_surfaces_task_failures() -> None:
+ live = _live_module()
+
+ async def wait_forever() -> None:
+ await asyncio.Event().wait()
+
+ async def fail() -> None:
+ raise RuntimeError("offline session failure")
+
+ orderly = asyncio.create_task(asyncio.sleep(0))
+ await orderly
+ cancelled = asyncio.create_task(wait_forever())
+ await live._cancel_tasks_and_raise_unexpected((orderly, cancelled))
+ assert cancelled.cancelled()
+
+ failed = asyncio.create_task(fail())
+ await asyncio.sleep(0)
+ with pytest.raises(AssertionError, match="offline session failure"):
+ await live._cancel_tasks_and_raise_unexpected((failed,))
+
+
+def test_interruption_replay_check_rejects_cancelled_audio_but_allows_a_later_response() -> None:
+ live = _live_module()
+
+ live._assert_no_cancelled_audio_replay(
+ [1, 2],
+ pushed_before_interrupt=1,
+ response_count_at_interrupt=1,
+ )
+
+ with pytest.raises(AssertionError, match="Cancelled response audio"):
+ live._assert_no_cancelled_audio_replay(
+ [1, 1],
+ pushed_before_interrupt=1,
+ response_count_at_interrupt=1,
+ )
+
+
+@pytest.mark.asyncio
+async def test_resample_spy_delegates_real_24k_to_48k_and_doubles_samples(
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ live = _live_module()
+ resample_calls = live._install_console_resample_spy(monkeypatch)
+ output_queue: asyncio.Queue[tuple[int, np.ndarray]] = asyncio.Queue()
+ pushed: list[np.ndarray] = []
+ pushed_event = asyncio.Event()
+
+ class _Handler:
+ async def emit(self) -> tuple[int, np.ndarray]:
+ return await output_queue.get()
+
+ def push_audio(frame: np.ndarray) -> None:
+ pushed.append(frame)
+ pushed_event.set()
+
+ handler = _Handler()
+ media = SimpleNamespace(
+ audio=SimpleNamespace(clear_player=lambda: None),
+ get_output_audio_samplerate=lambda: 48_000,
+ push_audio_sample=push_audio,
+ )
+ stream = LocalStream(handler, SimpleNamespace(media=media))
+ play_task = asyncio.create_task(stream.play_loop())
+ try:
+ await output_queue.put((24_000, np.arange(8, dtype=np.int16).reshape(1, -1)))
+ await asyncio.wait_for(pushed_event.wait(), timeout=0.5)
+ finally:
+ stream._stop_event.set()
+ play_task.cancel()
+ await asyncio.gather(play_task, return_exceptions=True)
+
+ assert resample_calls == [(24_000, 48_000, 8, 16)]
+ assert len(pushed) == 1
+ assert pushed[0].dtype == np.float32
+ assert pushed[0].shape == (16,)
+
+
+@pytest.mark.asyncio
+async def test_playback_gate_proves_player_and_queue_are_cleared_before_release() -> None:
+ live = _live_module()
+ output_queue: asyncio.Queue[tuple[int, np.ndarray]] = asyncio.Queue()
+ first_audio = asyncio.Event()
+
+ class _Handler:
+ def __init__(self) -> None:
+ self.output_queue = output_queue
+
+ async def emit(self) -> tuple[int, np.ndarray]:
+ return await output_queue.get()
+
+ class _AudioPlayer:
+ def __init__(self) -> None:
+ self.pending: list[np.ndarray] = []
+ self.clear_calls = 0
+
+ def clear_player(self) -> None:
+ self.clear_calls += 1
+ self.pending.clear()
+
+ audio_player = _AudioPlayer()
+
+ def push_audio(frame: np.ndarray) -> None:
+ audio_player.pending.append(frame)
+ first_audio.set()
+
+ handler = _Handler()
+ media = SimpleNamespace(
+ audio=audio_player,
+ get_output_audio_samplerate=lambda: 48_000,
+ push_audio_sample=push_audio,
+ )
+ stream = LocalStream(handler, SimpleNamespace(media=media))
+ gate_blocked, release_gate = live._install_emit_gate(handler, first_audio)
+ await output_queue.put((24_000, np.ones((1, 8), dtype=np.int16)))
+ play_task = asyncio.create_task(stream.play_loop())
+ try:
+ await asyncio.wait_for(gate_blocked.wait(), timeout=0.5)
+ assert len(audio_player.pending) == 1
+ pending_waiter = asyncio.create_task(live._wait_for_queued_audio(output_queue, timeout=0.5))
+ await asyncio.sleep(0)
+ assert not pending_waiter.done()
+ await output_queue.put((24_000, np.ones((1, 8), dtype=np.int16)))
+ assert await pending_waiter == 1
+
+ stream.clear_audio_queue()
+
+ assert audio_player.clear_calls == 1
+ assert audio_player.pending == []
+ assert output_queue.empty()
+ assert live._queued_audio_count(output_queue) == 0
+ release_gate.set()
+ await asyncio.sleep(0)
+ assert audio_player.pending == []
+ finally:
+ stream._stop_event.set()
+ release_gate.set()
+ play_task.cancel()
+ await asyncio.gather(play_task, return_exceptions=True)
+
+
+def test_live_smoke_source_uses_one_handler_two_feeds_and_finally_teardown() -> None:
+ live = _live_module()
+ tree = ast.parse(inspect.getsource(live.test_real_sample_round_trip_and_barge_in))
+ calls = [node for node in ast.walk(tree) if isinstance(node, ast.Call)]
+
+ def count_named(name: str) -> int:
+ return sum(isinstance(call.func, ast.Name) and call.func.id == name for call in calls)
+
+ def count_method(name: str) -> int:
+ return sum(isinstance(call.func, ast.Attribute) and call.func.attr == name for call in calls)
+
+ assert count_named("OpenAIRealtimeHandler") == 1
+ assert count_named("LocalStream") == 1
+ assert count_named("_feed_realtime") == 2
+ assert count_named("_run_single_realtime_session") == 1
+ assert count_named("_assert_response_budget") == 1
+ assert count_named("_install_console_resample_spy") == 1
+ assert count_named("_install_emit_gate") == 1
+ assert count_method("start_up") == 0
+ assert count_method("shutdown") == 1
+ assert any(isinstance(node, ast.Try) and node.finalbody for node in ast.walk(tree))
+
+
+@pytest.mark.asyncio
+async def test_manual_sink_barge_in_clears_player_without_network() -> None:
+ movement = MagicMock()
+ movement.is_idle.return_value = True
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement)
+ handler = OpenAIRealtimeHandler(deps, startup_voice="marin")
+ cancel = AsyncMock()
+ handler.connection = SimpleNamespace(response=SimpleNamespace(cancel=cancel))
+ clear_player = MagicMock()
+ media = SimpleNamespace(
+ audio=SimpleNamespace(clear_player=clear_player),
+ get_output_audio_samplerate=lambda: 48_000,
+ push_audio_sample=MagicMock(),
+ )
+ LocalStream(handler, SimpleNamespace(media=media))
+ await handler.output_queue.put((24_000, np.ones((1, 8), dtype=np.int16)))
+ def event(event_type: str, **fields: object) -> SimpleNamespace:
+ return SimpleNamespace(type=event_type, **fields)
+
+ await handler._handle_event(event("response.created", response=SimpleNamespace(id="offline-response")))
+
+ await handler._handle_event(event("input_audio_buffer.speech_started"))
+
+ late_delta = base64.b64encode(np.ones(8, dtype=" None:
+ """Create a minimal UI-style profile under the writable user root."""
+ personality_mod._write_profile(name, "Be brief.", "")
+
+
+def test_delete_removes_user_profile(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """A UI-created profile under the user root can be deleted."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ _make_user_profile("doomed")
+ profile_dir = tmp_path / "user_personalities" / "doomed"
+ assert profile_dir.is_dir()
+
+ assert delete_personality("user_personalities/doomed") is True
+ assert not profile_dir.exists()
+
+
+def test_delete_refuses_builtin_profile(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Built-in profiles live outside the user root and must never be deletable."""
+ builtin_dir = personality_mod.resolve_profile_dir("mad_scientist_assistant")
+ assert builtin_dir.is_dir()
+
+ assert delete_personality("mad_scientist_assistant") is False
+ assert builtin_dir.is_dir()
+
+
+def test_delete_refuses_path_outside_user_root(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """A traversal selection escaping the user root is refused, not followed."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ victim = tmp_path / "user_personalities" / "outside_target"
+ victim.mkdir(parents=True)
+
+ assert delete_personality("user_personalities/../outside_target") is False
+ assert victim.is_dir()
+
+
+def _client(monkeypatch: pytest.MonkeyPatch, persisted: str | None = None) -> TestClient:
+ """Mount the personality routes with stub callbacks for delete-guard tests."""
+ app = FastAPI()
+ mount_personality_routes(
+ app,
+ handler=object(), # type: ignore[arg-type] # delete route does not touch the handler
+ get_loop=lambda: None,
+ get_persisted_personality=(lambda: persisted),
+ )
+ return TestClient(app)
+
+
+def test_route_refuses_deleting_current_profile(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Deleting the live profile would break get_session_instructions() next startup."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "user_personalities/live")
+ _make_user_profile("live")
+
+ resp = _client(monkeypatch).delete("/personalities", params={"name": "user_personalities/live"})
+
+ assert resp.status_code == 409
+ assert resp.json()["error"] == "profile_in_use"
+ assert (tmp_path / "user_personalities" / "live").is_dir()
+
+
+def test_route_refuses_deleting_startup_profile(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """The persisted startup profile is guarded even when it is not the live one."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+ _make_user_profile("boots")
+
+ client = _client(monkeypatch, persisted="user_personalities/boots")
+ resp = client.delete("/personalities", params={"name": "user_personalities/boots"})
+
+ assert resp.status_code == 409
+ assert resp.json()["error"] == "profile_in_use"
+ assert (tmp_path / "user_personalities" / "boots").is_dir()
+
+
+def test_route_deletes_inactive_profile(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """A profile that is neither live nor startup is deleted and returns ok."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "user_personalities/live")
+ _make_user_profile("live")
+ _make_user_profile("spare")
+
+ resp = _client(monkeypatch).delete("/personalities", params={"name": "user_personalities/spare"})
+
+ assert resp.status_code == 200
+ assert resp.json()["ok"] is True
+ assert not (tmp_path / "user_personalities" / "spare").exists()
+
+
+def test_route_returns_404_for_non_deletable(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Built-in/missing deletes report a non-2xx so the UI keeps the card."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+
+ resp = _client(monkeypatch).delete("/personalities", params={"name": "mad_scientist_assistant"})
+
+ assert resp.status_code == 404
+ assert resp.json()["error"] == "not_deletable"
diff --git a/tests/test_profile_paths.py b/tests/test_profile_paths.py
new file mode 100644
index 0000000000000000000000000000000000000000..d07a0902f26c06b988401fd60d6fec9d39b8ee39
--- /dev/null
+++ b/tests/test_profile_paths.py
@@ -0,0 +1,341 @@
+import shutil
+import logging
+import zipfile
+import os
+import sys
+import subprocess
+from pathlib import Path, PurePosixPath
+
+import pytest
+
+import peachy.config as config_mod
+import peachy.prompts as prompts_mod
+import peachy.personality as headless_mod
+from peachy.config import DEFAULT_PROFILES_DIRECTORY, config
+from peachy.personality import (
+ DEFAULT_OPTION,
+ read_tools_for,
+ read_greeting_for,
+ list_personalities,
+ resolve_profile_dir,
+ read_instructions_for,
+)
+
+
+# Path characters budget computation
+# ─────────────────
+# Windows MAX_PATH limit: 259 usable characters (failures start at 260)
+#
+# Project files (WINDOWS_PATH_BUDGET = 130):
+# C:\Users\
+# \.cache\huggingface\hub
+# \spaces--pollen-robotics--peachy
+# \snapshots\\
+# = 158 characters => 101 remaining to 259.
+# The project root folder is not cloned in the snapshot, so we add it
+# back to the budget: 101 + len("peachy\") (29) = 130.
+#
+# Wheel files (WINDOWS_WHEEL_PATH_BUDGET = 71):
+# C:\Users\
+# \.cache\huggingface\hub
+# \spaces--pollen-robotics--peachy
+# \snapshots\
+# \build\bdist.win-amd64\wheel\
+# = 186 characters => 73 remaining to 259.
+# In practice the copy fails at 257 because of an intermediate \.\
+# folder, bringing the real budget down to 71.
+
+WINDOWS_PATH_BUDGET = 130
+WINDOWS_WHEEL_PATH_BUDGET = 71
+
+
+def _git_tracked_files(project_root: Path) -> list[Path]:
+ """Return git-tracked files that still exist in the working tree."""
+ try:
+ result = subprocess.run(
+ ["git", "ls-files"],
+ cwd=project_root,
+ check=True,
+ capture_output=True,
+ text=True,
+ )
+ except (OSError, subprocess.CalledProcessError) as exc:
+ pytest.skip(f"git-tracked file listing unavailable: {exc}")
+
+ tracked_files = [project_root / relative_path for relative_path in result.stdout.splitlines() if relative_path]
+ return [path for path in tracked_files if path.is_file()]
+
+
+def test_profile_name_resolves_directly_to_storage_dir() -> None:
+ """Built-in profile names should map directly to their on-disk directory."""
+ profile_dir = resolve_profile_dir("mad_scientist_assistant")
+
+ assert profile_dir.name == "mad_scientist_assistant"
+ assert (profile_dir / "instructions.txt").is_file()
+
+
+def test_prompts_load_from_compact_builtin_profile(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Prompt loading should read compact built-in profile instructions directly."""
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "mad_scientist_assistant")
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", DEFAULT_PROFILES_DIRECTORY)
+
+ expected = (
+ (DEFAULT_PROFILES_DIRECTORY / "mad_scientist_assistant" / "instructions.txt")
+ .read_text(encoding="utf-8")
+ .strip()
+ )
+
+ assert prompts_mod.get_session_instructions(instance_path=tmp_path) == expected
+ assert read_instructions_for("mad_scientist_assistant") == expected
+
+
+def test_default_session_instructions_load_from_default_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """The no-profile session prompt should come from the built-in default profile."""
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+
+ expected = (DEFAULT_PROFILES_DIRECTORY / "default" / "instructions.txt").read_text(encoding="utf-8").strip()
+
+ assert prompts_mod.get_session_instructions(instance_path=tmp_path) == expected
+ assert read_instructions_for(DEFAULT_OPTION) == expected
+
+
+def test_bracketed_prompt_line_stays_plain_text(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Bracketed prompt text should not be treated as an include."""
+ profile_dir = tmp_path / "literal_prompt"
+ profile_dir.mkdir()
+ (profile_dir / "instructions.txt").write_text("[custom_prompt]\n\nStay extra brief.\n", encoding="utf-8")
+
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "literal_prompt")
+
+ assert prompts_mod.get_session_instructions(instance_path=tmp_path) == "[custom_prompt]\n\nStay extra brief."
+
+
+def test_session_instructions_fall_back_to_default_for_incomplete_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Incomplete selected profiles should not stop session startup."""
+ profile_dir = tmp_path / "incomplete_prompt"
+ profile_dir.mkdir()
+
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "incomplete_prompt")
+
+ expected = (DEFAULT_PROFILES_DIRECTORY / "default" / "instructions.txt").read_text(encoding="utf-8").strip()
+
+ assert prompts_mod.get_session_instructions(instance_path=tmp_path) == expected
+
+
+def test_explicit_default_profile_does_not_fall_back_to_itself(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ """A broken explicit default profile should fail without a self-fallback log."""
+ default_dir = tmp_path / "default"
+ default_dir.mkdir()
+
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+ monkeypatch.setattr(prompts_mod, "DEFAULT_PROFILES_DIRECTORY", tmp_path)
+
+ with caplog.at_level(logging.WARNING, logger="peachy.prompts"):
+ with pytest.raises(RuntimeError, match="Default profile has no usable instructions.txt"):
+ prompts_mod.get_session_instructions(instance_path=tmp_path)
+
+ assert "Using default profile instructions" not in caplog.text
+
+
+def test_builtin_default_profile_tools_load_for_ui() -> None:
+ """The UI should read built-in default tools from the packaged default profile."""
+ expected = (DEFAULT_PROFILES_DIRECTORY / "default" / "tools.txt").read_text(encoding="utf-8")
+
+ assert read_tools_for(DEFAULT_OPTION) == expected
+
+
+def test_session_voice_defaults_to_hf_voice(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Session voice should fall back to the Hugging Face default voice."""
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+
+ assert prompts_mod.get_session_voice() == "Aiden"
+
+
+def test_session_greeting_prompt_loads_from_selected_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Profile greeting.txt should steer the startup greeting prompt."""
+ profile_dir = tmp_path / "friendly"
+ profile_dir.mkdir()
+ (profile_dir / "instructions.txt").write_text("test instructions\n", encoding="utf-8")
+ (profile_dir / "greeting.txt").write_text("Greet me like a tiny stage host.\n", encoding="utf-8")
+
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "friendly")
+
+ assert prompts_mod.get_session_greeting_prompt() == "Greet me like a tiny stage host."
+
+
+def test_session_greeting_prompt_uses_builtin_default_without_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """The no-profile greeting should come from the built-in constant only."""
+ default_dir = tmp_path / "default"
+ default_dir.mkdir()
+ (default_dir / "greeting.txt").write_text("Do not use this default file.\n", encoding="utf-8")
+
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", None)
+
+ assert prompts_mod.get_session_greeting_prompt() == prompts_mod.DEFAULT_GREETING_PROMPT
+
+
+def test_read_greeting_for_missing_file_returns_empty_for_ui(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """The profile editor should show only explicitly saved greeting text."""
+ profile_dir = tmp_path / "friendly"
+ profile_dir.mkdir()
+ (profile_dir / "instructions.txt").write_text("test instructions\n", encoding="utf-8")
+
+ monkeypatch.setattr(config, "PROFILES_DIRECTORY", tmp_path)
+
+ assert read_greeting_for("friendly") == ""
+
+
+def test_headless_profile_write_can_store_greeting(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """New headless profiles can persist a greeting prompt next to instructions/tools/voice."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+
+ headless_mod._write_profile(
+ "with_greeting",
+ "test instructions",
+ "",
+ greeting="Open with a quick astronomy joke.",
+ )
+
+ greeting_file = tmp_path / "user_personalities" / "with_greeting" / "greeting.txt"
+ assert greeting_file.read_text(encoding="utf-8") == "Open with a quick astronomy joke.\n"
+ assert read_greeting_for("user_personalities/with_greeting") == "Open with a quick astronomy joke."
+
+
+def test_headless_profile_write_skips_empty_greeting(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Empty custom greetings should fall back without creating greeting.txt."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+
+ headless_mod._write_profile("without_greeting", "test instructions", "", greeting="")
+
+ greeting_file = tmp_path / "user_personalities" / "without_greeting" / "greeting.txt"
+ assert not greeting_file.exists()
+
+
+def test_headless_profile_write_defaults_voice_at_call_time(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """New headless profiles should use the Hugging Face default voice."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+
+ headless_mod._write_profile("runtime_voice_default", "test instructions", "")
+
+ voice_file = tmp_path / "user_personalities" / "runtime_voice_default" / "voice.txt"
+ assert voice_file.read_text(encoding="utf-8") == "Aiden\n"
+
+
+def test_user_profile_round_trips_through_instance_dir(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """UI-created profiles persist in the writable instance dir and load back from it."""
+ monkeypatch.setattr(config, "INSTANCE_PATH", tmp_path)
+ monkeypatch.setattr(config, "REACHY_MINI_CUSTOM_PROFILE", "user_personalities/zen_master")
+
+ headless_mod._write_profile("zen_master", "Be calm.", "")
+
+ assert (tmp_path / "user_personalities" / "zen_master" / "instructions.txt").is_file()
+ assert "user_personalities/zen_master" in list_personalities()
+ assert prompts_mod.get_session_instructions(instance_path=tmp_path) == "Be calm."
+
+
+def test_packaged_profiles_win_outside_source_checkout(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ """Installed builds should use packaged profiles, not an unrelated sibling folder."""
+ unrelated_profiles = tmp_path / "profiles"
+ unrelated_profiles.mkdir()
+ packaged_profiles = tmp_path / "package_data" / "profiles"
+ packaged_profiles.mkdir(parents=True)
+
+ monkeypatch.setattr(config_mod, "PROJECT_ROOT", tmp_path)
+ monkeypatch.setattr(config_mod, "_packaged_profiles_directory", lambda: packaged_profiles)
+
+ assert config_mod._resolve_default_profiles_directory() == packaged_profiles
+
+
+def test_project_file_paths_stay_within_windows_budget() -> None:
+ """Git-tracked project file paths should stay below the agreed Windows budget."""
+ project_root = Path(__file__).parents[1].resolve()
+ project_files = _git_tracked_files(project_root)
+
+ violations = []
+ for path in project_files:
+ relative = str(Path(project_root.name) / path.relative_to(project_root))
+ length = len(relative)
+ if length > WINDOWS_PATH_BUDGET:
+ violations.append(
+ f"Windows path budget exceeded ({WINDOWS_PATH_BUDGET}): {relative} is {length} characters long"
+ )
+
+ assert not violations, "\n".join(violations)
+
+
+def test_wheel_file_paths_stay_within_windows_budget(tmp_path: Path) -> None:
+ """Built wheel paths should stay below the agreed Windows budget."""
+ project_root = Path(__file__).parents[1].resolve()
+ source_checkout = tmp_path / "checkout"
+ dist_dir = tmp_path / "dist"
+
+ for source_file in _git_tracked_files(project_root):
+ target_file = source_checkout / source_file.relative_to(project_root)
+ target_file.parent.mkdir(parents=True, exist_ok=True)
+ shutil.copy2(source_file, target_file)
+
+ try:
+ subprocess.run(
+ [sys.executable, "-m", "build", "--no-isolation", "--wheel", "--outdir", str(dist_dir)],
+ cwd=source_checkout,
+ check=True,
+ capture_output=True,
+ text=True,
+ env={**os.environ, "PIP_NO_INDEX": "1", "UV_OFFLINE": "1"},
+ )
+ except (OSError, subprocess.CalledProcessError) as exc:
+ details = exc.stderr if isinstance(exc, subprocess.CalledProcessError) and exc.stderr else str(exc)
+ pytest.fail(f"Wheel build failed while checking Windows path budget: {details}")
+
+ wheel_files = list(dist_dir.glob("*.whl"))
+ assert len(wheel_files) == 1, f"Expected exactly one built wheel in {dist_dir}, found: {wheel_files}"
+
+ with zipfile.ZipFile(wheel_files[0]) as archive:
+ archived_paths = [PurePosixPath(info.filename) for info in archive.infolist() if not info.is_dir()]
+
+ violations = []
+ for path in archived_paths:
+ length = len(path.as_posix())
+ if length > WINDOWS_WHEEL_PATH_BUDGET:
+ violations.append(
+ f"Windows wheel path budget exceeded ({WINDOWS_WHEEL_PATH_BUDGET}): "
+ f"{path.as_posix()} is {length} characters long"
+ )
+
+ assert not violations, "\n".join(violations)
diff --git a/tests/test_providers.py b/tests/test_providers.py
new file mode 100644
index 0000000000000000000000000000000000000000..dffef5aae1b45c6e9bb153630d18df786005dbac
--- /dev/null
+++ b/tests/test_providers.py
@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from unittest.mock import MagicMock
+
+import pytest
+
+from peachy.huggingface_realtime import HuggingFaceRealtimeHandler
+from peachy.openai_realtime import OpenAIRealtimeHandler
+from peachy.providers import (
+ available_provider_names,
+ get_provider_definition,
+ redact_secrets,
+ resolve_provider_name,
+)
+from peachy.tools.core_tools import ToolDependencies
+
+
+def _deps() -> ToolDependencies:
+ return ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+
+
+def test_provider_defaults_to_openai(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.delenv("PEACHY_REALTIME_PROVIDER", raising=False)
+ monkeypatch.setenv("OPENAI_API_KEY", "sk-test-default")
+ definition = get_provider_definition()
+ handler = definition.build_handler(_deps(), None, None)
+ assert resolve_provider_name() == "openai"
+ assert definition.name == "openai"
+ assert definition.readiness().state == "ready"
+ assert isinstance(handler, OpenAIRealtimeHandler)
+
+
+def test_huggingface_is_only_selected_explicitly(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "huggingface")
+ definition = get_provider_definition()
+ handler = definition.build_handler(_deps(), "/tmp/peachy-state", "Aiden")
+ assert definition.name == "huggingface"
+ assert isinstance(handler, HuggingFaceRealtimeHandler)
+
+
+def test_missing_openai_key_is_waiting_not_hf_fallback(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "openai")
+ monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+ definition = get_provider_definition()
+ readiness = definition.readiness()
+ assert definition.name == "openai"
+ assert readiness.state == "waiting_for_config"
+ assert "OPENAI_API_KEY" in (readiness.message or "")
+
+
+def test_invalid_provider_is_visible_configuration_error(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("PEACHY_REALTIME_PROVIDER", "mystery")
+ definition = get_provider_definition()
+ readiness = definition.readiness()
+ assert definition.name == "mystery"
+ assert readiness.state == "configuration_error"
+ assert "mystery" in (readiness.message or "")
+ assert type(definition.build_handler(_deps(), None, None)).__name__ == "UnavailableConversationHandler"
+
+
+def test_status_is_redacted(monkeypatch: pytest.MonkeyPatch) -> None:
+ secret = "sk-test-never-return-this"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ status = get_provider_definition("openai").redacted_status()
+ assert status["has_openai_api_key"] is True
+ assert status["openai_model"] == "gpt-realtime"
+ assert secret not in repr(status)
+ assert available_provider_names() == ("openai", "huggingface")
+
+
+def test_redact_secrets_removes_configured_provider_credentials(monkeypatch: pytest.MonkeyPatch) -> None:
+ openai_secret = "sk-test-provider-redaction"
+ hf_secret = "hf_test_provider_redaction"
+ monkeypatch.setenv("OPENAI_API_KEY", openai_secret)
+ monkeypatch.setenv("HF_TOKEN", hf_secret)
+
+ rendered = redact_secrets(f"OpenAI={openai_secret}; Hugging Face={hf_secret}")
+
+ assert openai_secret not in rendered
+ assert hf_secret not in rendered
+ assert rendered.count("[redacted]") == 2
+
+
+def test_openai_status_redacts_secret_embedded_in_model(monkeypatch: pytest.MonkeyPatch) -> None:
+ secret = "sk-test-model-status-redaction"
+ monkeypatch.setenv("OPENAI_API_KEY", secret)
+ monkeypatch.setenv("OPENAI_REALTIME_MODEL", "model-" + secret)
+
+ status = get_provider_definition("openai").redacted_status()
+
+ assert secret not in repr(status)
+ assert status["openai_model"] == "model-[redacted]"
diff --git a/tests/test_shared_apps_venv.py b/tests/test_shared_apps_venv.py
new file mode 100644
index 0000000000000000000000000000000000000000..dfdba1452cfa9e9840eae5dd762d7ec057a39e46
--- /dev/null
+++ b/tests/test_shared_apps_venv.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+from pathlib import Path
+
+from _package_build import build_wheel_from_sdist, offline_env
+
+
+PROJECT_ROOT = Path(__file__).parents[1]
+
+
+def test_offline_shared_apps_venv_install_keeps_sdk_and_loads_wheel(tmp_path: Path) -> None:
+ uv = shutil.which("uv")
+ assert uv is not None, "uv is required by the documented app install workflow"
+ wheel = build_wheel_from_sdist(tmp_path, project_root=PROJECT_ROOT)
+ shared = tmp_path / "apps_venv"
+ env = offline_env()
+ subprocess.run([uv, "venv", "--python", sys.executable, str(shared)], check=True, cwd=tmp_path, env=env)
+ python = shared / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+ subprocess.run(
+ [uv, "pip", "install", "--offline", "--python", str(python), str(wheel)],
+ check=True,
+ cwd=tmp_path,
+ env=env,
+ )
+ state_root = tmp_path / "state"
+ probe = textwrap.dedent(
+ f"""
+ import importlib.metadata as metadata
+ import stat
+ from importlib.resources import files
+ from pathlib import Path
+
+ import numpy as np
+
+ from peachy.audio.resampling import pcm16_at_rate, resample_audio
+ from peachy.state import resolve_state_root
+
+ assert metadata.version("reachy-mini") == "1.9.0"
+ requirements = "\\n".join(metadata.requires("peachy") or []).lower()
+ assert "reachy-mini==1.9.0" in requirements.replace(" ", "")
+ assert "mujoco" not in requirements
+ entry = next(
+ item for item in metadata.entry_points(group="reachy_mini_apps")
+ if item.name == "peachy"
+ )
+ assert entry.value == "peachy.main:Peachy"
+ assert entry.load().__name__ == "Peachy"
+ package = files("peachy")
+ assert package.joinpath("profiles/peachy/instructions.txt").is_file()
+ assert package.joinpath("profiles/default/instructions.txt").is_file()
+ assert package.joinpath("static/index.html").is_file()
+ assert pcm16_at_rate(np.ones(160, dtype=np.float32), 16_000, 24_000).shape == (240,)
+ assert resample_audio(np.ones(160, dtype=np.int16), 16_000, 48_000).shape == (480,)
+ root = resolve_state_root(environ={{"PEACHY_STATE_DIR": {str(state_root)!r}}})
+ assert stat.S_IMODE(root.stat().st_mode) == 0o700
+ package_path = Path(str(package)).resolve()
+ assert root.resolve() != package_path
+ assert package_path not in root.resolve().parents
+ """
+ )
+ subprocess.run([str(python), "-I", "-c", probe], check=True, cwd=tmp_path, env=env)
diff --git a/tests/test_startup_settings.py b/tests/test_startup_settings.py
new file mode 100644
index 0000000000000000000000000000000000000000..4f0496e82ff52236060d8b33a3c35be007914157
--- /dev/null
+++ b/tests/test_startup_settings.py
@@ -0,0 +1,80 @@
+"""Tests for persisted instance-local startup settings."""
+
+from peachy.startup_settings import (
+ StartupSettings,
+ read_startup_settings,
+ write_startup_settings,
+ load_startup_settings_into_runtime,
+)
+
+
+def test_write_and_read_startup_settings(tmp_path) -> None:
+ """Startup settings should round-trip through startup_settings.json."""
+ write_startup_settings(tmp_path, profile="sorry_bro", voice="shimmer")
+
+ assert read_startup_settings(tmp_path) == StartupSettings(profile="sorry_bro", voice="shimmer")
+
+
+def test_load_startup_settings_into_runtime_applies_profile_when_no_env(monkeypatch, tmp_path) -> None:
+ """Startup settings should seed the runtime profile when no explicit env override exists."""
+ write_startup_settings(tmp_path, profile="sorry_bro", voice="shimmer")
+ applied_profiles: list[str | None] = []
+ monkeypatch.delenv("REACHY_MINI_CUSTOM_PROFILE", raising=False)
+ monkeypatch.setattr(
+ "peachy.config.set_custom_profile",
+ lambda profile: applied_profiles.append(profile),
+ )
+
+ settings = load_startup_settings_into_runtime(tmp_path)
+
+ assert settings == StartupSettings(profile="sorry_bro", voice="shimmer")
+ assert applied_profiles == ["sorry_bro"]
+
+
+def test_load_startup_settings_into_runtime_saved_settings_override_instance_env(monkeypatch, tmp_path) -> None:
+ """Saved startup settings should override an instance-local profile env value."""
+ write_startup_settings(tmp_path, profile="sorry_bro", voice="shimmer")
+ applied_profiles: list[str | None] = []
+ monkeypatch.setenv("REACHY_MINI_CUSTOM_PROFILE", "env_profile")
+ monkeypatch.setattr(
+ "peachy.config.set_custom_profile",
+ lambda profile: applied_profiles.append(profile),
+ )
+
+ settings = load_startup_settings_into_runtime(tmp_path)
+
+ assert settings == StartupSettings(profile="sorry_bro", voice="shimmer")
+ assert applied_profiles == ["sorry_bro"]
+
+
+def test_load_startup_settings_into_runtime_saved_settings_override_inherited_env(monkeypatch, tmp_path) -> None:
+ """Saved startup settings should override a profile inherited from another `.env`."""
+ write_startup_settings(tmp_path, profile="nature_documentarian", voice="cedar")
+ applied_profiles: list[str | None] = []
+ monkeypatch.setenv("REACHY_MINI_CUSTOM_PROFILE", "env_profile")
+ monkeypatch.setattr(
+ "peachy.config.set_custom_profile",
+ lambda profile: applied_profiles.append(profile),
+ )
+
+ settings = load_startup_settings_into_runtime(tmp_path)
+
+ assert settings == StartupSettings(profile="nature_documentarian", voice="cedar")
+ assert applied_profiles == ["nature_documentarian"]
+
+
+def test_load_startup_settings_into_runtime_preserves_inherited_env_without_saved_settings(
+ monkeypatch, tmp_path
+) -> None:
+ """Inherited env config should still apply when no startup settings have been saved."""
+ applied_profiles: list[str | None] = []
+ monkeypatch.setenv("REACHY_MINI_CUSTOM_PROFILE", "env_profile")
+ monkeypatch.setattr(
+ "peachy.config.set_custom_profile",
+ lambda profile: applied_profiles.append(profile),
+ )
+
+ settings = load_startup_settings_into_runtime(tmp_path)
+
+ assert settings == StartupSettings()
+ assert applied_profiles == []
diff --git a/tests/test_state_root.py b/tests/test_state_root.py
new file mode 100644
index 0000000000000000000000000000000000000000..2723e23dac14f1f09a05c91ee958627f9c7f7c91
--- /dev/null
+++ b/tests/test_state_root.py
@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+import asyncio
+import stat
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+
+import pytest
+
+from peachy.console import LocalStream
+from peachy.state import resolve_state_root
+
+
+def _mode(path: Path) -> int:
+ return stat.S_IMODE(path.stat().st_mode)
+
+
+def test_state_root_precedence_and_permissions(tmp_path: Path) -> None:
+ explicit = tmp_path / "explicit"
+ xdg = tmp_path / "xdg"
+ home = tmp_path / "home"
+ result = resolve_state_root(
+ environ={"PEACHY_STATE_DIR": str(explicit), "XDG_STATE_HOME": str(xdg)},
+ home=home,
+ )
+ assert result == explicit
+ assert _mode(result) == 0o700
+
+
+def test_state_root_uses_xdg_then_home(tmp_path: Path) -> None:
+ xdg = tmp_path / "xdg"
+ home = tmp_path / "home"
+ assert resolve_state_root(environ={"XDG_STATE_HOME": str(xdg)}, home=home) == xdg / "peachy"
+ assert resolve_state_root(environ={}, home=home) == home / ".local" / "state" / "peachy"
+
+
+@pytest.mark.parametrize(
+ "environ",
+ [
+ {"PEACHY_STATE_DIR": "relative/path"},
+ {"XDG_STATE_HOME": "relative/path"},
+ ],
+)
+def test_state_root_rejects_relative_overrides(environ: dict[str, str], tmp_path: Path) -> None:
+ with pytest.raises(ValueError, match="absolute"):
+ resolve_state_root(environ=environ, home=tmp_path)
+
+
+def test_persisted_env_is_owner_only(tmp_path: Path) -> None:
+ handler = MagicMock()
+ handler.output_queue = asyncio.Queue()
+ handler.last_activity_time = 0.0
+ robot = SimpleNamespace(media=SimpleNamespace(audio=None, backend=None))
+ stream = LocalStream(handler, robot, instance_path=str(tmp_path))
+
+ stream._persist_env_values({"OPENAI_API_KEY": "sk-test-file-mode"})
+
+ assert _mode(tmp_path / ".env") == 0o600
diff --git a/tests/test_streaming.py b/tests/test_streaming.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b10d5cbe261979c32bb1e39f4c9fd22ec179d6b
--- /dev/null
+++ b/tests/test_streaming.py
@@ -0,0 +1,56 @@
+import asyncio
+
+import numpy as np
+import pytest
+
+from peachy.streaming import (
+ AdditionalOutputs,
+ wait_for_item,
+ audio_to_int16,
+ audio_to_float32,
+)
+from peachy.audio.resampling import pcm16_at_rate
+
+
+def test_additional_outputs_stores_messages() -> None:
+ """Additional outputs should keep the emitted role/content payloads."""
+ message = {"role": "assistant", "content": "hello"}
+
+ outputs = AdditionalOutputs(message)
+
+ assert outputs.args == (message,)
+
+
+@pytest.mark.asyncio
+async def test_wait_for_item_returns_none_on_timeout() -> None:
+ """Queue waits should time out without raising."""
+ queue: asyncio.Queue[int] = asyncio.Queue()
+
+ assert await wait_for_item(queue, timeout=0.01) is None
+
+
+def test_audio_to_int16_scales_float32() -> None:
+ """Float audio should scale into the int16 sample range."""
+ audio = np.array([-1.0, 0.0, 1.0], dtype=np.float32)
+
+ np.testing.assert_array_equal(audio_to_int16(audio), np.array([-32767, 0, 32767], dtype=np.int16))
+
+
+def test_audio_to_float32_scales_int16() -> None:
+ """Int16 audio should scale into the float sample range."""
+ audio = np.array([-32768, 0, 32767], dtype=np.int16)
+
+ np.testing.assert_allclose(audio_to_float32(audio), np.array([-1.0, 0.0, 32767 / 32768], dtype=np.float32))
+
+
+def test_audio_converters_reject_unsupported_dtype() -> None:
+ """Unsupported audio dtypes should fail explicitly."""
+ audio = np.array([1.0], dtype=np.float64)
+
+ with pytest.raises(TypeError, match="Unsupported audio data type"):
+ audio_to_int16(audio)
+
+
+def test_pcm_boundary_clips_float_audio() -> None:
+ source = np.array([-1.5, 1.5], dtype=np.float32)
+ assert pcm16_at_rate(source, 24_000, 24_000).tolist() == [-32767, 32767]
diff --git a/tests/test_tool_space_runtime.py b/tests/test_tool_space_runtime.py
new file mode 100644
index 0000000000000000000000000000000000000000..19a7666aefd85f9b4adff98dd3e911e937ebb1db
--- /dev/null
+++ b/tests/test_tool_space_runtime.py
@@ -0,0 +1,272 @@
+from __future__ import annotations
+import sys
+import json
+import importlib
+from types import ModuleType
+from pathlib import Path
+from unittest.mock import AsyncMock
+
+import pytest
+
+import peachy.config as config_mod
+import peachy.tool_spaces as tool_spaces_mod
+from peachy.mcp_client import McpToolTimeoutError, McpToolInvocationError
+from peachy.tool_spaces import (
+ InstalledToolSpace,
+ InstalledToolSpaceTool,
+ InstalledToolSpacesManifest,
+ write_installed_tool_spaces,
+)
+
+
+SEARCH_SPACE_SLUG = "example/search-tool"
+SEARCH_ALIAS = "example_search_tool"
+SEARCH_TOOL_ID = f"{SEARCH_ALIAS}__search_web"
+SEARCH_CLIENT_TOOL_ID = f"{SEARCH_ALIAS}__search_tool_search_web"
+SEARCH_MCP_URL = "https://example-search-tool.hf.space/gradio_api/mcp/"
+
+
+@pytest.fixture(autouse=True)
+def _isolate_peachy_state(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("PEACHY_STATE_DIR", str((tmp_path / "peachy-state").resolve()))
+
+
+def _reload_core_tools() -> ModuleType:
+ for module_name in list(sys.modules):
+ if module_name.startswith("peachy.tools."):
+ sys.modules.pop(module_name, None)
+
+ sys.modules.pop("peachy.tools.core_tools", None)
+ return importlib.import_module("peachy.tools.core_tools")
+
+
+def _installed_search_space() -> InstalledToolSpace:
+ return InstalledToolSpace(
+ slug=SEARCH_SPACE_SLUG,
+ alias=SEARCH_ALIAS,
+ mcp_url=SEARCH_MCP_URL,
+ private=False,
+ tools=[
+ InstalledToolSpaceTool(
+ local_name=SEARCH_TOOL_ID,
+ client_tool_name=SEARCH_CLIENT_TOOL_ID,
+ remote_name="search_tool_search_web",
+ description="Search the web",
+ parameters_schema={
+ "type": "object",
+ "properties": {"query": {"type": "string"}},
+ "required": ["query"],
+ },
+ )
+ ],
+ )
+
+
+@pytest.mark.asyncio
+async def test_initialize_tools_loads_enabled_installed_remote_tools_and_dispatches(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Enabled public Space tools should join the registry and dispatch through the normal path."""
+ monkeypatch.chdir(tmp_path)
+ external_profiles_root = tmp_path / "external_profiles"
+ profile_dir = external_profiles_root / "mcp_profile"
+ profile_dir.mkdir(parents=True)
+ (profile_dir / "instructions.txt").write_text("hello\n", encoding="utf-8")
+ (profile_dir / "tools.txt").write_text(f"{SEARCH_TOOL_ID}\n", encoding="utf-8")
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "mcp_profile")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles_root)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ client = AsyncMock()
+ client.call_tool.return_value = {
+ "status": "ok",
+ "server_alias": SEARCH_ALIAS,
+ "remote_tool_name": "reachy_mini_search_tool_search_web",
+ "namespaced_tool_name": SEARCH_CLIENT_TOOL_ID,
+ "content_blocks": [],
+ "text": "hello",
+ }
+ captured_cached_tools: list[InstalledToolSpaceTool] | None = None
+
+ def _build_remote_client(
+ alias: str,
+ mcp_url: str,
+ *,
+ private: bool,
+ cached_tools: list[InstalledToolSpaceTool],
+ ) -> AsyncMock:
+ nonlocal captured_cached_tools
+ assert alias == SEARCH_ALIAS
+ assert mcp_url == SEARCH_MCP_URL
+ assert private is False
+ captured_cached_tools = cached_tools
+ return client
+
+ monkeypatch.setattr(tool_spaces_mod, "build_remote_client", _build_remote_client)
+
+ write_installed_tool_spaces(
+ None,
+ InstalledToolSpacesManifest(spaces=[_installed_search_space()]),
+ )
+
+ core_tools_mod = _reload_core_tools()
+ core_tools_mod.initialize_tools()
+
+ assert SEARCH_TOOL_ID in core_tools_mod.ALL_TOOLS
+ assert captured_cached_tools == _installed_search_space().tools
+ tool_specs = core_tools_mod.get_tool_specs()
+ assert any(spec["name"] == SEARCH_TOOL_ID for spec in tool_specs)
+
+ result = await core_tools_mod.dispatch_tool_call(
+ SEARCH_TOOL_ID,
+ json.dumps({"query": "hello"}),
+ core_tools_mod.ToolDependencies(
+ reachy_mini=object(),
+ movement_manager=object(),
+ ),
+ )
+
+ assert result["namespaced_tool_name"] == SEARCH_TOOL_ID
+ assert result["tool_space_slug"] == SEARCH_SPACE_SLUG
+ client.call_tool.assert_awaited_once_with(SEARCH_CLIENT_TOOL_ID, {"query": "hello"})
+
+
+def test_initialize_tools_warns_when_enabled_tool_missing_from_manifest(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ """A tool enabled in the profile but absent from the cached manifest is skipped with a warning."""
+ monkeypatch.chdir(tmp_path)
+ external_profiles_root = tmp_path / "external_profiles"
+ profile_dir = external_profiles_root / "remote_profile"
+ profile_dir.mkdir(parents=True)
+ (profile_dir / "instructions.txt").write_text("hello\n", encoding="utf-8")
+ (profile_dir / "tools.txt").write_text(f"{SEARCH_TOOL_ID}\n", encoding="utf-8")
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "remote_profile")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles_root)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ write_installed_tool_spaces(
+ None,
+ InstalledToolSpacesManifest(
+ spaces=[
+ InstalledToolSpace(
+ slug=SEARCH_SPACE_SLUG,
+ alias=SEARCH_ALIAS,
+ mcp_url=SEARCH_MCP_URL,
+ private=False,
+ ),
+ ]
+ ),
+ )
+
+ core_tools_mod = _reload_core_tools()
+ with caplog.at_level("WARNING"):
+ core_tools_mod.initialize_tools()
+
+ assert any(SEARCH_SPACE_SLUG in record.message for record in caplog.records)
+ assert SEARCH_TOOL_ID not in core_tools_mod.ALL_TOOLS
+
+
+def test_initialize_tools_inherits_default_tools_txt_for_profile_without_local_tool_list(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Profiles without a local tools.txt should inherit the built-in default tool set."""
+ external_profiles_root = tmp_path / "external_profiles"
+ profile_dir = external_profiles_root / "inherit_default"
+ profile_dir.mkdir(parents=True)
+ (profile_dir / "instructions.txt").write_text("hello\n", encoding="utf-8")
+
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "inherit_default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles_root)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+ core_tools_mod = _reload_core_tools()
+ core_tools_mod.initialize_tools()
+
+ assert "dance" in core_tools_mod.ALL_TOOLS
+
+
+def _mcp_profile(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ external_profiles_root = tmp_path / "external_profiles"
+ profile_dir = external_profiles_root / "mcp_profile"
+ profile_dir.mkdir(parents=True)
+ (profile_dir / "instructions.txt").write_text("hello\n", encoding="utf-8")
+ (profile_dir / "tools.txt").write_text(f"{SEARCH_TOOL_ID}\n", encoding="utf-8")
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "mcp_profile")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles_root)
+ monkeypatch.setattr(config_mod.config, "TOOLS_DIRECTORY", None)
+ monkeypatch.setattr(config_mod.config, "AUTOLOAD_EXTERNAL_TOOLS", False)
+
+
+@pytest.mark.asyncio
+async def test_remote_tool_retries_once_after_transport_failure(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Transient remote transport failures should get one fast retry."""
+ monkeypatch.chdir(tmp_path)
+ _mcp_profile(tmp_path, monkeypatch)
+
+ client = AsyncMock()
+ client.call_tool.side_effect = [
+ McpToolInvocationError("connection reset"),
+ {
+ "status": "ok",
+ "server_alias": SEARCH_ALIAS,
+ "remote_tool_name": "reachy_mini_search_tool_search_web",
+ "namespaced_tool_name": SEARCH_CLIENT_TOOL_ID,
+ "content_blocks": [],
+ "text": "hello",
+ },
+ ]
+ monkeypatch.setattr(tool_spaces_mod, "build_remote_client", lambda *a, **k: client)
+ write_installed_tool_spaces(None, InstalledToolSpacesManifest(spaces=[_installed_search_space()]))
+
+ core_tools_mod = _reload_core_tools()
+ monkeypatch.setattr(core_tools_mod, "_REMOTE_TOOL_RETRY_DELAY_S", 0.0)
+ core_tools_mod.initialize_tools()
+
+ result = await core_tools_mod.dispatch_tool_call(
+ SEARCH_TOOL_ID,
+ json.dumps({"query": "hello"}),
+ core_tools_mod.ToolDependencies(reachy_mini=object(), movement_manager=object()),
+ )
+
+ assert result["status"] == "ok"
+ assert client.call_tool.await_count == 2
+
+
+@pytest.mark.asyncio
+async def test_remote_tool_does_not_retry_timeout(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Remote timeouts should fail once instead of doubling the user wait."""
+ monkeypatch.chdir(tmp_path)
+ _mcp_profile(tmp_path, monkeypatch)
+
+ client = AsyncMock()
+ client.call_tool.side_effect = McpToolTimeoutError("slow tool")
+ monkeypatch.setattr(tool_spaces_mod, "build_remote_client", lambda *a, **k: client)
+ write_installed_tool_spaces(None, InstalledToolSpacesManifest(spaces=[_installed_search_space()]))
+
+ core_tools_mod = _reload_core_tools()
+ core_tools_mod.initialize_tools()
+
+ result = await core_tools_mod.dispatch_tool_call(
+ SEARCH_TOOL_ID,
+ json.dumps({"query": "hello"}),
+ core_tools_mod.ToolDependencies(reachy_mini=object(), movement_manager=object()),
+ )
+
+ assert "error" in result
+ assert client.call_tool.await_count == 1
diff --git a/tests/test_tool_spaces.py b/tests/test_tool_spaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..a218f4f75586c2809da27e474520efdcf68f1d8d
--- /dev/null
+++ b/tests/test_tool_spaces.py
@@ -0,0 +1,513 @@
+from __future__ import annotations
+import os
+import sys
+import json
+from types import SimpleNamespace
+from pathlib import Path
+from argparse import Namespace
+
+import httpx
+import pytest
+from huggingface_hub.errors import RepositoryNotFoundError
+
+import peachy.config as config_mod
+import peachy.tool_spaces as tool_spaces_mod
+from peachy.main import main
+from peachy.mcp_client import RemoteToolSpec
+from peachy.tool_spaces import (
+ resolve_tool_space_sync,
+ handle_tool_spaces_command,
+ read_installed_tool_spaces,
+)
+
+
+SEARCH_SPACE_SLUG = "example/search-tool"
+COLLIDING_SEARCH_SPACE_SLUG = "example/search_tool"
+PRIVATE_SPACE_SLUG = "example/private-space"
+SEARCH_ALIAS = "example_search_tool"
+SEARCH_REMOTE_NAME = "search_tool_search_web"
+SEARCH_TOOL_ID = f"{SEARCH_ALIAS}__search_web"
+SEARCH_CLIENT_TOOL_ID = f"{SEARCH_ALIAS}__{SEARCH_REMOTE_NAME}"
+
+
+@pytest.fixture(autouse=True)
+def _isolate_peachy_state(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setenv("PEACHY_STATE_DIR", str((tmp_path / "peachy-state").resolve()))
+
+
+def _test_state_root() -> Path:
+ return Path(os.environ["PEACHY_STATE_DIR"])
+
+
+def _mock_public_space_info(slug: str) -> SimpleNamespace:
+ return SimpleNamespace(
+ id=slug,
+ private=False,
+ disabled=False,
+ sdk="gradio",
+ host=None,
+ subdomain=slug.replace("/", "-"),
+ tags=["reachy-mini-tool", "mcp"],
+ )
+
+
+def _mock_private_space_info(slug: str) -> SimpleNamespace:
+ info = _mock_public_space_info(slug)
+ info.private = True
+ return info
+
+
+async def _mock_list_tool_specs(self: object) -> list[RemoteToolSpec]:
+ return [
+ RemoteToolSpec(
+ server_alias=SEARCH_ALIAS,
+ remote_name=SEARCH_REMOTE_NAME,
+ namespaced_name=SEARCH_CLIENT_TOOL_ID,
+ description="Search the web",
+ parameters_schema={
+ "type": "object",
+ "properties": {"query": {"type": "string"}},
+ "required": ["query"],
+ },
+ )
+ ]
+
+
+def _run_cli(monkeypatch: pytest.MonkeyPatch, argv: list[str]) -> int:
+ monkeypatch.setattr(sys, "argv", argv)
+ with pytest.raises(SystemExit) as exc:
+ main()
+ return int(exc.value.code)
+
+
+def test_tool_spaces_add_list_remove_round_trip(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """The CLI should install, list, and remove a public Space tool source cleanly."""
+ monkeypatch.chdir(tmp_path)
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_public_space_info(slug),
+ )
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ assert (
+ _run_cli(
+ monkeypatch,
+ [
+ "reachy-mini-conversation-app",
+ "tool-spaces",
+ "add",
+ SEARCH_SPACE_SLUG,
+ "--install-only",
+ ],
+ )
+ == 0
+ )
+
+ manifest_path = _test_state_root() / "installed_tool_spaces.json"
+ assert manifest_path.is_file()
+ written = json.loads(manifest_path.read_text(encoding="utf-8"))
+ assert written["version"] == 2
+ added_entry = next(space for space in written["spaces"] if space["slug"] == SEARCH_SPACE_SLUG)
+ assert added_entry == {
+ "slug": SEARCH_SPACE_SLUG,
+ "alias": SEARCH_ALIAS,
+ "mcp_url": "https://example-search-tool.hf.space/gradio_api/mcp/",
+ "private": False,
+ "tools": [
+ {
+ "local_name": SEARCH_TOOL_ID,
+ "client_tool_name": SEARCH_CLIENT_TOOL_ID,
+ "remote_name": SEARCH_REMOTE_NAME,
+ "description": "Search the web",
+ "parameters_schema": {
+ "type": "object",
+ "properties": {"query": {"type": "string"}},
+ "required": ["query"],
+ },
+ }
+ ],
+ }
+
+ assert _run_cli(monkeypatch, ["reachy-mini-conversation-app", "tool-spaces", "list"]) == 0
+
+ assert _run_cli(monkeypatch, ["reachy-mini-conversation-app", "tool-spaces", "remove", SEARCH_SPACE_SLUG]) == 0
+ assert SEARCH_SPACE_SLUG not in [space.slug for space in read_installed_tool_spaces(_test_state_root()).spaces]
+
+
+def test_tool_spaces_add_installs_private_space_with_token(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A private Space resolves and installs when an HF token is available."""
+ monkeypatch.chdir(tmp_path)
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_private_space_info(slug),
+ )
+ monkeypatch.setattr("peachy.tool_spaces.get_token", lambda: "hf_test_token")
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "add", PRIVATE_SPACE_SLUG, "--install-only"]) == 0
+ assert PRIVATE_SPACE_SLUG in [space.slug for space in read_installed_tool_spaces(_test_state_root()).spaces]
+
+
+def test_resolve_tool_space_attaches_auth_header_for_private_space(monkeypatch: pytest.MonkeyPatch) -> None:
+ """A private Space's MCP client must carry the HF bearer token from the hf-login fallback."""
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_private_space_info(slug),
+ )
+ monkeypatch.setattr(config_mod.config, "HF_TOKEN", None)
+ monkeypatch.setattr("peachy.tool_spaces.get_token", lambda: "hf_test_token")
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ resolved = resolve_tool_space_sync(PRIVATE_SPACE_SLUG)
+ assert resolved.client.server.headers["Authorization"] == "Bearer hf_test_token"
+
+
+def test_resolve_tool_space_prefers_app_config_hf_token(monkeypatch: pytest.MonkeyPatch) -> None:
+ """The token must come from the app config (loaded from .env), not only from get_token()."""
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_private_space_info(slug),
+ )
+ monkeypatch.setattr(config_mod.config, "HF_TOKEN", "hf_env_token")
+ monkeypatch.setattr("peachy.tool_spaces.get_token", lambda: None)
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ resolved = resolve_tool_space_sync(PRIVATE_SPACE_SLUG)
+ assert resolved.client.server.headers["Authorization"] == "Bearer hf_env_token"
+
+
+def test_resolve_tool_space_omits_auth_header_for_public_space(monkeypatch: pytest.MonkeyPatch) -> None:
+ """A public Space must never receive the HF token, even when one is set."""
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_public_space_info(slug),
+ )
+ monkeypatch.setattr(config_mod.config, "HF_TOKEN", None)
+ monkeypatch.setattr("peachy.tool_spaces.get_token", lambda: "hf_test_token")
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ resolved = resolve_tool_space_sync(SEARCH_SPACE_SLUG)
+ assert "Authorization" not in resolved.client.server.headers
+
+
+def test_tool_spaces_add_private_space_without_token_hints_at_auth(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+ capsys: pytest.CaptureFixture[str],
+) -> None:
+ """Without a token, adding a private Space fails cleanly and points at HF auth."""
+ monkeypatch.chdir(tmp_path)
+
+ def _raise_not_found(self: object, slug: str, **kwargs: object) -> SimpleNamespace:
+ raise RepositoryNotFoundError(
+ "404 Client Error", response=httpx.Response(404, request=httpx.Request("GET", "https://hf.co"))
+ )
+
+ monkeypatch.setattr("peachy.tool_spaces.HfApi.space_info", _raise_not_found)
+ monkeypatch.setattr(config_mod.config, "HF_TOKEN", None)
+ monkeypatch.setattr("peachy.tool_spaces.get_token", lambda: None)
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "add", PRIVATE_SPACE_SLUG]) == 1
+ assert "hf auth login" in capsys.readouterr().err
+ assert not (_test_state_root() / "installed_tool_spaces.json").exists()
+
+
+def test_tool_spaces_manifest_uses_instance_path_when_provided(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Managed instance paths should store the manifest beside other instance-local state."""
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_public_space_info(slug),
+ )
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ args = Namespace(
+ tool_spaces_command="add",
+ space_slug=SEARCH_SPACE_SLUG,
+ install_only=True,
+ profile=None,
+ )
+ assert handle_tool_spaces_command(args, instance_path=tmp_path) == 0
+ assert (tmp_path / "installed_tool_spaces.json").is_file()
+ assert not (tmp_path / "external_content" / "installed_tool_spaces.json").exists()
+
+
+def test_read_installed_tool_spaces_raises_on_alias_collision_in_manifest(tmp_path: Path) -> None:
+ """A manifest with two slugs that normalize to the same alias must be rejected on read."""
+ mcp_url = "https://example.hf.space/gradio_api/mcp/"
+ payload = {
+ "version": 2,
+ "spaces": [
+ {"slug": "owner/my-tool", "alias": "owner_my_tool", "mcp_url": mcp_url, "private": False, "tools": []},
+ {"slug": "owner/my_tool", "alias": "owner_my_tool", "mcp_url": mcp_url, "private": False, "tools": []},
+ ],
+ }
+ (tmp_path / "installed_tool_spaces.json").write_text(json.dumps(payload), encoding="utf-8")
+
+ with pytest.raises(RuntimeError, match="alias collision"):
+ read_installed_tool_spaces(tmp_path)
+
+
+def test_tool_spaces_add_rejects_alias_collision(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """A second Space whose slug normalizes to the same alias must be rejected."""
+ monkeypatch.chdir(tmp_path)
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_public_space_info(slug),
+ )
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+ assert (
+ _run_cli(
+ monkeypatch,
+ ["app", "tool-spaces", "add", SEARCH_SPACE_SLUG, "--install-only"],
+ )
+ == 0
+ )
+
+ # The owner separator style differs, but both slugs normalize to the same alias.
+ assert (
+ _run_cli(
+ monkeypatch,
+ ["app", "tool-spaces", "add", COLLIDING_SEARCH_SPACE_SLUG, "--install-only"],
+ )
+ == 1
+ )
+
+
+def _setup_profile(tmp_path: Path, profile: str, existing_tools: list[str] | None = None) -> Path:
+ """Create a profile directory with an optional tools.txt."""
+ profile_dir = tmp_path / profile
+ profile_dir.mkdir(parents=True)
+ tools_txt = profile_dir / "tools.txt"
+ tools_txt.write_text("\n".join(existing_tools or []) + "\n" if existing_tools else "", encoding="utf-8")
+ return tools_txt
+
+
+def _mock_add(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+ monkeypatch.chdir(tmp_path)
+ monkeypatch.setattr(
+ "peachy.tool_spaces.HfApi.space_info",
+ lambda self, slug, **kwargs: _mock_public_space_info(slug),
+ )
+ monkeypatch.setattr(
+ "peachy.tool_spaces.RemoteMcpToolClient.list_tool_specs",
+ _mock_list_tool_specs,
+ )
+
+
+def test_tool_spaces_add_enables_in_active_profile_by_default(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Add without flags should enable tools in the active profile."""
+ _mock_add(monkeypatch, tmp_path)
+ tools_txt = _setup_profile(tmp_path, "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", None)
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "add", SEARCH_SPACE_SLUG]) == 0
+
+ assert SEARCH_TOOL_ID in tools_txt.read_text(encoding="utf-8")
+
+
+def test_tool_spaces_remove_disables_tools_in_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """Removing a Space strips its tool IDs from the profile they were enabled in."""
+ _mock_add(monkeypatch, tmp_path)
+ tools_txt = _setup_profile(_test_state_root() / "user_personalities", "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "user_personalities/default")
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "add", SEARCH_SPACE_SLUG]) == 0
+ assert SEARCH_TOOL_ID in tools_txt.read_text(encoding="utf-8")
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "remove", SEARCH_SPACE_SLUG]) == 0
+ assert SEARCH_TOOL_ID not in tools_txt.read_text(encoding="utf-8")
+ assert SEARCH_SPACE_SLUG not in [space.slug for space in read_installed_tool_spaces(_test_state_root()).spaces]
+
+
+def test_tool_spaces_add_install_only_skips_tools_txt(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """--install-only should not modify any profile's tools.txt."""
+ _mock_add(monkeypatch, tmp_path)
+ tools_txt = _setup_profile(tmp_path, "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", tmp_path)
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "add", SEARCH_SPACE_SLUG, "--install-only"]) == 0
+
+ assert tools_txt.read_text(encoding="utf-8") == ""
+
+
+def test_tool_spaces_add_profile_flag_enables_in_specified_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """--profile should enable tools in the named profile, not the active one."""
+ _mock_add(monkeypatch, tmp_path)
+ default_tools_txt = _setup_profile(tmp_path, "default")
+ canary_tools_txt = _setup_profile(tmp_path, "canary")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", tmp_path)
+ monkeypatch.setattr(config_mod.config, "REACHY_MINI_CUSTOM_PROFILE", "default")
+
+ assert _run_cli(monkeypatch, ["app", "tool-spaces", "add", SEARCH_SPACE_SLUG, "--profile", "canary"]) == 0
+
+ assert SEARCH_TOOL_ID in canary_tools_txt.read_text(encoding="utf-8")
+ assert default_tools_txt.read_text(encoding="utf-8") == ""
+
+
+def test_read_installed_tool_spaces_seeds_bundled_pollen_spaces(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ """With no manifest, the three bundled Pollen Spaces are seeded with their tools cached offline."""
+ monkeypatch.chdir(tmp_path)
+
+ spaces = read_installed_tool_spaces(_test_state_root()).spaces
+ assert [space.slug for space in spaces] == [
+ "pollen-robotics/reachy-mini-search-tool",
+ "pollen-robotics/reachy-mini-time-tool",
+ "pollen-robotics/reachy-mini-weather-tool",
+ ]
+ search_tool = spaces[0].tools[0]
+ assert search_tool.local_name == "pollen_robotics_reachy_mini_search_tool__search_web"
+ assert search_tool.remote_name == "reachy_mini_search_tool_search_web"
+ assert spaces[0].private is False
+
+
+def test_builtin_profile_cannot_be_mutated(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ builtin = tmp_path / "package-profiles"
+ tools_txt = _setup_profile(builtin, "default")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", builtin)
+ monkeypatch.setattr(tool_spaces_mod, "DEFAULT_PROFILES_DIRECTORY", builtin)
+
+ with pytest.raises(RuntimeError, match="read-only"):
+ tool_spaces_mod._append_tools_to_profile("default", [SEARCH_TOOL_ID])
+
+ assert tools_txt.read_text(encoding="utf-8") == ""
+
+
+def test_append_tools_rejects_profile_traversal(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ external_profiles = tmp_path / "external-profiles"
+ escaped_tools = _setup_profile(tmp_path, "static")
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles)
+
+ with pytest.raises(RuntimeError, match="Invalid profile selector"):
+ tool_spaces_mod._append_tools_to_profile("../static", [SEARCH_TOOL_ID])
+
+ assert escaped_tools.read_text(encoding="utf-8") == ""
+
+
+def test_append_tools_rejects_tools_file_symlink_to_builtin_profile(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ builtin = tmp_path / "package-profiles"
+ builtin_tools = _setup_profile(builtin, "default", ["builtin_tool"])
+ external_profiles = tmp_path / "external-profiles"
+ external_profile = external_profiles / "custom"
+ external_profile.mkdir(parents=True)
+ (external_profile / "tools.txt").symlink_to(builtin_tools)
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", external_profiles)
+ monkeypatch.setattr(tool_spaces_mod, "DEFAULT_PROFILES_DIRECTORY", builtin)
+ original_contents = builtin_tools.read_bytes()
+
+ with pytest.raises(RuntimeError, match="not inside a writable profile root"):
+ tool_spaces_mod._append_tools_to_profile("custom", [SEARCH_TOOL_ID])
+
+ assert builtin_tools.read_bytes() == original_contents
+
+
+def test_remove_space_only_rewrites_user_profiles(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ builtin = tmp_path / "package-profiles"
+ user = tmp_path / "state" / "user_personalities"
+ builtin_tools = _setup_profile(builtin, "default", [SEARCH_TOOL_ID])
+ user_tools = _setup_profile(user, "custom", [SEARCH_TOOL_ID])
+ monkeypatch.setattr(config_mod.config, "PROFILES_DIRECTORY", builtin)
+ monkeypatch.setattr(config_mod.config, "user_personalities_root", lambda: user)
+
+ removed = tool_spaces_mod._disable_space_tools_in_profiles(SEARCH_ALIAS)
+
+ assert removed == [("custom", [SEARCH_TOOL_ID])]
+ assert SEARCH_TOOL_ID in builtin_tools.read_text(encoding="utf-8")
+ assert SEARCH_TOOL_ID not in user_tools.read_text(encoding="utf-8")
+
+
+def test_remove_space_skips_symlinked_user_profile_that_escapes_state_root(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ builtin = tmp_path / "package-profiles"
+ builtin_tools = _setup_profile(builtin, "default", [SEARCH_TOOL_ID])
+ user_root = tmp_path / "state" / "user_personalities"
+ user_root.mkdir(parents=True)
+ (user_root / "escaped").symlink_to(builtin / "default", target_is_directory=True)
+ monkeypatch.setattr(config_mod.config, "user_personalities_root", lambda: user_root)
+
+ removed = tool_spaces_mod._disable_space_tools_in_profiles(SEARCH_ALIAS)
+
+ assert removed == []
+ assert SEARCH_TOOL_ID in builtin_tools.read_text(encoding="utf-8")
+
+
+def test_remove_space_skips_user_root_symlink_to_builtin_profiles(
+ tmp_path: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ builtin = tmp_path / "package-profiles"
+ builtin_tools = _setup_profile(builtin, "default", [SEARCH_TOOL_ID])
+ user_root_link = tmp_path / "state" / "user_personalities"
+ user_root_link.parent.mkdir(parents=True)
+ user_root_link.symlink_to(builtin, target_is_directory=True)
+ monkeypatch.setattr(config_mod.config, "user_personalities_root", lambda: user_root_link)
+ monkeypatch.setattr(tool_spaces_mod, "DEFAULT_PROFILES_DIRECTORY", builtin)
+
+ removed = tool_spaces_mod._disable_space_tools_in_profiles(SEARCH_ALIAS)
+
+ assert removed == []
+ assert SEARCH_TOOL_ID in builtin_tools.read_text(encoding="utf-8")
diff --git a/tests/test_typecheck_config.py b/tests/test_typecheck_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..d0a649b7f77d209a2af62b47527b1bb42d768d51
--- /dev/null
+++ b/tests/test_typecheck_config.py
@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import configparser
+import tomllib
+from pathlib import Path
+
+
+REPOSITORY_ROOT = Path(__file__).parents[2]
+
+
+def test_repository_mypy_config_preserves_onrobot_strict_policy() -> None:
+ config_path = REPOSITORY_ROOT / "mypy.ini"
+ assert config_path.is_file(), "repository-root mypy invocations need a discoverable config"
+
+ config = configparser.ConfigParser()
+ config.read(config_path)
+ onrobot = tomllib.loads((REPOSITORY_ROOT / "onrobot" / "pyproject.toml").read_text(encoding="utf-8"))
+ onrobot_mypy = onrobot["tool"]["mypy"]
+
+ root_mypy = dict(config["mypy"])
+ assert root_mypy.pop("files") == "onrobot/src/"
+ assert root_mypy == {
+ key: str(onrobot_mypy[key]).lower()
+ for key in (
+ "ignore_missing_imports",
+ "python_version",
+ "show_error_codes",
+ "strict",
+ "warn_unused_ignores",
+ )
+ }
diff --git a/tests/test_wheel.py b/tests/test_wheel.py
new file mode 100644
index 0000000000000000000000000000000000000000..b44b0238a12aee63ad162371aecd331f5788a22f
--- /dev/null
+++ b/tests/test_wheel.py
@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import email
+import shutil
+import subprocess
+import sys
+import zipfile
+from pathlib import Path
+
+from _package_build import build_wheel_from_sdist, offline_env
+
+
+PROJECT_ROOT = Path(__file__).parents[1]
+
+
+def _build_wheel(tmp_path: Path, *, project_root: Path = PROJECT_ROOT) -> Path:
+ return build_wheel_from_sdist(tmp_path, project_root=project_root)
+
+
+def _copy_project_source(destination: Path) -> Path:
+ destination.mkdir()
+ for name in ("LICENSE", "MANIFEST.in", "README.md", "pyproject.toml"):
+ shutil.copy2(PROJECT_ROOT / name, destination / name)
+ shutil.copytree(PROJECT_ROOT / "src", destination / "src")
+ return destination
+
+
+def test_wheel_build_ignores_persistent_build_tree(tmp_path: Path) -> None:
+ project = _copy_project_source(tmp_path / "project")
+ stale = project / "build" / "lib" / "peachy" / "stale_from_previous_build.py"
+ stale.parent.mkdir(parents=True)
+ stale.write_text("raise AssertionError('stale build output was packaged')\n", encoding="utf-8")
+
+ wheel = _build_wheel(tmp_path / "build-work", project_root=project)
+
+ with zipfile.ZipFile(wheel) as archive:
+ assert "peachy/stale_from_previous_build.py" not in archive.namelist()
+
+
+def test_wheel_contains_profiles_static_and_env(tmp_path: Path) -> None:
+ wheel = _build_wheel(tmp_path)
+ with zipfile.ZipFile(wheel) as archive:
+ names = set(archive.namelist())
+ assert "peachy/profiles/default/instructions.txt" in names
+ assert "peachy/profiles/peachy/instructions.txt" in names
+ assert "peachy/static/index.html" in names
+ assert "peachy/.env.example" in names
+ assert not [name for name in names if "__pycache__" in Path(name).parts or name.endswith(".pyc")]
+ forbidden_names = {".env", "startup_settings.json", "installed_tool_spaces.json"}
+ assert not [name for name in names if Path(name).name in forbidden_names]
+
+
+def test_wheel_runtime_inventory_exactly_matches_source(tmp_path: Path) -> None:
+ wheel = _build_wheel(tmp_path)
+ source_root = PROJECT_ROOT / "src" / "peachy"
+ expected = {
+ (Path("peachy") / path.relative_to(source_root)).as_posix()
+ for path in source_root.rglob("*")
+ if path.is_file() and "__pycache__" not in path.parts and path.suffix not in {".pyc", ".pyo"}
+ }
+ with zipfile.ZipFile(wheel) as archive:
+ actual = {name for name in archive.namelist() if name.startswith("peachy/") and not name.endswith("/")}
+
+ assert actual == expected
+ assert "peachy/profiles/default/sweep_look.py" in actual
+
+
+def test_wheel_metadata_has_safe_runtime_contract(tmp_path: Path) -> None:
+ wheel = _build_wheel(tmp_path)
+ with zipfile.ZipFile(wheel) as archive:
+ metadata_name = next(name for name in archive.namelist() if name.endswith(".dist-info/METADATA"))
+ metadata = email.message_from_bytes(archive.read(metadata_name))
+ requirements = metadata.get_all("Requires-Dist") or []
+ normalized = "\n".join(requirements).lower()
+ assert "reachy-mini==1.9.0" in normalized.replace(" ", "")
+ assert "openai==2.28.0" in normalized.replace(" ", "")
+ assert "numpy" in normalized
+ assert "scipy" in normalized
+ assert "mujoco" not in normalized
+ assert "reachy-mini-conversation-app" not in normalized
+
+
+def test_wheel_imports_without_source_tree_on_sys_path(tmp_path: Path) -> None:
+ wheel = _build_wheel(tmp_path)
+ target = tmp_path / "target"
+ subprocess.run(
+ [sys.executable, "-m", "pip", "install", "--no-deps", "--target", str(target), str(wheel)],
+ check=True,
+ cwd=tmp_path,
+ env=offline_env(),
+ )
+ probe = (
+ f"import sys; sys.path.insert(0, {str(target)!r}); "
+ "from importlib.resources import files; "
+ "from pathlib import Path; "
+ "import peachy; "
+ "root=files('peachy'); "
+ f"assert Path(peachy.__file__).resolve().is_relative_to(Path({str(target)!r}).resolve()); "
+ "assert root.joinpath('profiles/peachy/instructions.txt').is_file(); "
+ "assert root.joinpath('static/index.html').is_file()"
+ )
+ subprocess.run(
+ [sys.executable, "-I", "-c", probe],
+ check=True,
+ cwd=tmp_path,
+ env=offline_env(),
+ )
diff --git a/tests/tools/test_background_tool_manager.py b/tests/tools/test_background_tool_manager.py
new file mode 100644
index 0000000000000000000000000000000000000000..80568acfb6a795058ad4252d838594df5c2de085
--- /dev/null
+++ b/tests/tools/test_background_tool_manager.py
@@ -0,0 +1,545 @@
+"""Tests for BackgroundToolManager."""
+
+from __future__ import annotations
+import asyncio
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from peachy.tools.tool_constants import ToolState
+from peachy.tools.background_tool_manager import (
+ ToolProgress,
+ BackgroundTool,
+ ToolCallRoutine,
+ ToolNotification,
+ BackgroundToolManager,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _make_routine(
+ tool_name: str = "test_tool",
+ result: dict[str, Any] | None = None,
+ error: Exception | None = None,
+ delay: float = 0.0,
+) -> ToolCallRoutine:
+ """Create a mock ToolCallRoutine that returns *result* or raises *error*.
+
+ If *delay* > 0, the routine will sleep for that many seconds before
+ returning / raising so we can test cancellation and progress.
+
+ Mirrors the contract of ``_dispatch_tool_call`` in core_tools: exceptions
+ (including ``CancelledError``) are caught and returned as
+ ``{"error": "..."}`` dicts so that ``_run_tool`` never sees a raw raise.
+ """
+ routine = MagicMock(spec=ToolCallRoutine)
+ routine.tool_name = tool_name
+ routine.args_json_str = "{}"
+
+ async def _call(manager: BackgroundToolManager) -> dict[str, Any]:
+ try:
+ if delay:
+ await asyncio.sleep(delay)
+ if error is not None:
+ raise error
+ return result or {"ok": True}
+ except asyncio.CancelledError:
+ return {"error": "Tool cancelled"}
+ except Exception as e:
+ return {"error": f"{type(e).__name__}: {e}"}
+
+ routine.__call__ = _call # type: ignore[method-assign]
+ routine.side_effect = _call
+ return routine
+
+
+# ---------------------------------------------------------------------------
+# Model / data-class sanity checks
+# ---------------------------------------------------------------------------
+
+
+class TestToolProgress:
+ """Validate ToolProgress construction and bounds."""
+
+ def test_valid_progress(self) -> None:
+ """Accept valid progress values and messages."""
+ p = ToolProgress(progress=0.5, message="halfway")
+ assert p.progress == 0.5
+ assert p.message == "halfway"
+
+ def test_bounds(self) -> None:
+ """Allow 0.0 and 1.0 as boundary values."""
+ assert ToolProgress(progress=0.0).progress == 0.0
+ assert ToolProgress(progress=1.0).progress == 1.0
+
+ def test_out_of_bounds_raises(self) -> None:
+ """Reject progress values outside [0, 1]."""
+ with pytest.raises(Exception):
+ ToolProgress(progress=-0.1)
+ with pytest.raises(Exception):
+ ToolProgress(progress=1.1)
+
+
+class TestToolNotification:
+ """Validate ToolNotification construction."""
+
+ def test_creation(self) -> None:
+ """Create a notification and verify its fields."""
+ n = ToolNotification(
+ id="abc",
+ tool_name="my_tool",
+ is_idle_tool_call=False,
+ status=ToolState.COMPLETED,
+ result={"data": 1},
+ )
+ assert n.id == "abc"
+ assert n.status == ToolState.COMPLETED
+ assert n.result == {"data": 1}
+ assert n.error is None
+
+
+class TestBackgroundTool:
+ """Validate BackgroundTool helpers."""
+
+ def test_tool_id(self) -> None:
+ """Verify the composite tool_id property includes started_at."""
+ t = BackgroundTool(
+ id="123",
+ tool_name="weather",
+ is_idle_tool_call=False,
+ status=ToolState.RUNNING,
+ )
+ assert t.tool_id == f"weather-123-{t.started_at}"
+
+ def test_get_notification(self) -> None:
+ """Convert a BackgroundTool to a ToolNotification."""
+ t = BackgroundTool(
+ id="1",
+ tool_name="t",
+ is_idle_tool_call=True,
+ status=ToolState.COMPLETED,
+ result={"x": 1},
+ error=None,
+ )
+ n = t.get_notification()
+ assert isinstance(n, ToolNotification)
+ assert n.id == "1"
+ assert n.tool_name == "t"
+ assert n.is_idle_tool_call is True
+ assert n.status == ToolState.COMPLETED
+ assert n.result == {"x": 1}
+
+
+# ---------------------------------------------------------------------------
+# BackgroundToolManager
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def manager() -> BackgroundToolManager:
+ """Return a fresh BackgroundToolManager for each test."""
+ return BackgroundToolManager()
+
+
+class TestSetLoop:
+ """Verify event-loop assignment via set_loop."""
+
+ @pytest.mark.asyncio
+ async def test_set_loop_uses_running_loop(self, manager: BackgroundToolManager) -> None:
+ """Default to the current running loop."""
+ manager.set_loop()
+ assert manager._loop is asyncio.get_running_loop()
+
+ def test_set_loop_explicit(self, manager: BackgroundToolManager) -> None:
+ """Accept an explicitly provided loop."""
+ loop = asyncio.new_event_loop()
+ try:
+ manager.set_loop(loop)
+ assert manager._loop is loop
+ finally:
+ loop.close()
+
+ def test_set_loop_creates_new_when_no_running(self, manager: BackgroundToolManager) -> None:
+ """When called outside an async context it falls back to a new loop."""
+ manager.set_loop()
+ assert manager._loop is not None
+
+
+class TestStartTool:
+ """Verify tool registration via start_tool."""
+
+ @pytest.mark.asyncio
+ async def test_start_registers_tool(self, manager: BackgroundToolManager) -> None:
+ """Register a tool and verify its initial state."""
+ routine = _make_routine("greet")
+ bg = await manager.start_tool(
+ call_id="c1",
+ tool_call_routine=routine,
+ is_idle_tool_call=False,
+ )
+ assert bg.tool_name == "greet"
+ assert bg.id == "c1"
+ assert bg.status == ToolState.RUNNING
+ assert manager.get_tool(bg.tool_id) is bg
+
+ # Let the task finish
+ await asyncio.sleep(0.05)
+
+ @pytest.mark.asyncio
+ async def test_start_with_progress(self, manager: BackgroundToolManager) -> None:
+ """Initialize progress tracking when requested."""
+ routine = _make_routine("slow", delay=0.1)
+ bg = await manager.start_tool(
+ call_id="c2",
+ tool_call_routine=routine,
+ is_idle_tool_call=True,
+ with_progress=True,
+ )
+ assert bg.progress is not None
+ assert bg.progress.progress == 0.0
+ await asyncio.sleep(0.15)
+
+
+class TestRunToolLifecycle:
+ """Test _run_tool via start_tool (the public entry point)."""
+
+ @pytest.mark.asyncio
+ async def test_successful_completion(self, manager: BackgroundToolManager) -> None:
+ """Complete a tool and verify result, status, and notification."""
+ routine = _make_routine("ok_tool", result={"answer": 42})
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+
+ # Wait for the task to finish
+ await asyncio.sleep(0.05)
+
+ assert bg.status == ToolState.COMPLETED
+ assert bg.result == {"answer": 42}
+ assert bg.completed_at is not None
+ assert bg.error is None
+
+ # Notification should be queued
+ notification = manager._notification_queue.get_nowait()
+ assert notification.status == ToolState.COMPLETED
+
+ @pytest.mark.asyncio
+ async def test_tool_failure(self, manager: BackgroundToolManager) -> None:
+ """Mark a tool as FAILED when it raises an exception."""
+ routine = _make_routine("bad_tool", error=ValueError("boom"))
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+
+ await asyncio.sleep(0.05)
+
+ assert bg.status == ToolState.FAILED
+ assert "ValueError: boom" in (bg.error or "")
+ assert bg.completed_at is not None
+
+ notification = manager._notification_queue.get_nowait()
+ assert notification.status == ToolState.FAILED
+
+ @pytest.mark.asyncio
+ async def test_tool_cancellation(self, manager: BackgroundToolManager) -> None:
+ """Cancel a running tool and verify CANCELLED status."""
+ routine = _make_routine("long_tool", delay=10.0)
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+
+ # Give the task a moment to start, then cancel
+ await asyncio.sleep(0.02)
+ cancelled = await manager.cancel_tool(bg.tool_id)
+ assert cancelled is True
+
+ # Let cancellation propagate
+ await asyncio.sleep(0.05)
+
+ assert bg.status == ToolState.CANCELLED
+ assert bg.error == "Tool cancelled"
+ assert bg.completed_at is not None
+
+
+class TestUpdateProgress:
+ """Verify progress updates on running tools."""
+
+ @pytest.mark.asyncio
+ async def test_update_progress_success(self, manager: BackgroundToolManager) -> None:
+ """Update progress value and message on a tracked tool."""
+ routine = _make_routine("prog", delay=0.5)
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False, with_progress=True)
+
+ ok = await manager.update_progress(bg.tool_id, 0.5, "half done")
+ assert ok is True
+ assert bg.progress is not None
+ assert bg.progress.progress == 0.5
+ assert bg.progress.message == "half done"
+
+ # Cancel to clean up
+ await manager.cancel_tool(bg.tool_id)
+ await asyncio.sleep(0.05)
+
+ @pytest.mark.asyncio
+ async def test_update_progress_clamps(self, manager: BackgroundToolManager) -> None:
+ """Clamp out-of-range progress values to [0, 1]."""
+ routine = _make_routine("prog", delay=0.5)
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False, with_progress=True)
+
+ await manager.update_progress(bg.tool_id, 1.5)
+ assert bg.progress is not None
+ assert bg.progress.progress == 1.0
+
+ await manager.update_progress(bg.tool_id, -0.5)
+ assert bg.progress.progress == 0.0
+
+ await manager.cancel_tool(bg.tool_id)
+ await asyncio.sleep(0.05)
+
+ @pytest.mark.asyncio
+ async def test_update_progress_unknown_tool(self, manager: BackgroundToolManager) -> None:
+ """Return False for an unknown tool_id."""
+ ok = await manager.update_progress("nonexistent", 0.5)
+ assert ok is False
+
+ @pytest.mark.asyncio
+ async def test_update_progress_no_tracking(self, manager: BackgroundToolManager) -> None:
+ """Return False when progress tracking is disabled."""
+ routine = _make_routine("fast", delay=0.5)
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False, with_progress=False)
+
+ ok = await manager.update_progress(bg.tool_id, 0.5)
+ assert ok is False
+
+ await manager.cancel_tool(bg.tool_id)
+ await asyncio.sleep(0.05)
+
+
+class TestCancelTool:
+ """Verify tool cancellation behaviour."""
+
+ @pytest.mark.asyncio
+ async def test_cancel_nonexistent(self, manager: BackgroundToolManager) -> None:
+ """Return False when the tool_id does not exist."""
+ result = await manager.cancel_tool("does-not-exist")
+ assert result is False
+
+ @pytest.mark.asyncio
+ async def test_cancel_already_completed(self, manager: BackgroundToolManager) -> None:
+ """Return True when cancelling an already-completed tool."""
+ routine = _make_routine("done")
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.05) # let it finish
+ assert bg.status == ToolState.COMPLETED
+
+ # Cancelling a completed tool should return True (not running, no-op)
+ result = await manager.cancel_tool(bg.tool_id)
+ assert result is True
+
+
+class TestTimeoutTools:
+ """Verify automatic timeout of long-running tools."""
+
+ @pytest.mark.asyncio
+ async def test_timeout_cancels_old_tools(self, manager: BackgroundToolManager) -> None:
+ """Cancel tools exceeding max duration."""
+ # Use a very short max duration
+ manager._max_tool_duration_seconds = 0.01
+
+ routine = _make_routine("slow", delay=10.0)
+ await manager.start_tool("c1", routine, is_idle_tool_call=False)
+
+ # Wait longer than the timeout
+ await asyncio.sleep(0.05)
+
+ count = await manager.timeout_tools()
+ assert count == 1
+
+ await asyncio.sleep(0.05)
+
+ @pytest.mark.asyncio
+ async def test_timeout_ignores_recent_tools(self, manager: BackgroundToolManager) -> None:
+ """Leave recent tools untouched."""
+ manager._max_tool_duration_seconds = 9999
+
+ routine = _make_routine("fast", delay=10.0)
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+
+ count = await manager.timeout_tools()
+ assert count == 0
+
+ await manager.cancel_tool(bg.tool_id)
+ await asyncio.sleep(0.05)
+
+
+class TestCleanupTools:
+ """Verify cleanup of completed tools from memory."""
+
+ @pytest.mark.asyncio
+ async def test_cleanup_removes_old_completed(self, manager: BackgroundToolManager) -> None:
+ """Remove completed tools past the retention window."""
+ manager._max_tool_memory_seconds = 0.01
+
+ routine = _make_routine("old")
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.05)
+ assert bg.status == ToolState.COMPLETED
+
+ # Wait for the memory retention to expire
+ await asyncio.sleep(0.05)
+
+ removed = await manager.cleanup_tools()
+ assert removed == 1
+ assert manager.get_tool(bg.tool_id) is None
+
+ @pytest.mark.asyncio
+ async def test_cleanup_keeps_recent_completed(self, manager: BackgroundToolManager) -> None:
+ """Keep recently completed tools."""
+ manager._max_tool_memory_seconds = 9999
+
+ routine = _make_routine("recent")
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.05)
+
+ removed = await manager.cleanup_tools()
+ assert removed == 0
+ assert manager.get_tool(bg.tool_id) is not None
+
+ @pytest.mark.asyncio
+ async def test_cleanup_ignores_running(self, manager: BackgroundToolManager) -> None:
+ """Never remove still-running tools."""
+ manager._max_tool_memory_seconds = 0.0 # immediate expiry
+
+ routine = _make_routine("still_going", delay=10.0)
+ bg = await manager.start_tool("c1", routine, is_idle_tool_call=False)
+
+ removed = await manager.cleanup_tools()
+ assert removed == 0
+
+ await manager.cancel_tool(bg.tool_id)
+ await asyncio.sleep(0.05)
+
+
+class TestGetters:
+ """Verify tool retrieval helpers."""
+
+ @pytest.mark.asyncio
+ async def test_get_tool(self, manager: BackgroundToolManager) -> None:
+ """Return None for missing tools and the instance for known ones."""
+ assert manager.get_tool("nope") is None
+
+ routine = _make_routine("x")
+ bg = await manager.start_tool("1", routine, is_idle_tool_call=False)
+ assert manager.get_tool(bg.tool_id) is bg
+ await asyncio.sleep(0.05)
+
+ @pytest.mark.asyncio
+ async def test_get_running_tools(self, manager: BackgroundToolManager) -> None:
+ """Return only tools that are still running."""
+ r1 = _make_routine("a", delay=10.0)
+ r2 = _make_routine("b", delay=10.0)
+ r3 = _make_routine("c") # finishes immediately
+
+ bg1 = await manager.start_tool("1", r1, is_idle_tool_call=False)
+ bg2 = await manager.start_tool("2", r2, is_idle_tool_call=False)
+ await manager.start_tool("3", r3, is_idle_tool_call=False)
+ await asyncio.sleep(0.05) # let r3 finish
+
+ running = manager.get_running_tools()
+ assert len(running) == 2
+ names = {t.tool_name for t in running}
+ assert names == {"a", "b"}
+
+ # Clean up
+ await manager.cancel_tool(bg1.tool_id)
+ await manager.cancel_tool(bg2.tool_id)
+ await asyncio.sleep(0.05)
+
+ @pytest.mark.asyncio
+ async def test_get_all_tools_sorted(self, manager: BackgroundToolManager) -> None:
+ """Tools are returned most-recent-first."""
+ r1 = _make_routine("first")
+ r2 = _make_routine("second")
+
+ await manager.start_tool("1", r1, is_idle_tool_call=False)
+ await asyncio.sleep(0.02) # ensure different started_at
+ await manager.start_tool("2", r2, is_idle_tool_call=False)
+
+ await asyncio.sleep(0.05)
+
+ all_tools = manager.get_all_tools()
+ assert len(all_tools) == 2
+ assert all_tools[0].tool_name == "second"
+ assert all_tools[1].tool_name == "first"
+
+ @pytest.mark.asyncio
+ async def test_get_all_tools_limit(self, manager: BackgroundToolManager) -> None:
+ """Respect the limit parameter on get_all_tools."""
+ for i in range(5):
+ r = _make_routine(f"t{i}")
+ await manager.start_tool(str(i), r, is_idle_tool_call=False)
+
+ await asyncio.sleep(0.05)
+
+ limited = manager.get_all_tools(limit=3)
+ assert len(limited) == 3
+
+
+class TestStartUp:
+ """Verify start_up bootstraps background tasks."""
+
+ @pytest.mark.asyncio
+ async def test_startup_creates_tasks(self, manager: BackgroundToolManager) -> None:
+ """start_up should create the listener and cleanup background tasks."""
+ callback = AsyncMock()
+ manager.start_up(tool_callbacks=[callback])
+
+ # Start a tool and let it complete — the listener should invoke the callback
+ routine = _make_routine("ping")
+ await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.1)
+
+ assert callback.call_count == 1
+ notification = callback.call_args[0][0]
+ assert isinstance(notification, ToolNotification)
+ assert notification.status == ToolState.COMPLETED
+
+ @pytest.mark.asyncio
+ async def test_startup_multiple_callbacks(self, manager: BackgroundToolManager) -> None:
+ """Invoke all registered callbacks on completion."""
+ cb1 = AsyncMock()
+ cb2 = AsyncMock()
+ manager.start_up(tool_callbacks=[cb1, cb2])
+
+ routine = _make_routine("multi")
+ await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.1)
+
+ assert cb1.call_count == 1
+ assert cb2.call_count == 1
+
+
+class TestNotificationQueue:
+ """Verify notifications are enqueued on tool completion or failure."""
+
+ @pytest.mark.asyncio
+ async def test_notifications_queued_on_completion(self, manager: BackgroundToolManager) -> None:
+ """Queue a COMPLETED notification with the tool result."""
+ routine = _make_routine("notif", result={"v": 1})
+ await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.05)
+
+ n = manager._notification_queue.get_nowait()
+ assert n.tool_name == "notif"
+ assert n.status == ToolState.COMPLETED
+ assert n.result == {"v": 1}
+
+ @pytest.mark.asyncio
+ async def test_notifications_queued_on_failure(self, manager: BackgroundToolManager) -> None:
+ """Queue a FAILED notification with the error message."""
+ routine = _make_routine("fail", error=RuntimeError("oops"))
+ await manager.start_tool("c1", routine, is_idle_tool_call=False)
+ await asyncio.sleep(0.05)
+
+ n = manager._notification_queue.get_nowait()
+ assert n.status == ToolState.FAILED
+ assert "RuntimeError: oops" in (n.error or "")
diff --git a/tests/tools/test_camera.py b/tests/tools/test_camera.py
new file mode 100644
index 0000000000000000000000000000000000000000..f9800cca2acd47997f325f88e438bad40724604b
--- /dev/null
+++ b/tests/tools/test_camera.py
@@ -0,0 +1,60 @@
+"""Tests for the camera tool."""
+
+import base64
+from unittest.mock import MagicMock
+
+import pytest
+
+from peachy.tools.camera import Camera
+from peachy.tools.core_tools import ToolDependencies
+
+
+@pytest.mark.asyncio
+async def test_camera_tool_returns_base64_of_sdk_jpeg() -> None:
+ """The tool base64-encodes the JPEG bytes returned by the SDK."""
+ jpeg_bytes = b"\xff\xd8jpeg\xff\xd9"
+ reachy_mini = MagicMock()
+ reachy_mini.media.get_frame_jpeg.return_value = jpeg_bytes
+
+ deps = ToolDependencies(
+ reachy_mini=reachy_mini,
+ movement_manager=MagicMock(),
+ camera_enabled=True,
+ )
+
+ result = await Camera()(deps, question="What color is this?")
+
+ assert result["b64_im"] == base64.b64encode(jpeg_bytes).decode("utf-8")
+
+
+@pytest.mark.asyncio
+async def test_camera_tool_reports_error_when_no_frame() -> None:
+ """With no frame available the tool returns an error."""
+ reachy_mini = MagicMock()
+ reachy_mini.media.get_frame_jpeg.return_value = None
+
+ deps = ToolDependencies(
+ reachy_mini=reachy_mini,
+ movement_manager=MagicMock(),
+ camera_enabled=True,
+ )
+
+ result = await Camera()(deps, question="What color is this?")
+
+ assert "error" in result
+
+
+@pytest.mark.asyncio
+async def test_camera_tool_reports_error_when_camera_disabled() -> None:
+ """With the camera disabled the tool returns an error and never reads a frame."""
+ reachy_mini = MagicMock()
+ deps = ToolDependencies(
+ reachy_mini=reachy_mini,
+ movement_manager=MagicMock(),
+ camera_enabled=False,
+ )
+
+ result = await Camera()(deps, question="What color is this?")
+
+ assert "error" in result
+ reachy_mini.media.get_frame_jpeg.assert_not_called()
diff --git a/tests/tools/test_go_to_sleep.py b/tests/tools/test_go_to_sleep.py
new file mode 100644
index 0000000000000000000000000000000000000000..51ce13d5057c5d7a8e33be9759434d9caa6beaba
--- /dev/null
+++ b/tests/tools/test_go_to_sleep.py
@@ -0,0 +1,46 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from peachy.tools.core_tools import ToolDependencies
+from peachy.tools.go_to_sleep import GoToSleep
+
+
+def test_go_to_sleep_has_no_required_arguments() -> None:
+ """The tool should be callable without a confirmation argument."""
+ assert GoToSleep.parameters_schema == {
+ "type": "object",
+ "properties": {},
+ "required": [],
+ }
+
+
+@pytest.mark.asyncio
+async def test_go_to_sleep_returns_unavailable_without_runtime_callback() -> None:
+ """The tool should fail gracefully if the runtime did not inject a sleep callback."""
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+
+ result = await GoToSleep()(deps)
+
+ assert result == {"error": "go_to_sleep is unavailable in this runtime"}
+
+
+@pytest.mark.asyncio
+async def test_go_to_sleep_calls_runtime_callback() -> None:
+ """The tool should delegate the actual movement and app stop to the host runtime."""
+ expected = {
+ "status": "sleeping",
+ "stop_current_app_requested": True,
+ "local_stop_requested": True,
+ }
+ go_to_sleep = MagicMock(return_value=expected)
+ deps = ToolDependencies(
+ reachy_mini=MagicMock(),
+ movement_manager=MagicMock(),
+ go_to_sleep=go_to_sleep,
+ )
+
+ result = await GoToSleep()(deps)
+
+ assert result == expected
+ go_to_sleep.assert_called_once_with()
diff --git a/tests/tools/test_head_tracking.py b/tests/tools/test_head_tracking.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fb05819a215fc7f392d46a9c030944075c2dcaf
--- /dev/null
+++ b/tests/tools/test_head_tracking.py
@@ -0,0 +1,20 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from peachy.tools.core_tools import ToolDependencies
+from peachy.tools.head_tracking import HeadTracking
+
+
+@pytest.mark.asyncio
+async def test_head_tracking_enables_and_disables() -> None:
+ """The tool forwards the toggle to the movement manager."""
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=MagicMock())
+
+ result = await HeadTracking()(deps, enabled=True)
+ deps.movement_manager.set_head_tracking.assert_called_with(True)
+ assert result == {"status": "following"}
+
+ result = await HeadTracking()(deps, enabled=False)
+ deps.movement_manager.set_head_tracking.assert_called_with(False)
+ assert result == {"status": "stopped following"}
diff --git a/tests/tools/test_play_emotion.py b/tests/tools/test_play_emotion.py
new file mode 100644
index 0000000000000000000000000000000000000000..787acefee3f4442e10a929e529afcfcd092b9909
--- /dev/null
+++ b/tests/tools/test_play_emotion.py
@@ -0,0 +1,230 @@
+import logging
+from unittest.mock import MagicMock
+
+import pytest
+
+from peachy.tools import play_emotion as play_emotion_module
+from peachy.tools.core_tools import ToolDependencies
+from peachy.tools.play_emotion import (
+ EMOTION_INTENTS,
+ PlayEmotion,
+ resolve_emotion_name,
+ random_curated_emotion,
+)
+
+
+AVAILABLE_EMOTIONS = [
+ "cheerful1",
+ "confused1",
+ "no1",
+ "no_sad1",
+ "no_excited1",
+ "resigned1",
+ "understanding2",
+ "yes_sad1",
+]
+
+
+def test_play_emotion_schema_uses_compact_intents() -> None:
+ """Expose compact intents instead of the full recorded-move catalog."""
+ emotion_schema = PlayEmotion.parameters_schema["properties"]["emotion"]
+
+ assert emotion_schema["enum"] == list(EMOTION_INTENTS)
+ assert "no_sad" in emotion_schema["enum"]
+ assert "no_excited" in emotion_schema["enum"]
+ assert "no_firm" in emotion_schema["enum"]
+ assert "yes_understanding" in emotion_schema["enum"]
+ assert "no_confused" not in emotion_schema["enum"]
+ assert "oops" not in emotion_schema["enum"]
+ assert "yes_sad" not in emotion_schema["enum"]
+ assert "yes_proud" not in emotion_schema["enum"]
+ assert "loving1" not in emotion_schema["enum"]
+ assert "Available emotions" not in emotion_schema["description"]
+
+
+@pytest.mark.parametrize(
+ ("requested", "expected"),
+ [
+ ("no_sad1", "no_sad1"),
+ ("sad no", "no_sad1"),
+ ("no_excited", "no_excited1"),
+ ("yes_understanding", "understanding2"),
+ ],
+)
+def test_resolve_emotion_name_accepts_ids_intents_and_yes_no_phrases(requested: str, expected: str) -> None:
+ """Resolve exact IDs, compact intents, and exposed yes/no phrase variants."""
+ assert resolve_emotion_name(requested, AVAILABLE_EMOTIONS) == expected
+
+
+def test_resolve_emotion_name_returns_none_for_random_or_unknown() -> None:
+ """Let the caller choose a random fallback when there is no resolved match."""
+ assert resolve_emotion_name("random", AVAILABLE_EMOTIONS) is None
+ assert resolve_emotion_name("contento", AVAILABLE_EMOTIONS) is None
+ assert resolve_emotion_name("totally mysterious mood", AVAILABLE_EMOTIONS) is None
+
+
+@pytest.mark.parametrize(
+ "removed_intent",
+ [
+ "confused no",
+ "curious",
+ "inquiring",
+ "lost",
+ "no_confused",
+ "oops",
+ "proud",
+ "uncomfortable",
+ "yes proud",
+ "yes sad",
+ "yes_proud",
+ "yes_sad",
+ ],
+)
+def test_resolve_emotion_name_does_not_accept_removed_substitute_intents(removed_intent: str) -> None:
+ """Removed intents should not resolve through unrelated substitute moves."""
+ assert resolve_emotion_name(removed_intent, AVAILABLE_EMOTIONS) is None
+
+
+@pytest.mark.parametrize(
+ ("intent", "poor_options"),
+ [
+ ("excited", ["success2"]),
+ ("grateful", ["helpful1", "loving1"]),
+ ("happy", ["loving1"]),
+ ("lonely", ["sad1"]),
+ ("no", ["no_sad1", "no_excited1"]),
+ ("no_excited", ["no1"]),
+ ("no_sad", ["downcast1"]),
+ ("uncertain", ["resigned1"]),
+ ("yes_understanding", ["yes1"]),
+ ],
+)
+def test_resolve_emotion_name_does_not_use_weak_fallbacks(intent: str, poor_options: list[str]) -> None:
+ """Do not use loosely related moves when a precise move is unavailable."""
+ assert resolve_emotion_name(intent, poor_options) is None
+
+
+@pytest.mark.parametrize("bad_move", ["cheerful1", "oops1", "oops2", "reprimand3", "understanding1", "yes_sad1"])
+def test_resolve_emotion_name_does_not_accept_bad_exact_moves(bad_move: str) -> None:
+ """Bad-quality recorded move IDs should not bypass the curated resolver."""
+ assert resolve_emotion_name(bad_move, [*AVAILABLE_EMOTIONS, bad_move]) is None
+
+
+@pytest.mark.parametrize(
+ "ambiguous_move",
+ [
+ "contempt1",
+ "curious1",
+ "dance1",
+ "furious1",
+ "helpful2",
+ "impatient1",
+ "incomprehensible2",
+ "inquiring1",
+ "lost1",
+ "proud2",
+ "proud3",
+ "tired1",
+ "uncomfortable1",
+ "welcoming1",
+ ],
+)
+def test_resolve_emotion_name_does_not_accept_redundant_ambiguous_exact_moves(ambiguous_move: str) -> None:
+ """OK ambiguous moves should be skipped when clear or excellent alternatives exist."""
+ assert resolve_emotion_name(ambiguous_move, [*AVAILABLE_EMOTIONS, ambiguous_move]) is None
+
+
+def test_random_curated_emotion_uses_curated_pool(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Random fallback should avoid non-curated moves when curated options exist."""
+ choices_seen: list[str] = []
+
+ def fake_choice(choices: list[str]) -> str:
+ choices_seen.extend(choices)
+ return choices[0]
+
+ monkeypatch.setattr(play_emotion_module.random, "choice", fake_choice)
+
+ assert random_curated_emotion(["cheerful1", "yes_sad1", "confused1"]) == "confused1"
+ assert choices_seen == ["confused1"]
+
+
+def test_random_curated_emotion_falls_back_when_no_curated_moves(monkeypatch: pytest.MonkeyPatch) -> None:
+ """Fallback should still return an available move if the curated pool is unavailable."""
+ choices_seen: list[str] = []
+
+ def fake_choice(choices: list[str]) -> str:
+ choices_seen.extend(choices)
+ return choices[0]
+
+ monkeypatch.setattr(play_emotion_module.random, "choice", fake_choice)
+
+ assert random_curated_emotion(["cheerful1"]) == "cheerful1"
+ assert choices_seen == ["cheerful1"]
+
+
+@pytest.mark.asyncio
+async def test_play_emotion_queues_resolved_emotion(monkeypatch: pytest.MonkeyPatch) -> None:
+ """The tool should queue the resolved recorded-move ID."""
+
+ class FakeRecordedMoves:
+ def list_moves(self) -> list[str]:
+ return AVAILABLE_EMOTIONS
+
+ class FakeEmotionQueueMove:
+ def __init__(self, emotion_name: str, recorded_moves: FakeRecordedMoves) -> None:
+ self.emotion_name = emotion_name
+ self.recorded_moves = recorded_moves
+
+ monkeypatch.setattr(play_emotion_module, "EMOTION_AVAILABLE", True)
+ monkeypatch.setattr(play_emotion_module, "EmotionQueueMove", FakeEmotionQueueMove)
+
+ movement_manager = MagicMock()
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement_manager)
+
+ tool = PlayEmotion()
+ monkeypatch.setattr(tool, "_library", FakeRecordedMoves())
+ result = await tool(deps, emotion="sad no")
+
+ assert result == {"status": "queued", "emotion": "no_sad1"}
+ queued_move = movement_manager.queue_move.call_args.args[0]
+ assert queued_move.emotion_name == "no_sad1"
+
+
+@pytest.mark.asyncio
+async def test_play_emotion_queues_random_for_unknown_emotion(
+ monkeypatch: pytest.MonkeyPatch,
+ caplog: pytest.LogCaptureFixture,
+) -> None:
+ """Unknown explicit values should fall back to a random recorded emotion."""
+
+ class FakeRecordedMoves:
+ def list_moves(self) -> list[str]:
+ return AVAILABLE_EMOTIONS
+
+ class FakeEmotionQueueMove:
+ def __init__(self, emotion_name: str, recorded_moves: FakeRecordedMoves) -> None:
+ self.emotion_name = emotion_name
+ self.recorded_moves = recorded_moves
+
+ monkeypatch.setattr(play_emotion_module, "EMOTION_AVAILABLE", True)
+ monkeypatch.setattr(play_emotion_module, "EmotionQueueMove", FakeEmotionQueueMove)
+
+ def fake_choice(emotion_names: list[str]) -> str:
+ assert "cheerful1" not in emotion_names
+ assert "yes_sad1" not in emotion_names
+ return "confused1"
+
+ monkeypatch.setattr(play_emotion_module.random, "choice", fake_choice)
+
+ movement_manager = MagicMock()
+ deps = ToolDependencies(reachy_mini=MagicMock(), movement_manager=movement_manager)
+
+ tool = PlayEmotion()
+ monkeypatch.setattr(tool, "_library", FakeRecordedMoves())
+ with caplog.at_level(logging.INFO, logger=play_emotion_module.logger.name):
+ result = await tool(deps, emotion="contento")
+
+ assert result == {"status": "queued", "emotion": "confused1"}
+ assert "play_emotion: 'contento' did not resolve; using random curated" in caplog.text
+ queued_move = movement_manager.queue_move.call_args.args[0]
+ assert queued_move.emotion_name == "confused1"
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 0000000000000000000000000000000000000000..bc2c0dd3dabd9f5cfc5b0e5d4a9dce9c9187c34a
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,2806 @@
+version = 1
+revision = 2
+requires-python = ">=3.12"
+resolution-markers = [
+ "python_full_version >= '3.14' and sys_platform == 'win32'",
+ "python_full_version >= '3.14' and sys_platform != 'win32'",
+ "python_full_version < '3.14' and sys_platform == 'win32'",
+ "python_full_version < '3.14' and sys_platform != 'win32'",
+]
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/f4/eec0465c2f67b2664688d0240b3212d5196fd89e741df67ddb81f8d35658/aiohappyeyeballs-2.7.1.tar.gz", hash = "sha256:065665c041c42a5938ed220bdcd7230f22527fbec085e1853d2402c8a3615d9d", size = 24757, upload-time = "2026-07-01T17:11:55.501Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/71/43/1947f06babed6b3f1d7f38b0c767f52df66bfb2bc10b468c4a7de9eceff2/aiohappyeyeballs-2.7.1-py3-none-any.whl", hash = "sha256:9243213661e29250eb41368e5daa826fc017156c3b8a11440826b2e3ed376472", size = 15038, upload-time = "2026-07-01T17:11:54.055Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.14.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "aiohappyeyeballs" },
+ { name = "aiosignal" },
+ { name = "attrs" },
+ { name = "frozenlist" },
+ { name = "multidict" },
+ { name = "propcache" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+ { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/58/d9/22ce5786ac0c1653ae8b6c23bded02c1686d11f0dbb45b31ce128e0df985/aiohttp-3.14.3.tar.gz", hash = "sha256:9491196535a88924a60afd5b5f434b5b203b6cc616250878dbdb223a8f7844bc", size = 7971213, upload-time = "2026-07-23T01:57:27.037Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/18/d4/eb96299230e20acf2efae207cb8d69051f1f68e357e5ea5e479bf6fb097a/aiohttp-3.14.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:39aded8c7f3b935b54aab1d8d73c70ec0ee2d3ec3b943e0e86611bc150ba47f5", size = 754690, upload-time = "2026-07-23T01:53:47.332Z" },
+ { url = "https://files.pythonhosted.org/packages/88/11/e7a70a209eb9a067c0d3212b518a0134e3484f5178c7533878b6b514d469/aiohttp-3.14.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5bcb6ff3fdab1258a192679ff1a05d44f59626430aa05cd1a9d2447423599228", size = 509484, upload-time = "2026-07-23T01:53:51.159Z" },
+ { url = "https://files.pythonhosted.org/packages/30/07/4bbc222cc8dbe31d4c3e8a5baad2286e4d42026ac0c570027b89afce6344/aiohttp-3.14.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:617105e2c3018ee38d0c8ce5ee3c84f621a6d8b9f723202aacaff28449ca91ee", size = 511949, upload-time = "2026-07-23T01:53:55.083Z" },
+ { url = "https://files.pythonhosted.org/packages/54/b9/42e74c46b7b7c794b995bbc1f573fb48950c38b19d8600c62a6804ee2d67/aiohttp-3.14.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f631fe87a6f30df5fbe6d79640b25e4cffb38c31c7fb6f10871517b84b0f8c1a", size = 1765282, upload-time = "2026-07-23T01:53:59.662Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/ed/62bc4d74363ad346d518e0720363a949f63e2e23439a79eb5813d4d29bb3/aiohttp-3.14.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a94dbaae5ae27bd849c93570669bff91e0510f33a80805738e3de72a7be0447b", size = 1741511, upload-time = "2026-07-23T01:54:04.063Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/9f/181e8a8bc79e47d13c7fc4540bd7a3b729d9505609c61f392a8dd2fbfe55/aiohttp-3.14.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8f2f1c4c032c7cedd7d8da6f54c97b70266c6570c3108d3fdffee7188bb70529", size = 1810680, upload-time = "2026-07-23T01:54:09.882Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/9a/dec94d6ad694552fe3424e3f1928d7a606a5d9d9433a04e7ecdd9d38ae7f/aiohttp-3.14.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ea05e1f97ceea523942d9b2a7d7c0359d781d683d6b043f5943a602b14da4787", size = 1905646, upload-time = "2026-07-23T01:54:13.475Z" },
+ { url = "https://files.pythonhosted.org/packages/52/b7/7cd31f29d6055bd711ae6e669367fba6f5ae9de463910a793e30556a8db7/aiohttp-3.14.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:543906c127fb1d929b95076db19b83fa2d46751006ff1e23b093aa5ac4d8db42", size = 1792122, upload-time = "2026-07-23T01:54:15.752Z" },
+ { url = "https://files.pythonhosted.org/packages/66/73/10b1ef93afa61f4963c746257b70ced619cf31a4798671de5fdb2608501d/aiohttp-3.14.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a5ff2dfbb9ce645fa5b8ef3e02c6c0b9cc3f6030ff863d0c51fffc50cb5541b", size = 1591127, upload-time = "2026-07-23T01:54:19.489Z" },
+ { url = "https://files.pythonhosted.org/packages/49/ed/3b203fa6de1b338c14acdc06bf6ca9b043b7944f005966958c2ced932cde/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:041badb8f84396357c4d3ad26de6afd7a32b112f43d3c63045c0c8278cfd2043", size = 1725210, upload-time = "2026-07-23T01:54:24.129Z" },
+ { url = "https://files.pythonhosted.org/packages/28/b7/1c2aab8c706436dcc28598452488ac9cd7c409da815237c28c27d58993e6/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:530125ee1163c4219af35dc3aa1206e541e7b31b6efc1a3f93b70a136f65d427", size = 1764848, upload-time = "2026-07-23T01:54:27.973Z" },
+ { url = "https://files.pythonhosted.org/packages/54/50/94c28f08b131c4bf10984ea2c7a536c9920608bb2d6e7f95642c30cc87b7/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c8653fd547c93a61aadc612007790f5555cdd18946fa48cf45e26d8ea4ea473d", size = 1777102, upload-time = "2026-07-23T01:54:31.775Z" },
+ { url = "https://files.pythonhosted.org/packages/13/d4/e7d09ba7d345fb2d74440fd2fa033c5e079fac05552927705986f41a364f/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:89176250f686cb9853c0fb7ead90e639e915b84a6f43eedc2a4e7ec21f1037f0", size = 1580205, upload-time = "2026-07-23T01:54:34.518Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/84/072a91d68e1e1eb587985b54baab94221277f877e8ef274fc213a0ceae28/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3a26434dafe408229ff3403458ca58de24fb51936504decac49ce6755f77e59d", size = 1797219, upload-time = "2026-07-23T01:54:36.995Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/eb/aad34e897e668424d6e995da5dff8a4a09af93363d3392488772957a63aa/aiohttp-3.14.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d1558173930a5a8d3069cee5c92fc91c87c4dbcb099debbb3622053717145a19", size = 1768629, upload-time = "2026-07-23T01:54:40.103Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/2b/6bb88ddba0fecd9122aa3ebcad25996cf6c083a4a7040dbb3a4f97972af6/aiohttp-3.14.3-cp312-cp312-win32.whl", hash = "sha256:16100ad3ab8d649fdfbee87602d9d2dcdca9df0b9eda8a1b5fdc0d41f96da559", size = 451481, upload-time = "2026-07-23T01:54:42.547Z" },
+ { url = "https://files.pythonhosted.org/packages/76/9b/f2f8f108da17ecef2cc3efc424e8b7ad3782b1a8360f7b8eae8ced84f6ea/aiohttp-3.14.3-cp312-cp312-win_amd64.whl", hash = "sha256:33a2d7c28d33797a2e99923dffa63f83d908a19b6bf26cfe80fa790aa5e1a75a", size = 476845, upload-time = "2026-07-23T01:54:44.853Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/44/28dac80a8941b604f4da10ce21097614ca1bf905ce93dca28d8d7de9c1e7/aiohttp-3.14.3-cp312-cp312-win_arm64.whl", hash = "sha256:362a3fd481769cac1a824514bcd86fda51c65e8fe6e051099e008fddde6db17c", size = 448050, upload-time = "2026-07-23T01:54:47.087Z" },
+ { url = "https://files.pythonhosted.org/packages/57/be/5afd201cc0ab139029aadb75392efe85a293403d9dd3a3226161c21ce00c/aiohttp-3.14.3-cp313-cp313-android_21_arm64_v8a.whl", hash = "sha256:2e9878ae68e4a5f1c0abe4dd497dbc3d51946f5837b56759e2a02e78fa90ef86", size = 506269, upload-time = "2026-07-23T01:54:49.075Z" },
+ { url = "https://files.pythonhosted.org/packages/22/09/dec8189d62b45ade009f6792a2264b942a90cb88aeaf181239933cd72c3c/aiohttp-3.14.3-cp313-cp313-android_21_x86_64.whl", hash = "sha256:f3d2669fe7dec7fc359ecdb5984b29b50d85d5d00f8c1cb61de4f4a24ee42627", size = 515166, upload-time = "2026-07-23T01:54:51.894Z" },
+ { url = "https://files.pythonhosted.org/packages/28/24/2854869d29ed8a8b19d74f9ec6629515f7e04d02dd329d9d179201e58e47/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:cc7cb243a68167172f48c1fd43cee91ec4b1d40cefd190edd43369d1a6bc9c82", size = 486263, upload-time = "2026-07-23T01:54:54.223Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/dd/57187c8be2a35aea65eaee3bd2c3dcbbcf0204f5106c89637e3610380cd1/aiohttp-3.14.3-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:78253b573e6ffab5028924fc98bc281aae05445969982a10864bc360dea2016c", size = 492299, upload-time = "2026-07-23T01:54:56.236Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/11/06ae6ed8f0d414edf4068861e233d8fe23ee699bfd4b3ceb8663db948a62/aiohttp-3.14.3-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7041d52c3a7fa20c9e8c182b534704abb19502c8bdcbde7ab23bfda6f642394f", size = 502235, upload-time = "2026-07-23T01:54:58.377Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/a3/559639c34a345d2cf7c52dff6838119f2eaf29eb508227b5b83f573af813/aiohttp-3.14.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ac74facc01463f138b0da5580329cfcc82818dea5656e83ddcd11268fc12ff80", size = 750883, upload-time = "2026-07-23T01:55:00.65Z" },
+ { url = "https://files.pythonhosted.org/packages/91/cd/41e131f13afd1e7b0172a9d9eda085ef90eb8439f41f0d279db81ed3ae60/aiohttp-3.14.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d6218d92e450824e9b4881f44e8c09f1853b490f9a64130801024a4793b1b3b0", size = 508473, upload-time = "2026-07-23T01:55:02.945Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/6b/e7f13410d391c6e55b4c007a8de024355389d7d459e3d64c42b2d33617e5/aiohttp-3.14.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:11fb37ef075669eee52ab1928fbf6e1741fada40409fa309ebde9607a962aebf", size = 509190, upload-time = "2026-07-23T01:55:05.173Z" },
+ { url = "https://files.pythonhosted.org/packages/97/21/6464573e53d69672cc1eada3e5c5cb2d2efa82701e8305a0f2047a576967/aiohttp-3.14.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55bdcc472aafe2de4a253045cc128007a64f1e0264fb675791e132ea5edaa3bd", size = 1761478, upload-time = "2026-07-23T01:55:07.383Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/81/d217043a4c17fbce360905e3b2bdd20139ebc9a2de836d035d179c4da006/aiohttp-3.14.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c39846c3aad97a8530c89d7a3869a8f8e9e3762c6ac0504481e5c80948f7e807", size = 1735092, upload-time = "2026-07-23T01:55:09.803Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/66/e13a02d0eeb1a9a502402a977abb4e4abff9fe4051c26f80558c57a7c975/aiohttp-3.14.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5895ef58c4620afe02fa16044f023dc4dafec08158f9d08874a46a7dbc0341b8", size = 1800546, upload-time = "2026-07-23T01:55:12.012Z" },
+ { url = "https://files.pythonhosted.org/packages/26/5e/57d42fca1d18cb5acc1cad945d017fabc5d6ae71d8a08ad66be8dc3ee544/aiohttp-3.14.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa9467a8113aa69d3d7c55a70ef0b7c636010a40993f3df9d9d0d73b3eb7ef24", size = 1895250, upload-time = "2026-07-23T01:55:14.357Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/1c/7da8d08e74d56f00070822f9638ff3f1c563f8ad87d1efa996c87bfc8644/aiohttp-3.14.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7d2deec16eeedf55f2c7cf75b521ea3856a5177e123844f8fd0f114ce252cb5", size = 1789289, upload-time = "2026-07-23T01:55:16.668Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/0f/cf16bcf56896981c1a0319f5d5db9337994b5165730c48a8fa07e9b34be6/aiohttp-3.14.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dd54d0e8717de95939766febac482ac0474d8ac3b048115f9f2b1d23a16e7db4", size = 1586706, upload-time = "2026-07-23T01:55:18.913Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/6f/76eac12a7f2480e1e304f842efdb07db33256b0d9165b866b6ef0806c202/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:df82f3787c940c94986b34222d59c9e38843fba85139f36e85255a82ad5355a9", size = 1724652, upload-time = "2026-07-23T01:55:21.296Z" },
+ { url = "https://files.pythonhosted.org/packages/39/b6/19c8c592baeeb94b75f966547d40c02ac7590902306ec5863d5c027cf506/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:42a67efc36300d052fb4508a53e8b6901b9284b599ae63945c377569c5fcc1e1", size = 1756239, upload-time = "2026-07-23T01:55:23.705Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/c9/4e9383150296f97f873b680c4de8fb2cd88608fb9f48c79edcb111611abc/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7a75aa63cbf9b21cfaf60dc2657e19df2c2867d91707d653fee171ffeedd1371", size = 1769161, upload-time = "2026-07-23T01:55:26.082Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/1e/147bdc6cc5de5f3ab011be8bf5d6e786633249f22c20bae06f85e45f5387/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:e92eb8acc45eb6a9f4935071a77edf5b85cc6f8dfad5cd99e97653c26593cdde", size = 1578759, upload-time = "2026-07-23T01:55:28.846Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/31/78388a9d6040ece2e11df62ea229a822cf5e52d238374b220ae9975b2623/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b014a6ed7cf912e787149fdc529166d3ceabac23f26efeea3158c9aba2354e7e", size = 1792025, upload-time = "2026-07-23T01:55:31.457Z" },
+ { url = "https://files.pythonhosted.org/packages/03/51/a3d29fdf2c25d796746af8ad6fe56a45d6256c38b0a8a2ed752e1160b3a2/aiohttp-3.14.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3d4f72af88ac2474bb5bca640030320e3d38a0163a1d7533500e87be458eef71", size = 1768477, upload-time = "2026-07-23T01:55:33.87Z" },
+ { url = "https://files.pythonhosted.org/packages/29/a6/442e18b5afeade534d877a2dc3c3e392aff8d49787890b0cf84790410267/aiohttp-3.14.3-cp313-cp313-win32.whl", hash = "sha256:5f08ec777f35ee70720233b8b9811d3bb5d728137f30ac91b7457709c3261ac0", size = 451069, upload-time = "2026-07-23T01:55:36.121Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/69/3d876ac02659f271cf7f6769f14a8e3de5b6e888ed8b5a7e998086a4cec8/aiohttp-3.14.3-cp313-cp313-win_amd64.whl", hash = "sha256:dff9461ec275f22135650d5ba4b4931a11f3958df7dfbb8db630000d4dee0883", size = 476518, upload-time = "2026-07-23T01:55:38.303Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/0e/50d6e6471cd31edce8b282bdec59375a3a69124d8a989a0b1313355cae52/aiohttp-3.14.3-cp313-cp313-win_arm64.whl", hash = "sha256:ddcac3c6b382e81f1dd0499199d4136b877beb4cb5ef770bbbfba56c4b8f55d2", size = 447676, upload-time = "2026-07-23T01:55:40.451Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/20/887fdcf832326571b370ffc347b3e70abe101096f3720126aac161b1d872/aiohttp-3.14.3-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:49f7325beb0f85ef4aef5f48f490269575f83e6e2acad00a1d80b807eb027062", size = 509067, upload-time = "2026-07-23T01:55:42.618Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/a3/92cec936f78cc4bf0fa5554ebe593b73459d94e3c62303e1902a4cccb6f7/aiohttp-3.14.3-cp314-cp314-android_24_x86_64.whl", hash = "sha256:e3be98a7c30b8c25d573dafba7171d66dfb05ee6a9070fc46535464ff97700a6", size = 514774, upload-time = "2026-07-23T01:55:44.937Z" },
+ { url = "https://files.pythonhosted.org/packages/29/ba/2a0c38df3fc557620b6a5acd98364af050053b6285b4dc7ee74100c63c18/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:614c61d478b83953e261d02bb2df750f17227cd33ef8002945bf5aebbde21919", size = 488134, upload-time = "2026-07-23T01:55:47.135Z" },
+ { url = "https://files.pythonhosted.org/packages/48/d6/d51b7d4bf309af3693940d8ffd2b9ed0b682434ef85959b7c9c137f60cf8/aiohttp-3.14.3-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:1caa7b0d05f3e3a36f87788c59e970a7ee1cefcfcbb924a9f138c4a6551c9cb7", size = 494201, upload-time = "2026-07-23T01:55:49.451Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/5a/8f624384e5f1efabb5229b94157eb966b021e97bdb188c62860c2ae243c2/aiohttp-3.14.3-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:dfa68deb2a443bdaa3ea5297b0699c1464f08aef3812b486d1348eee61b07dc0", size = 502766, upload-time = "2026-07-23T01:55:51.656Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/26/4ff0164370deec18fb19254ee4ab10b7a73304ac0c860b13f5f84663759b/aiohttp-3.14.3-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:e72ee89e28d907a18f46959b4eb0bb06701cc7f8cf4366e00029e2ccfaaf5924", size = 756557, upload-time = "2026-07-23T01:55:53.964Z" },
+ { url = "https://files.pythonhosted.org/packages/97/a3/7056b86dc0d9ec709ea9777eae3b0161428f943372f8b98c01c11593b682/aiohttp-3.14.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ad4c8b7488d745d2ca4838ebd8ae5ba9b56341d30b1da43640e4ce87f9f49646", size = 510168, upload-time = "2026-07-23T01:55:56.22Z" },
+ { url = "https://files.pythonhosted.org/packages/85/ed/0357a015892fd68058bf2d39d3fd1958e459b997a7db30aaa6aaa434ae96/aiohttp-3.14.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:db332af25642007330fca8be5c4d194caf2bea7a7fc84415aff3497af5dfee6b", size = 512957, upload-time = "2026-07-23T01:55:58.437Z" },
+ { url = "https://files.pythonhosted.org/packages/47/d1/8aba53f15ccb2238405f5e9d30e2a8ca44f93878c26e7165ade00d374b1c/aiohttp-3.14.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:25bd2708db6bdf6a6630dd37bdcdfcb47c4434d22ac69c64665b802910140b30", size = 1750149, upload-time = "2026-07-23T01:56:00.856Z" },
+ { url = "https://files.pythonhosted.org/packages/49/bd/40c3fee327529284375c6701cbb0fa4600cc2e8432af1378f897e2ef7d3a/aiohttp-3.14.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:cef89a58e628c4efcac3275c2d68083f82426dcdc89c1492a6f654f9f7ea6ab9", size = 1707685, upload-time = "2026-07-23T01:56:03.371Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/a3/ca0cc6724cca8114b05694abd916060758c79894c3aa5b012cdadc1bc28e/aiohttp-3.14.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c23ec8ee9d5ab2f5421f9c7fffce208435607af27fd46d4a44e031954352838f", size = 1803911, upload-time = "2026-07-23T01:56:05.817Z" },
+ { url = "https://files.pythonhosted.org/packages/95/b5/85b099c299c3ffd38ad9b3e43694c8a346934e4a30c88c4fd5a841234f77/aiohttp-3.14.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e2667f0bbe7eb6c74eae5e9691441ad186e5845ca3cff63230fc09c4e7514f5d", size = 1876929, upload-time = "2026-07-23T01:56:08.413Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/b7/1da684a04175473fa4cddbf9a2f572e79514c3fd27a74597f43057d4f3da/aiohttp-3.14.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18cb43369747b2ae007bd2655fb8e63a099c2ff1d207962943636dac989b3147", size = 1761112, upload-time = "2026-07-23T01:56:10.918Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/16/bc4b55e3e5cb175fd69c53c90d60d2f47797cb343da5106e23863dc4dba4/aiohttp-3.14.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d77640cc618c1d99fc4f8589c0f24a730adfa54eb1e57ef7bf0c8dfb78da898c", size = 1583500, upload-time = "2026-07-23T01:56:13.613Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/e8/13a9d957a1ee40837f46aa30f0f4c657e673ad86a2e6362a9f9be20d26d9/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:53e5179d8abb5710f8e83ba207c41c8d1261fcffd4616500e15ca2b7a33be10a", size = 1713940, upload-time = "2026-07-23T01:56:15.969Z" },
+ { url = "https://files.pythonhosted.org/packages/38/05/d33c680c1bcf1c7e130f9cbfc1fc02fe8bb0c4af2a94a53dd5fb56131e5c/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:cd817772b2fcf2b8c0905795318485f9ec16eae60b29feb7f4c77085311637f0", size = 1724413, upload-time = "2026-07-23T01:56:18.591Z" },
+ { url = "https://files.pythonhosted.org/packages/85/1d/af798d306f7a74b6a632dbcabcf62a4c91391b7582d2a8c6d7712e2cc54e/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4e3ac92d90e92773b2362d506068e9a948192bd553e743c5b2429e28527c8661", size = 1770748, upload-time = "2026-07-23T01:56:21.074Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/92/ad720d472556a995049206867765e9410969684f86ee09423ff9969044c1/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:3f42e9b78301f11c8f861746175d8b9c1ccef713fcad9eab396e2f6db8ed4a22", size = 1577564, upload-time = "2026-07-23T01:56:23.475Z" },
+ { url = "https://files.pythonhosted.org/packages/60/ad/0ed7586cbef7a884e23a752fa2bb987a122e6a5dd50dab109258d0a95193/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:9d9edccfe496b476db5f398d97b865e9a6752bcf8aec4eef8390ce20fb64bb41", size = 1782080, upload-time = "2026-07-23T01:56:25.994Z" },
+ { url = "https://files.pythonhosted.org/packages/97/ea/dbaed0d73e8a69aad653b045dab451c67c2454bb731a37b45a86593e9422/aiohttp-3.14.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:1c5ec8fb1bcc31a8466f74aaf26c345d5c386fa4bd08a3f0eb9c7a4a3fe8b5bf", size = 1745813, upload-time = "2026-07-23T01:56:28.604Z" },
+ { url = "https://files.pythonhosted.org/packages/81/1b/6893d4bc57e434fc93a6c9217c637d967a0b651d989f6e3265179375754a/aiohttp-3.14.3-cp314-cp314-win32.whl", hash = "sha256:38901a84da3ce22249f6e860bf8f90d141bcab7da090cc398f8bb58c0e44b7da", size = 455872, upload-time = "2026-07-23T01:56:31.031Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/8b/c7baa1ba1eda4db6989baefe5de6d99834921b84ebd7918624febcb9f290/aiohttp-3.14.3-cp314-cp314-win_amd64.whl", hash = "sha256:8b3b60de05f3dcb6f6a00f818bb2ec781cee4de0645f59ccaf99b1d1823b6100", size = 481030, upload-time = "2026-07-23T01:56:33.365Z" },
+ { url = "https://files.pythonhosted.org/packages/22/8c/c29d067df825a2df88ca432db848aa2fe8199598359cc06c12b09320cac9/aiohttp-3.14.3-cp314-cp314-win_arm64.whl", hash = "sha256:1576145bdceeb92382d899751e12743a3a5b8e460a841e3e50543859e54864dc", size = 453669, upload-time = "2026-07-23T01:56:35.731Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/a4/9c033beb355d39b6147980597ec9645e4729243f686ee4dc73945de72030/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:8800c996b01c2772a783e3e46f3e1abd5823029adca0df54231960de9bfefa5b", size = 791403, upload-time = "2026-07-23T01:56:37.972Z" },
+ { url = "https://files.pythonhosted.org/packages/80/ca/87c32a0a7704583cfc49660bd817889bae5b830bf53b5dcb4e92145ac2da/aiohttp-3.14.3-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ebe8e504f058fe91223351cecd2d9d6946c9d241bb0250d898ffbdf584cc72b0", size = 526413, upload-time = "2026-07-23T01:56:40.523Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/d8/8ec0e471248c500acdce2be3f46db8fb62b5eb60efef072529cc85ee1d26/aiohttp-3.14.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:30402d03a7c0ff52bce290b57e564e9079fd9d0cb545c8aba73f86a103162d2e", size = 532135, upload-time = "2026-07-23T01:56:42.876Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/45/f8919fd936e8b79fcd9bda7b6d8e62613462a713f4f17987fd7c34399142/aiohttp-3.14.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fc7b5bfec6573f3ae844f457fdde5adeb713f8b8e4a81ad64fc207b49383716", size = 1922742, upload-time = "2026-07-23T01:56:45.528Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/ec/9ca76b28a27525b0cc53e20842e0228b022f301ce1f436b7d814b4aaf2df/aiohttp-3.14.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8a5fd34f7f7410d1730d5c2ba873cacb2eed3fede366feb268a70ba22581ed8f", size = 1787371, upload-time = "2026-07-23T01:56:48.045Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/04/6acdbf17315f7b55f1937e3387acb89a3cddeb4995689553d064af8e92ab/aiohttp-3.14.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:270d3dace9ca2f10f0da5d8ebe519b7a310fc6112ed916e32df5866df0888553", size = 1912623, upload-time = "2026-07-23T01:56:50.605Z" },
+ { url = "https://files.pythonhosted.org/packages/86/e6/438b0c79ca6f45eb9fd9817dd4c01a91919a38c0de5ee9e05e2b4dc0ece7/aiohttp-3.14.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3ae5b3a59436d089b5395d910121a390feed4d00578eb95a0fd1a329fe963100", size = 2005515, upload-time = "2026-07-23T01:56:53.153Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/6b/62cbd6577758699525f5c712d1ddef57d9875fbab0ae8d5f5a202fd598f8/aiohttp-3.14.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2498f0fe69ead802f9675beca44a7c21c62fdaa4ec5145ea1c3ad6edbee29f85", size = 1879906, upload-time = "2026-07-23T01:56:55.818Z" },
+ { url = "https://files.pythonhosted.org/packages/00/95/18bcbf830a21dc3aae24d8f6b6feaf3db1d2090242d00a7868db2ffb0b67/aiohttp-3.14.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0dc483c00da8b673abbb367eb6f8d8f4bcec30eb58529ea13cb42e7fd2dfa33", size = 1675849, upload-time = "2026-07-23T01:56:58.861Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/19/47f4968659c5e23606c3790c80fc624e691c153d036148449ee84d31b287/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c7d3a97c678d34fc5b59da671ee9cd630096ddc643e7b5a30d54a2a6f3574d3f", size = 1843496, upload-time = "2026-07-23T01:57:01.591Z" },
+ { url = "https://files.pythonhosted.org/packages/64/af/38c33c4dd82fddcb4e56c4653b6f1072a8edbc6b7fa15809f14932c41e2d/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f8fb78a83c9e5f741ca3a68cfb455c1f5bb83b4e7249a3848b3cd78d0a8563b0", size = 1827746, upload-time = "2026-07-23T01:57:05.131Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/9d/0537cda4885ac8f5b7053d164dd06312f4c483a4edcb8ee5b8aaf2a989bf/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:74ab5b6a9fb13e873e5a90946588baecaf488745e1db1a4a5c433f971f035098", size = 1853810, upload-time = "2026-07-23T01:57:08.043Z" },
+ { url = "https://files.pythonhosted.org/packages/19/fe/26f9c5e6458385aa86497836b0dea6fb2f027827d63f37c7856cce9286ee/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:bd52f811e65f6fb634b1047159657c98f52b407f8efec907bcfc09da9a4c0a25", size = 1668895, upload-time = "2026-07-23T01:57:10.837Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/4c/618b1db9b9ba079b8875d2cdf78e7c4a3bf72903bd5850fee7dd9544600a/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f0f177d1b195b9e06376cfd7d308d8a1b920909a609d03ac82a8c73bbb16d3b9", size = 1883833, upload-time = "2026-07-23T01:57:13.672Z" },
+ { url = "https://files.pythonhosted.org/packages/94/c6/bd959bd1e4771f9fd944e9e436224c48c77b018b73b519b5aad346335bcc/aiohttp-3.14.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:498c6c623134f8e09a3c4e60bcd607a0b4590dd7dbf08dd40851b27cbb520ccb", size = 1844251, upload-time = "2026-07-23T01:57:16.593Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/19/08d41839658bdd44a0ed2480f3891705ecb487ce28c0dde62c9040c997e0/aiohttp-3.14.3-cp314-cp314t-win32.whl", hash = "sha256:b304db572b4368edd8dda8a2274f73156fe15558fca4a917cb8a09fc47af5963", size = 474180, upload-time = "2026-07-23T01:57:19.306Z" },
+ { url = "https://files.pythonhosted.org/packages/99/5d/3cd6ef0a2b2851f7ab913b5b079334781bd50ff56a323e4454063377a080/aiohttp-3.14.3-cp314-cp314t-win_amd64.whl", hash = "sha256:b20032766aedf6261c7a566585a40867d092ac03a0d81592d5370ef9b054f99b", size = 500528, upload-time = "2026-07-23T01:57:21.762Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/37/cfd1ed540a4d318da025590d96b728e63713c09e9377950fc655dadeb856/aiohttp-3.14.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2e1161602f45a54de2ce0905243a95f58cb42dcd378402f3697f5e0b21e9d2e7", size = 469280, upload-time = "2026-07-23T01:57:24.241Z" },
+]
+
+[[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.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.14.2"
+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/61/cc/a381afa6efea9f496eff839d4a6a1aed3bfafc7b3ab4b0d1b243a12573dd/anyio-4.14.2.tar.gz", hash = "sha256:cfa139f3ed1a23ee8f88a145ddb5ac7605b8bbfd8592baacd7ce3d8bb4313c7f", size = 260176, upload-time = "2026-07-12T20:29:07.082Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/da/35/f2287558c17e29fafc8ef3daf819bb9834061cfa43bff8014f7df7f63bdc/anyio-4.14.2-py3-none-any.whl", hash = "sha256:9f505dda5ac9f0c8309b5e8bd445a8c2bf7246f3ce950121e45ea15bc41d1494", size = 125813, upload-time = "2026-07-12T20:29:05.763Z" },
+]
+
+[[package]]
+name = "asgiref"
+version = "3.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/26/3b59f2bdae5f640389becb1f673cded775287f5fc4f816309d9ca9a3f93d/asgiref-3.12.1.tar.gz", hash = "sha256:59dcb51c272ad209d59bed5708a64a333083e86017d7fcdd67498eeab7784340", size = 42378, upload-time = "2026-07-14T09:56:18.087Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c0/1b/54f4ad77cd8a584fa70746c47df988e002cf1ee1eba43364d46f87803647/asgiref-3.12.1-py3-none-any.whl", hash = "sha256:fe386d1c2bff7259ea95929266d12a8cf9a8b5a1c2598402967d8792e7a7c094", size = 25478, upload-time = "2026-07-14T09:56:16.926Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "26.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/8e/82a0fe20a541c03148528be8cac2408564a6c9a0cc7e9171802bc1d26985/attrs-26.1.0.tar.gz", hash = "sha256:d03ceb89cb322a8fd706d4fb91940737b6642aa36998fe130a9bc96c985eff32", size = 952055, upload-time = "2026-03-19T14:22:25.026Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/64/b4/17d4b0b2a2dc85a6df63d1157e028ed19f90d4cd97c36717afef2bc2f395/attrs-26.1.0-py3-none-any.whl", hash = "sha256:c647aa4a12dfbad9333ca4e71fe62ddc36f4e63b2d260a37a8b83d2f043ac309", size = 67548, upload-time = "2026-03-19T14:22:23.645Z" },
+]
+
+[[package]]
+name = "build"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "os_name == 'nt'" },
+ { name = "packaging" },
+ { name = "pyproject-hooks" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/78/e0/df5e171f685f82f37b12e1f208064e24244911079d7b767447d1af7e0d70/build-1.5.0.tar.gz", hash = "sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647", size = 89796, upload-time = "2026-04-30T03:18:25.17Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0d/fe/6bea5c9162869c5beba5d9c8abbed835ec85bf1ec1fba05a3822325c45f3/build-1.5.0-py3-none-any.whl", hash = "sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f", size = 26018, upload-time = "2026-04-30T03:18:23.644Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.7.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/c2/24167ea9858356b47a87a50d39908bfdb72ceeefe0041586e704e5376b3a/certifi-2026.7.22.tar.gz", hash = "sha256:741e2c3b351ddf169a738da9f2c048608ff7f2c5cc02f1ebc6b118bb090d5d55", size = 138112, upload-time = "2026-07-22T03:35:12.644Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl", hash = "sha256:62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775", size = 136983, upload-time = "2026-07-22T03:35:11.276Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/5f/ff100cae70ebe9d8df1c01a00e510e45d9adb5c1fdda84791b199141de97/cffi-2.1.0.tar.gz", hash = "sha256:efc1cdd798b1aaf39b4610bba7aad28c9bea9b910f25c784ccf9ec1fa719d1f9", size = 531036, upload-time = "2026-07-06T21:34:30.382Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1e/85/990925db5df586ec90beb97529c853497e7f85ba0234830447faf41c3057/cffi-2.1.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:df2b82571a1b30f58a87bf4e5a9e78d2b1eff6c6ce8fd3aa3757221f93f0863f", size = 184829, upload-time = "2026-07-06T21:32:44.324Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/92/e7bb136ad6b5352603732cf907ef862ca103f20f2031c1735a46300c20c9/cffi-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:78474632761faa0fb96f30b1c928c84ebcf68713cbb80d15bab09dfe61640fde", size = 184728, upload-time = "2026-07-06T21:32:45.683Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/c0/d1ec30ffb370f748f2fb54425972bfef9871e0132e82fb589c46b6676049/cffi-2.1.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:5972433ad71a9e46516584ef60a0fda12d9dc459938d1539c3ddecf9bdc1368d", size = 214815, upload-time = "2026-07-06T21:32:48.557Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/dc/5620cf930688be01f2d673804291de757a934c90b946dbdc3d84130c2ea4/cffi-2.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b6422532152adf4e59b110cb2808cee7a033800952f5c036b4af047ee43199e7", size = 222429, upload-time = "2026-07-06T21:32:49.848Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/a4/77b53abbf7a1e0beb9637edbef2a94d15f9c822f591e85d439ffd91519a6/cffi-2.1.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:46b1c8db8f6122420f32d02fffb924c2fe9bc772d228c7c711748fff56aabb2b", size = 210315, upload-time = "2026-07-06T21:32:51.221Z" },
+ { url = "https://files.pythonhosted.org/packages/58/0c/f528df19cc94b675087324d4760d9e6d5bfae97d6217aa4fac43de4f5fcc/cffi-2.1.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9fafc5aa2e2a39aaf7f8cc0c1f044a9b07fca12e558dca53a3cc5c654ad67a7", size = 208859, upload-time = "2026-07-06T21:32:52.512Z" },
+ { url = "https://files.pythonhosted.org/packages/62/f2/c9522a81c32132799a1972c39f5c5f8b4c8b9f00488a23feaa6c06f07741/cffi-2.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1e9f50d192a3e525b15a75ab5114e442d83d657b7ec29182a991bc9a88fd3a66", size = 221844, upload-time = "2026-07-06T21:32:53.704Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/28/bd53988b9833e8f8ad539d26f4c07a6b3f6bcb1e9e02e7ca038250b3428d/cffi-2.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:98fff996e983a36d3aa2eca83af40c5821202e7e6f32d13ae94e3d2286f10cfe", size = 225287, upload-time = "2026-07-06T21:32:54.907Z" },
+ { url = "https://files.pythonhosted.org/packages/79/99/0d0fd37f055224085f42bbb2c022d002e17dde4a97972822327b07d84101/cffi-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:379de10ce1ba048b1448599d1b37b24caee16309d1ac98d3982fc997f768700b", size = 223681, upload-time = "2026-07-06T21:32:56.329Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/80/c138990aa2a70b1a269f6e06348729836d733d6f970867943f61d367f8cc/cffi-2.1.0-cp312-cp312-win32.whl", hash = "sha256:9b8f0f26ca4e7513c534d351eca551947d053fac438f2a04ac96d882909b0d3a", size = 175269, upload-time = "2026-07-06T21:32:57.777Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/eb/f636456ff21a83fc13c032b58cc5dde061691546ac79efa284b2989b7982/cffi-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:c97f080ea627e2863524c5af3836e2270b5f5dfff1f104392b959f8df0c5d384", size = 185881, upload-time = "2026-07-06T21:32:59.253Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/2c/400ea43e721727dca8a65c4521390e9196757caba4a45643acb2b63271b8/cffi-2.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:6d194185eabd279f1c05ebe3504265ddfc5ad2b58d0714f7db9f01da592e9eb6", size = 180088, upload-time = "2026-07-06T21:33:02.278Z" },
+ { url = "https://files.pythonhosted.org/packages/96/88/a996879e2eeccb815f6e3a5967b12a308257412acec882039d386bd2aa7b/cffi-2.1.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:10537b1df4967ca26d21e5072d7d54188354483b91dc75058968d3f0cf13fbda", size = 194331, upload-time = "2026-07-06T21:33:03.697Z" },
+ { url = "https://files.pythonhosted.org/packages/58/85/7ae00d5c8dd6266f4e944c3db630f3c5c9a98b61d469c714d848b1d8138a/cffi-2.1.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:a95b05f9baf29b91171b3a8bd2020b028835243e7b0ff6bb23e2a3c228518b1b", size = 196966, upload-time = "2026-07-06T21:33:05.353Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/e9/45c3a76ad8d43ad9261f4c95436da61128d3ca545d72b9612c0ab5be0b1c/cffi-2.1.0-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:15faec4adfff450819f3aee0e2e02c812de6edb88203aa58807955db2003472a", size = 184795, upload-time = "2026-07-06T21:33:06.699Z" },
+ { url = "https://files.pythonhosted.org/packages/84/4c/82f132cb4418ee6d953d982b19191e87e2a6372c8a4ce36e50b69d6ade4a/cffi-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:716ff8ec22f20b4d988b12884086bcef0fc99737043e503f7a3935a6be99b1ea", size = 184746, upload-time = "2026-07-06T21:33:08.071Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/1c/4ed5a0e5bdca6cbc275556de3328dd1b76fd0c11cc13c88fe66d1d8715f2/cffi-2.1.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:63960549e4f8dc41e31accb97b975abaecfc44c03e396c093a6436763c2ea7db", size = 214747, upload-time = "2026-07-06T21:33:09.671Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/a6/e879bb68cc23a2bc9ba8f4b7d8019f0c2694bad2ab6c4a3701d429439f58/cffi-2.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ff067a8d8d880e7809e4ac88eb009bb848870115317b306666502ccad30b147f", size = 222392, upload-time = "2026-07-06T21:33:10.896Z" },
+ { url = "https://files.pythonhosted.org/packages/88/f6/01890cfd63c08f8eb96a8319b0443690197d240a8bd6346048cf7bde9190/cffi-2.1.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3b926723c13eba9f81d2ef3820d63aeceec3b2d4639906047bf675cb8a7a500d", size = 210285, upload-time = "2026-07-06T21:33:12.251Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/cf/2b684132056f438567b61e19d690dd31cd0921ace051e0a458be6074369e/cffi-2.1.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:47ff3a8bfd8cb9da1af7524b965127095055654c177fcfc7578debcb015eecd0", size = 208801, upload-time = "2026-07-06T21:33:13.617Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/08/f2e7d62c460faae0926f2d6e423694aa409ced3bc1fe2927a0a6e5f05416/cffi-2.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:799416bae98336e400981ff6e532d67d5c709cfb30afb79865a1315f94b0e224", size = 221808, upload-time = "2026-07-06T21:33:15.466Z" },
+ { url = "https://files.pythonhosted.org/packages/38/37/04f54b8e63a02f3d908332c9effbf8c366167c6f733ed8a3d4f79b7e2a1e/cffi-2.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:961be50688f7fba2fa65f63712d3b9b341a22311f5253460ce933f52f0de1c8c", size = 225241, upload-time = "2026-07-06T21:33:16.869Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/d6/c72eecca433cd3e681c65ed313ab4835d9d4a379704d0f628a6a05f51c2e/cffi-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bf5c6cf48238b0eb4c086978c492ad1cbc22373fc5b2d7353b3a598ce6db887a", size = 223588, upload-time = "2026-07-06T21:33:18.239Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/4b/e706f67279140f92939da3475ad610df18bfd52d50f14953a8e5fede71d5/cffi-2.1.0-cp313-cp313-win32.whl", hash = "sha256:db3eb7d46527159a878ec3460e9d40615bc25ba337d477db681aea6e4f05c5d2", size = 175248, upload-time = "2026-07-06T21:33:19.799Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/47/59eb7975cb0e4ef0afa764ea945b29a5bb4537a9f771cb7d6c8a5dd74c95/cffi-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:8e74a6135550c4748af665b1b1118b6aab33b1fc6a16f9aff630af107c3b4512", size = 185717, upload-time = "2026-07-06T21:33:21.47Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/af/34fee85c48f8d94efc8597bc09470c9dd274c145f1c12e0fbc6ab6d38d74/cffi-2.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:2282cd5e38aa8accd03e99d1256af8411c84cdbee6a89d841b563fdbd1f3e50f", size = 180114, upload-time = "2026-07-06T21:33:22.515Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/f0/81478e482afa03f6d18dc8f2afb5edc45b3080853b634b5ed91961be0998/cffi-2.1.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2117334c3af3bdcb9a88522b844a2bdb5efdc4f71c6c822df55486ae1c3347a", size = 194142, upload-time = "2026-07-06T21:33:23.657Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/95/8de304305cd9204974b0ca051b86d307cafca13aa575a0ef1b44d92c0d8c/cffi-2.1.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:702c436735fbe99d59ada02a1f65cfc0d31c0ee8b7290912f8fbc5cd1e4b16c3", size = 196819, upload-time = "2026-07-06T21:33:25.007Z" },
+ { url = "https://files.pythonhosted.org/packages/20/71/7c8372d30e42415602ed9f268f7cfd66f1b855fed881ecd168bcb45dbc0b/cffi-2.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1ff3456eab0d889592d1936d6125bbfbc7ae4d3354a700f8bd80450a66445d4d", size = 184965, upload-time = "2026-07-06T21:33:26.605Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/5c/584e626835f0375c928176c04137c96927165cb8733cdb3150ec04e5ee5e/cffi-2.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c4165821e131d6d4ca444347c2b694e2311bcfa3fe5a861cc72968f28867beac", size = 184952, upload-time = "2026-07-06T21:33:27.823Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/d2/065fcae1c73979fac8e054462478d0ff8a29c40cdc2ed7ea5676a061df53/cffi-2.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:276f20fffd7b396e12516ba8edf9509210ac248cbbc5acbc39cd512f9f59ebe6", size = 222353, upload-time = "2026-07-06T21:33:29.178Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/a5/e8bbb1ce5b3ac2f53ad6a10bde44318a5a8d99d4f4a000d44a6e39aeb3e4/cffi-2.1.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:7d5980a3433d4b71a5e120f9dd551403d7824e31e2e67124fe2769c404c06913", size = 210051, upload-time = "2026-07-06T21:33:30.534Z" },
+ { url = "https://files.pythonhosted.org/packages/28/ed/c127d3ac36e899c965e3361357c3befacd6578c03f40125183e41c3b219e/cffi-2.1.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:6ca4919c6e4f89aa99c42510b42cf54596892c00b3f9077f6bdd1505e24b9c8d", size = 208630, upload-time = "2026-07-06T21:33:31.753Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/d7/97d3136f81db489ec8d1d67748c110d6c994268fd7528014aa9f2b085e4e/cffi-2.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d53d10f7da99ae46f7373b9150393e9c5eab9b224909982b43832668de4779f5", size = 221593, upload-time = "2026-07-06T21:33:33.044Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/27/93195977168ee63aed233a1a0993a2178798654d1f4bddcdd321d6fd3b21/cffi-2.1.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c351efb95e832a853a29361675f33a7ce53de1a109cd73fd47af0712213aa4ce", size = 225146, upload-time = "2026-07-06T21:33:34.224Z" },
+ { url = "https://files.pythonhosted.org/packages/b3/c1/6dbd291ee2ae5a50a034aa057207081f545923bbf15dad4511e985aafff5/cffi-2.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf7c7a88e2bac086f06d14577332760bdeecc42bdec8ac4077f6260557d9326", size = 223240, upload-time = "2026-07-06T21:33:35.57Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/6f/ade5ce9863a57992a6ea3d0d10d7e29b8749fc127204b3d493d667b2815f/cffi-2.1.0-cp314-cp314-win32.whl", hash = "sha256:1854b724d00f6654c742097d5387569021be12d3a0f770eae1df8f8acfcc6acd", size = 177723, upload-time = "2026-07-06T21:33:51.626Z" },
+ { url = "https://files.pythonhosted.org/packages/41/de/92b9eeed4ae4a21d6fd9b2a2c8505cbed573299902ea73981cc13f7ff62c/cffi-2.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:1b96bfe2c4bd825681b7d311ad6d9b7280a091f43e8f63da5729638083cd3bfb", size = 187937, upload-time = "2026-07-06T21:33:53.403Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/1a/cc6ae6c2913a03aab8898eee57963cf1035b8df5872ed8b9115fcc7e2be8/cffi-2.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:7d28dff1db6764108bc30788d85d61c876beff416d9a49cb9dd7c5a9f34f5804", size = 183001, upload-time = "2026-07-06T21:33:54.74Z" },
+ { url = "https://files.pythonhosted.org/packages/14/f0/134c00ce0779ec86dea2aa1aac69339c2741a8045072676763512363a2ea/cffi-2.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7ea6b3e2c4250ff1de21c630fe72d0f63eb95c2c32ffbf64a358cf4a8836d714", size = 188538, upload-time = "2026-07-06T21:33:36.792Z" },
+ { url = "https://files.pythonhosted.org/packages/50/d8/3b86aba791cb610d24e8a3e1b2cd529e71fa15096b04e4d4e360049d4a4c/cffi-2.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6af371f3767faeffc6ac1ef57cdfd25844403e9d3f476c5537caee499de96376", size = 188230, upload-time = "2026-07-06T21:33:38.011Z" },
+ { url = "https://files.pythonhosted.org/packages/14/d0/117dcd9209255ad8571fbc8c92ef32593a1d294dcec91ddc4e4db50606f2/cffi-2.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eb4e8997a49aa2c08a3e43c9045d224448b8941d88e7ac163c7d383e560cbf98", size = 223899, upload-time = "2026-07-06T21:33:39.514Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/3d/f20f8b886b254e3ad10e15cd4186d3aed49f3e6a35ab37aab9f8f25f7c03/cffi-2.1.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:bf01d8c84cbea96b944c73b22182e6c7c432b3475632b8111dbfdc95ddad6e13", size = 211652, upload-time = "2026-07-06T21:33:40.851Z" },
+ { url = "https://files.pythonhosted.org/packages/28/3b/fad54de07260b93ddeef4b96d0131d57ea900675df1d410ae1deee52d7a6/cffi-2.1.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:33eb1ad83ebe8f313e0df035c406227d55a79456704a863fad9842136af5ad7d", size = 210755, upload-time = "2026-07-06T21:33:42.183Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/82/3d5c705acb7abbba9bbd7d79b8e62e0f25b6120eb7ae6ac49f1b721722fe/cffi-2.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ac0f1a2d0cfa7eea3f2aaf006ab6e70e8feeb16b75d65b7e5939982ca2f11056", size = 223933, upload-time = "2026-07-06T21:33:43.603Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/d0/47e338384ab6b1004241002fa616301020cea4fc95f283506565d252f276/cffi-2.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c16914df9fb7f500e440e6875fa23ff5e0b31db01fa9c06af98d59a91f0dc2e4", size = 226749, upload-time = "2026-07-06T21:33:45.046Z" },
+ { url = "https://files.pythonhosted.org/packages/70/25/65bd5b58ea4bfdfc15cde02cb5365f89ef8ab8b2adfb8fe5c4bd4233382f/cffi-2.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5ecbd0499275d57506d397eebe1981cee87b47fcd9ef5c22cab7ed7644a39a94", size = 225703, upload-time = "2026-07-06T21:33:46.374Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/78/aa01ac599a8a4322533d45a1f9bc93b338276d2d59dabbe7c6d92a775c81/cffi-2.1.0-cp314-cp314t-win32.whl", hash = "sha256:7d034dcffa09e9a46c93fa3a3be402096cb5354ac6e41ab8e5cc9cd8b642ad76", size = 182857, upload-time = "2026-07-06T21:33:47.696Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/26/d00496b22de4d4228f32dde94ad996f350c8aad676d63bcca0743c8dea4d/cffi-2.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0582a58f3051372229ca8e7f5f589f9e5632678208d8636fea3676711fdf7fe5", size = 194065, upload-time = "2026-07-06T21:33:48.953Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/dd/0c7dbf815a579ff005008a2d815a55d6bb047c349eef536d9dc53d3f0a8d/cffi-2.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:510aeeeac94811b138077451da1fb18b308a5feab47dd2b603af55804155e1c8", size = 186404, upload-time = "2026-07-06T21:33:50.309Z" },
+ { url = "https://files.pythonhosted.org/packages/55/c7/8c8c50cb11c6750051daf12164098a9a6f027ac4356967fd4d800a07f242/cffi-2.1.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:2e9dabb9abcb7ad15938c7196ad5c1718a4e6d33cc79b4c0209bdb64c4a54a5c", size = 194121, upload-time = "2026-07-06T21:33:56.109Z" },
+ { url = "https://files.pythonhosted.org/packages/99/e2/67680bf19a6b60d2bb7ff83baefa2a4c3d2d7dc0f3277034b802e1fc504c/cffi-2.1.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:37f525a7e7e50c017fdebe58b787be310ad59357ae43a053943a6e1a6c526001", size = 196820, upload-time = "2026-07-06T21:33:57.288Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/da/4bbe583a3b3a5c8c60892124fe17f3fa3656523faf0d3484eae90f091853/cffi-2.1.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:95f2954c2c9473d892eca6e0409f3568b37ab62a8eedb122461f73cc273476e3", size = 184936, upload-time = "2026-07-06T21:33:58.765Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/4b/1f4c36ab273980d7aa75bb126ea4f8971f24a96108acad3a0a084028c57b/cffi-2.1.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:cdf2448aab5f661c9315308ec8b93f4e8a1a67a3c733f8631067a2b67d5913dc", size = 185045, upload-time = "2026-07-06T21:34:00.085Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/c3/ad299dc38f3583f8d916b299f028af418a9ec98bc695fcbebeae7420691c/cffi-2.1.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:90bec57cf82089383bd06a605b3eb8daebf7e5a668520beaf6e327a83a947699", size = 222342, upload-time = "2026-07-06T21:34:01.814Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/d8/df4543cc087245044ed02ef3ad8e0a26619d0075ac7a77a12dc81177851b/cffi-2.1.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6274dcb2d15cef48daa73ed1be5a40d501d74dccd0cd6db364776d12cb6ba022", size = 210073, upload-time = "2026-07-06T21:34:03.255Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/0e/fac738d73728c6cea2a88a2883dca54892496cbba88a1dc1f2909cb8a6f5/cffi-2.1.0-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:2b71d409cccee78310ab5dec549aed052aaea483346e282c7b02362596e01bb0", size = 208551, upload-time = "2026-07-06T21:34:04.433Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/3f/0b04a700dd64f465c93020253a793a82c9b4dff9961f48facd0df945d9b8/cffi-2.1.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7d3538f9c0e50670f4deb93dbb696576e60590369cae2faf7de681e597a8a1f1", size = 221649, upload-time = "2026-07-06T21:34:06.157Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/7c/b7379a5704c79eda57ce075869ba70a0368d1c850f803b3c0d078d39dcaf/cffi-2.1.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:8f9ec95b8a043d3dfbc74d9abc6f7baf524dd27a8dc160b0a32ff9cdab650c28", size = 225203, upload-time = "2026-07-06T21:34:07.489Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/02/d5e6c43ea85c41bda2a184a3418f195fe7cf602967a8d2b94e085b83deef/cffi-2.1.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:af5e2915d41fe6c961694d7bfdc8562942638200f3ce2765dfb8b745cf997629", size = 223263, upload-time = "2026-07-06T21:34:08.712Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/d8/772b8259bf75749adffb1c546828978381fb516f60cf701f6c83daf60c85/cffi-2.1.0-cp315-cp315-win32.whl", hash = "sha256:0a42c688d19fca6e095a53c6a6e2295a5b050a8b289f109adab02a9e61a25de6", size = 177696, upload-time = "2026-07-06T21:34:26.355Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/dd/afa2191fc6d57fedd26e5844a2fe2fcc0bbfa00961bbaa5a41e4921e7cca/cffi-2.1.0-cp315-cp315-win_amd64.whl", hash = "sha256:bccbbb5ee76a61f9d99b5bf3846a51d7fca4b6a732fe46f89295610edaf41853", size = 187914, upload-time = "2026-07-06T21:34:27.58Z" },
+ { url = "https://files.pythonhosted.org/packages/05/ef/6cd4f8c671517162379dc79cfae5aea9106bc38abb89628d5c16adf6a838/cffi-2.1.0-cp315-cp315-win_arm64.whl", hash = "sha256:8d35c139744adb3e727cd51b1a18324bbe44b8bd41bf8322bca4d41289f48eda", size = 183004, upload-time = "2026-07-06T21:34:28.905Z" },
+ { url = "https://files.pythonhosted.org/packages/11/b6/12fc55092817a5faa26fb8c40c7f9d662e11a46ee248c137aafc42517d92/cffi-2.1.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f9912624a0c0b834b7520d7769b3644453aabc0a7e1c839da7359f050750e9bc", size = 188378, upload-time = "2026-07-06T21:34:09.926Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/2e/cdac88979f295fde5daa69622c7d2111e56e7ceb94f211357fbe452339e4/cffi-2.1.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:df92f2aba50eb4d96718b68ef76f2e57a57b54f2fa62333496d16c6d585a85ca", size = 188319, upload-time = "2026-07-06T21:34:11.101Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/27/1d0b408497e41a74795af122d7b603c418c5fed0171450f899afd04e594f/cffi-2.1.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0520e1f4c35f44e209cbbb421b67eec42e6a157f59444dfb6058874ff3610e5d", size = 223904, upload-time = "2026-07-06T21:34:12.606Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/31/e115c985105dd7ffb32444505f18ceb874bb42d992af05d5dced7ecf1980/cffi-2.1.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:3681e031db29958a7502f5c0c9d6bbc4c36cb20f7b104086fa642d1799631ff8", size = 211554, upload-time = "2026-07-06T21:34:13.987Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/67/9e6e09409336d9e515c58367e7cfcf4f89df06ad25252675595a58eb59d5/cffi-2.1.0-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:762f99479dcb369f60ab9017ad4ab97a36a1dd7c1ee5a3b15db0f4b8659120cd", size = 210795, upload-time = "2026-07-06T21:34:15.972Z" },
+ { url = "https://files.pythonhosted.org/packages/19/e5/d3cc82a4a0be7902af279c04181ad038449c096734464a5ae1de3e1401bd/cffi-2.1.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0611e7ebf90573a535ebdc33ae9da222d037853983e13359f580fab781ca017f", size = 223843, upload-time = "2026-07-06T21:34:17.509Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/65/b434abc97ce7cecc2c640fde160507c0ecc7e21544b483ba3325d2e2ea17/cffi-2.1.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:86cf8755a791f72c85dc287128cc62d4f24d392e3f1e15837245623f4a33cccc", size = 226773, upload-time = "2026-07-06T21:34:19.05Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/9f/d4dc66ca651eb1145a133314cda721abf13cfac3d28c4a0402263ae6ad75/cffi-2.1.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:ba00f661f8ba35d075c937174e27c2c421cec3942fd2e0ea3e66996757c0fdd9", size = 225719, upload-time = "2026-07-06T21:34:20.576Z" },
+ { url = "https://files.pythonhosted.org/packages/68/5a/e536c528bc8057496c360c0978559a2dc45653f89dd6151078aa7d8fca1a/cffi-2.1.0-cp315-cp315t-win32.whl", hash = "sha256:cb96698e3c7413d906ce83f8ffd245ec1bd94707541f299d0ce4d6b0193e982b", size = 182760, upload-time = "2026-07-06T21:34:22.059Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/0b/0ffe8b82d3875bced5fa1e7986a7a46b748262a40ab7f60b475eb9fb1bb3/cffi-2.1.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f146d154428a2523f9cc7936c02353c2459b8f6cf07d3cd1ee1c0a611109c5d5", size = 193769, upload-time = "2026-07-06T21:34:23.589Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/17/1073b53b68c9b5ca6914adf5f8bf55aacc2d3be102418c90700160ea8605/cffi-2.1.0-cp315-cp315t-win_arm64.whl", hash = "sha256:cbb7640ce37159548d2147b5b8c241f962143d4c71231431820783f4dc78f210", size = 186405, upload-time = "2026-07-06T21:34:24.857Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.9"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/2a/23f34ec9d04624958e137efdc394888716353190e75f25dd22c7a2c7a8aa/charset_normalizer-3.4.9.tar.gz", hash = "sha256:673611bbd43f0810bec0b0f028ddeaaa501190339cac411f347ac76917c3ae7b", size = 152439, upload-time = "2026-07-07T14:34:58.454Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/70/4a/ecbd131485c07fcdfad54e28946d513e3da22ef3b4bd854dcafae54ec739/charset_normalizer-3.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:45b0cc4e3556cd875e09102988d1ab8356c998b596c9fced84547c8138b487a0", size = 319300, upload-time = "2026-07-07T14:33:15.666Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/96/5d9364e3342d69f3a045e1777bc47c85c383e6e9466d561b33fdb419d1f9/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b2aff1c7b3884512b9512c3eaadd9bab39fb45042ffaaa1dd08ff2b9f8109d9", size = 215802, upload-time = "2026-07-07T14:33:17.031Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/4c/5361f9aa7f2cb58d94f2ab831b3d493f69efb1d239654b4744e3c09527cb/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9104ed0bd76a429d46f9ec0dbc9b08ad1d2dcdf2b00a5a0daa1c145329b35b44", size = 237171, upload-time = "2026-07-07T14:33:18.576Z" },
+ { url = "https://files.pythonhosted.org/packages/50/78/ce342ca4ff30b2eb49fe6d9578df85974f90c67d294113e94efdd9664cbd/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7b86a2b16095d250c6f58b3d9b2eee6f4147754344f3dab0922f7c9bf7d226c9", size = 233075, upload-time = "2026-07-07T14:33:20.084Z" },
+ { url = "https://files.pythonhosted.org/packages/01/c4/4fa4c8b3097a11f3c5f09a35b72ed6855fb1d332469504962ab7bafcc702/charset_normalizer-3.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5e226f6218febc71f6c1fc2fafb91c226f75bdc1d8fb12d66823716e891608fd", size = 224256, upload-time = "2026-07-07T14:33:21.747Z" },
+ { url = "https://files.pythonhosted.org/packages/87/3a/ad914516df7e358a81aae018caa5e0470ba827fa6d763b1d2e87d920a5f6/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:90c44bc373b7687f6948b693cceaea1348ae0975d7474746559494468e3c1d84", size = 208784, upload-time = "2026-07-07T14:33:23.313Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/74/3c12f9755717dfe5c5c87da63f35d765fa0c00382ec26bf23f7fae34f2ba/charset_normalizer-3.4.9-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9cdef90ae47919cae358d8ab15797a800ed41da7aba5d72419fb510729e2ed4b", size = 219928, upload-time = "2026-07-07T14:33:24.814Z" },
+ { url = "https://files.pythonhosted.org/packages/33/9a/895095b83e7907abd6d3d99aad3a38ad0d9686cc186cb0c94c24320fe63e/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:60f44ade2cf573dad7a277e6f8ca9a51a21dda572b13bd7d8539bb3cd5dbedde", size = 218489, upload-time = "2026-07-07T14:33:26.42Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/34/ef5c05f412f42520d7709b7d3784d19640839eb7366ded1755511585429f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a1786910334ed46ab1dd73222f2cd1e05c2c3bb39f6dddb4f8b36fc382058a39", size = 210267, upload-time = "2026-07-07T14:33:27.952Z" },
+ { url = "https://files.pythonhosted.org/packages/83/dc/9b29fa4412b318bf3bfea985c35d67eb55e04b59a7c3f2237168b0e0be6f/charset_normalizer-3.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:03d07803992c6c7bbc976327f34b18b6160327fc81cb82c9d504720ac0be3b62", size = 226030, upload-time = "2026-07-07T14:33:29.397Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/42/6dbc00b8cd16011691203e33570fa42ed5746599a2e878112d16eab403a3/charset_normalizer-3.4.9-cp312-cp312-win32.whl", hash = "sha256:78841cccf1af7b40f6f716338d50c0902dbe88d9f800b3c973b7a9a0a693a642", size = 151185, upload-time = "2026-07-07T14:33:30.781Z" },
+ { url = "https://files.pythonhosted.org/packages/80/cc/f920afd1a23c58ccd53c1d36085a71893a4737ff5e66e0371efab6809850/charset_normalizer-3.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:4b3dac63058cc36820b0dd072f89898604e2d39686fe05321729d00d8ac185a0", size = 162557, upload-time = "2026-07-07T14:33:32.176Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/e6/0386d43a261ff4e4b30c5857af7df877254b46bec7b9d1b74b6bf969a90b/charset_normalizer-3.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:78fa18e436a1a0e58dbd7e02fc4473f3f32cceb12df9dfca542d075961c307d2", size = 152665, upload-time = "2026-07-07T14:33:33.711Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/06/97ec2aeae780b31d742b6352218b43841a6871e2564578ca522dce4a45c3/charset_normalizer-3.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:440eede837960000d74978f0eba527be106b5b9aee0daf779d395276ed0b0614", size = 317688, upload-time = "2026-07-07T14:33:35.408Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/39/8ff066c672434225f8d25f8b739f992af250944392173dcc88362681c9bf/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:21e764fd1e70b6a3e205a0e46f3051701f98a8cb3fad66eeb80e48bb502f8698", size = 214982, upload-time = "2026-07-07T14:33:36.996Z" },
+ { url = "https://files.pythonhosted.org/packages/92/8f/3a47a3667c83c2df9483d91644c6c107de3bf8874aa1793da9d3012eb986/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e4fd89cc178bced6ad29cb3e6dd4aa63fa5017c3524dbd0b25998fb64a87cc8b", size = 236460, upload-time = "2026-07-07T14:33:38.536Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/60/b22cdbee7e4013dab8b0d7647fc6181120fbbbc8f7025c226d15bd5a47fc/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:bd47ba7fc3ca94896759ea0109775132d3e7ab921fbf54038e1bab2e46c313c9", size = 232003, upload-time = "2026-07-07T14:33:40.059Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/f8/72eb13dcabe7257035cea8aefd922caad2f110d252bf9f67c4c2ca763aee/charset_normalizer-3.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:84fd18bcc17526fc2b3c1af7d2b9217d32c9c04448c16ec693b9b4f1985c3d33", size = 223149, upload-time = "2026-07-07T14:33:41.631Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/3e/faee8f9de92b14ee1198e9163252bb15efee7301b31256a3b6d9ebfdd0dd/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:5b10cd92fc5c498b35a8635df6d5a100207f88b63a4dc1de7ef9a548e1e2cd63", size = 207901, upload-time = "2026-07-07T14:33:43.209Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/25/45f30093ae27dd7b92a793b61882a38685f993700113ca36e0c9c14965e1/charset_normalizer-3.4.9-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a4fbdde9dd4a9ce5fd52c2b3a347bb50cc89483ef783f1cb00d408c13f7a96c0", size = 219176, upload-time = "2026-07-07T14:33:44.725Z" },
+ { url = "https://files.pythonhosted.org/packages/48/18/c8f397329c35e32f6a837e488986f4ae03bd2abebc453b48714991630c2f/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:416c229f77e5ea25b3dfd4b582f8d73d7e43c22320302b9ab128a2d3a0b38efe", size = 217356, upload-time = "2026-07-07T14:33:46.192Z" },
+ { url = "https://files.pythonhosted.org/packages/86/7e/5ce0bba863470fd1902d5e5843968951bddf38abe4742fc97116ef4598b3/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:75286256590a6320cf106a0d28970d3560aad9ee09aa7b34fb40524792436d35", size = 209614, upload-time = "2026-07-07T14:33:47.705Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/ef/2473d3c4d869155be4af1191111d59c4d5c4e0173026f7e85b176e23bf65/charset_normalizer-3.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:69b157c5d3292bcd443faca052f3096f637f1e074b98212a933c074ae23dc3b8", size = 224991, upload-time = "2026-07-07T14:33:49.238Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/a3/53ddae3db108a088156aa8ddfafd411ebbc1340f48c5573f697b27f69a39/charset_normalizer-3.4.9-cp313-cp313-win32.whl", hash = "sha256:51307f5c71007673a2bf8232ad973483d281e74cb99c8c5a990af1eefa6277d9", size = 150622, upload-time = "2026-07-07T14:33:50.711Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/ef/6953a77c7cf2c2ff9998e6f575ab3e380119f100223381565a4f94c1f836/charset_normalizer-3.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:fe2c7201c642b7c308f1675355ad7ff7b66acfe3541625efe5a3ad38f29d6115", size = 161947, upload-time = "2026-07-07T14:33:52.197Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/fb/d560d1d1555debbfe7849d9cac6145c1b537709d79576bf22557ed803b82/charset_normalizer-3.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:611057cc5d5c0afc743ba8be6bd828c17e0aaa8643f9d0a9b9bb7dea80eb8012", size = 152594, upload-time = "2026-07-07T14:33:53.486Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/8d/496817fa0944239ecae662dd57ea765cfeaec6a735f9f025d4b7b72e7143/charset_normalizer-3.4.9-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:0327fcd59a935777d83410750c50600ee9571af2846f71ce40f25b13da1ef380", size = 317253, upload-time = "2026-07-07T14:33:54.994Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/f9/ef4a69ea338ad3c0deceea0f5f7d2380ae8b52132b06d652cb0d2cd86706/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a79d9f4d8001473a30c163556b3c3bfebec837495a412dde78b51672f6134f9", size = 215898, upload-time = "2026-07-07T14:33:56.334Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/e7/5ddfd76fc061eb52de219658a4aa431cbacadf0a0219c8854f00da50d289/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:33bdcc2a32c0a0e861f60841a512c8acc658c87c2ac59d89e3a46dacf7d866e4", size = 236718, upload-time = "2026-07-07T14:33:57.9Z" },
+ { url = "https://files.pythonhosted.org/packages/49/ba/768fa3f36048d81c477a0ce61f813bc1454d80917ccfe550abd9f44f5e24/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f840ed6d8ecba8255df8c42b87fadeda98ddfc6eeec05e2dc66e26d46dd6f58a", size = 232519, upload-time = "2026-07-07T14:33:59.811Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/c4/b3e049d2aa3766180c78507110543d9d50894cc97f57de543f1be521dcdc/charset_normalizer-3.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c25fe15c70c59eb7c5ce8c06a1f3fa1da0ecc5ea1e7a5922c40fd2fa9b0d5046", size = 223143, upload-time = "2026-07-07T14:34:01.517Z" },
+ { url = "https://files.pythonhosted.org/packages/19/79/55c32d06d76ae4feafe053f061f3e3ab70bcf19f4007797ce8c3efda7830/charset_normalizer-3.4.9-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:f7fb7d750cfa0a070d2c24e831fd3481019a60dd317ea2b39acbcebc08b6ed81", size = 206742, upload-time = "2026-07-07T14:34:03.04Z" },
+ { url = "https://files.pythonhosted.org/packages/10/e0/47c079dd82d217c807479cd59ffd30af56307ea31c108b75758970459ad3/charset_normalizer-3.4.9-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d1c96a7a18b9690a4d46df09e3e3382406ae3213727cd1019ebade1c4a81917", size = 219191, upload-time = "2026-07-07T14:34:04.657Z" },
+ { url = "https://files.pythonhosted.org/packages/42/ab/b9bc2e77d6b44a7e46ef62ec5cac1c9a6ba7b9135a5d560f002696ec9995/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a4cfde78a9f2880208d16a93b795726a3017d5977e08d1e162a7a31322479c41", size = 218328, upload-time = "2026-07-07T14:34:06.115Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/78/c9c71d599f5aa2d42bcdd35cbbd46d7f535351a57e40ff7d8e5a7e219401/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4d6fcde76f94f5cb9e43e9e9a61f16dacefd228cbbf6f1a09bd9b219a92f1a1", size = 207406, upload-time = "2026-07-07T14:34:07.554Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/39/c914445c321a845097ce4f6ac7de9a18228a77b766272125a1ce00d851eb/charset_normalizer-3.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:898f0e9068ca27d37f8e83a5b962821df851532e6c4a7d615c1c033f9da6eedf", size = 225157, upload-time = "2026-07-07T14:34:09.061Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/f2/c0d4b8508565a36bc5c624e88ed297f5b0b1095011034d7f5b83a69908b5/charset_normalizer-3.4.9-cp314-cp314-win32.whl", hash = "sha256:c1c948747b03be832dceed96ca815cef7360de9aa19d37c730f8e3f6101aca48", size = 151095, upload-time = "2026-07-07T14:34:10.901Z" },
+ { url = "https://files.pythonhosted.org/packages/49/fd/a1d26144398c67486422a72bf5812cda22cb4ccfcd95a290fb41ceb4b8e2/charset_normalizer-3.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:16b65ea0f2465b6fb52aa22de5eca612aa964ddfec00a912e26f4656cbef890b", size = 162796, upload-time = "2026-07-07T14:34:12.47Z" },
+ { url = "https://files.pythonhosted.org/packages/20/95/d75e82f8ce9fd323ebf059c16c9aadefb22a1ecde13b7840b35835e4886c/charset_normalizer-3.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:40a126142a56b2dfc0aacbad1de8310cbf60da7656db0e6b16eebd48e3e93519", size = 153334, upload-time = "2026-07-07T14:34:14.044Z" },
+ { url = "https://files.pythonhosted.org/packages/00/5e/17398df3a139985ba9d11ed072531986f408c8fca952835ef1ab1820c02b/charset_normalizer-3.4.9-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:609b3ba8fcc0fb5ab7af00719d0fb6ad0cb518e48e7712d12fd68f1327951198", size = 338848, upload-time = "2026-07-07T14:34:15.688Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/91/7253a32e86b7e1d1239b1b36ba6dd0f021a21107ab33054b53119cc083b9/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51447e9aa2684679af07ca5021c3db526e0284347ebf4ffcec1154c3350cfe32", size = 223022, upload-time = "2026-07-07T14:34:17.248Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/32/2e64bd2be10e89c61e57ebe6a93fd98ae88eb7ebe414b5121f22c96c69eb/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cc1b0fff8ead343dae06305f954eb8468ba0ec1a97881f42489d198e4ce3c632", size = 241590, upload-time = "2026-07-07T14:34:18.813Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/ef/d96ec496cfea0c21db43b0ad03891308b02388d054cc902cf0e5a1ad6a88/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fa36ec09ef71d158186bc79e359ff5fdd6e7996fe8ab638f00d6b93139ba4fcf", size = 239584, upload-time = "2026-07-07T14:34:20.52Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/ce/9af95f7876194bd7a14e3dfe4a4de2e0bff02666a3910d72beafd06cc297/charset_normalizer-3.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df115d4d83168fdf2cae48ef1ff6d1cb4c466364e30861b37121de0f3bf1b990", size = 230224, upload-time = "2026-07-07T14:34:22.189Z" },
+ { url = "https://files.pythonhosted.org/packages/52/94/af74dde74a3996bd959c350709bfe50e297823d70a8c1cbd54b838880863/charset_normalizer-3.4.9-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:f86c6358749bd4fda175388691e3ba8c46e24c5347d0afd20f9b7edfc9faf07d", size = 212667, upload-time = "2026-07-07T14:34:23.857Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/f0/f1c4fe746c395922961b5916ed1d7d6e7d4c84851d19ed43cc89980ec953/charset_normalizer-3.4.9-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:32286a2c8d167e897177b673176c1e3e00d4057caf5d2b64eef9a3666b03018e", size = 227179, upload-time = "2026-07-07T14:34:25.586Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/56/6c745619ac397e8871e2bcd3cea1eec86b877488f33888b3aef5c3ed506e/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:83aed2c10721ddd90f68140685391b50811a880af20654c59af6b6c66c40513c", size = 225372, upload-time = "2026-07-07T14:34:27.212Z" },
+ { url = "https://files.pythonhosted.org/packages/78/ad/98aae8630ac71f16711968e38a5acfecce41b778bf2f0312851020f565a8/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cd6c3d4b783c556fa00bf540854e42f135e2f256abd29669fcd0da0f2dec79c2", size = 215222, upload-time = "2026-07-07T14:34:28.774Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/40/9593d54209765207a7f11073c06494c1721e4ca4a0a426c597679bf7f91e/charset_normalizer-3.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ee2f2a527e3c1a6e6411eb4209642e138b544a2d72fe5d0d76daf77b24063534", size = 231958, upload-time = "2026-07-07T14:34:30.345Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/27/693ee5e8a18191eb38647360c51cd505013e2bd3b366aa43fd5344c21e3c/charset_normalizer-3.4.9-cp314-cp314t-win32.whl", hash = "sha256:0d861473f743244d349b50f850d10eb87aeb22bbdcc8e64f79273c94af5a8226", size = 155580, upload-time = "2026-07-07T14:34:31.884Z" },
+ { url = "https://files.pythonhosted.org/packages/80/3f/bd97d3d9c613013d07cb7733d299385b41df37f0471310f5a73dc359f0b8/charset_normalizer-3.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:9b8e0f3107e2200b76f6054de99016eac3ee6762713587b36baaa7e4bd2ae177", size = 167620, upload-time = "2026-07-07T14:34:33.438Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/c6/eee9dca4439b1061f76373f06ea855678cc4a64c1c3c90b50e479edbb8eb/charset_normalizer-3.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:19ac87f93086ce37b86e098888555c4b4bc48102279bae3350098c0ed664b501", size = 158037, upload-time = "2026-07-07T14:34:35.018Z" },
+ { url = "https://files.pythonhosted.org/packages/98/2b/f97f1c193fb855c345d678f5077d6926034db0722df74c8f057020e05a25/charset_normalizer-3.4.9-py3-none-any.whl", hash = "sha256:68e5f26a1ad57ded6d1cfb85331d1c1a195314756471d97758c48498bb4dcdf5", size = 64538, upload-time = "2026-07-07T14:34:56.993Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/76/d4/81420972a676e8ffea40450d8c8c92943e7218a78fe9b64359836cc9876b/click-8.4.2.tar.gz", hash = "sha256:9a6cea6e60b17ebe0a44c5cc636d94f09bd66142c1cd7d8b4cd731c4917a15f6", size = 338000, upload-time = "2026-06-24T17:45:15.148Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fb/e2/79c688af8b210d232694e31e59da9f6ec747bae31c3f5946e4e9b98860d5/click-8.4.2-py3-none-any.whl", hash = "sha256:e6f9f66136c816745b9d65817da91d61d957fb16e02e4dcd0552553c5a197b76", size = 119243, upload-time = "2026-06-24T17:45:13.73Z" },
+]
+
+[[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 = "comtypes"
+version = "1.4.16"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c6/2a/65274c13327f637ec13af8d39f2cf579d9ebe7a0e683696b5f05236d2805/comtypes-1.4.16.tar.gz", hash = "sha256:cd66d1add01265cface4df51ba1e31cd1657e04463c281c802e737e79e1ba93c", size = 260252, upload-time = "2026-03-02T23:11:42.413Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5f/7c/0eb685107290b6221c03c46d39214a4e42a124189691cb83ae3228257f46/comtypes-1.4.16-py3-none-any.whl", hash = "sha256:e18d85179ff12955524c5a8c3bc09cb3c0d890f1da4d7123d14244c7b78f84c8", size = 296230, upload-time = "2026-03-02T23:11:41.049Z" },
+]
+
+[[package]]
+name = "cryptography"
+version = "49.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/99/d1c90d6041656cc6ee229dc99cd67fd0cd5aec3c5f7d72fffc27cc750054/cryptography-49.0.0.tar.gz", hash = "sha256:f89660a348f4f78a92366240a61404e337586ef7f5909a2fef59ca88ef505493", size = 854345, upload-time = "2026-06-12T20:02:30.512Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9b/22/adf66990e63584a68dfb50c24f48a125c07b1699899381c8151e63ed458c/cryptography-49.0.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:966fe0e9c67490071f14c0d2b1cb2dfb3023c5ce39457343931415f08382f2db", size = 4032100, upload-time = "2026-06-12T20:02:32.143Z" },
+ { url = "https://files.pythonhosted.org/packages/09/41/3797cfaf69cae04a13ee78ebd83f0678d9c02b4779d21ce24445326f1a69/cryptography-49.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:36d1709f992593689b45bda411498d62c6e365f2ca00b84657d4dadd24de16db", size = 4692978, upload-time = "2026-06-12T20:01:21.305Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/8b/43011f7ebe515a8aa20d61f290a326cd890c2e738e16e59eaff8d9c3a412/cryptography-49.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0e959b578856a3924bc0cbb710fc12c387b9412a951389f3ca61704a9e25f325", size = 4716422, upload-time = "2026-06-12T20:01:48.566Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/91/01ce7303a4579e6d3a6abef01bd322848e9ea7a219adcabc5048b9033571/cryptography-49.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:53ecee2e23f7169b6117e99fc8a944e5e50f79e69758a83b52a00cb98ab2b2d2", size = 4700503, upload-time = "2026-06-12T20:02:47.091Z" },
+ { url = "https://files.pythonhosted.org/packages/62/99/a2c95cf8293f07491e9e27c20cc4dcd18176d944e674679adeb1d0173fd6/cryptography-49.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2eda353d8a27bcbcaa4cbed18994a74ab4d19a2ca897db188ea269ab9b71419b", size = 5309779, upload-time = "2026-06-12T20:02:08.987Z" },
+ { url = "https://files.pythonhosted.org/packages/20/2c/0622f20ff02b2ef32558733443805dc82fd4c275be01b2d19d14676f3a1b/cryptography-49.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2afe9051da7ae7bd5905da5a949280c7d2bb75682e188f650a9d0f2756b834c6", size = 4749683, upload-time = "2026-06-12T20:02:03.335Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/5b/c5246635d5fd3b64e0d45ae10e99fd32fe9676a79915ccfe5a61ba9af1a5/cryptography-49.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:0b82e28ee398a386f0807bba7884d30f25218855690f45115831bcce5d90822c", size = 4337874, upload-time = "2026-06-12T20:02:54.323Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/88/05563c7fe2e914e87d1a536d06fe83e66b4e1d95cb593e05aea375531da8/cryptography-49.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ccac2bfebc306b862133e3bb71f3f6ee8bb525240089b2d952e4144b3a6d5da7", size = 4700283, upload-time = "2026-06-12T20:01:34.822Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/b6/d7696e4e890d6ae1469935164c9e5215c557671cb78d6e3f458ccceaa632/cryptography-49.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d0527ce944105f257f605a827d6ebead966c752038b6e8656abb9c5edee6fc68", size = 5265844, upload-time = "2026-06-12T20:01:24.09Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/3c/f3ad17eecc1a57b0ba236dc01f90e783c51f4a2f35f64777cc4f47a184b2/cryptography-49.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:cbc77da8c523d5abd028635ba850a6966fcee2c82e2bf65a41d1d8afe0f98be9", size = 4749290, upload-time = "2026-06-12T20:01:30.848Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/01/339573cf1023163a400b0b5d16f6d507de413b9f60be6fd1b77feeaf6737/cryptography-49.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b87e65d263b3e5d3bb92a57e2a6638e2f31110fa7aa890c7b2dbba42248d0a3f", size = 4834612, upload-time = "2026-06-12T20:01:29.246Z" },
+ { url = "https://files.pythonhosted.org/packages/71/fd/577302e213a1be9468f92d1afef66fcf1ef83d516819d9992ca547f592bd/cryptography-49.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:66ec79c3904820572d7e987abdf304281f141d37ad9a489b8e97066e7b9b6459", size = 4980804, upload-time = "2026-06-12T20:01:42.853Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/09/f42b1d190c5ba75f72062a387f8030d1d75f6ab035788f1d9c4b01de6525/cryptography-49.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:e5dfc1e64de5677cec922ffa8da89c546d0415bf6efdf081842e5d44c84e1f0e", size = 3810026, upload-time = "2026-06-12T20:02:39.262Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/9e/db72b3ae7fc9cfad53e630e56c6ae83b9b6ff0bf3718ffb8012d20b3aabf/cryptography-49.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:73a205dce83953d131a4aa1e0fd917a2fd1c5b1eef251e9d7152efefcbf5caf7", size = 4013892, upload-time = "2026-06-12T20:02:10.735Z" },
+ { url = "https://files.pythonhosted.org/packages/86/12/c48a424f38db03027be9f7ed5c7dc5de9933dbee992865f98b13727a009d/cryptography-49.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:196ecd6a36e4e9aa10270393bb98d8df88fccee0bf1e5128b91ae4eb4375896d", size = 4678835, upload-time = "2026-06-12T20:02:48.743Z" },
+ { url = "https://files.pythonhosted.org/packages/68/28/8a3ad4653662c93fc44dc4e5d8fd374c25c42e07b34bbfbadf49cf57a5a8/cryptography-49.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7abcee80084cda3f7691f3eb1ce480d8df49cec637b429aa35986c1de71738aa", size = 4697239, upload-time = "2026-06-12T20:02:56.03Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/b2/2193fc74f81aee4f9b62733133b73b5176718932ed8f2e4b03fa040480a6/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:4ae387c9cb68ea569ca17e490d66d8142b81c3cc814bf179974b7d146e490bbb", size = 4685593, upload-time = "2026-06-12T20:02:50.666Z" },
+ { url = "https://files.pythonhosted.org/packages/47/f1/1d3eaa243bfc5de4a187b22aa8c048b3e4980bfbe830ac46e6bac2e66947/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:f37d847238971164fdbc68ade6f6574aecc9c0af714190e2083429ff68f4ce9d", size = 5289961, upload-time = "2026-06-12T20:01:46.468Z" },
+ { url = "https://files.pythonhosted.org/packages/58/39/2d51306721330c486495853eda1c567880ff036de15a14c4b74f399934af/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:c2bc30226390d60ea19d9f82b19db005fe0452154a23c1c410c12ea801e43561", size = 4731145, upload-time = "2026-06-12T20:02:16.832Z" },
+ { url = "https://files.pythonhosted.org/packages/17/50/983e838c7fd0d87fd8c969bcdd328edaf5f756e38df5281637424c155873/cryptography-49.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:07cab27cc7b7e0fd28e5e26bb9eeedde5c135c868b46de4a27845abe94af6122", size = 4321719, upload-time = "2026-06-12T20:02:52.611Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/f5/8f571d7e27c55bce9f76f026143bcb1e040a4233149ecca0bea5fa5dd5f7/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:b20133d204d2bb56ba047642199603876c872026ca53e79c35b83772ab2cc505", size = 4685209, upload-time = "2026-06-12T20:02:07.282Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/84/0e27016a6fc5a0886f797018b26aa42f40c09a82332bff77822a451deaaa/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b970c6da94d5bb18629db453d14f2a1300f6bf59b61e9b82377931ef95504866", size = 5246285, upload-time = "2026-06-12T20:01:32.439Z" },
+ { url = "https://files.pythonhosted.org/packages/11/2d/5e1fb307cb5931881516b464c98774b3f2c36b5d4bb9a2830253cf553cad/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:d8ecde755e2e91bf773fc94e8c9d730cd7f2007004cb492263a794ec3899a1c8", size = 4730441, upload-time = "2026-06-12T20:02:01.469Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/c0/bff5a02ee731d207d6a1ed51732549d8c53d2bc8da1d10ec6f2844201d68/cryptography-49.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e3fb64c420688e5319ae25113a354015abbd8dffbfbc41781a1ea66fc7622ac3", size = 4815869, upload-time = "2026-06-12T20:01:36.574Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/26/814681d14248d95d73d5c3eea0c39a94eb8302df966f670a2c60de90974b/cryptography-49.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32703d93296f5c1f4b53349ad3a250c2cae0fdecd3a3dd5d47e616d8d616af27", size = 4960948, upload-time = "2026-06-12T20:02:18.688Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/fe/93ecac273d3738939d023612ad12cca9a3740a5345d69fda04134c43fd96/cryptography-49.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:33cd0565932807baddb67b96dbee92f2c374b5c89dee09fd74079aeb8c8dba61", size = 3799153, upload-time = "2026-06-12T20:01:39.059Z" },
+ { url = "https://files.pythonhosted.org/packages/19/2a/5bb823f5bedcf80718cea7fbc95ec5515cca3769633c4b01a32be7f30e7c/cryptography-49.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ec5e529fb80935c94fe7b729f9972b50e351a0e6b50aa294fd5cabb109fcc29a", size = 4025947, upload-time = "2026-06-12T20:01:25.745Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/df/40577043ca124e17012f408ddddaeb213b856336ac82ddb3bc915f39e29f/cryptography-49.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f78ff2c9ed8dc2d036b0f4d640e22522213d047c1b14e61205a7e55c80a494d4", size = 4692429, upload-time = "2026-06-12T20:01:53.628Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/99/2d13299eb3dd27b02dcfaafcc91d6b5cb3329f7cbd6d8f51921acd566c1a/cryptography-49.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:35b151772baff2c74cba7fa290ceaff4c3b11c0c881eb93eb5dbc05a7cfbba18", size = 4700968, upload-time = "2026-06-12T20:02:45.383Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/4d/9c0cd02f95e2602dd5e563da149ee0830abef3537be8b34dc56281ebe27a/cryptography-49.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0f21641cf4b30fca7aee061ced0ec7ad7b073518088b7c9969a297c0ae796c69", size = 4697758, upload-time = "2026-06-12T20:01:41.13Z" },
+ { url = "https://files.pythonhosted.org/packages/24/01/186c825898477d77e2324d5360fefe622ff1d8d1963ec0554e2cada8ec77/cryptography-49.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9e82dcc8e56052715fb18b2429e3bca4823b1629136a2084fc45a9a5cecb9b64", size = 5298863, upload-time = "2026-06-12T20:02:24.579Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/7b/62cbbab75d0659865bf0273790031544a0b16c8072d258f9428dcd8190dc/cryptography-49.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6f2debedf9ca60cf1d5bd466475638af5130f89965605cd818484d19987d3a21", size = 4735983, upload-time = "2026-06-12T20:01:50.14Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/72/3e798c064bc39e471008075d0f9bc9daf77a80879c092e4a8e170c585ed4/cryptography-49.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:8c25ceb16df5b9435f3f6a9829204985b0e0cbee3b48aacd432c7d2c850b44d9", size = 4334173, upload-time = "2026-06-12T20:01:44.743Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/ee/6fca21d1ac73e06f8bef71940abfd4d2f6472b4bca284d770f32bd4086f6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:28d8b15e6275f12c8a207dc309dfa957903c927d08d0cc937ee3f63f200693cc", size = 4697298, upload-time = "2026-06-12T20:02:20.918Z" },
+ { url = "https://files.pythonhosted.org/packages/67/d0/a5fcd3515f0bae49a7b6d0413cc1bdccdcc1fc0047037a0d480642cdc5d6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:6fc361c34fb6aac015ce19435876635e5c6d21db31998b0920f675f131e043b8", size = 5254338, upload-time = "2026-06-12T20:02:22.737Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/84/84fe36f19caf857d61cb7fc9c63035a47ffabd84ea12d1d393148efa3615/cryptography-49.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:2400ef9c9e2299a25614eb1dea3db54a69b1349efd043bfac9c67630d136df36", size = 4735650, upload-time = "2026-06-12T20:02:41.389Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/a0/db537264e234f7273a73ec020873d6d6b39dfd8a53db78b550ca8320440e/cryptography-49.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:67e1d20ad9ef3a563c59ef22e7a8a0b8210bd26604369ea4a30a7c66aefe504e", size = 4834820, upload-time = "2026-06-12T20:01:51.847Z" },
+ { url = "https://files.pythonhosted.org/packages/93/77/8df9eb486495979bccecd1062e2eaf435250e84437040295b57d09048b0b/cryptography-49.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:42b0684e0e40cf26122427802486f6d93aea593612603a94fbf260c7eb1e9c1b", size = 4967968, upload-time = "2026-06-12T20:02:12.524Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/e6/f60198ea8d9dfa15fff9ed4ca02ce362f6eadd9ba757dcc50634c4257b63/cryptography-49.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:026ac7423e6fa66872d3bf889be5974507da3944f866f704fa200eadacd00001", size = 3785547, upload-time = "2026-06-12T20:02:26.847Z" },
+]
+
+[[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 = "fastapi"
+version = "0.139.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "annotated-doc" },
+ { name = "pydantic" },
+ { name = "starlette" },
+ { name = "typing-extensions" },
+ { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/95/d3f0ae10836324a2eab98a52b61210ac609f08200bf4bb0dc8132d32f78a/fastapi-0.139.2.tar.gz", hash = "sha256:333145a6891e9b5b3cfceb69baf817e8240cde4d4588ae5a10bf56ffacb6255e", size = 423428, upload-time = "2026-07-16T15:06:17.912Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5f/c7/cb03251d9dfb177246a9809a76f189d21df32dbd4a845951881d11323b7f/fastapi-0.139.2-py3-none-any.whl", hash = "sha256:b9ad015a835173d59865e2f5d8296fbc2b317bf56a2ba1a5bfbdd03de2fd4b1c", size = 130234, upload-time = "2026-07-16T15:06:19.557Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "3.32.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c0/80/8232b582c4b318b817cf1274ba74976b07b34d35ef439b3eb948f98645a1/filelock-3.32.0.tar.gz", hash = "sha256:7be2ad23a14607ccc71808e68fe30848aeace7058ace17852f68e2a68e310402", size = 213757, upload-time = "2026-07-21T13:17:42.898Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/06/79/b4c714bef36bc4ec2beeae1e0c124f0223888cd8c6feb1cdc56038116920/filelock-3.32.0-py3-none-any.whl", hash = "sha256:d396bea984af47333ef05e50eae7eff88c84256de6112aea0ec48a233c064fe3", size = 97732, upload-time = "2026-07-21T13:17:41.55Z" },
+]
+
+[[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/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+ { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+ { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+ { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+ { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+ { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+ { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+ { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+ { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+ { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+ { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+ { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+ { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+ { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+ { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+ { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+ { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+ { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+ { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+ { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+ { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "fsspec"
+version = "2026.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/10/a1/ae4e3e5003468d6391d2c77b6fa1cd73bd5d13511d81c642d7b28ac90ed4/fsspec-2026.6.0.tar.gz", hash = "sha256:f5bac145310fe30e16e1471bd6840b2d990d609e872251d7e674241822abf01a", size = 313646, upload-time = "2026-06-16T01:57:28.105Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e5/22/4222d7ddf3da30f363edaa98e329c2bce6c65497c9cb2810931c8b2c0fbc/fsspec-2026.6.0-py3-none-any.whl", hash = "sha256:02e0b71817df9b2169dc30a16832045764def1191b43dcff5bb85bdee212d2a1", size = 203949, upload-time = "2026-06-16T01:57:26.358Z" },
+]
+
+[[package]]
+name = "gstreamer-bundle"
+version = "1.28.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-cli" },
+ { name = "gstreamer-gtk" },
+ { name = "gstreamer-libs" },
+ { name = "gstreamer-plugins" },
+ { name = "gstreamer-plugins-gpl" },
+ { name = "gstreamer-plugins-gpl-restricted" },
+ { name = "gstreamer-plugins-restricted" },
+ { name = "gstreamer-python" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/07/0f/0dedd5e30e6a7f553cddf850ee39dadbd729a40e9509976f85437a9aaf26/gstreamer_bundle-1.28.3-py3-none-any.whl", hash = "sha256:1270a2f84b4bdb72ecc76c20802d7fafc58a8af0c8540a8e25dbcff91e190b71", size = 2572, upload-time = "2026-05-16T00:03:25.433Z" },
+]
+
+[[package]]
+name = "gstreamer-cli"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-libs" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0d/f6/461c620679617231ad7b98b989ed780f43553ddc9e83568a77d1ba36de44/gstreamer_cli-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:82c3f80c7a595a3c68945dfe84f7aa28aec2e0fb06d28c68e90b21a07fdf448b", size = 5650998, upload-time = "2026-07-10T12:00:34.937Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/fe/b404e83b9299484cd69599ab2375320c384a4859975de5c6273222d495c6/gstreamer_cli-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:e1462bc20322d1a5f9a044aa395e1eeb53f875a9b6adb81e2d9c09057bb1d331", size = 6332966, upload-time = "2026-07-10T12:00:38.977Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/d5/1e3bf98c1b7b32a7656e47b65c56572f4564ce1040471aeb339cf0fbdc96/gstreamer_cli-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:76f7c42114cde932797642fa64d368aacab1526b947842174512c69afdbffe14", size = 5753734, upload-time = "2026-07-10T12:00:42.615Z" },
+ { url = "https://files.pythonhosted.org/packages/59/81/ee1455d70506739f9a6cf34f1d0eac88cc28b62e345a0c6023fbcc40b3de/gstreamer_cli-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:46842a311d27c96054d352b3f3e8f98c4ae83ec68fbec65b4fb404048414c080", size = 6582110, upload-time = "2026-07-10T12:00:46.182Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/c0/f04b1a7ab78057b573ceec59db0edf641d6c675ed0d2e02fcbaf6c2f9e87/gstreamer_cli-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:3b133e91b2f54432efa8ab06e52f76356a7f3c17c8ef39a02da649a787a7c8a5", size = 15777557, upload-time = "2026-07-10T00:52:37.076Z" },
+ { url = "https://files.pythonhosted.org/packages/42/18/7c15da7a9ee631c2d3a13718cf30972478a7d13027f1e716bd3fa2623b99/gstreamer_cli-1.28.5-cp39-abi3-win32.whl", hash = "sha256:04fb5e02d7fb6a5eeab7e578332259812aca0002e110b0108326916b4e46b7c5", size = 5651002, upload-time = "2026-07-10T11:59:11.989Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/f1/66fd4995a2a17e06ac1d80c69892659877af478eccef5a5da29504a225e4/gstreamer_cli-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:ef562bfc43817e7f497b11456be50609184672e4f276b77b8c126e5b247544ca", size = 6332968, upload-time = "2026-07-10T11:59:18.251Z" },
+]
+
+[[package]]
+name = "gstreamer-ext-runtime"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/52/1a/3ef5a68c4352b7f1281b70a45c1b2191b09b822cf8bee191064a4e334574/gstreamer_ext_runtime-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:32f632051f3afce7bca1b1a0242bce2fd43499eb6caa439c1c0945b9eafa5465", size = 871749, upload-time = "2026-07-10T12:00:48.386Z" },
+ { url = "https://files.pythonhosted.org/packages/57/52/5add1e50e52822dbcb4a6f03f389fc58a3b846ad55eeef0a72879c208ab6/gstreamer_ext_runtime-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:68f2c5a3051d7dadf5b62856379acde0bb81bbe80eb0cd3f657b43d2923a6adb", size = 1004084, upload-time = "2026-07-10T12:00:50.844Z" },
+ { url = "https://files.pythonhosted.org/packages/c7/81/d571150897eb186db3fe1d40ca349815dac0cc817cf7e17068847201da69/gstreamer_ext_runtime-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:78240e75147778460178946294af534dadddaafd5db00052104df557611bdf35", size = 894965, upload-time = "2026-07-10T12:00:52.882Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/fe/f4ea9b1ef63790ca95c16f9727ae9890f3423a2b9d9ba7163400878d9112/gstreamer_ext_runtime-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:3ed21adb76a1cb0c1ed87674d9ea7049d88fd4eb64960cc3b884bfc3d21fcf71", size = 1032488, upload-time = "2026-07-10T12:00:55.304Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/a7/bdd530c7f0ec292c031160a600bfe71d62dad80051716822c5e540d9cbdf/gstreamer_ext_runtime-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:d72d7af6341950db1cad3011dfb761bbf63bd5f05c0654cbde7da774397584d8", size = 2375, upload-time = "2026-07-10T00:52:57.581Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/51/8e58263a0ebd2fde453cafef6da22e1d161c8e1fcfcaeeb795c065a24a40/gstreamer_ext_runtime-1.28.5-cp39-abi3-win32.whl", hash = "sha256:e00cbea8b27784ee9b72e1c8f526ab92824c56c3b1d25b30ae9c9d3cdd2b63f1", size = 871750, upload-time = "2026-07-10T11:59:20.316Z" },
+ { url = "https://files.pythonhosted.org/packages/26/8a/49400f845578acc9c453fa1cd74acc2439755eca2759326e967bc324e490/gstreamer_ext_runtime-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:19d19e9307db904ab8623fb22d519234b8a24d8c7b7e42311d465ee1b9409a4c", size = 1004084, upload-time = "2026-07-10T11:59:22.995Z" },
+]
+
+[[package]]
+name = "gstreamer-gtk"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/42/a7/b74a32e74e2ede49e9ad2a921c4b3fc682885e3068cdc1f29aa4498af38e/gstreamer_gtk-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:7fffda1108083bbff5f9f4049779f22a81c4fd816372b52018aa717787ed21e9", size = 4852407, upload-time = "2026-07-10T12:00:57.891Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/b5/c3acbe731eeed23ee1d6e2b8808ffbbaa81dafc1abcde8559a7490b1d53b/gstreamer_gtk-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:42f051b72adf7f3b3c73ffce2f09b34965b80a10d6ff28abaab54de380096b4e", size = 5876880, upload-time = "2026-07-10T12:01:00.942Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/4e/97cba0eb2c1c452a22c6bcceb9c5dcc1e0ec14bcdf2b306c5412c92c17f3/gstreamer_gtk-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:448d209369babdd6093d1349426c4a52c4c72be7f8e772abed379629df993db8", size = 4968595, upload-time = "2026-07-10T12:01:03.72Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/1e/1dbe6bb84db5ce0f72280b4f5d0ee8b46068c42754a5c5a9b74a44b6710a/gstreamer_gtk-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:1319b796717070b7b64714267612080dced863baa42d7ff524ab7bc64ec67c9b", size = 6130886, upload-time = "2026-07-10T12:01:06.635Z" },
+ { url = "https://files.pythonhosted.org/packages/28/e9/40de1f9c21ef406541b06e9ed5cfee85c201b9a45649926bb949811685ef/gstreamer_gtk-1.28.5-cp39-abi3-macosx_10_15_universal2.whl", hash = "sha256:f01e531be1ce712a10981fd493ba7d74ccc1b21fe9b86c5e282cad9507061cce", size = 20498112, upload-time = "2026-07-10T00:53:05.106Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/8c/2b13061de691ef80e83ee44b4d22ad19f195f044397c42f39323afd2ac8c/gstreamer_gtk-1.28.5-cp39-abi3-win32.whl", hash = "sha256:72c650b8f1c102451b42e7d9c73d70dd29bbcd97c33e705e70f8f0f154481799", size = 4852403, upload-time = "2026-07-10T11:59:26.215Z" },
+ { url = "https://files.pythonhosted.org/packages/46/06/0ecbbf1213d6e50e81d359d7340f383510925fd8ec389133b967d3895570/gstreamer_gtk-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:7d04e0304f3c1912b918b948ff4eb4880c28d50242c3a6bed95ae0c8a5a94e59", size = 5876877, upload-time = "2026-07-10T11:59:29.129Z" },
+]
+
+[[package]]
+name = "gstreamer-libs"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-ext-runtime" },
+ { name = "setuptools" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/77/62/b2183c787d262cb277835c81ebbda727d754c73650b38231f10c1124bc0b/gstreamer_libs-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:87d01a6a2a5b82e83ca95ac45224920a3ad2abbd2b38cf94163dbe967b89ffec", size = 29137526, upload-time = "2026-07-10T12:01:11.297Z" },
+ { url = "https://files.pythonhosted.org/packages/11/52/6655ba937c9fac0e0b96c32d3d60f149f5ce62d122bfd4c1e2db05cdc3fd/gstreamer_libs-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:d1aa817a74529be9b02f460ffff1d284fd53d932bb3214a1304c8410d1d9b5fa", size = 33060437, upload-time = "2026-07-10T12:01:18.167Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/cd/ec942e1f767476e1e76771e18b516fa3075bbfe9815db6ee43ed5abab3a1/gstreamer_libs-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:5fdbd5e5ce8a5bff542e8c179d2691c7fcf4dc617abe133cebb117ea8a97dcca", size = 29947441, upload-time = "2026-07-10T12:01:24.298Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/ea/9773b10b4ccc09e81792d1c5721ff9d18087eb8259cd28fb95d764759759/gstreamer_libs-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:d3ffb826e99bfe58eb2737f9b70a21febe6b3ff720761b5324bfa11782165153", size = 34145258, upload-time = "2026-07-10T12:01:30.707Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/a7/2fbc85a031d7a1786501f884eeb65724c59dab7946112480d0f8a602c3d9/gstreamer_libs-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:19f5967955d3df6fb380a0afbccfcaf705abbbcfd22345a474b09c8c98c66ce9", size = 96339373, upload-time = "2026-07-10T00:53:29.532Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/63/710f3ec05641da838e48adbe5f23d0762aff4e7f8a9b688d66bf49d3d0ba/gstreamer_libs-1.28.5-cp39-abi3-win32.whl", hash = "sha256:7381548dcbcb7c8e8671282461058cea1b7bcd02fc52ac81f245060c3ac25f31", size = 29137523, upload-time = "2026-07-10T11:59:33.954Z" },
+ { url = "https://files.pythonhosted.org/packages/97/ef/9a3a47c48c2b71c8048bc3f36b8b3b359bfe7007f3748eb4eb0267cee853/gstreamer_libs-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:5244509d0c4746cb3d4618ff6d1753d25265131b421e54e2d88a7e1658585d7a", size = 33060433, upload-time = "2026-07-10T11:59:40.54Z" },
+]
+
+[[package]]
+name = "gstreamer-plugins"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-plugins-libs" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/11/64/5728e3b39f1907bcf3ae7d776f624311f08811030b935f12757b2ac572cd/gstreamer_plugins-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:38ff2b04a2dfee26f47f298dbcc2393a240300ea17b1da21cfb497b24aa63838", size = 39961005, upload-time = "2026-07-10T12:01:37.537Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/10/b3701b27224e498e8763ec50a516acfbb4f626e63d9d7fe339ae54a0f76d/gstreamer_plugins-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:fbd5f34851a9cfb4f8216e9581b78e0b2a0943af9b5660c64b3216a68522b457", size = 46610151, upload-time = "2026-07-10T12:01:44.806Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/44/13a558834d7dec5b13b8a0703c807901eb38fae079134b4028658710c4f5/gstreamer_plugins-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:077f8bb9703243c5d34f643b927a08f79e58061d9ac152d07f1a081e87f63e49", size = 41001806, upload-time = "2026-07-10T12:01:51.848Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/6a/5b2a21d0c941513bbf697ed7d975a106aa2ae02b5b76544343be22527bba/gstreamer_plugins-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:80743f10dc14bdb213c5e234e69682e4d18dab551ff7ecfff8383f0b80a1f95f", size = 48011705, upload-time = "2026-07-10T12:01:59.442Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/2d/06190cc2a739f5907c328559cd3ba28001c88322225464c03ffe4482dfee/gstreamer_plugins-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:d6b4a6f41f5a1a31050a43d4ae7419e9fb7db64ba2aaeae62596a116146c710e", size = 101236572, upload-time = "2026-07-10T00:53:56.838Z" },
+ { url = "https://files.pythonhosted.org/packages/34/c0/5ad66e0f3fb3580b3e7c45802403792d8a680456fb7d6d3b94865a84e72c/gstreamer_plugins-1.28.5-cp39-abi3-win32.whl", hash = "sha256:249a746d8f90f7d83c6a532736f557092b5025fc77757384d0a38c42dc297889", size = 39961009, upload-time = "2026-07-10T11:59:47.902Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/5d/19b265c00cab34e78fc2c0ef0b8d719644d56df86a77257100da4f1d9ac4/gstreamer_plugins-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:37be04432945a5ff3db0d0a17eacf7dcac9ba343a55b854779f5e8dd07e3bb02", size = 46610150, upload-time = "2026-07-10T11:59:55.772Z" },
+]
+
+[[package]]
+name = "gstreamer-plugins-gpl"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-plugins-libs" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/96/cd/d14d848d10a73e4d5bf21430fd942cbe17fa326f78bae68c5461a02f7eb0/gstreamer_plugins_gpl-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:ca6f4e0234b3b6eedf184772aeca0a0e12f9b8d884ff33540a008be376396306", size = 318904, upload-time = "2026-07-10T12:02:11.575Z" },
+ { url = "https://files.pythonhosted.org/packages/23/8d/ff427008a78b6199cad0aef05314ec02b2aa52d1bc61c125bf0f44275337/gstreamer_plugins_gpl-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:10de1edd2fe179befe3556658ab8ce7eff862219aaefcfa77c06e6cf371210e4", size = 356388, upload-time = "2026-07-10T12:02:13.265Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/ef/39631b4b99c2098d6fbf4acf46f1f2a25e7ea3ee7195b7840431d17abb41/gstreamer_plugins_gpl-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:c80f14d3060d60fbfaac8f26b41527c031ede56905090e9e0430d2be410bc681", size = 326144, upload-time = "2026-07-10T12:02:15.016Z" },
+ { url = "https://files.pythonhosted.org/packages/85/06/ed34a1f4f2dc3798f294015befa8e7717831cb78e3d362328827f9393db8/gstreamer_plugins_gpl-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:59446af4dd9df1ebe7db3dc503aba10be0129525c13fd2856d1cd1845beff731", size = 363936, upload-time = "2026-07-10T12:02:17.002Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/47/8506b3e8661abac29251e863f89381c9a28b1e58c06c6889926b3eaec5f9/gstreamer_plugins_gpl-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:32c43f684fe0479b66849cd9bb45a06f2f2c9d972de0c509be3773620463fd35", size = 1049772, upload-time = "2026-07-10T00:54:03.783Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/67/5de2051765b373c220094312178f41234535787f4c3569825d8740ea00aa/gstreamer_plugins_gpl-1.28.5-cp39-abi3-win32.whl", hash = "sha256:522eda3b6113437514d1fde99ab1c0257622d873941c19c405ed7b9e38054084", size = 318904, upload-time = "2026-07-10T12:00:03.428Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/c0/d3603360835c3ee00fce7afae6d8087ed580095611fc4bc24492b6b7ffeb/gstreamer_plugins_gpl-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:6fea124c396cfad93acb95022ca2a375b9bafdb74b3808f8f54ac76fca9927f7", size = 356384, upload-time = "2026-07-10T12:00:05.59Z" },
+]
+
+[[package]]
+name = "gstreamer-plugins-gpl-restricted"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-plugins-libs" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/88/44/bc9fc6f92c415ff98bbc5700b4646b73fd7710a89982371a701909376c8b/gstreamer_plugins_gpl_restricted-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:305dd4ca0814abec0c1f612331994c19ab046cd456ebee17b8ad7741ae3eb904", size = 2150272, upload-time = "2026-07-10T12:02:19.474Z" },
+ { url = "https://files.pythonhosted.org/packages/55/c2/76f3d8cff1c74b21516855a40deb1a44609d170752d6faaf6329d0f3e188/gstreamer_plugins_gpl_restricted-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:4a650a786a150b4ddacc7a97c703e2586c608065b95222d41cb30748e49c9aed", size = 3403230, upload-time = "2026-07-10T12:02:21.543Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/0e/e1fe4f07d7f4553d7a1b3fd08217216f5dd967ef65ab331c3aca2336c077/gstreamer_plugins_gpl_restricted-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:75b54118f2edef71c2b7eb937d463696b8a83f1377f7be22c463bc3554095861", size = 2203801, upload-time = "2026-07-10T12:02:23.67Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/b8/faffa3f1f9ffab959483f89b98fe7a7e9468ec3e7a9a8a37d277920b42a3/gstreamer_plugins_gpl_restricted-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:5e1e56b344285203bd04f18c129bae266a932fd37e18e6ce7fb239c149b13e8d", size = 3498318, upload-time = "2026-07-10T12:02:26.043Z" },
+ { url = "https://files.pythonhosted.org/packages/34/80/ff847068980e8f39bde8229fe8896f4521401d6bf302fc1a664d5d6982b3/gstreamer_plugins_gpl_restricted-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:c6f9318181920699950ae2734f80fca78d5ef1785d91c7d4da9ccdabda4262d9", size = 13453412, upload-time = "2026-07-10T00:54:08.199Z" },
+ { url = "https://files.pythonhosted.org/packages/18/b5/46d8d70292df1a9f480cdcfcbdccb158c7ba680683ba7b09b6cb7a061a8a/gstreamer_plugins_gpl_restricted-1.28.5-cp39-abi3-win32.whl", hash = "sha256:4bc7dc476c1dcf58e2f9267523680fc7bbecbac2c31da4fce1192c7c5d1a4bdf", size = 2150271, upload-time = "2026-07-10T12:00:08.206Z" },
+ { url = "https://files.pythonhosted.org/packages/16/fc/f41ee69874ef62023b7712fe8d8ade9439cf4b3072cb1a066541754ed1de/gstreamer_plugins_gpl_restricted-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:6f62ab847d7cea443556f281ce9115ea03fc3655facce499c6df40f92cbaf32f", size = 3403222, upload-time = "2026-07-10T12:00:10.802Z" },
+]
+
+[[package]]
+name = "gstreamer-plugins-libs"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-libs" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a6/0b/04c1e09fd82f52a18cf9cbe27c0ff2f27b64b819a4311bd117095beae466/gstreamer_plugins_libs-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:9527af76b1f28c7481899a72e70dea7cbe0934b11fdb4acd5402ff18592b1551", size = 16393418, upload-time = "2026-07-10T12:02:29.755Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/de/7743684538b5eee4b3779244fe10b13e7fd17f071ee8789cd9a85f70f79c/gstreamer_plugins_libs-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:0458ceda5930ae9214a2f277b01d44fde836847f893f8b1c4f5043e59b5c5415", size = 21167719, upload-time = "2026-07-10T12:02:34.295Z" },
+ { url = "https://files.pythonhosted.org/packages/67/0c/c7c46d73e3dd1ded410836790dcb2575900684d50716fb8f1fd119497d4d/gstreamer_plugins_libs-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:2550dc270fb71ea437a0665371ece59f223a06ba038f6353f527076c16d62f4f", size = 16687260, upload-time = "2026-07-10T12:02:38.664Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/9a/a0b00e60b370cb6180455ec71fa69d9d2337939c8e35517ab13b5a70d0ff/gstreamer_plugins_libs-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c7596dd04f10c6a0ee76628191e1e7f0e4674404571c447069ef3e9bee886e3d", size = 21649958, upload-time = "2026-07-10T12:02:43.196Z" },
+ { url = "https://files.pythonhosted.org/packages/51/42/4955f904ef848345c517ed76550aec839389e0973e8ee39e97c7cc9d8ee3/gstreamer_plugins_libs-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:82e63232343b4bc463227a18ea0b15bbcd7fe243f57f10e505cd5fdd02386753", size = 83517973, upload-time = "2026-07-10T00:54:30.908Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/3c/e21ae1e90cae70cb125ea90065a344c7cf93c863e07352c473d5e662b8fe/gstreamer_plugins_libs-1.28.5-cp39-abi3-win32.whl", hash = "sha256:47fbe20b480605bc96cfc714f78fa1763ef437a3164e03fbdf9552a3419eb4ad", size = 16393417, upload-time = "2026-07-10T12:00:14.212Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/31/79902cc2e38988546645b7692aa26a4212e5272a39dc26cac7155dcd19ef/gstreamer_plugins_libs-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:79a5516f5b8f8f7766b27e328c63c3dd12e8fc001f79199136e71fd3ba02f931", size = 21167716, upload-time = "2026-07-10T12:00:18.885Z" },
+]
+
+[[package]]
+name = "gstreamer-plugins-restricted"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "gstreamer-plugins-libs" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/69/9c/e51ddf39656fd6d8db129524e48dd609846b56f548b225e2560739935c13/gstreamer_plugins_restricted-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:27159aedb22b616f8f07c4b5b6b8d046bdf8a11b378a846736143a5930dedfdb", size = 1421721, upload-time = "2026-07-10T12:02:48.896Z" },
+ { url = "https://files.pythonhosted.org/packages/5d/6a/7533dbdf0f8d5e3e5efc986645ae9ee55ca4aa26dc443da5518689452e60/gstreamer_plugins_restricted-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:aba1174d882a2082c75b55872b23d544f7920822896fa8374576f6963a650895", size = 1513659, upload-time = "2026-07-10T12:02:52.022Z" },
+ { url = "https://files.pythonhosted.org/packages/57/cd/ac1112dbcf4e3fbae06e1404edeb5321faf030c675b0e45d82ec4f94d371/gstreamer_plugins_restricted-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:30085d5b42ae9f8a0499057456a6d36eacbf6d20f5534d8005e23445f4e42a52", size = 1456803, upload-time = "2026-07-10T12:02:54.381Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/19/8c7ff578c4825401dc8740df10da7e2c476a80dd3c6fe0198def91e0b74a/gstreamer_plugins_restricted-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:79b81f81f954fbc40986428d9f3fef2d1cba8d06b1c37cdec06fd25a3d5ab654", size = 1561279, upload-time = "2026-07-10T12:02:56.326Z" },
+ { url = "https://files.pythonhosted.org/packages/04/55/14ecedf6f3d6a8d6addf1ead57364d1f7c41828138ad93cb8e02f02c279a/gstreamer_plugins_restricted-1.28.5-cp39-abi3-macosx_10_13_universal2.whl", hash = "sha256:e63a97cd416dfdbd0eee423b9e15ae85c0d5ea9625128222c681e5839534391b", size = 6104660, upload-time = "2026-07-10T00:54:37.755Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/1e/d069992fbadaa7d1bb720b83e18c4c8f61c3b2d447b14528117a31378cdc/gstreamer_plugins_restricted-1.28.5-cp39-abi3-win32.whl", hash = "sha256:386978119aebee2339c4604f13dbfe18f60788d3cad59955c87debf59b295c6a", size = 1421719, upload-time = "2026-07-10T12:00:21.603Z" },
+ { url = "https://files.pythonhosted.org/packages/56/b6/933796d3e73e9a1f2390304b7db5d763a9f31a37cb86437953a6028c18ef/gstreamer_plugins_restricted-1.28.5-cp39-abi3-win_amd64.whl", hash = "sha256:6384881ccaf2c693a8138ad8fd985b3ff591fff311695631d92aa9979ca10f7b", size = 1513653, upload-time = "2026-07-10T12:00:23.645Z" },
+]
+
+[[package]]
+name = "gstreamer-python"
+version = "1.28.5"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/8e/3c/dbfc4292ca6287ec60bb050d74366c6f80012bded55529a81332be623f00/gstreamer_python-1.28.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:605eadd4d0be5885a51e122062ca5252620274ef5bdbd422fffc623d3aeaf6ac", size = 1196708, upload-time = "2026-07-10T03:36:06.689Z" },
+ { url = "https://files.pythonhosted.org/packages/80/92/486617743d0a48199f7c85553e2bf5759150e08a06cc7d9183831395fc01/gstreamer_python-1.28.5-cp312-cp312-win32.whl", hash = "sha256:461c668d05ac929e539f5bad9872b9f33f0b9e0d957ab034601e975b1ea0e6f5", size = 933317, upload-time = "2026-07-10T12:03:07.227Z" },
+ { url = "https://files.pythonhosted.org/packages/41/1f/d639f729704c3a5d7e027aa27002a3ebecddb1a39fc4badd21a3789ed497/gstreamer_python-1.28.5-cp312-cp312-win_amd64.whl", hash = "sha256:7f8e5c5262c7f385b3ab9de2d0783fc109e0178f33fe24459f4b0fee90140e33", size = 973974, upload-time = "2026-07-10T12:03:09.835Z" },
+ { url = "https://files.pythonhosted.org/packages/05/dd/65a471710cc07ba7e91f90e79b26ef844fb5b274748d977521e3c84e0d4f/gstreamer_python-1.28.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0d50e4555fe79d0c9a975d513e4e8204e60bf73d4baa7ce4cffef0e99ee1a6d4", size = 1205527, upload-time = "2026-07-10T03:36:09.673Z" },
+ { url = "https://files.pythonhosted.org/packages/84/ea/23b2176ce3455c504d398825d0980b6c3436366a21a6d3f4a8c0777311f3/gstreamer_python-1.28.5-cp313-cp313-win32.whl", hash = "sha256:0b6778183baee73e0d651520a7e2d5ee0f705c66e715f0a372147dc578e78d02", size = 934029, upload-time = "2026-07-10T12:03:16.031Z" },
+ { url = "https://files.pythonhosted.org/packages/da/07/b1b57622e52c2a1c177ae2671dd1e6da4c61f82e9c083b12829ddb27cf19/gstreamer_python-1.28.5-cp313-cp313-win_amd64.whl", hash = "sha256:c015cba22a8a181695c2e712b31d1756bff691c02812dce23ab2712aa29f85ea", size = 975175, upload-time = "2026-07-10T12:03:18.644Z" },
+ { url = "https://files.pythonhosted.org/packages/15/7c/6694798dd8328cf9e0f74921e3c5709f3233bb24e751d04088b9df463abb/gstreamer_python-1.28.5-cp313-cp313t-win32.whl", hash = "sha256:848532ea7883bf3be7ae04452b95e63c92f5c36bd16dec9b7df87c41587de6d4", size = 948180, upload-time = "2026-07-10T12:03:11.893Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/01/117e0b981483eefb2078c31c6addd417847b78773713f9b76dd3685ea767/gstreamer_python-1.28.5-cp313-cp313t-win_amd64.whl", hash = "sha256:454c774a84ac61ec676e674d6c354efbfa3c6a0fd28700b8b0f5789edac96c71", size = 994634, upload-time = "2026-07-10T12:03:13.726Z" },
+ { url = "https://files.pythonhosted.org/packages/43/98/b40643b4b7d27a96748f0878f5565d63ed379f91c0769585ea3d0a7aad8b/gstreamer_python-1.28.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:23f1b7a23d2ed5ffa4013914f714be1c8ad7528ff53bc61498e17f3aa9538a0c", size = 1204440, upload-time = "2026-07-10T03:36:12.429Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/f8/ef0beffe3f843ed96e4903189425d2a3e53535d79efddc733e568d6a7174/gstreamer_python-1.28.5-cp314-cp314-win32.whl", hash = "sha256:3838bda1ea1154cc14b6b7a6d4e6dd35875c1b2a387d72330552cf91ec544860", size = 959569, upload-time = "2026-07-10T12:03:24.666Z" },
+ { url = "https://files.pythonhosted.org/packages/91/f5/6692bd94c5396c8f13aa32eb3e0ee7f206c3da949df4f7a17705c02b6d04/gstreamer_python-1.28.5-cp314-cp314-win_amd64.whl", hash = "sha256:4b92de3d73eb16fb7b376522cbb6a2fb8f05a7094d0d3f36fafdee03172bed12", size = 1000978, upload-time = "2026-07-10T12:03:26.793Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/eb/c0380e3e56030db049ccabe0860c3aa0b8b22f04c21b4cd16a181e8b47b8/gstreamer_python-1.28.5-cp314-cp314t-win32.whl", hash = "sha256:437162aa10e55a6b58b7ac93326ea6987312f24120f16a9291bf97f38ac7994e", size = 974933, upload-time = "2026-07-10T12:03:21.097Z" },
+ { url = "https://files.pythonhosted.org/packages/de/58/5c95004987dd2505f2f1e56ccb290af985c2274d379adffad41fac655cff/gstreamer_python-1.28.5-cp314-cp314t-win_amd64.whl", hash = "sha256:2e47a396f4eebaa054e06aa36a66c0f323ffa7651d594445b617f804f7b056eb", size = 1023363, upload-time = "2026-07-10T12:03:23.057Z" },
+]
+
+[[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 = "hf-xet"
+version = "1.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/63/39/67be8d71f900d9a55761b6022821d6679fb56c64f1b6063d5af2c2606727/hf_xet-1.5.2.tar.gz", hash = "sha256:73044bd31bae33c984af832d19c752a0dffb67518fee9ddbd91d616e1101cf47", size = 903674, upload-time = "2026-07-16T17:29:56.833Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/29/be/525eabac5d1736b679c39e342ecd4292534012546a2d18f0043c8e3b6021/hf_xet-1.5.2-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:4a5ecb9cda8512ba2aa8ee5d37c87a1422992165892d653098c7b90247481c3b", size = 4064284, upload-time = "2026-07-16T17:29:29.907Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/3f/699749dd78442480eda4e4fca494284b0e3542e4063cc37654d5fdc929e6/hf_xet-1.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8764488197c1d7b1378c8438c18d2eea902e150dbca0b0f0d2d32603fb9b5576", size = 3828537, upload-time = "2026-07-16T17:29:31.549Z" },
+ { url = "https://files.pythonhosted.org/packages/22/d7/2658ac0a5b9f4664ca27ce31bd015044fe9dea50ed455fb5197aba819c11/hf_xet-1.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8d7446f72abbf7e01ca5ff131786bc2e74a56393462c17a6bf1e303fbab81db4", size = 4417133, upload-time = "2026-07-16T17:29:33.391Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/58/8343f3cb63c8fa058d576136df3871550f7d5214a8f048a7ea2eab6ac906/hf_xet-1.5.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:580e59e29bf37aece1f2b68537de1e3fb04f43a23d910dcf6f128280b5bfbba4", size = 4212613, upload-time = "2026-07-16T17:29:34.989Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/33/a968f4e4535037b36941ec00714625fb60e026302407e7e26ca9f3e65f4e/hf_xet-1.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bee28c619622d36968056532fd49cf2b35ca75099b1d616c31a618a893491380", size = 4412710, upload-time = "2026-07-16T17:29:36.646Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/d9/9e33981173dbaf194ba0015202b02d467b624d44d4eba89e1bf06c0d2995/hf_xet-1.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e396ab0faf6298199ad7a95305c3ca8498cb825978a6485be6d00587ee4ec577", size = 4628455, upload-time = "2026-07-16T17:29:38.352Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/4b/cc682832de4264a03880a2d1b5ec3e1fab3bf307f508817250baafdb9996/hf_xet-1.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:fd3add255549e8ef58fa35b2e42dc016961c050600444e7d77d030ba6b57120e", size = 3979044, upload-time = "2026-07-16T17:29:40.329Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/09/b2cdf2a0fb39a08af3222b96092a36bd3b40c54123eef07de4422e870971/hf_xet-1.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d6f9c58549407b84b9a5383afd68db0acc42345326a3159990b36a5ca8a20e4e", size = 3808037, upload-time = "2026-07-16T17:29:42.357Z" },
+ { url = "https://files.pythonhosted.org/packages/de/ba/2b70603c7552db82baeb2623e2336898304a17328845151be4fe1f48d420/hf_xet-1.5.2-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:f922b8f5fb84f1dd3d7ab7a1316354a1bca9b1c73ecfc19c76e51a2a49d29799", size = 4033760, upload-time = "2026-07-16T17:29:43.884Z" },
+ { url = "https://files.pythonhosted.org/packages/60/ac/b097a86a1e4a6098f3a79382643ab09d5733d87ccc864877ad1e12b49b70/hf_xet-1.5.2-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:045f84440c55cdeb659cf1a1dd48c77bcd0d2e93632e2fea8f2c3bdee79f38ed", size = 3841438, upload-time = "2026-07-16T17:29:45.539Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/35/db860aa3a0780660324a506ad4b3d322ddc6ecbba4b9340aed0942cbf21c/hf_xet-1.5.2-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:db78c39c83d6279daddc98e2238f373ab8980685556d42472b4ec51abcf03e8c", size = 4428006, upload-time = "2026-07-16T17:29:46.996Z" },
+ { url = "https://files.pythonhosted.org/packages/af/6b/832dd980af4b0c3ae0660e309285f2ffcdff2faa38129390dbb47aa4a3f9/hf_xet-1.5.2-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:7db73c810500c54c6760be8c39d4b2e476974de85424c50063efc22fdda13025", size = 4221099, upload-time = "2026-07-16T17:29:48.525Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/05/ae50f0d34e3254e6c3e208beb2519f6b8673016fc4b3643badaf6450d186/hf_xet-1.5.2-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6395cfe3c9cbead4f16b31808b0e67eac428b66c656f856e99636adaddea878f", size = 4420766, upload-time = "2026-07-16T17:29:50.092Z" },
+ { url = "https://files.pythonhosted.org/packages/07/a9/c050bc2743a2bcd68928bfee157b08681667a164a24ec95fbfcfcd717e08/hf_xet-1.5.2-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:cde8cd167126bb6109b2ceb19b844433a4988643e8f3e01dd9dd0e4a34535097", size = 4636716, upload-time = "2026-07-16T17:29:51.62Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/f8/68b01c5c2edb56ac9a67b3d076ffddcb90867abaee923923eb34e7a14e76/hf_xet-1.5.2-cp38-abi3-win_amd64.whl", hash = "sha256:ecf63d1cb69a9a7319910f8f83fcf9b46e7a32dfcf4b8f8eeddb55f647306e65", size = 3988373, upload-time = "2026-07-16T17:29:53.395Z" },
+ { url = "https://files.pythonhosted.org/packages/39/c6/988383e9dc17294d536fcbcd6fd16eed882e411ad16c954984a53e47b09c/hf_xet-1.5.2-cp38-abi3-win_arm64.whl", hash = "sha256:1da28519496eb7c8094c11e4d25509b4a468457a0302d58136099db2fd9a671d", size = 3816957, upload-time = "2026-07-16T17:29:54.991Z" },
+]
+
+[[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 = "httptools"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/e5/d471fcb0e14523fe1c3f4ba58ca52480e7bd70ad7109a3846bc75892f7fb/httptools-0.8.0.tar.gz", hash = "sha256:6b2a32f18d97e16e90827d7a819ffa8dbd8cc245fc4e1fa9d1095b54ef4bd999", size = 271342, upload-time = "2026-05-25T22:17:48.841Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/14/88/1d21a36da8f5cb0fa49eafd4b169eba5608d57e75bbcf61845cbc6243216/httptools-0.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:880490234c10f70a9830743097e8958d6e4b9f5a0ffc24515023afeef984054d", size = 208247, upload-time = "2026-05-25T22:17:07.843Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/42/cc4feea2945cb3051038f090c9b36bd5b8a9d7f5a894a506a8983e33fd1c/httptools-0.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5931891fb7b441b8a3853cf1b85c82c903defce084dd5f6771ca46e31bf862c5", size = 113064, upload-time = "2026-05-25T22:17:09.136Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/a6/febbb8b8db0f58b38e44ad6cb946e6a255ae49b55f2e8543408fb7501ccd/httptools-0.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b15fc622b0f869d19207c4089a501d9bcc63ca5e071ffdd2f03f922df882dcb2", size = 523851, upload-time = "2026-05-25T22:17:10.106Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/e4/f90a0df0b83beff265b7e3b65f2a4cefd95792d4be0ac3e16049f2acd3c2/httptools-0.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:425f83884fd6343828d8c565f046cb72b6d19063f6924093e11bcd8e1548cd09", size = 518842, upload-time = "2026-05-25T22:17:11.218Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/2d/0c9ac76dd2c893841fbf6498d6acec4f2442e1b7067f6e3e316a80e494e8/httptools-0.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ef7c3c97f4311c7be57e2986629df89d49cb434dbff78eafcd48c2bff986b15a", size = 501238, upload-time = "2026-05-25T22:17:12.728Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/42/906adc91ae3a5fa9c59c0a2f21c139725bd7e5b41ae6acd485cd14123ebf/httptools-0.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a1afd7c9fbff0d9f5d489c4ce2768bd09c84a46ddefc7161e6aa82ae35c85745", size = 509567, upload-time = "2026-05-25T22:17:13.842Z" },
+ { url = "https://files.pythonhosted.org/packages/05/0b/4240efeb672751ee5b9b380cb0e3fdc050bc05f68adc7a8aefc4fcd9a69a/httptools-0.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:cd96f29b4bab1d42fa6e3d008711c75e0f79e94e06827330160e3a304227f150", size = 90918, upload-time = "2026-05-25T22:17:15.155Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/e5/8cfcabc5546e8022f168be28bcdaa128a240a0befdd03b59d558b4f18bd6/httptools-0.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:614ceea8ea606848bece2338ac03b3ce5324bcb4be8dc7d377ed708012fa4db8", size = 205148, upload-time = "2026-05-25T22:17:16.333Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/0e/0fb14848c19a686c8062ff9067c1a48793e3224b47bc5b201535b6036fce/httptools-0.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2d689918c15a013c65ef52d9fd495d766893ab831a2c8d89f2ac5940a5df847c", size = 111368, upload-time = "2026-05-25T22:17:17.586Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/1b/46f1cecf06b9bbde8e4b8c88034ac7908989e5ff7a3a388ef38392949c1f/httptools-0.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb3028cca2fc0a6d720e52ef61d8ebb62fcbfeb1de56874546d858d3f25a26b7", size = 486447, upload-time = "2026-05-25T22:17:18.564Z" },
+ { url = "https://files.pythonhosted.org/packages/77/00/258bfc0837221f81d9725c45f9b948a6a6b2994a147a4fb66e85100c668f/httptools-0.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:88bdd940f2b5d487b4d032c6afa5489a7dc4694410d43de3c38c4fb3af0dc45d", size = 482448, upload-time = "2026-05-25T22:17:19.912Z" },
+ { url = "https://files.pythonhosted.org/packages/04/ab/d1cef3b5523f4d272a70f42a776c3169a2dddfe3a54de4b2ce4a36341528/httptools-0.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6a43c9dd399758ccc0531acb0a3c4a6c299ee893ee9400e9c893b7bdcfae0681", size = 464460, upload-time = "2026-05-25T22:17:20.882Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/48/5d1d072442277bb2b3434e0e60690b8e8c23840ef7de8b6ea54040a536d3/httptools-0.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0770728beb05094c809b98e814edff5fef69d26ad7d21185f2f6d5884a0ba683", size = 471312, upload-time = "2026-05-25T22:17:22.085Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/66/b96623b27e51a68199ef4efdda0613cced9233fe3062ac74e50749c5ad37/httptools-0.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:7685df791fad561384bfb139e77fde27a1ffd93134e016f95a0db424ffbf77b1", size = 90117, upload-time = "2026-05-25T22:17:23.074Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/12/fa3fbf5f9517b273edea2dc982aa82a8c634091e67c590792b729017bc6f/httptools-0.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:de242a49b5d18e0a8776e654e9f6bf6d89f3875a5c35b425a0e7ce940feb3fd6", size = 206183, upload-time = "2026-05-25T22:17:24.004Z" },
+ { url = "https://files.pythonhosted.org/packages/30/fc/5e7c4cb443370f2090a3aba0453a07384d29ff66b7435bb90e77e1037599/httptools-0.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:159e9ab5f701ccd42e555a12f1ad8ff69702910fc1c996cf2bb66e5fcb7a231b", size = 112079, upload-time = "2026-05-25T22:17:25.216Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/53/771bd891eb0f236f32145d6a1775777ec85745f3cc983a1f23d1a3b8ddfe/httptools-0.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c4a9f1707e4823d54dfec6c33fa3697d302aed536ed352a7ebb5a061ddb869d0", size = 481596, upload-time = "2026-05-25T22:17:26.186Z" },
+ { url = "https://files.pythonhosted.org/packages/62/42/94e15bc68ce3d423243c45d7f1b0c7561f13844f97dc52ae23182fb65628/httptools-0.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d76ad7b951387e3632c8716a9bb03ac5b45c5f16119aa409db0459520887944e", size = 480865, upload-time = "2026-05-25T22:17:27.542Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/7c/fe2980fc03723272e30f135b62360b075f513dfe7cc73aef36c7f04012bd/httptools-0.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a3b7387147361c3fd47a0bde763c5c91b5b4cd4dc9989b8ece84ff436c99843b", size = 463189, upload-time = "2026-05-25T22:17:28.546Z" },
+ { url = "https://files.pythonhosted.org/packages/15/1b/47fc5fff68acd1bfa20b4734059c9a06cadb88119dcd5258b5b0d21d91c8/httptools-0.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f256d6ce930c52ca1cb2a960b7da03548c454e7d28b06059ad41bfe789036ce0", size = 466610, upload-time = "2026-05-25T22:17:29.816Z" },
+ { url = "https://files.pythonhosted.org/packages/60/bd/07b13c93ffd9bec9546e0d43f8e19378dd696dbd278511406bc07371ef1f/httptools-0.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:19d1ee275bb59ba2643ba9a3a1e51cc0c788caf2b8df506368e03f56fdd08527", size = 92705, upload-time = "2026-05-25T22:17:31.133Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/c4/121648f68ce066d7bd762d6b6d97e620847642d38d54f3d90ff11d947629/httptools-0.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:de1ed58a974e75d56560acc7e7fed01a454994429456f65209789992e41f2568", size = 215023, upload-time = "2026-05-25T22:17:32.401Z" },
+ { url = "https://files.pythonhosted.org/packages/b9/b0/312a062ae741ae3e8baa8c8bf20be81b2e67337b259ab4349bebc7b6142e/httptools-0.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e93c227b595c6926c1acee96891dd9da4be338cfbe82e5cd3bb9d8dd7dc4ac0b", size = 117405, upload-time = "2026-05-25T22:17:33.742Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/37/fccd705f795386bb05bf413012fecff2a33e5aa8c2f069096de3e9fd8702/httptools-0.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2a021c3a8e65cc125390d72f59b968afca3bdcaff25bd67965e0a055a14946ca", size = 558497, upload-time = "2026-05-25T22:17:34.732Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/39/f172e8003576de35f5ba77ff417cf0e34429d35dc014deef15afa337a72c/httptools-0.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48774d39cbb70e2b1f71f88852a3087ae1d3a1eb80482bb48c13067ab080c14f", size = 571585, upload-time = "2026-05-25T22:17:35.813Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/b9/f5564760af99f3dbbf3f9104dc00e5da27e96cf433c6bdcf77617f70bf3f/httptools-0.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:88eead8ec8680a9f146c655bc88445a325bd7921cfd8194c7337e9467282427d", size = 543297, upload-time = "2026-05-25T22:17:37.08Z" },
+ { url = "https://files.pythonhosted.org/packages/99/67/8d9f2c313618e161b82f3873188e7196126da1d6e29688df40eb3997c77a/httptools-0.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2c032fa028f46871ec7e1fc59fc15e8023eab3e6bbe6ece786a1611719a5d081", size = 539535, upload-time = "2026-05-25T22:17:38.032Z" },
+ { url = "https://files.pythonhosted.org/packages/48/63/b906c01e53f50d432c0defe43ce52764a111dc1bdd028bafbeb54dcfd008/httptools-0.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:384c17174464c8e873398b7af24f0b1f44d992c820328413951a625323155d77", size = 108209, upload-time = "2026-05-25T22:17:39.473Z" },
+]
+
+[[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 = "httpx-sse"
+version = "0.4.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0f/4c/751061ffa58615a32c31b2d82e8482be8dd4a89154f003147acee90f2be9/httpx_sse-0.4.3.tar.gz", hash = "sha256:9b1ed0127459a66014aec3c56bebd93da3c1bc8bb6618c8082039a44889a755d", size = 15943, upload-time = "2025-10-10T21:48:22.271Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d2/fd/6668e5aec43ab844de6fc74927e155a3b37bf40d7c3790e49fc0406b6578/httpx_sse-0.4.3-py3-none-any.whl", hash = "sha256:0ac1c9fe3c0afad2e0ebb25a934a59f4c7823b60792691f779fad2c5568830fc", size = 8960, upload-time = "2025-10-10T21:48:21.158Z" },
+]
+
+[[package]]
+name = "huggingface-hub"
+version = "1.24.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "click" },
+ { name = "filelock" },
+ { name = "fsspec" },
+ { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" },
+ { name = "httpx" },
+ { name = "packaging" },
+ { name = "pyyaml" },
+ { name = "tqdm" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/9b/d3bb4e7d792835daf34dd7091bbc7d7b4e0437d9388f1ea7239cce49f478/huggingface_hub-1.24.0.tar.gz", hash = "sha256:18431ff4daae0749aa9ba102fc952e314c98e1d30ebdec5319d85ca0a83e1ae5", size = 921848, upload-time = "2026-07-17T09:54:01.022Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5f/c3/aeaaf3911d2529614be18d1c8b5496afc185560e76568063d517283318af/huggingface_hub-1.24.0-py3-none-any.whl", hash = "sha256:6ed4120a84a6beec900640aa7e346bd766a6b7341e41526fef5dc8bd81fb7d59", size = 771904, upload-time = "2026-07-17T09:53:59.106Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "ifaddr"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/ac/fb4c578f4a3256561548cd825646680edcadb9440f3f68add95ade1eb791/ifaddr-0.2.0.tar.gz", hash = "sha256:cc0cbfcaabf765d44595825fb96a99bb12c79716b73b44330ea38ee2b0c4aed4", size = 10485, upload-time = "2022-06-15T21:40:27.561Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/9c/1f/19ebc343cc71a7ffa78f17018535adc5cbdd87afb31d7c34874680148b32/ifaddr-0.2.0-py3-none-any.whl", hash = "sha256:085e0305cfe6f16ab12d72e2024030f5d52674afad6911bb1eee207177b8a748", size = 12314, upload-time = "2022-06-15T21:40:25.756Z" },
+]
+
+[[package]]
+name = "importlib-resources"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e4/06/b56dfa750b44e86157093bc8fca0ab81dccbf5260510de4eaf1cb69b5b99/importlib_resources-7.1.0.tar.gz", hash = "sha256:0722d4c6212489c530f2a145a34c0a7a3b4721bc96a15fada5930e2a0b760708", size = 44985, upload-time = "2026-04-12T16:36:09.232Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/8a/db/55a262f3606bebcae07cc14095338471ad7c0bbcaa37707e6f0ee49725b7/importlib_resources-7.1.0-py3-none-any.whl", hash = "sha256:1bd7b48b4088eddb2cd16382150bb515af0bd2c70128194392725f82ad2c96a1", size = 37232, upload-time = "2026-04-12T16:36:08.219Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "jinja2"
+version = "3.1.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "markupsafe" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" },
+]
+
+[[package]]
+name = "jiter"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/1f/10936e16d8860c70698a1aa939a46aa0224813b782bce4e000e637da0b2d/jiter-0.16.0.tar.gz", hash = "sha256:7b24c3492c5f4f84a37946ad9cf504910cf6a782d6a4e0689b6673c5894b4a1c", size = 176431, upload-time = "2026-06-29T13:05:13.657Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/83/2b/52ace16ed031354f0539749a49e4bf33797d82bea5137910835fa4b09793/jiter-0.16.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:67c3bc1760f8c99d805dcab4e644027142a53b1d5d861f18780ebdbd5d40b72a", size = 306943, upload-time = "2026-06-29T13:03:14.035Z" },
+ { url = "https://files.pythonhosted.org/packages/94/2e/34957c2c1b661c252ba9bcc60ae0bddc27e0f7202c6073326a13c5390eec/jiter-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5af7780e4a26bd7d0d989592bf9ef12ebf806b74ab709223ecca37c749872ea9", size = 307779, upload-time = "2026-06-29T13:03:15.418Z" },
+ { url = "https://files.pythonhosted.org/packages/88/6c/59bd309cab4460c54cf1079f3eb7fe7af6a4c895c5c957a53378693bad2b/jiter-0.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d5bf78d0e05e45cfdd66558893938d59afe3d1b1a824a202039b20e607d25a72", size = 335826, upload-time = "2026-06-29T13:03:17.11Z" },
+ { url = "https://files.pythonhosted.org/packages/3b/8c/f5ef7b65f0df47afa16596969defb281ebb86e96df346d62be6fd853d620/jiter-0.16.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f4444a83f946605990c98f625cdd3d2725bfb818158760c5748c653170a20e0e", size = 362573, upload-time = "2026-06-29T13:03:18.781Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/0b/ace4354da061ee38844a0c27dc2c21eecd27aea119e8da324bea987522d0/jiter-0.16.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3a23f0e4f957e1be65752d2dfac9a5a06b1917af8dc85deb639c3b9d02e31290", size = 457979, upload-time = "2026-06-29T13:03:20.293Z" },
+ { url = "https://files.pythonhosted.org/packages/55/40/c0253d3772eb9dcd8e6606ee9b2d53ec8e5b814589c47f140aa585f21eaa/jiter-0.16.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c22a488f7b9218e245a0025a9ba6b100e2e54700831cf4cf16833a27fba3ad01", size = 372302, upload-time = "2026-06-29T13:03:21.739Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/d2/4839422241aa12860ce597b20068727094ba0bc480723c74924ca5bad483/jiter-0.16.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46add52f4ad47a08bfb1219f3e673da972191489a33016edefdb5ea55bfa8c48", size = 343805, upload-time = "2026-06-29T13:03:23.384Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/59/e196888a05befdda7dbe299b722d56f2f6eec65402bc34c0a3306d595feb/jiter-0.16.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:9c8a956fd72c2cf1e730d01ea080341f13aa0a97a4a33b51abebe725b7ae9ca9", size = 351107, upload-time = "2026-06-29T13:03:24.815Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/74/4cd9e0fca65232136400354b630fbfcd2de634e22ccbb96567725981b548/jiter-0.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:561926e0573ffe4a32498420a76d64b16c513e1ab413b9d28158a8764ac701e5", size = 388441, upload-time = "2026-06-29T13:03:26.266Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/8c/554691e48bc711299c0a293dd8a6179e24b2d66a54dc295421fcf64569c0/jiter-0.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:44d019fa8cdaf89bf29c71b39e3712143fdd0ac76725c6ef954f9957a5ea8730", size = 516354, upload-time = "2026-06-29T13:03:28.02Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/cb/01e9d69dc2cc6759d4f91e230b34489c4fdb2518992650633f9e20bece89/jiter-0.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:0df91907609837f33341b8e6fe73b95991fdaa57caf1a0fbd343dffe826f386f", size = 547880, upload-time = "2026-06-29T13:03:29.534Z" },
+ { url = "https://files.pythonhosted.org/packages/79/70/2953195f1c6ad00f49fa67e13df7e60acb3dd4f387101bc15abccddd905e/jiter-0.16.0-cp312-cp312-win32.whl", hash = "sha256:51d7b836acb0108d7c77df1742332cac2a1fa04a74d6dacec46e7091f0e91274", size = 203473, upload-time = "2026-06-29T13:03:31.025Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/05/2909a8b10699a4d560f8c502b6b2c5f3991b682b1922c1eedda242b225bd/jiter-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:1878349266f8ee36ecb1375cc5ba2f115f35fd9f0a1a4119e725e379126647f7", size = 196905, upload-time = "2026-06-29T13:03:32.472Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/a9/6b82bb1c8d7790d602489b967b982a909e5d092875a6c2ade96444c8dfc5/jiter-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:2ed5738ae4af18271a51a528b8811b0cbfa4a1858de9d83359e4169855d6a331", size = 190618, upload-time = "2026-06-29T13:03:34.672Z" },
+ { url = "https://files.pythonhosted.org/packages/91/c0/555fc60473d30d66894ba825e63615e3be7524fac23858356afa7a38906c/jiter-0.16.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:41977aa5654023948c2dae2a81cbf9c43343954bef1cd59a154dd15a4d84c195", size = 306203, upload-time = "2026-06-29T13:03:36.243Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/2b/c3eaf16f5d7c9bad66ea32f40a95bd169b29a91217fcc7f081375157e99c/jiter-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d28bb3c26762358dadf3e5bf0bccd29ae987d65e6988d2e6f49829c76b003c09", size = 306489, upload-time = "2026-06-29T13:03:37.846Z" },
+ { url = "https://files.pythonhosted.org/packages/96/3f/02fdfc6705cad96127d883af5c34e4867f554f29ec7705ec1a46156400a9/jiter-0.16.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0542a7189c26920778658fc8fcf2af8bae05bae9924577f71804acef37996536", size = 335453, upload-time = "2026-06-29T13:03:39.221Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/a6/e4bda5920d4b0d7c5dfb7174ce4a6b2e4d3e11c9162c452ef0eab4cdbdbd/jiter-0.16.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8fb8de1e23a0cb2a7f53c335049c7b72b6db41aa6227cdcc0972a1de5cb39450", size = 361625, upload-time = "2026-06-29T13:03:40.597Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/97/4e6b59b2c6e55cbb3e183595f81ad65dcfb21c915fee5e19e335df21bc55/jiter-0.16.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b72d0b2990ca754a9102779ac98d8597b7cb31678958562214a007f909eab78e", size = 456958, upload-time = "2026-06-29T13:03:42.074Z" },
+ { url = "https://files.pythonhosted.org/packages/15/e0/97e9557686d2f94f4b93786eccb7eed28e9228ad132ea8237f44727314a7/jiter-0.16.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d5f91b1c27fc22a57993d5a5cb8a627cb8ed4b10502716fac1ffbfe1d19d84e8", size = 372017, upload-time = "2026-06-29T13:03:43.658Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/94/db768b6938e0df35c86beeba3dfbbb025c9ee5c19e1aa271f2396e50864d/jiter-0.16.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c682bea068a90b764577bdb78a60a4c1d1606daf9cd4c893832a37c7cc9d9026", size = 343320, upload-time = "2026-06-29T13:03:45.226Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/d6/5a59d938244a30735fe62d9433fd325f9021ea29d89780ea4596ea93bc89/jiter-0.16.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:8d031aabecc4f1b6276adfb42e3aabb77c89d468bf616600e8d3a11328929053", size = 350520, upload-time = "2026-06-29T13:03:46.671Z" },
+ { url = "https://files.pythonhosted.org/packages/67/f8/c4a857f49c9af125f6bbcac7e3eee7f7978ed89682833062e2dbf62576b1/jiter-0.16.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:eab2cd170150e70153de16896a1774e3a1dca80154c56b54d7a812c479a7165e", size = 387550, upload-time = "2026-06-29T13:03:48.361Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/d6/5fbc2f7d6b67b754caa61a993a2e626e815dec47ffc2f9e35f01adfebec7/jiter-0.16.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:6edb63a46e65a82c26800a868e49b2cac30dd5a4218b88d74bc2c848c8ad60bb", size = 515424, upload-time = "2026-06-29T13:03:49.881Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/54/284f0164b64a5fed915fea6ba7e9ba9b3d8d37c67d59cf2e3bb99d45cdfe/jiter-0.16.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:659039cc50b5addcc35fcc87ae2c1833b7c0a8e5326ef631a75e4478447bcf84", size = 546981, upload-time = "2026-06-29T13:03:51.363Z" },
+ { url = "https://files.pythonhosted.org/packages/13/c5/2a467585a576594384e1d2c43e1224deaafc085f24e243529cf98beef8e1/jiter-0.16.0-cp313-cp313-win32.whl", hash = "sha256:c9c53be232c2e206ef9cdbad81a48bfa74c3d3f08bcf8124630a8a748aad993e", size = 202853, upload-time = "2026-06-29T13:03:53.015Z" },
+ { url = "https://files.pythonhosted.org/packages/88/6a/de61d04b9eec69c71719968d2f716532a3bc121170c44a39e14979c6be81/jiter-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:baad945ed47f163ad833314f8e3288c396118934f94e7bbb9e243ce4b341a4fd", size = 196160, upload-time = "2026-06-29T13:03:54.447Z" },
+ { url = "https://files.pythonhosted.org/packages/19/4b/b390ed59bafb3f31d008d1218578f10327714484b334439947f7e5b11e7f/jiter-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:3c1fd2dbe1b0af19e987f03fe66c5f5bd105a2229c1aff4ab14890b24f41d21a", size = 189862, upload-time = "2026-06-29T13:03:55.754Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/89/bc4f1b57d5da938fd344a466396541e586d161320d70bffd929aaafcd8f4/jiter-0.16.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b2c61484666ad42726029af0c00ef4541f0f3b5cdc550221f56c2343208018ee", size = 308239, upload-time = "2026-06-29T13:03:57.205Z" },
+ { url = "https://files.pythonhosted.org/packages/65/7a/c415453e5213001bf3b411ff65dec3d303b0e76a4a2cfea9768cd4960994/jiter-0.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:63efadc657488f45db1c676d81e704cac2abf3fdb892def1faea61db053127e2", size = 308928, upload-time = "2026-06-29T13:03:58.643Z" },
+ { url = "https://files.pythonhosted.org/packages/11/fc/1f4fb7ebf9a724c7741994f4aae18fba1e2f3133df14521a79194952c34a/jiter-0.16.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf0d73f50e7b6935677854f6e8e31d499ca7064dd24734f703e060f5b237d883", size = 336998, upload-time = "2026-06-29T13:04:00.071Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/8d/72cadaac05ccfa7cc3a0a2232862e6c72443ca40cf300ba8b57f9f18b69b/jiter-0.16.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bf3ea07d9bc8e7d03a9fbc051295462e6dbc295b894fd72457c3136e3e43d898", size = 362112, upload-time = "2026-06-29T13:04:01.52Z" },
+ { url = "https://files.pythonhosted.org/packages/58/4a/c4b0d5f651fda90a24ffce9f8d56cde462a2e09d31ae3de3c68cef34c04e/jiter-0.16.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:26798522707abb47d767db536e4148ceac1b14446bf028ee85e579a2e043cfe5", size = 459807, upload-time = "2026-06-29T13:04:03.214Z" },
+ { url = "https://files.pythonhosted.org/packages/80/58/ef77879ea9aa56b50824edc5a445e226422c7a8d211f3fd2a56bcb9493cf/jiter-0.16.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bc837c1b9631be10abfe0191537fe8009838204cec7e44827401ace390ddb567", size = 373181, upload-time = "2026-06-29T13:04:04.629Z" },
+ { url = "https://files.pythonhosted.org/packages/49/2e/ffbc3f254e4d8a66da3062c624a7df4b7c2b2cf9e1fe43cf394b3e104041/jiter-0.16.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49060fd70737fad59d33ba9dcc0d83247dc9e77187de26053a19c16c9f32bd69", size = 344927, upload-time = "2026-06-29T13:04:06.067Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/f6/0be5dc6d64a89f80aa8fec984f94dedb2973e251edcae55841d60786d578/jiter-0.16.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:adbb8edeadd431bc4477879d5d371ece7cb1334486584e0f252656dd7ffada29", size = 352754, upload-time = "2026-06-29T13:04:07.477Z" },
+ { url = "https://files.pythonhosted.org/packages/da/6e/7d31243b3b91cd261dd19e9d3557fc3251a80883d3d8049c86174e7ab7af/jiter-0.16.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:31aaee5b80f672c1dc21272bcfb9cbdcfc1ea04ff50f00ed5af500b80c44fa93", size = 390553, upload-time = "2026-06-29T13:04:08.92Z" },
+ { url = "https://files.pythonhosted.org/packages/25/33/51ae371fde3c88897520f62b4d5f8b27ad7103e2bb10812ff52195609853/jiter-0.16.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:6722bcef4ffc86c835574b1b2fac6b33b9fb4a889c781e67950e891591f3c55a", size = 516900, upload-time = "2026-06-29T13:04:10.407Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/45/6449b3d123ea439ba79507c657288f461d55049e7bcbdc2cf8eb8210f491/jiter-0.16.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:5ab4f50ff971b611d656554ea10b75f80097392c827bc32923c6eeb6386c8b00", size = 548754, upload-time = "2026-06-29T13:04:12.046Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/e7/fd2fb11ae3e2649333da3aa170d04d7b3000bbdc3b270f6513382fdf4e04/jiter-0.16.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:710cc51d4ebdcd3c1f70b232c1db1ea1344a075770422bbd4bede5708335acbe", size = 122381, upload-time = "2026-06-29T13:04:13.413Z" },
+ { url = "https://files.pythonhosted.org/packages/26/80/f0b147a62c315a164ed2168908286ca302310824c218d3aae52b06c0c9a9/jiter-0.16.0-cp314-cp314-win32.whl", hash = "sha256:57b37fc887a32d44798e4d8ebfa7c9683ff3da1d5bf38f08d1bb3573ccb39106", size = 204578, upload-time = "2026-06-29T13:04:14.813Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/e6/4758a14304b4523a6f5adb2419340086aa3593bd4327c2b25b5948a90548/jiter-0.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:cbd18dd5e2df96b580487b5745adf57ef64ad89ba2d9662fc3c19386acce7db8", size = 198154, upload-time = "2026-06-29T13:04:16.272Z" },
+ { url = "https://files.pythonhosted.org/packages/26/be/41fa54a2e7ea41d6c99f1dc5b1f0fd4cb474680304b5d268dd518e81da3a/jiter-0.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:a32d2027a9fa67f109ff245a3252ece3ccc32cc56703e1deab6cc846a59e0585", size = 191458, upload-time = "2026-06-29T13:04:17.707Z" },
+ { url = "https://files.pythonhosted.org/packages/81/6b/59127338b86d9fe4d99418f5a15118bea778103ee0fe9d9dd7e0af174e95/jiter-0.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2577196f4474ef3fc4779a088a23b0897bbf86f9ea3679c372d45b8383b43207", size = 316739, upload-time = "2026-06-29T13:04:19.663Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/95/49461034d5388196d3dabf98748935f017b7785d8f3f5349f834bcc4ed0d/jiter-0.16.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:616e89e008a93c01104161c75b4988e58716b01d62307ebfe161e52a56d2a818", size = 340911, upload-time = "2026-06-29T13:04:21.257Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/97/a4369f2fb82cb3dda13b98622f31249b2e014b223fe64ee534413ad72294/jiter-0.16.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0e2e9efbe042210df657bade597f66d6d75723e3d8f45a12ea6d8167ff8bbce3", size = 361747, upload-time = "2026-06-29T13:04:22.677Z" },
+ { url = "https://files.pythonhosted.org/packages/28/51/49b6ed456261646e1906016a6760367a28aacd3c24805e4e5fe64116c1db/jiter-0.16.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3f4d9e473a5ce7d27fef8b848df4dc16e283893d3f53b4a585e72c9595f3c284", size = 460225, upload-time = "2026-06-29T13:04:24.441Z" },
+ { url = "https://files.pythonhosted.org/packages/33/b5/5689aff4f66c5b60be63106e591dbfcba2190df97d2c9c7cf052361ddb98/jiter-0.16.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d30a4a1c87713060c8d1cc59a7b6c8fb6b8ef0a6900368014c76c87922a2929", size = 373169, upload-time = "2026-06-29T13:04:25.884Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/96/3ae1b85ee0d6d6cab254fb7f8da018272b932bbf2d69b07e98aa2a96c746/jiter-0.16.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bae96332410f866e5900d809298b1ed82735932986c672495f9701daacd80620", size = 350332, upload-time = "2026-06-29T13:04:27.302Z" },
+ { url = "https://files.pythonhosted.org/packages/15/32/c99d7bafd78986556c95bf60ce84c6cc98786eac56066c12d7f828bb6747/jiter-0.16.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:da3d7ec75dc83bb18bca888b5edfae0656a26849056c59e05a7728badd17e7af", size = 353377, upload-time = "2026-06-29T13:04:28.731Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/4b/f99a8e571287c3dec766bcc18528bbe8e8fb5365522ab5e6d64c93e87066/jiter-0.16.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ee6162b77d49a9939229df666dfa8af3e656b6701b54c4c84966d740e189264e", size = 387746, upload-time = "2026-06-29T13:04:30.319Z" },
+ { url = "https://files.pythonhosted.org/packages/75/69/c78a5b3f71040e34eb5917df26fb7ae9a2174cad1ccbf277512507c53a6e/jiter-0.16.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:63ffdbdae7d4499f4cda14eadc12ddcabef0fc0c081191bdc2247489cb698077", size = 517292, upload-time = "2026-06-29T13:04:31.709Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/f7/095b38eda4c70d03651c403f29a5590f16d12ddc5d544aac9f9cddf72277/jiter-0.16.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a111256a7193bea0759267b10385e5870949c239ed7b6ddbaaf57573edb38734", size = 549259, upload-time = "2026-06-29T13:04:33.721Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/c5/6a0207d90e5f656d95af98ebd0934f382d37674416f215aeda2ff8063e51/jiter-0.16.0-cp314-cp314t-win32.whl", hash = "sha256:de5ba8763e56b793561f43bed197c9ea55776daa5e9a6b91eed68a909bc9cdbf", size = 206523, upload-time = "2026-06-29T13:04:35.068Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/31/c757d5f30a8980fd945ce7b98be10be9e4ff59c7c42f5fd86804c2e87db8/jiter-0.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b8a3f9a6008048fe9def7bf465180564a6e458047d2ce499149cfbe73c3ae9db", size = 200366, upload-time = "2026-06-29T13:04:36.61Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/a2/d88de6d313d734a544a7901353ad5db67cb38dcfcd91713b7979dafc345d/jiter-0.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0fa25b09b13075c46f5bc174f2690525a925a4fc2f7c82969a2bbabff22386ce", size = 190516, upload-time = "2026-06-29T13:04:38.004Z" },
+ { url = "https://files.pythonhosted.org/packages/98/ab/664fd8c4be028b2bedd3d2ff08769c4ede23d0dbc87a77c62384a0515b5d/jiter-0.16.0-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:f17d61a28b4b3e0e3e2ba98490c70501403b4d196f78732439160e7fd3678127", size = 303106, upload-time = "2026-06-29T13:05:07.118Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/07/421f1d5b65493a76e16027b848aba6a7d28073ae75944fa4289cc914d39f/jiter-0.16.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:96e38eea538c8ddf853a35727c7be0741c76c13f04148ac5c116222f50ece3b3", size = 304658, upload-time = "2026-06-29T13:05:08.708Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/db/bba1155f01a01c3c37a89425d571da751bbedf5c54247b831a04cb971798/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d284fb8d94d5855d60c44fefcab4bf966f1da6fada73992b01f6f0c9bc0c6702", size = 339719, upload-time = "2026-06-29T13:05:10.41Z" },
+ { url = "https://files.pythonhosted.org/packages/78/f7/18a1afcd64f35314b68c1f23afcd9994d0bc13e65cc77517afff4e83986d/jiter-0.16.0-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64d613743df53199b1aa256a7d328340da6d7078aac7705a7db9d7a791e9cfd2", size = 343885, upload-time = "2026-06-29T13:05:12.087Z" },
+]
+
+[[package]]
+name = "jsonschema"
+version = "4.26.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "attrs" },
+ { name = "jsonschema-specifications" },
+ { name = "referencing" },
+ { name = "rpds-py" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/69/90/f63fb5873511e014207a475e2bb4e8b2e570d655b00ac19a9a0ca0a385ee/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce", size = 90630, upload-time = "2026-01-07T13:41:05.306Z" },
+]
+
+[[package]]
+name = "jsonschema-specifications"
+version = "2025.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "referencing" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/41/45/1a4ed80516f02155c51f51e8cedb3c1902296743db0bbc66608a0db2814f/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe", size = 18437, upload-time = "2025-09-08T01:34:57.871Z" },
+]
+
+[[package]]
+name = "libusb-package"
+version = "1.0.30.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "importlib-resources" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/42/a8/8b3d5dae7340880d556f9f866874b9674b2e3a22fee1e2b96f1ab0feae36/libusb_package-1.0.30.0-py3-none-macosx_10_9_x86_64.whl", hash = "sha256:2b98784bac3bedda7e95bb5039dd0eded84b02f36110e4d5d607375366c61090", size = 69516, upload-time = "2026-06-30T07:41:02.451Z" },
+ { url = "https://files.pythonhosted.org/packages/52/6f/26de4e9f858ab50e87931f0be268f3c1bbfce33e8584add60da857632142/libusb_package-1.0.30.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4ad25f8d254bbbdd234446d5580b24d62d59bb0e690d8090457dac347f044437", size = 65700, upload-time = "2026-06-30T07:41:03.557Z" },
+ { url = "https://files.pythonhosted.org/packages/11/12/9ba8fa91dc95b1cbfa4a68207d4048b08b900fd3686fa72b99846608de01/libusb_package-1.0.30.0-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c71b5f8c65b286425c02c7d624eee1fd7f08bfb1dfa492ddc20e27f06fee3829", size = 76166, upload-time = "2026-06-30T07:41:04.462Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/e1/a7c83535749332825f02d6693868f8ee9ae99c4104e60a483773bb652c0e/libusb_package-1.0.30.0-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f502ad5a0527b8c0431de817662325c88a1bba2cc334173665b04ad168d7b6d3", size = 76159, upload-time = "2026-06-30T07:41:05.543Z" },
+ { url = "https://files.pythonhosted.org/packages/de/56/a1fb1726fc96a8ee3bd0e04e5e505500f022dd310dd348ecebf5cdae7a60/libusb_package-1.0.30.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:7a2a1c82f6ef85d9920cbe2898aa6927d4c487744ef9f20b0d7d6d95705095bb", size = 77162, upload-time = "2026-06-30T07:41:06.581Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/03/264cefc51275ecb047194c4973bc40b3b278566a64bbe6e74f86bf1e0afc/libusb_package-1.0.30.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:2ee5ef8ac6f08402b4e8334f7404850316bdd26037c9a97f2a7456ee9a5d1550", size = 76676, upload-time = "2026-06-30T07:41:07.505Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/95/d166eeefe0d9dd5833d5724a97b023ec380c3a2d364040ec0485fd57703c/libusb_package-1.0.30.0-py3-none-win32.whl", hash = "sha256:79728146e1f01e525786900b2ccd8298a8eca53cd94b37fb0885e56aa6f9d60a", size = 78769, upload-time = "2026-06-30T07:41:08.432Z" },
+ { url = "https://files.pythonhosted.org/packages/60/4a/ff49bd77f33af05ca26fee29d601beb1e19ca791bb86efece82a3833885c/libusb_package-1.0.30.0-py3-none-win_amd64.whl", hash = "sha256:90808da724c8939a333d931d0c7226372ca5fefd98e2f2f3ef79fd918aa37522", size = 90711, upload-time = "2026-06-30T07:41:09.318Z" },
+]
+
+[[package]]
+name = "log-throttling"
+version = "0.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/be/09fda383d82a7b91f12ff5002bc909e101769c802ff3b1d2cb9f533d1a2f/log-throttling-0.0.3.tar.gz", hash = "sha256:df714e1448cd9cb4c916cf668ab88323032e61ece733548708d996ecf63190b9", size = 3533, upload-time = "2022-03-08T16:29:23.674Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b1/6e/995ebad4ab08250b4afe1d91fe3086b863ed9bb74539d90485250a50f08a/log_throttling-0.0.3-py3-none-any.whl", hash = "sha256:a82508f489dd44a60b737a0339c784dd8ee2b9db16bdcf587a8ae1012a7f6ffc", size = 4081, upload-time = "2022-03-08T16:29:21.443Z" },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "4.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b3/81/4da04ced5a082363ecfa159c010d200ecbd959ae410c10c0264a38cac0f5/markdown_it_py-4.2.0-py3-none-any.whl", hash = "sha256:9f7ebbcd14fe59494226453aed97c1070d83f8d24b6fc3a3bcf9a38092641c4a", size = 91687, upload-time = "2026-05-07T12:08:27.182Z" },
+]
+
+[[package]]
+name = "markupsafe"
+version = "3.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/7e/99/7690b6d4034fffd95959cbe0c02de8deb3098cc577c67bb6a24fe5d7caa7/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698", size = 80313, upload-time = "2025-09-27T18:37:40.426Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5a/72/147da192e38635ada20e0a2e1a51cf8823d2119ce8883f7053879c2199b5/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e", size = 11615, upload-time = "2025-09-27T18:36:30.854Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/81/7e4e08678a1f98521201c3079f77db69fb552acd56067661f8c2f534a718/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce", size = 12020, upload-time = "2025-09-27T18:36:31.971Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/2c/799f4742efc39633a1b54a92eec4082e4f815314869865d876824c257c1e/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d", size = 24332, upload-time = "2025-09-27T18:36:32.813Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/2e/8d0c2ab90a8c1d9a24f0399058ab8519a3279d1bd4289511d74e909f060e/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d", size = 22947, upload-time = "2025-09-27T18:36:33.86Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/54/887f3092a85238093a0b2154bd629c89444f395618842e8b0c41783898ea/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a", size = 21962, upload-time = "2025-09-27T18:36:35.099Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/2f/336b8c7b6f4a4d95e91119dc8521402461b74a485558d8f238a68312f11c/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b", size = 23760, upload-time = "2025-09-27T18:36:36.001Z" },
+ { url = "https://files.pythonhosted.org/packages/32/43/67935f2b7e4982ffb50a4d169b724d74b62a3964bc1a9a527f5ac4f1ee2b/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f", size = 21529, upload-time = "2025-09-27T18:36:36.906Z" },
+ { url = "https://files.pythonhosted.org/packages/89/e0/4486f11e51bbba8b0c041098859e869e304d1c261e59244baa3d295d47b7/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b", size = 23015, upload-time = "2025-09-27T18:36:37.868Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/e1/78ee7a023dac597a5825441ebd17170785a9dab23de95d2c7508ade94e0e/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d", size = 14540, upload-time = "2025-09-27T18:36:38.761Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/5b/bec5aa9bbbb2c946ca2733ef9c4ca91c91b6a24580193e891b5f7dbe8e1e/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c", size = 15105, upload-time = "2025-09-27T18:36:39.701Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/f1/216fc1bbfd74011693a4fd837e7026152e89c4bcf3e77b6692fba9923123/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f", size = 13906, upload-time = "2025-09-27T18:36:40.689Z" },
+ { url = "https://files.pythonhosted.org/packages/38/2f/907b9c7bbba283e68f20259574b13d005c121a0fa4c175f9bed27c4597ff/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795", size = 11622, upload-time = "2025-09-27T18:36:41.777Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/d9/5f7756922cdd676869eca1c4e3c0cd0df60ed30199ffd775e319089cb3ed/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219", size = 12029, upload-time = "2025-09-27T18:36:43.257Z" },
+ { url = "https://files.pythonhosted.org/packages/00/07/575a68c754943058c78f30db02ee03a64b3c638586fba6a6dd56830b30a3/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6", size = 24374, upload-time = "2025-09-27T18:36:44.508Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/21/9b05698b46f218fc0e118e1f8168395c65c8a2c750ae2bab54fc4bd4e0e8/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676", size = 22980, upload-time = "2025-09-27T18:36:45.385Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/71/544260864f893f18b6827315b988c146b559391e6e7e8f7252839b1b846a/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9", size = 21990, upload-time = "2025-09-27T18:36:46.916Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/28/b50fc2f74d1ad761af2f5dcce7492648b983d00a65b8c0e0cb457c82ebbe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1", size = 23784, upload-time = "2025-09-27T18:36:47.884Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/76/104b2aa106a208da8b17a2fb72e033a5a9d7073c68f7e508b94916ed47a9/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc", size = 21588, upload-time = "2025-09-27T18:36:48.82Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/99/16a5eb2d140087ebd97180d95249b00a03aa87e29cc224056274f2e45fd6/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12", size = 23041, upload-time = "2025-09-27T18:36:49.797Z" },
+ { url = "https://files.pythonhosted.org/packages/19/bc/e7140ed90c5d61d77cea142eed9f9c303f4c4806f60a1044c13e3f1471d0/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed", size = 14543, upload-time = "2025-09-27T18:36:51.584Z" },
+ { url = "https://files.pythonhosted.org/packages/05/73/c4abe620b841b6b791f2edc248f556900667a5a1cf023a6646967ae98335/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5", size = 15113, upload-time = "2025-09-27T18:36:52.537Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/3a/fa34a0f7cfef23cf9500d68cb7c32dd64ffd58a12b09225fb03dd37d5b80/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485", size = 13911, upload-time = "2025-09-27T18:36:53.513Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/d7/e05cd7efe43a88a17a37b3ae96e79a19e846f3f456fe79c57ca61356ef01/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73", size = 11658, upload-time = "2025-09-27T18:36:54.819Z" },
+ { url = "https://files.pythonhosted.org/packages/99/9e/e412117548182ce2148bdeacdda3bb494260c0b0184360fe0d56389b523b/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37", size = 12066, upload-time = "2025-09-27T18:36:55.714Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/e6/fa0ffcda717ef64a5108eaa7b4f5ed28d56122c9a6d70ab8b72f9f715c80/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19", size = 25639, upload-time = "2025-09-27T18:36:56.908Z" },
+ { url = "https://files.pythonhosted.org/packages/96/ec/2102e881fe9d25fc16cb4b25d5f5cde50970967ffa5dddafdb771237062d/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025", size = 23569, upload-time = "2025-09-27T18:36:57.913Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/30/6f2fce1f1f205fc9323255b216ca8a235b15860c34b6798f810f05828e32/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6", size = 23284, upload-time = "2025-09-27T18:36:58.833Z" },
+ { url = "https://files.pythonhosted.org/packages/58/47/4a0ccea4ab9f5dcb6f79c0236d954acb382202721e704223a8aafa38b5c8/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f", size = 24801, upload-time = "2025-09-27T18:36:59.739Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/70/3780e9b72180b6fecb83a4814d84c3bf4b4ae4bf0b19c27196104149734c/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb", size = 22769, upload-time = "2025-09-27T18:37:00.719Z" },
+ { url = "https://files.pythonhosted.org/packages/98/c5/c03c7f4125180fc215220c035beac6b9cb684bc7a067c84fc69414d315f5/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009", size = 23642, upload-time = "2025-09-27T18:37:01.673Z" },
+ { url = "https://files.pythonhosted.org/packages/80/d6/2d1b89f6ca4bff1036499b1e29a1d02d282259f3681540e16563f27ebc23/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354", size = 14612, upload-time = "2025-09-27T18:37:02.639Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/98/e48a4bfba0a0ffcf9925fe2d69240bfaa19c6f7507b8cd09c70684a53c1e/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218", size = 15200, upload-time = "2025-09-27T18:37:03.582Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/72/e3cc540f351f316e9ed0f092757459afbc595824ca724cbc5a5d4263713f/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287", size = 13973, upload-time = "2025-09-27T18:37:04.929Z" },
+ { url = "https://files.pythonhosted.org/packages/33/8a/8e42d4838cd89b7dde187011e97fe6c3af66d8c044997d2183fbd6d31352/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe", size = 11619, upload-time = "2025-09-27T18:37:06.342Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/64/7660f8a4a8e53c924d0fa05dc3a55c9cee10bbd82b11c5afb27d44b096ce/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026", size = 12029, upload-time = "2025-09-27T18:37:07.213Z" },
+ { url = "https://files.pythonhosted.org/packages/da/ef/e648bfd021127bef5fa12e1720ffed0c6cbb8310c8d9bea7266337ff06de/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737", size = 24408, upload-time = "2025-09-27T18:37:09.572Z" },
+ { url = "https://files.pythonhosted.org/packages/41/3c/a36c2450754618e62008bf7435ccb0f88053e07592e6028a34776213d877/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97", size = 23005, upload-time = "2025-09-27T18:37:10.58Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/20/b7fdf89a8456b099837cd1dc21974632a02a999ec9bf7ca3e490aacd98e7/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d", size = 22048, upload-time = "2025-09-27T18:37:11.547Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/a7/591f592afdc734f47db08a75793a55d7fbcc6902a723ae4cfbab61010cc5/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda", size = 23821, upload-time = "2025-09-27T18:37:12.48Z" },
+ { url = "https://files.pythonhosted.org/packages/7d/33/45b24e4f44195b26521bc6f1a82197118f74df348556594bd2262bda1038/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf", size = 21606, upload-time = "2025-09-27T18:37:13.485Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/0e/53dfaca23a69fbfbbf17a4b64072090e70717344c52eaaaa9c5ddff1e5f0/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe", size = 23043, upload-time = "2025-09-27T18:37:14.408Z" },
+ { url = "https://files.pythonhosted.org/packages/46/11/f333a06fc16236d5238bfe74daccbca41459dcd8d1fa952e8fbd5dccfb70/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9", size = 14747, upload-time = "2025-09-27T18:37:15.36Z" },
+ { url = "https://files.pythonhosted.org/packages/28/52/182836104b33b444e400b14f797212f720cbc9ed6ba34c800639d154e821/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581", size = 15341, upload-time = "2025-09-27T18:37:16.496Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/18/acf23e91bd94fd7b3031558b1f013adfa21a8e407a3fdb32745538730382/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4", size = 14073, upload-time = "2025-09-27T18:37:17.476Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/f0/57689aa4076e1b43b15fdfa646b04653969d50cf30c32a102762be2485da/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab", size = 11661, upload-time = "2025-09-27T18:37:18.453Z" },
+ { url = "https://files.pythonhosted.org/packages/89/c3/2e67a7ca217c6912985ec766c6393b636fb0c2344443ff9d91404dc4c79f/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175", size = 12069, upload-time = "2025-09-27T18:37:19.332Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/00/be561dce4e6ca66b15276e184ce4b8aec61fe83662cce2f7d72bd3249d28/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634", size = 25670, upload-time = "2025-09-27T18:37:20.245Z" },
+ { url = "https://files.pythonhosted.org/packages/50/09/c419f6f5a92e5fadde27efd190eca90f05e1261b10dbd8cbcb39cd8ea1dc/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50", size = 23598, upload-time = "2025-09-27T18:37:21.177Z" },
+ { url = "https://files.pythonhosted.org/packages/22/44/a0681611106e0b2921b3033fc19bc53323e0b50bc70cffdd19f7d679bb66/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e", size = 23261, upload-time = "2025-09-27T18:37:22.167Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/57/1b0b3f100259dc9fffe780cfb60d4be71375510e435efec3d116b6436d43/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5", size = 24835, upload-time = "2025-09-27T18:37:23.296Z" },
+ { url = "https://files.pythonhosted.org/packages/26/6a/4bf6d0c97c4920f1597cc14dd720705eca0bf7c787aebc6bb4d1bead5388/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523", size = 22733, upload-time = "2025-09-27T18:37:24.237Z" },
+ { url = "https://files.pythonhosted.org/packages/14/c7/ca723101509b518797fedc2fdf79ba57f886b4aca8a7d31857ba3ee8281f/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc", size = 23672, upload-time = "2025-09-27T18:37:25.271Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/df/5bd7a48c256faecd1d36edc13133e51397e41b73bb77e1a69deab746ebac/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d", size = 14819, upload-time = "2025-09-27T18:37:26.285Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/8a/0402ba61a2f16038b48b39bccca271134be00c5c9f0f623208399333c448/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9", size = 15426, upload-time = "2025-09-27T18:37:27.316Z" },
+ { url = "https://files.pythonhosted.org/packages/70/bc/6f1c2f612465f5fa89b95bead1f44dcb607670fd42891d8fdcd5d039f4f4/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa", size = 14146, upload-time = "2025-09-27T18:37:28.327Z" },
+]
+
+[[package]]
+name = "mcp"
+version = "1.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "httpx" },
+ { name = "httpx-sse" },
+ { name = "jsonschema" },
+ { name = "pydantic" },
+ { name = "pydantic-settings" },
+ { name = "pyjwt", extra = ["crypto"] },
+ { name = "python-multipart" },
+ { name = "pywin32", marker = "sys_platform == 'win32'" },
+ { name = "sse-starlette" },
+ { name = "starlette" },
+ { name = "typing-extensions" },
+ { name = "typing-inspection" },
+ { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6e/77/9450b8f251a13affb6281997d0523c4615f8a8b35d0b21ff30db3a5aac9d/mcp-1.28.1.tar.gz", hash = "sha256:d51e36a5f5644faea4f85ea649bfffa6bc6c26770d42798ad6a3de3d2ba69683", size = 638501, upload-time = "2026-06-26T12:57:29.093Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e2/5e/d118fce19f87a2e7d8101c35c8ae0ec289098a4df0ff244cec23e415aca0/mcp-1.28.1-py3-none-any.whl", hash = "sha256:2726bca5e7193f61c5dde8b12500a6de2d9acf6d1a1c0be9e8c2e706437991df", size = 222620, upload-time = "2026-06-26T12:57:27.218Z" },
+]
+
+[[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/8d/9c/f20e0e2cf80e4b2e4b1c365bf5fe104ee633c751a724246262db8f1a0b13/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172", size = 76893, upload-time = "2026-01-26T02:43:52.754Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/cf/18ef143a81610136d3da8193da9d80bfe1cb548a1e2d1c775f26b23d024a/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd", size = 45456, upload-time = "2026-01-26T02:43:53.893Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/65/1caac9d4cd32e8433908683446eebc953e82d22b03d10d41a5f0fefe991b/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7", size = 43872, upload-time = "2026-01-26T02:43:55.041Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/3b/d6bd75dc4f3ff7c73766e04e705b00ed6dbbaccf670d9e05a12b006f5a21/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53", size = 251018, upload-time = "2026-01-26T02:43:56.198Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/80/c959c5933adedb9ac15152e4067c702a808ea183a8b64cf8f31af8ad3155/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75", size = 258883, upload-time = "2026-01-26T02:43:57.499Z" },
+ { url = "https://files.pythonhosted.org/packages/86/85/7ed40adafea3d4f1c8b916e3b5cc3a8e07dfcdcb9cd72800f4ed3ca1b387/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b", size = 242413, upload-time = "2026-01-26T02:43:58.755Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/57/b8565ff533e48595503c785f8361ff9a4fde4d67de25c207cd0ba3befd03/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733", size = 268404, upload-time = "2026-01-26T02:44:00.216Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/50/9810c5c29350f7258180dfdcb2e52783a0632862eb334c4896ac717cebcb/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a", size = 269456, upload-time = "2026-01-26T02:44:02.202Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/8d/5e5be3ced1d12966fefb5c4ea3b2a5b480afcea36406559442c6e31d4a48/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961", size = 256322, upload-time = "2026-01-26T02:44:03.56Z" },
+ { url = "https://files.pythonhosted.org/packages/31/6e/d8a26d81ac166a5592782d208dd90dfdc0a7a218adaa52b45a672b46c122/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582", size = 253955, upload-time = "2026-01-26T02:44:04.845Z" },
+ { url = "https://files.pythonhosted.org/packages/59/4c/7c672c8aad41534ba619bcd4ade7a0dc87ed6b8b5c06149b85d3dd03f0cd/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e", size = 251254, upload-time = "2026-01-26T02:44:06.133Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/bd/84c24de512cbafbdbc39439f74e967f19570ce7924e3007174a29c348916/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3", size = 252059, upload-time = "2026-01-26T02:44:07.518Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/ba/f5449385510825b73d01c2d4087bf6d2fccc20a2d42ac34df93191d3dd03/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6", size = 263588, upload-time = "2026-01-26T02:44:09.382Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/11/afc7c677f68f75c84a69fe37184f0f82fce13ce4b92f49f3db280b7e92b3/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a", size = 259642, upload-time = "2026-01-26T02:44:10.73Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/17/ebb9644da78c4ab36403739e0e6e0e30ebb135b9caf3440825001a0bddcb/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba", size = 251377, upload-time = "2026-01-26T02:44:12.042Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/a4/840f5b97339e27846c46307f2530a2805d9d537d8b8bd416af031cad7fa0/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511", size = 41887, upload-time = "2026-01-26T02:44:14.245Z" },
+ { url = "https://files.pythonhosted.org/packages/80/31/0b2517913687895f5904325c2069d6a3b78f66cc641a86a2baf75a05dcbb/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19", size = 46053, upload-time = "2026-01-26T02:44:15.371Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/5b/aba28e4ee4006ae4c7df8d327d31025d760ffa992ea23812a601d226e682/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf", size = 43307, upload-time = "2026-01-26T02:44:16.852Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/22/929c141d6c0dba87d3e1d38fbdf1ba8baba86b7776469f2bc2d3227a1e67/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23", size = 76174, upload-time = "2026-01-26T02:44:18.509Z" },
+ { url = "https://files.pythonhosted.org/packages/c7/75/bc704ae15fee974f8fccd871305e254754167dce5f9e42d88a2def741a1d/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2", size = 45116, upload-time = "2026-01-26T02:44:19.745Z" },
+ { url = "https://files.pythonhosted.org/packages/79/76/55cd7186f498ed080a18440c9013011eb548f77ae1b297206d030eb1180a/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445", size = 43524, upload-time = "2026-01-26T02:44:21.571Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/3c/414842ef8d5a1628d68edee29ba0e5bcf235dbfb3ccd3ea303a7fe8c72ff/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177", size = 249368, upload-time = "2026-01-26T02:44:22.803Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/32/befed7f74c458b4a525e60519fe8d87eef72bb1e99924fa2b0f9d97a221e/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23", size = 256952, upload-time = "2026-01-26T02:44:24.306Z" },
+ { url = "https://files.pythonhosted.org/packages/03/d6/c878a44ba877f366630c860fdf74bfb203c33778f12b6ac274936853c451/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060", size = 240317, upload-time = "2026-01-26T02:44:25.772Z" },
+ { url = "https://files.pythonhosted.org/packages/68/49/57421b4d7ad2e9e60e25922b08ceb37e077b90444bde6ead629095327a6f/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d", size = 267132, upload-time = "2026-01-26T02:44:27.648Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/fe/ec0edd52ddbcea2a2e89e174f0206444a61440b40f39704e64dc807a70bd/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed", size = 268140, upload-time = "2026-01-26T02:44:29.588Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/73/6e1b01cbeb458807aa0831742232dbdd1fa92bfa33f52a3f176b4ff3dc11/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429", size = 254277, upload-time = "2026-01-26T02:44:30.902Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/b2/5fb8c124d7561a4974c342bc8c778b471ebbeb3cc17df696f034a7e9afe7/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6", size = 252291, upload-time = "2026-01-26T02:44:32.31Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/96/51d4e4e06bcce92577fcd488e22600bd38e4fd59c20cb49434d054903bd2/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9", size = 250156, upload-time = "2026-01-26T02:44:33.734Z" },
+ { url = "https://files.pythonhosted.org/packages/db/6b/420e173eec5fba721a50e2a9f89eda89d9c98fded1124f8d5c675f7a0c0f/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c", size = 249742, upload-time = "2026-01-26T02:44:35.222Z" },
+ { url = "https://files.pythonhosted.org/packages/44/a3/ec5b5bd98f306bc2aa297b8c6f11a46714a56b1e6ef5ebda50a4f5d7c5fb/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84", size = 262221, upload-time = "2026-01-26T02:44:36.604Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/f7/e8c0d0da0cd1e28d10e624604e1a36bcc3353aaebdfdc3a43c72bc683a12/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d", size = 258664, upload-time = "2026-01-26T02:44:38.008Z" },
+ { url = "https://files.pythonhosted.org/packages/52/da/151a44e8016dd33feed44f730bd856a66257c1ee7aed4f44b649fb7edeb3/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33", size = 249490, upload-time = "2026-01-26T02:44:39.386Z" },
+ { url = "https://files.pythonhosted.org/packages/87/af/a3b86bf9630b732897f6fc3f4c4714b90aa4361983ccbdcd6c0339b21b0c/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3", size = 41695, upload-time = "2026-01-26T02:44:41.318Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/35/e994121b0e90e46134673422dd564623f93304614f5d11886b1b3e06f503/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5", size = 45884, upload-time = "2026-01-26T02:44:42.488Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/61/42d3e5dbf661242a69c97ea363f2d7b46c567da8eadef8890022be6e2ab0/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df", size = 43122, upload-time = "2026-01-26T02:44:43.664Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/b3/e6b21c6c4f314bb956016b0b3ef2162590a529b84cb831c257519e7fde44/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1", size = 83175, upload-time = "2026-01-26T02:44:44.894Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/76/23ecd2abfe0957b234f6c960f4ade497f55f2c16aeb684d4ecdbf1c95791/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963", size = 48460, upload-time = "2026-01-26T02:44:46.106Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/57/a0ed92b23f3a042c36bc4227b72b97eca803f5f1801c1ab77c8a212d455e/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34", size = 46930, upload-time = "2026-01-26T02:44:47.278Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/66/02ec7ace29162e447f6382c495dc95826bf931d3818799bbef11e8f7df1a/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65", size = 242582, upload-time = "2026-01-26T02:44:48.604Z" },
+ { url = "https://files.pythonhosted.org/packages/58/18/64f5a795e7677670e872673aca234162514696274597b3708b2c0d276cce/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292", size = 250031, upload-time = "2026-01-26T02:44:50.544Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/ed/e192291dbbe51a8290c5686f482084d31bcd9d09af24f63358c3d42fd284/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43", size = 228596, upload-time = "2026-01-26T02:44:51.951Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/7e/3562a15a60cf747397e7f2180b0a11dc0c38d9175a650e75fa1b4d325e15/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca", size = 257492, upload-time = "2026-01-26T02:44:53.902Z" },
+ { url = "https://files.pythonhosted.org/packages/24/02/7d0f9eae92b5249bb50ac1595b295f10e263dd0078ebb55115c31e0eaccd/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd", size = 255899, upload-time = "2026-01-26T02:44:55.316Z" },
+ { url = "https://files.pythonhosted.org/packages/00/e3/9b60ed9e23e64c73a5cde95269ef1330678e9c6e34dd4eb6b431b85b5a10/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7", size = 247970, upload-time = "2026-01-26T02:44:56.783Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/06/538e58a63ed5cfb0bd4517e346b91da32fde409d839720f664e9a4ae4f9d/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3", size = 245060, upload-time = "2026-01-26T02:44:58.195Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/2f/d743a3045a97c895d401e9bd29aaa09b94f5cbdf1bd561609e5a6c431c70/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4", size = 235888, upload-time = "2026-01-26T02:44:59.57Z" },
+ { url = "https://files.pythonhosted.org/packages/38/83/5a325cac191ab28b63c52f14f1131f3b0a55ba3b9aa65a6d0bf2a9b921a0/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8", size = 243554, upload-time = "2026-01-26T02:45:01.054Z" },
+ { url = "https://files.pythonhosted.org/packages/20/1f/9d2327086bd15da2725ef6aae624208e2ef828ed99892b17f60c344e57ed/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c", size = 252341, upload-time = "2026-01-26T02:45:02.484Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/2c/2a1aa0280cf579d0f6eed8ee5211c4f1730bd7e06c636ba2ee6aafda302e/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52", size = 246391, upload-time = "2026-01-26T02:45:03.862Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/03/7ca022ffc36c5a3f6e03b179a5ceb829be9da5783e6fe395f347c0794680/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108", size = 243422, upload-time = "2026-01-26T02:45:05.296Z" },
+ { url = "https://files.pythonhosted.org/packages/dc/1d/b31650eab6c5778aceed46ba735bd97f7c7d2f54b319fa916c0f96e7805b/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32", size = 47770, upload-time = "2026-01-26T02:45:06.754Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/5b/2d2d1d522e51285bd61b1e20df8f47ae1a9d80839db0b24ea783b3832832/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8", size = 53109, upload-time = "2026-01-26T02:45:08.044Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/a3/cc409ba012c83ca024a308516703cf339bdc4b696195644a7215a5164a24/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118", size = 45573, upload-time = "2026-01-26T02:45:09.349Z" },
+ { url = "https://files.pythonhosted.org/packages/91/cc/db74228a8be41884a567e88a62fd589a913708fcf180d029898c17a9a371/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee", size = 75190, upload-time = "2026-01-26T02:45:10.651Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/22/492f2246bb5b534abd44804292e81eeaf835388901f0c574bac4eeec73c5/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2", size = 44486, upload-time = "2026-01-26T02:45:11.938Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/4f/733c48f270565d78b4544f2baddc2fb2a245e5a8640254b12c36ac7ac68e/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1", size = 43219, upload-time = "2026-01-26T02:45:14.346Z" },
+ { url = "https://files.pythonhosted.org/packages/24/bb/2c0c2287963f4259c85e8bcbba9182ced8d7fca65c780c38e99e61629d11/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d", size = 245132, upload-time = "2026-01-26T02:45:15.712Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/f9/44d4b3064c65079d2467888794dea218d1601898ac50222ab8a9a8094460/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31", size = 252420, upload-time = "2026-01-26T02:45:17.293Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/13/78f7275e73fa17b24c9a51b0bd9d73ba64bb32d0ed51b02a746eb876abe7/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048", size = 233510, upload-time = "2026-01-26T02:45:19.356Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/25/8167187f62ae3cbd52da7893f58cb036b47ea3fb67138787c76800158982/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362", size = 264094, upload-time = "2026-01-26T02:45:20.834Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/e7/69a3a83b7b030cf283fb06ce074a05a02322359783424d7edf0f15fe5022/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37", size = 260786, upload-time = "2026-01-26T02:45:22.818Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/3b/8ec5074bcfc450fe84273713b4b0a0dd47c0249358f5d82eb8104ffe2520/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709", size = 248483, upload-time = "2026-01-26T02:45:24.368Z" },
+ { url = "https://files.pythonhosted.org/packages/48/5a/d5a99e3acbca0e29c5d9cba8f92ceb15dce78bab963b308ae692981e3a5d/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0", size = 248403, upload-time = "2026-01-26T02:45:25.982Z" },
+ { url = "https://files.pythonhosted.org/packages/35/48/e58cd31f6c7d5102f2a4bf89f96b9cf7e00b6c6f3d04ecc44417c00a5a3c/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb", size = 240315, upload-time = "2026-01-26T02:45:27.487Z" },
+ { url = "https://files.pythonhosted.org/packages/94/33/1cd210229559cb90b6786c30676bb0c58249ff42f942765f88793b41fdce/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd", size = 245528, upload-time = "2026-01-26T02:45:28.991Z" },
+ { url = "https://files.pythonhosted.org/packages/64/f2/6e1107d226278c876c783056b7db43d800bb64c6131cec9c8dfb6903698e/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601", size = 258784, upload-time = "2026-01-26T02:45:30.503Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/c1/11f664f14d525e4a1b5327a82d4de61a1db604ab34c6603bb3c2cc63ad34/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1", size = 251980, upload-time = "2026-01-26T02:45:32.603Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/9f/75a9ac888121d0c5bbd4ecf4eead45668b1766f6baabfb3b7f66a410e231/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b", size = 243602, upload-time = "2026-01-26T02:45:34.043Z" },
+ { url = "https://files.pythonhosted.org/packages/9a/e7/50bf7b004cc8525d80dbbbedfdc7aed3e4c323810890be4413e589074032/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d", size = 40930, upload-time = "2026-01-26T02:45:36.278Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/bf/52f25716bbe93745595800f36fb17b73711f14da59ed0bb2eba141bc9f0f/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f", size = 45074, upload-time = "2026-01-26T02:45:37.546Z" },
+ { url = "https://files.pythonhosted.org/packages/97/ab/22803b03285fa3a525f48217963da3a65ae40f6a1b6f6cf2768879e208f9/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5", size = 42471, upload-time = "2026-01-26T02:45:38.889Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/6d/f9293baa6146ba9507e360ea0292b6422b016907c393e2f63fc40ab7b7b5/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581", size = 82401, upload-time = "2026-01-26T02:45:40.254Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/68/53b5494738d83558d87c3c71a486504d8373421c3e0dbb6d0db48ad42ee0/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a", size = 48143, upload-time = "2026-01-26T02:45:41.635Z" },
+ { url = "https://files.pythonhosted.org/packages/37/e8/5284c53310dcdc99ce5d66563f6e5773531a9b9fe9ec7a615e9bc306b05f/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c", size = 46507, upload-time = "2026-01-26T02:45:42.99Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/fc/6800d0e5b3875568b4083ecf5f310dcf91d86d52573160834fb4bfcf5e4f/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262", size = 239358, upload-time = "2026-01-26T02:45:44.376Z" },
+ { url = "https://files.pythonhosted.org/packages/41/75/4ad0973179361cdf3a113905e6e088173198349131be2b390f9fa4da5fc6/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59", size = 246884, upload-time = "2026-01-26T02:45:47.167Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/9c/095bb28b5da139bd41fb9a5d5caff412584f377914bd8787c2aa98717130/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889", size = 225878, upload-time = "2026-01-26T02:45:48.698Z" },
+ { url = "https://files.pythonhosted.org/packages/07/d0/c0a72000243756e8f5a277b6b514fa005f2c73d481b7d9e47cd4568aa2e4/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4", size = 253542, upload-time = "2026-01-26T02:45:50.164Z" },
+ { url = "https://files.pythonhosted.org/packages/c0/6b/f69da15289e384ecf2a68837ec8b5ad8c33e973aa18b266f50fe55f24b8c/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d", size = 252403, upload-time = "2026-01-26T02:45:51.779Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/76/b9669547afa5a1a25cd93eaca91c0da1c095b06b6d2d8ec25b713588d3a1/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609", size = 244889, upload-time = "2026-01-26T02:45:53.27Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/a9/a50d2669e506dad33cfc45b5d574a205587b7b8a5f426f2fbb2e90882588/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489", size = 241982, upload-time = "2026-01-26T02:45:54.919Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/bb/1609558ad8b456b4827d3c5a5b775c93b87878fd3117ed3db3423dfbce1b/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c", size = 232415, upload-time = "2026-01-26T02:45:56.981Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/59/6f61039d2aa9261871e03ab9dc058a550d240f25859b05b67fd70f80d4b3/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e", size = 240337, upload-time = "2026-01-26T02:45:58.698Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/29/fdc6a43c203890dc2ae9249971ecd0c41deaedfe00d25cb6564b2edd99eb/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c", size = 248788, upload-time = "2026-01-26T02:46:00.862Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/14/a153a06101323e4cf086ecee3faadba52ff71633d471f9685c42e3736163/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9", size = 242842, upload-time = "2026-01-26T02:46:02.824Z" },
+ { url = "https://files.pythonhosted.org/packages/41/5f/604ae839e64a4a6efc80db94465348d3b328ee955e37acb24badbcd24d83/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2", size = 240237, upload-time = "2026-01-26T02:46:05.898Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/60/c3a5187bf66f6fb546ff4ab8fb5a077cbdd832d7b1908d4365c7f74a1917/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7", size = 48008, upload-time = "2026-01-26T02:46:07.468Z" },
+ { url = "https://files.pythonhosted.org/packages/0c/f7/addf1087b860ac60e6f382240f64fb99f8bfb532bb06f7c542b83c29ca61/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5", size = 53542, upload-time = "2026-01-26T02:46:08.809Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/81/4629d0aa32302ef7b2ec65c75a728cc5ff4fa410c50096174c1632e70b3e/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2", size = 44719, upload-time = "2026-01-26T02:46:11.146Z" },
+ { url = "https://files.pythonhosted.org/packages/81/08/7036c080d7117f28a4af526d794aab6a84463126db031b007717c1a6676e/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56", size = 12319, upload-time = "2026-01-26T02:46:44.004Z" },
+]
+
+[[package]]
+name = "mypy"
+version = "1.18.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "mypy-extensions" },
+ { name = "pathspec" },
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c0/77/8f0d0001ffad290cef2f7f216f96c814866248a0b92a722365ed54648e7e/mypy-1.18.2.tar.gz", hash = "sha256:06a398102a5f203d7477b2923dda3634c36727fa5c237d8f859ef90c42a9924b", size = 3448846, upload-time = "2025-09-19T00:11:10.519Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/07/06/dfdd2bc60c66611dd8335f463818514733bc763e4760dee289dcc33df709/mypy-1.18.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:33eca32dd124b29400c31d7cf784e795b050ace0e1f91b8dc035672725617e34", size = 12908273, upload-time = "2025-09-19T00:10:58.321Z" },
+ { url = "https://files.pythonhosted.org/packages/81/14/6a9de6d13a122d5608e1a04130724caf9170333ac5a924e10f670687d3eb/mypy-1.18.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a3c47adf30d65e89b2dcd2fa32f3aeb5e94ca970d2c15fcb25e297871c8e4764", size = 11920910, upload-time = "2025-09-19T00:10:20.043Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/a9/b29de53e42f18e8cc547e38daa9dfa132ffdc64f7250e353f5c8cdd44bee/mypy-1.18.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5d6c838e831a062f5f29d11c9057c6009f60cb294fea33a98422688181fe2893", size = 12465585, upload-time = "2025-09-19T00:10:33.005Z" },
+ { url = "https://files.pythonhosted.org/packages/77/ae/6c3d2c7c61ff21f2bee938c917616c92ebf852f015fb55917fd6e2811db2/mypy-1.18.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01199871b6110a2ce984bde85acd481232d17413868c9807e95c1b0739a58914", size = 13348562, upload-time = "2025-09-19T00:10:11.51Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/31/aec68ab3b4aebdf8f36d191b0685d99faa899ab990753ca0fee60fb99511/mypy-1.18.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a2afc0fa0b0e91b4599ddfe0f91e2c26c2b5a5ab263737e998d6817874c5f7c8", size = 13533296, upload-time = "2025-09-19T00:10:06.568Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/83/abcb3ad9478fca3ebeb6a5358bb0b22c95ea42b43b7789c7fb1297ca44f4/mypy-1.18.2-cp312-cp312-win_amd64.whl", hash = "sha256:d8068d0afe682c7c4897c0f7ce84ea77f6de953262b12d07038f4d296d547074", size = 9828828, upload-time = "2025-09-19T00:10:28.203Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/04/7f462e6fbba87a72bc8097b93f6842499c428a6ff0c81dd46948d175afe8/mypy-1.18.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:07b8b0f580ca6d289e69209ec9d3911b4a26e5abfde32228a288eb79df129fcc", size = 12898728, upload-time = "2025-09-19T00:10:01.33Z" },
+ { url = "https://files.pythonhosted.org/packages/99/5b/61ed4efb64f1871b41fd0b82d29a64640f3516078f6c7905b68ab1ad8b13/mypy-1.18.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ed4482847168439651d3feee5833ccedbf6657e964572706a2adb1f7fa4dfe2e", size = 11910758, upload-time = "2025-09-19T00:10:42.607Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/46/d297d4b683cc89a6e4108c4250a6a6b717f5fa96e1a30a7944a6da44da35/mypy-1.18.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c3ad2afadd1e9fea5cf99a45a822346971ede8685cc581ed9cd4d42eaf940986", size = 12475342, upload-time = "2025-09-19T00:11:00.371Z" },
+ { url = "https://files.pythonhosted.org/packages/83/45/4798f4d00df13eae3bfdf726c9244bcb495ab5bd588c0eed93a2f2dd67f3/mypy-1.18.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a431a6f1ef14cf8c144c6b14793a23ec4eae3db28277c358136e79d7d062f62d", size = 13338709, upload-time = "2025-09-19T00:11:03.358Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/09/479f7358d9625172521a87a9271ddd2441e1dab16a09708f056e97007207/mypy-1.18.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7ab28cc197f1dd77a67e1c6f35cd1f8e8b73ed2217e4fc005f9e6a504e46e7ba", size = 13529806, upload-time = "2025-09-19T00:10:26.073Z" },
+ { url = "https://files.pythonhosted.org/packages/71/cf/ac0f2c7e9d0ea3c75cd99dff7aec1c9df4a1376537cb90e4c882267ee7e9/mypy-1.18.2-cp313-cp313-win_amd64.whl", hash = "sha256:0e2785a84b34a72ba55fb5daf079a1003a34c05b22238da94fcae2bbe46f3544", size = 9833262, upload-time = "2025-09-19T00:10:40.035Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/0c/7d5300883da16f0063ae53996358758b2a2df2a09c72a5061fa79a1f5006/mypy-1.18.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:62f0e1e988ad41c2a110edde6c398383a889d95b36b3e60bcf155f5164c4fdce", size = 12893775, upload-time = "2025-09-19T00:10:03.814Z" },
+ { url = "https://files.pythonhosted.org/packages/50/df/2cffbf25737bdb236f60c973edf62e3e7b4ee1c25b6878629e88e2cde967/mypy-1.18.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8795a039bab805ff0c1dfdb8cd3344642c2b99b8e439d057aba30850b8d3423d", size = 11936852, upload-time = "2025-09-19T00:10:51.631Z" },
+ { url = "https://files.pythonhosted.org/packages/be/50/34059de13dd269227fb4a03be1faee6e2a4b04a2051c82ac0a0b5a773c9a/mypy-1.18.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6ca1e64b24a700ab5ce10133f7ccd956a04715463d30498e64ea8715236f9c9c", size = 12480242, upload-time = "2025-09-19T00:11:07.955Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/11/040983fad5132d85914c874a2836252bbc57832065548885b5bb5b0d4359/mypy-1.18.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d924eef3795cc89fecf6bedc6ed32b33ac13e8321344f6ddbf8ee89f706c05cb", size = 13326683, upload-time = "2025-09-19T00:09:55.572Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/ba/89b2901dd77414dd7a8c8729985832a5735053be15b744c18e4586e506ef/mypy-1.18.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:20c02215a080e3a2be3aa50506c67242df1c151eaba0dcbc1e4e557922a26075", size = 13514749, upload-time = "2025-09-19T00:10:44.827Z" },
+ { url = "https://files.pythonhosted.org/packages/25/bc/cc98767cffd6b2928ba680f3e5bc969c4152bf7c2d83f92f5a504b92b0eb/mypy-1.18.2-cp314-cp314-win_amd64.whl", hash = "sha256:749b5f83198f1ca64345603118a6f01a4e99ad4bf9d103ddc5a3200cc4614adf", size = 9982959, upload-time = "2025-09-19T00:10:37.344Z" },
+ { url = "https://files.pythonhosted.org/packages/87/e3/be76d87158ebafa0309946c4a73831974d4d6ab4f4ef40c3b53a385a66fd/mypy-1.18.2-py3-none-any.whl", hash = "sha256:22a1748707dd62b58d2ae53562ffc4d7f8bcc727e8ac7cbc69c053ddc874d47e", size = 2352367, upload-time = "2025-09-19T00:10:15.489Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "numpy"
+version = "2.5.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/fd/89965aa4ac08c74998539fcbf24fa3540f3e15237fbeb6bcf9c908f4aade/numpy-2.5.1.tar.gz", hash = "sha256:a48a113e6afea91f5608793bafa7ef2ad481fefbda87ec5069f483de61cb9fa3", size = 20755553, upload-time = "2026-07-04T17:08:00.933Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/62/7b/14687aa674250e5e546f616f486b0d56d3631cd5b2415739141ce40bdcea/numpy-2.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2c889b56fe48b1018f764b0eec8df59ab654e9148aa91faa12596043500de277", size = 16801574, upload-time = "2026-07-04T17:06:12.423Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/19/cc5bb2a3f2913d27d6dbb2c78d25921fabaedc6741d4a5a615a11f3c5bf3/numpy-2.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ab451b59c5643c570974c43aef780703ef1d3b4965d2be07afd530615a9358d1", size = 11772250, upload-time = "2026-07-04T17:06:15.726Z" },
+ { url = "https://files.pythonhosted.org/packages/42/77/fdf34a71dd30f54979b18603bee915e0aaf825b07afe79acd60b04b691e2/numpy-2.5.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:78798bd5b9ad744056af8efa90e3b9ddaa53272a0848a483084a1cc0a13b2dc0", size = 5331516, upload-time = "2026-07-04T17:06:17.913Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/e2/eb7efa015b4cce41e2517bf182a7fce0d7d5b9d9ed76a29bfa0f4fe4505c/numpy-2.5.1-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:2ae0ca40bcb22d6ba59c1dfd5446f49940b0f2d821fde133f10dda11f816b84e", size = 6664863, upload-time = "2026-07-04T17:06:20.02Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/4b/a2b32dd94ee9ffbeecb28152240042a3949db33b1c834d44090b80e1b3b8/numpy-2.5.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61ac47e772e6b8ea489e1d2f441a34c5c3ac17327e7ce294cbdf535795ad4e75", size = 15167977, upload-time = "2026-07-04T17:06:21.621Z" },
+ { url = "https://files.pythonhosted.org/packages/b8/a9/6e73d68500f80773f65f0654ea932019d6694329a0eb0ed0533de38df376/numpy-2.5.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:59fda5e192b570217ec2580c96f00e9a7e12ef6866a900eb089b62c1a32545ca", size = 16672469, upload-time = "2026-07-04T17:06:24.064Z" },
+ { url = "https://files.pythonhosted.org/packages/24/7d/ad3e59015135f5261c95fd4cafeff159c955febd83a99a1d9250c4233815/numpy-2.5.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f7119ebff1a9829e9f431a4f9d28e703023bb6b9fe7c8f724467dbfc27c94ab3", size = 16527531, upload-time = "2026-07-04T17:06:26.69Z" },
+ { url = "https://files.pythonhosted.org/packages/83/d0/a39b2fbcde9cb17a1dac678f254b33a6336298af9df338824c685425d5e8/numpy-2.5.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e824c2acf8862052246be5a44c15da1777940c60d010dd2aab897824d9c430f9", size = 18431940, upload-time = "2026-07-04T17:06:29.521Z" },
+ { url = "https://files.pythonhosted.org/packages/04/12/cff070947791c1ed425ff76413189adbdc2fbe215eba7ce7fa454a03c7f8/numpy-2.5.1-cp312-cp312-win32.whl", hash = "sha256:08d60c810432eb83360958dea0999ac4cfb94531ea8efcbf0b7f277c2068aeb2", size = 6066764, upload-time = "2026-07-04T17:06:32.571Z" },
+ { url = "https://files.pythonhosted.org/packages/65/66/53f31807a48a750f9d748da273bc3fcedd12b27ff1f3e373bfec55ef2dc0/numpy-2.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:f7d60026c0bdb1380e83bfa7a0419c4577ee4b9a08880afcb6dadeb74c649fa2", size = 12430966, upload-time = "2026-07-04T17:06:34.926Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/2a/d1a88066b1c14186f5d3c0d18c94f17b064511982bab0578d49ee9d43c29/numpy-2.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:17a25e09640602e10bc8de0e6fa2b3fd68eedd84ba6d7842dc8f32f9ab87bd0b", size = 10350488, upload-time = "2026-07-04T17:06:37.785Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/07/ec2a3f0c91761581d4b7104a740791800025983f9a4dc4e73f91a99aeac4/numpy-2.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0bfebd8695f9863592fe744be833a258120b14a9f39da255e8aa8fade2c0ddd1", size = 16796419, upload-time = "2026-07-04T17:06:40.37Z" },
+ { url = "https://files.pythonhosted.org/packages/ab/ab/ddb499fc4f8780354395face5b65c7fd107bcd6e1d667a5f07d046956f6f/numpy-2.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:30b44a6b53a7ae63c54c089a8726e5563ed302716c5b7ccc85afade40b0e7ff6", size = 11765832, upload-time = "2026-07-04T17:06:42.768Z" },
+ { url = "https://files.pythonhosted.org/packages/88/b3/3c28c558a09fc72100c646dac6d2fce8e834c471b0edca01a29996706117/numpy-2.5.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6165343f81b56ef8f514f396989e529b61d9dc709b99421b07e9f3e698e2287d", size = 5325143, upload-time = "2026-07-04T17:06:45.466Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/0e/ce19b985bb15c596f4f05954e76cccc77c845083b3b8f938a6c68e523128/numpy-2.5.1-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:4939237038ada79308dda3204ac6462df056b5672b2e25db1149cf873668b3e1", size = 6659749, upload-time = "2026-07-04T17:06:47.288Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/20/1ee6614d64332a1bba6411f38e68cb79eec1b2459e20a623777c5c5492a2/numpy-2.5.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c6759f538fb912fc46de0a6b1758ccf7b57bc7c7ebebc23974fdac3de8db0cd", size = 15164716, upload-time = "2026-07-04T17:06:49.494Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/a7/2bcd3fdbb87804755c35b729bf8709d62025c5f4cfd7d5b2415997097515/numpy-2.5.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9726558e8db4a5bf7929a70ae50f63abda4daf0efe810e3bfbab95976f75fc1a", size = 16661440, upload-time = "2026-07-04T17:06:52.061Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/d7/a41e3310c886fe457d36e670bbf24fae411aca8a7b6ad92a32afd924077c/numpy-2.5.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3935f3b419b244a02732676fa5317a9193cc596a4c0646db07e5b421229ac9f7", size = 16526305, upload-time = "2026-07-04T17:06:54.605Z" },
+ { url = "https://files.pythonhosted.org/packages/53/75/4333a9a707c1edd3a4e1a0c58eca52c0f31e55089fa80db02b5565b24df7/numpy-2.5.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dc932a65ded7ce9013d120845a2514dcccb1a67bfc8deb8d37633762951904a6", size = 18423008, upload-time = "2026-07-04T17:06:57.54Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/90/e314a32b1c11a2ffe818ddad3a57b50b4b6e1b6c487192eb50cdef0415d0/numpy-2.5.1-cp313-cp313-win32.whl", hash = "sha256:4b4ff1608417eb7a59da7b967bbb798cacfe071d2caf526a24281cd562072ed9", size = 6063885, upload-time = "2026-07-04T17:07:00.14Z" },
+ { url = "https://files.pythonhosted.org/packages/10/70/800b3fca480af32df9e8ea9f3d4a0c8feb4b32d7f195d174eabbda4829ad/numpy-2.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:6c3fe51bc6a16453d452997053454f309e8e0ed7b42d6b361ce4ac8c32913d74", size = 12425674, upload-time = "2026-07-04T17:07:02.387Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/0b/196350c122f50f6ca56846f2d71efd5e0d24b7b2e07355e019b2e2c7a11e/numpy-2.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:f7feb014281029e628ba2d5a007407443b06e418b6fe451d1e2adcbc8eba0107", size = 10350256, upload-time = "2026-07-04T17:07:04.878Z" },
+ { url = "https://files.pythonhosted.org/packages/db/f4/731b6085a83faf6ca843394cbd5e217280c214399f7e8b21b9f552af0ae2/numpy-2.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7c786fe9a5bbe360022e584c5a34cf6b54265c71bd7ec8ac3d8fec38968071f8", size = 16795063, upload-time = "2026-07-04T17:07:07.374Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/64/0e215f2048dd11a55bb989ed41b3585ef57452404e638d703a211a3e4157/numpy-2.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32985c896d897419ef8da6917872d80b78ad0ea26d85b23245c7366ffde76d75", size = 11776652, upload-time = "2026-07-04T17:07:09.907Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/59/2b844c7a6e9deff69b404a66221e1542937734f65d5e6e39411876053862/numpy-2.5.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:efd736408cc97c79b9e6917338dfc8f06013b2274f992e96b1d9a81a71e2a2c2", size = 5335944, upload-time = "2026-07-04T17:07:12.227Z" },
+ { url = "https://files.pythonhosted.org/packages/86/51/9bf7cb2cabcebc9e017e4ec7e6322b378317a542c08b4cb68479c1efc716/numpy-2.5.1-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:ab84dc6b074fa881cae55bea94cc4f68e285181ba7f32497bf7dee6b1496165b", size = 6656266, upload-time = "2026-07-04T17:07:14.368Z" },
+ { url = "https://files.pythonhosted.org/packages/83/3e/fb7615b211b82a32f44d5180a6d421b61f84d4fadd578b48ba4ac34e189f/numpy-2.5.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caf3e317d33d60c37986b452613f4ab51246d0691350c03d0cb4a898627f4a95", size = 15179720, upload-time = "2026-07-04T17:07:16.272Z" },
+ { url = "https://files.pythonhosted.org/packages/41/5f/0f992cb24560673496c5d68de61913b57166ce530ffda07c1f280e0cc464/numpy-2.5.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:54ad769f17bc2d833b620851989f62054fb9ab93c969d9e1dc3c8e3d56beea21", size = 16664835, upload-time = "2026-07-04T17:07:19.021Z" },
+ { url = "https://files.pythonhosted.org/packages/a2/2f/97d6475ee91afe2587797d09446f9d3e475ad4cb681662d824809327b75a/numpy-2.5.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c12afb53450fa976d4c681c50a7423729a4c51c0465ed9f32b8a9cabbc472373", size = 16539135, upload-time = "2026-07-04T17:07:22.015Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/5b/4db81e4ba0be7e2776b1de68c82aa862c7f8ec27e1b4927d4ae075e20678/numpy-2.5.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8c11c405efc5ff6816d5983c96cdfa215bab3428961243af3ff59b228490438", size = 18426684, upload-time = "2026-07-04T17:07:24.941Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/64/c0ba2d90724d450279a7df8f32057241070250a26a7e2b5337d77347f481/numpy-2.5.1-cp314-cp314-win32.whl", hash = "sha256:f2479a47f8d5932d1718168a681ad6e536a9df484c83cfcf9de365e164537ace", size = 6116103, upload-time = "2026-07-04T17:07:27.622Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/1a/837f9ed7405adcd7a40538792eb169eddd8fa5630c16a1ef49dae71a30f4/numpy-2.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:24d0eb82c0541d3415a33425db64ae439dffccd7b4dbcb30e7c35120205c506a", size = 12562177, upload-time = "2026-07-04T17:07:29.887Z" },
+ { url = "https://files.pythonhosted.org/packages/22/ed/49707938b6dd0a78a9178dd93227dc89e4c11af47f5c798d70366e8d0483/numpy-2.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:5a4c988b38d261deeeaad9954e3deb091ad905c94e8bb6708654ef1d97f286b0", size = 10627739, upload-time = "2026-07-04T17:07:32.568Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/c7/bb4b882cfe7f299cbc8b66e42e7dd78cf9d14e40f9469fc5e3db7e15b3bd/numpy-2.5.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a33276be12fa045805f477f22482088b66bb758ffbe89a9d21457de863a32e22", size = 11894709, upload-time = "2026-07-04T17:07:34.941Z" },
+ { url = "https://files.pythonhosted.org/packages/40/3f/5af7f4a7f6224aef48017aa82bb6174c7a659d724be0c75017b7e64a55b4/numpy-2.5.1-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:f089d7b00756190aacf1f5d34bdf38c3c430ac82b4f868f8cede73380460fce7", size = 5453810, upload-time = "2026-07-04T17:07:37.495Z" },
+ { url = "https://files.pythonhosted.org/packages/20/c9/3474309bc94d634d3f9c3eddf03250ecb8c22cd948ef16fef69a77cc5d7b/numpy-2.5.1-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:09e9bfd8d2cf479c7d174804fb3811c53a8e9f20a37444008606b57d6b7a826d", size = 6761189, upload-time = "2026-07-04T17:07:39.563Z" },
+ { url = "https://files.pythonhosted.org/packages/90/8a/558ae39fdd55d7e7f7fef9a84a6e964ac6b23edbd2a07e52bb084500507d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e68d8dd1e7eba712948f2053a29ec86917bc70ba1358df869d9f06649ef9cf09", size = 15225039, upload-time = "2026-07-04T17:07:41.682Z" },
+ { url = "https://files.pythonhosted.org/packages/63/27/ca7392b2d030277bdf0273e7d23255b3ee57d57a7c170a6f4fb3981e1e5d/numpy-2.5.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:99d5095fa265a0c4152e7bb12759e14381ef5496152f1ce58f44bdf55c44beb4", size = 16701306, upload-time = "2026-07-04T17:07:44.611Z" },
+ { url = "https://files.pythonhosted.org/packages/02/42/03d53ae7996c44d4374a8262e9dc41671fd56cbb98f7d47ef85cf5da4c6b/numpy-2.5.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ab87a91b3cc3382b8956095bd8f95e00cf679bb81554339be1a2ba404a1473c1", size = 16589955, upload-time = "2026-07-04T17:07:47.694Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/15/6c1784ae469640e65db111e9a34b3d0f14d91e8a38b9ce34810ced370dbb/numpy-2.5.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:224ca51130ef7da85bea2191625181cb4f337f9cb64b471f10c1a12aa8b60077", size = 18464252, upload-time = "2026-07-04T17:07:50.684Z" },
+ { url = "https://files.pythonhosted.org/packages/94/a8/f98e50356cf167df656c526c2dfeec2d7dde182f2a3da4b458a5938e2776/numpy-2.5.1-cp314-cp314t-win32.whl", hash = "sha256:6eab239876581b2b3c5a242281b6007bbdbcd1c7085d7709bb57c5929b11e6bf", size = 6263298, upload-time = "2026-07-04T17:07:53.445Z" },
+ { url = "https://files.pythonhosted.org/packages/72/ac/96ae880cdecad0b3275d9359fcec72667b49a4863c9f12942e43679dda02/numpy-2.5.1-cp314-cp314t-win_amd64.whl", hash = "sha256:83ce9c80d5b521b0d77ddcbe5447c218d247929b6cc056ca5351342accfff0af", size = 12748623, upload-time = "2026-07-04T17:07:55.384Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/5a/4d2b1601df3602dba7a14f3348ba9bfe94a18adb428e693df6154c293831/numpy-2.5.1-cp314-cp314t-win_arm64.whl", hash = "sha256:5a6db61f9aaa57e369905c67d852045d3c4f7126405b29d09b19dec118e9c9cb", size = 10697674, upload-time = "2026-07-04T17:07:58.506Z" },
+]
+
+[[package]]
+name = "onnxruntime"
+version = "1.27.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "flatbuffers" },
+ { name = "numpy" },
+ { name = "packaging" },
+ { name = "protobuf" },
+]
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c3/b7/dd3a524ed93a820dff1af902d0412957ab12499953333e9daa01af5bc480/onnxruntime-1.27.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a14c2ce45312def86b77aea651f46565e45960cf5f0721bfdff449165086ab76", size = 18433506, upload-time = "2026-06-15T22:43:47.026Z" },
+ { url = "https://files.pythonhosted.org/packages/84/86/c3b6b17745a1997d784dadc9bd88d713d2e6721139a5a0e885b28cfb79b1/onnxruntime-1.27.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6fddce0539a4898c7bef35b052ffd37935b2190e35488eab99ce91887743ea1", size = 16438140, upload-time = "2026-06-15T22:42:40.666Z" },
+ { url = "https://files.pythonhosted.org/packages/26/81/24dd9b31b0fb912ee19ca53ac1c9764bfd79d58a2ccef564eb693be831a5/onnxruntime-1.27.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c65a7438632d55dfbc8a02ee60bd6cf7dd9d1ba05a43d4b851452f32338e194", size = 18658316, upload-time = "2026-06-15T22:43:04.012Z" },
+ { url = "https://files.pythonhosted.org/packages/4f/88/8ec9db1a4d126bb8b758992beb40d1249df171917d75f44a327eb5f20dda/onnxruntime-1.27.0-cp312-cp312-win_amd64.whl", hash = "sha256:20c321cf187ba496e648acf6b4cf90b4d398b0d17c2a77fdaeba365b908cc1c1", size = 13358769, upload-time = "2026-06-15T22:43:34.581Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/9f/fdad359dfcba7e7cd8815569b304a596531d4efa77a75d77f8b4981891a2/onnxruntime-1.27.0-cp312-cp312-win_arm64.whl", hash = "sha256:d0d1f68868e2ef30ef70998ba9bbbc5c305e9b17041e3936751c1b8aa6aade06", size = 13104440, upload-time = "2026-06-15T22:43:22.893Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/2b/54208fd03ad410480bc17edf4869376362da8bbf46fe186ddf4cb5cc20fe/onnxruntime-1.27.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:b3e5b58b8c89c2b20e086e890aa9527377e5c240dc3ecc1640d18e07705eeb1c", size = 18432958, upload-time = "2026-06-15T22:42:53.105Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/88/24fc51fcbb126da6d032372314e47b55c3faad58f2aa78c0e199ccd20b9c/onnxruntime-1.27.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48b3d87eb560ff6a772240506f3c78d6d27c63cafedd5c775672e1194f968cfd", size = 16438180, upload-time = "2026-06-15T22:42:43.093Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/19/14929c3c2fe0b79b41cce24463062bf3afa4cdd3c19dccf00319caa92bff/onnxruntime-1.27.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6872443f236a554921cda6f318c900e2d0c226792cf3534d00e5057c6926e5d2", size = 18658445, upload-time = "2026-06-15T22:43:08.053Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/76/59ed932b0244acd7bbbd6449480053a6d958ea66357f022f932872e19287/onnxruntime-1.27.0-cp313-cp313-win_amd64.whl", hash = "sha256:760021bca514d64a811837820d351a08a41741f16f8b4c26450da708fecf14e6", size = 13357856, upload-time = "2026-06-15T22:43:37.315Z" },
+ { url = "https://files.pythonhosted.org/packages/79/51/d1ec60ec7b1e2ae2d7340ba52b8a13529140039cd4407ba8dddbbc046582/onnxruntime-1.27.0-cp313-cp313-win_arm64.whl", hash = "sha256:2fdfa9df40a0ded0028ce6f9cd863264237f3970559dea2b81456e9ac4622b94", size = 13104412, upload-time = "2026-06-15T22:43:27.457Z" },
+ { url = "https://files.pythonhosted.org/packages/5e/7d/e6bb1c6445c94f708c38cd8fbb7bf0264108c33498b9445c93e60fe6d329/onnxruntime-1.27.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:54c0c4e9202c36c4ecdb1f3443f5dfbfd5ee3b54d1362c4b4c6134110e74fb32", size = 16443331, upload-time = "2026-06-15T22:42:45.649Z" },
+ { url = "https://files.pythonhosted.org/packages/72/1b/b18b31e806eabc41077810199fbbb36fbc2d5f19912416e5ccfbf73053d1/onnxruntime-1.27.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1b215aa662c8f983f7d6dedafe65a9be72c26e5338e0fe98b3e0422c32c85428", size = 18670967, upload-time = "2026-06-15T22:43:10.621Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/37/48ab79c39b58a7c9f6f5aac1fa0ff2b993eb2643393d6ed9e839ddb6f347/onnxruntime-1.27.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:0874edc171f470fc4dd2bbb60bc0989612ed1a8b89b365cda016630a93227f13", size = 18433941, upload-time = "2026-06-15T22:42:58.867Z" },
+ { url = "https://files.pythonhosted.org/packages/6e/24/d535ca8a09dbf697f853377c8dc0820dbcaae5f334316b400b953afbcba8/onnxruntime-1.27.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b51c014cf1a4fcd93c29a97eac8071fa27710dae05a4d0380bb60a66d60a62c", size = 16439970, upload-time = "2026-06-15T22:42:48.023Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/b1/ea9ee80c0bdaa4efb13f29f8c236f3740f6655e8c092a2d119515a5a652c/onnxruntime-1.27.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:445fb702ea5241ba813a3ce2febe2e9408a64f6ad2eb610924322c536165f7cd", size = 18659240, upload-time = "2026-06-15T22:43:13.165Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/f2/1404507d76a21940e8bf46f414e3d1abd94dc888cb89a30f4a540275846f/onnxruntime-1.27.0-cp314-cp314-win_amd64.whl", hash = "sha256:49e416be0d717338b6d041b99911b716d70c397d277056450724f93bdded3fc2", size = 13685306, upload-time = "2026-06-15T22:43:40.416Z" },
+ { url = "https://files.pythonhosted.org/packages/10/e5/ca5cf012ccccb806c70e94aadfebca5606acc62b33eb88cec13352d0778f/onnxruntime-1.27.0-cp314-cp314-win_arm64.whl", hash = "sha256:856032937dd3bc7a7c141909c8d7ae4fde3e3f59bddf061ae627b9a051bda95c", size = 13456280, upload-time = "2026-06-15T22:43:29.693Z" },
+ { url = "https://files.pythonhosted.org/packages/67/7b/dca330a8397e9d816c976d7aed4e24a4a2d279bb1e551e3d0221d1389b1d/onnxruntime-1.27.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c6197a02e3f620c4dc13cff51b80672409fc1ffab3aa2593911b19fd322ff48b", size = 16443274, upload-time = "2026-06-15T22:42:50.467Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/f6/2bac21f722aa45d876d4a51f26bd0ef30e704068a3cd5021a5a7cd784271/onnxruntime-1.27.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:370d211e1ceeac4cd5f45301655463ac59e27cdc74d9f7aeb2d19ff4b7a76715", size = 18670781, upload-time = "2026-06-15T22:43:17.151Z" },
+]
+
+[[package]]
+name = "openai"
+version = "2.28.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/56/87/eb0abb4ef88ddb95b3c13149384c4c288f584f3be17d6a4f63f8c3e3c226/openai-2.28.0.tar.gz", hash = "sha256:bb7fdff384d2a787fa82e8822d1dd3c02e8cf901d60f1df523b7da03cbb6d48d", size = 670334, upload-time = "2026-03-13T19:56:27.306Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c0/5a/df122348638885526e53140e9c6b0d844af7312682b3bde9587eebc28b47/openai-2.28.0-py3-none-any.whl", hash = "sha256:79aa5c45dba7fef84085701c235cf13ba88485e1ef4f8dfcedc44fc2a698fc1d", size = 1141218, upload-time = "2026-03-13T19:56:25.46Z" },
+]
+
+[[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 = "pathspec"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" },
+]
+
+[[package]]
+name = "peachy"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+ { name = "httpx" },
+ { name = "huggingface-hub" },
+ { name = "mcp" },
+ { name = "numpy" },
+ { name = "openai" },
+ { name = "python-dotenv" },
+ { name = "reachy-mini" },
+ { name = "reachy-mini-dances-library" },
+ { name = "reachy-mini-toolbox" },
+ { name = "scipy" },
+]
+
+[package.dev-dependencies]
+dev = [
+ { name = "build" },
+ { name = "certifi" },
+ { name = "mypy" },
+ { name = "pytest" },
+ { name = "pytest-asyncio" },
+ { name = "pytest-timeout" },
+ { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+ { name = "httpx", specifier = ">=0.28.1" },
+ { name = "huggingface-hub", specifier = ">=1.17.0" },
+ { name = "mcp", specifier = ">=1.27.1" },
+ { name = "numpy" },
+ { name = "openai", specifier = "==2.28.0" },
+ { name = "python-dotenv" },
+ { name = "reachy-mini", specifier = "==1.9.0" },
+ { name = "reachy-mini-dances-library" },
+ { name = "reachy-mini-toolbox" },
+ { name = "scipy" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+ { name = "build" },
+ { name = "certifi" },
+ { name = "mypy", specifier = "==1.18.2" },
+ { name = "pytest" },
+ { name = "pytest-asyncio" },
+ { name = "pytest-timeout" },
+ { name = "ruff", specifier = "==0.12.0" },
+]
+
+[[package]]
+name = "pip"
+version = "26.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/91/47e7d486260f618783899587af63ccf7980fb60245c3e63dd4571c6b57ad/pip-26.1.2.tar.gz", hash = "sha256:f49cd134c61cf2fd75e0ce2676db03e4054504a5a4986d00f8299ae632dc4605", size = 1840799, upload-time = "2026-05-31T17:33:58.56Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5d/95/6b5cb3461ea5673ba0995989746db58eb18b91b54dbf331e72f569540946/pip-26.1.2-py3-none-any.whl", hash = "sha256:382ff9f685ee3bc25864f820aa50505825f10f5458ffff07e30a6d96e5715cab", size = 1813144, upload-time = "2026-05-31T17:33:56.772Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.11.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/78/9b/560e4be8e26f6fd133a03630a8df0c663b9e8d61b4ade152b72005aec83b/platformdirs-4.11.0.tar.gz", hash = "sha256:0555d18370482847566ffabcaa53ad7c6c1c29f195989ae1ed634a05f76ea1e0", size = 31953, upload-time = "2026-07-21T13:09:36.565Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7d/68/d8d58938dfb1370b266a1a729e6d77a985be23689a0496498ee17b2cbf90/platformdirs-4.11.0-py3-none-any.whl", hash = "sha256:360ccded2b7fce0af0ff80cc8f5942a1c5d99b0e856033acb030bfc634709e74", size = 23247, upload-time = "2026-07-21T13:09:35.422Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "prompt-toolkit"
+version = "3.0.52"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "wcwidth" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.5.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ec/44/c87281c333769159c50594f22610f77398a47ccbfbbf23074e744e86f87c/propcache-0.5.2.tar.gz", hash = "sha256:01c4fc7480cd0598bb4b57022df55b9ca296da7fc5a8760bd8451a7e63a7d427", size = 50208, upload-time = "2026-05-08T21:02:12.199Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/4a/cb/e27bc2b2737a0bb49962b275efa051e8f1c35a936df7d5139b6b658b7dc9/propcache-0.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:806719138ecd720339a12410fb9614ac9b2b2d3a5fdf8235d56981c36f4039ba", size = 95887, upload-time = "2026-05-08T21:00:11.277Z" },
+ { url = "https://files.pythonhosted.org/packages/e6/13/b8ae04c59392f8d11c6cd9fb4011d1dc7c86b81225c770280300e259ffe1/propcache-0.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:db2b80ea58eab4f86b2beec3cc8b39e8ff9276ac20e96b7cce43c8ae84cd6b5a", size = 54654, upload-time = "2026-05-08T21:00:12.604Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/7d/49777a3e20b55863d4794384a38acd460c04157b0a00f8602b0d508b8431/propcache-0.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e5cbfac9f61484f7e9f3597775500cd3ebe8274e9b050c38f9525c77c97520bf", size = 55190, upload-time = "2026-05-08T21:00:13.935Z" },
+ { url = "https://files.pythonhosted.org/packages/44/c7/085d0cd63062e84044e3f05797749c3f8e3938ff3aeb0eb2f69d43fafc91/propcache-0.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbc581d2814337da56222fab8dc5f161cd798a434e49bac27930aaef798e144", size = 59995, upload-time = "2026-05-08T21:00:15.526Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/42/32cf8e3009e92b2645cf1e944f701e8ea4e924dffde1ee26db860bcbf7e4/propcache-0.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:857187f381f88c8e2fa2fe56ab94879d011b883d5a2ee5a1b60a8cd2a06846d9", size = 63422, upload-time = "2026-05-08T21:00:16.824Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/1b/f112433f99fc979431b87a39ef169e3f8df070d99a72792c56d6937ac48b/propcache-0.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:178b4a2cdaac1818e2bf1c5a99b94383fa73ea5382e032a48dec07dc5668dc42", size = 64342, upload-time = "2026-05-08T21:00:18.362Z" },
+ { url = "https://files.pythonhosted.org/packages/14/15/5574111ae50dd6e879456888c0eadd4c5a869959775854e18e18a6b345f3/propcache-0.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f328175a2cde1f0ff2c4ed8ce968b9dcfb55f3a7153f39e2957ed994da13476", size = 61639, upload-time = "2026-05-08T21:00:19.692Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/da/4d775080b1490c0ae604acda868bd71aabe3a89ed16f2aa4339eb8a283e7/propcache-0.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5671d09a36b06d0fd4a3da0fccbcae360e9b1570924171a15e9e0997f0249fba", size = 61588, upload-time = "2026-05-08T21:00:21.155Z" },
+ { url = "https://files.pythonhosted.org/packages/04/ac/f076982cbe2195ee9cf32de5a1e46951d9fb399fc207f390562dd0fd8fb2/propcache-0.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:80168e2ebe4d3ec6599d10ad8f520304ae1cad9b6c5a95372aef1b66b7bfb53a", size = 60029, upload-time = "2026-05-08T21:00:22.713Z" },
+ { url = "https://files.pythonhosted.org/packages/70/60/189be62e0dd898dce3b331e1b8c7a543cd3a405ac0c81fe8ee8a9d5d77e1/propcache-0.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:45f11346f884bc47444f6e6647131055844134c3175b629f84952e2b5cd62b64", size = 56774, upload-time = "2026-05-08T21:00:24.001Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/9e/93377b9c7939c1ffae98f878dee955efadfd638078bc86dbc21f9d52f651/propcache-0.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8e778ebd44ef4f66ed60a0416b06b489687db264a9c0b3620362f26489492913", size = 63532, upload-time = "2026-05-08T21:00:25.545Z" },
+ { url = "https://files.pythonhosted.org/packages/14/f9/590ef6cfb9b8028d516d287812ece32bb0bc5f11fbb9c8bf6b2e6313fec8/propcache-0.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c0cb9ed24c8964e172768d455a38254c2dd8a552905729ce006cad3d3dda59b1", size = 61592, upload-time = "2026-05-08T21:00:27.186Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/5e/70958b3034c297a630bba2f17ca7abc2d5f39a803ad7e370ab79d1ecd022/propcache-0.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:1d1ad32d9d4355e2be65574fd0bfd3677e7066b009cd5b9b2dee8aa6a6393b33", size = 64788, upload-time = "2026-05-08T21:00:28.8Z" },
+ { url = "https://files.pythonhosted.org/packages/12/fd/77fe5936d8c3086ca9048f7f415f122ed82e53884a9ec193646b42deef06/propcache-0.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c80f4ba3e8f00189165999a742ee526ebeccedf6c3f7beb0c7df821e9772435a", size = 62514, upload-time = "2026-05-08T21:00:30.098Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/74/66bd798b5b3be70aa1b391f5cc9d6a0a5532d7fd3b19ec0b213e72e6ad9d/propcache-0.5.2-cp312-cp312-win32.whl", hash = "sha256:8c7972d8f193740d9175f0998ab38717e6cd322d5935c5b0fef8c0d323fd9031", size = 39018, upload-time = "2026-05-08T21:00:31.622Z" },
+ { url = "https://files.pythonhosted.org/packages/61/7c/5c0d34aa3024694d6dcb9271cdbdd08c4e47c1c0ad95ec7e7bc74cdea145/propcache-0.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:d9ee8826a7d47863a08ac44e1a5f611a462eefc3a194b492da242128bec75b42", size = 42322, upload-time = "2026-05-08T21:00:32.918Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/91/875812f1a3feb20ceba818ef39fbe4d92f1081e04ac815c822496d0d038b/propcache-0.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:2800a4a8ead6b28cccd1ec54b59346f0def7922ee1c7598e8499c733cfbb7c84", size = 38172, upload-time = "2026-05-08T21:00:35.124Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/09/f049e45385503fe67db75a6b6186a7b9f0c3930366dc960522c312a825b1/propcache-0.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:099aaf4b4d1a02265b92a977edf00b5c4f63b3b17ac6de39b0d637c9cac0188a", size = 94457, upload-time = "2026-05-08T21:00:36.355Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/65/83d1d05655baf63113731bd5a1008435e14f8d1e5a06cbe4ec5b23ad7a31/propcache-0.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68ce1c44c7a813a7f71ea04315a8c7b330b63db99d059a797a4651bb6f69f117", size = 53835, upload-time = "2026-05-08T21:00:38.072Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/12/a6ba6482bb5ea3260c000c9b20881c95fa11c6b30173715668259f844ed7/propcache-0.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fc299c129490f55f254cd90be0deca4764e36e9a7c08b4aa588479a3bbed3098", size = 54545, upload-time = "2026-05-08T21:00:39.319Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/19/7fa086f5764c59ec8a8e157cd93aa8497acc00aba9dcdec56bfffb32602d/propcache-0.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a6ae2198be502c10f09b2516e7b5d019816924bc3183a43ce792a7bd6625e6f4", size = 59886, upload-time = "2026-05-08T21:00:40.621Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/e4/5d7663dc8235956c8f5281698a3af1d351d8820341ddd890f59d9a9127f2/propcache-0.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6041d31504dc1779d700e1edcfb08eea334b357620b06681a4eabb57a74e574e", size = 63261, upload-time = "2026-05-08T21:00:41.775Z" },
+ { url = "https://files.pythonhosted.org/packages/4a/4a/15a03adee24d6350da4292caeac44c34c033d2afe5e87eb370f38854560f/propcache-0.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7eabc04151c78a9f4d5bbb5f1faf571e4defeb4b585e0fe95b60ff2dbe4d3d7", size = 64184, upload-time = "2026-05-08T21:00:43.018Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/c6/979176efdaa3d239e36d503d5af63a0a773b36662ed8f52e5b6a6d9fd40e/propcache-0.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4db0ba63d693afd40d249bd93f842b5f144f8fcbb83de05660373bcf30517b1d", size = 61534, upload-time = "2026-05-08T21:00:44.507Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/22/63e8cd1bae4c2d2be6493b6b7d10566ddafad88137cfbc99964a1119853c/propcache-0.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1dbcf7675229b35d31abb6547d8ebc8c27a830ac3f9a794edff6254873ec7c0a", size = 61500, upload-time = "2026-05-08T21:00:45.796Z" },
+ { url = "https://files.pythonhosted.org/packages/60/5a/28e5d9acbac1cc9ccb67045e8c1b943aa8d79fdf39c93bd73cacd68008ea/propcache-0.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d310c013aad2c72f1c3f2f8dd3279d460a858c551f97aeb8c63e4693cca7b4d2", size = 59994, upload-time = "2026-05-08T21:00:47.093Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/40/db650677f554a95b9c01a7c9d93d629e93a15562f5deb4573c9ee136fed2/propcache-0.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:06187263ddad280d05b4d8a8b3bb7d164cbebd469236544a42e6d9b28ac6a4fa", size = 56884, upload-time = "2026-05-08T21:00:48.376Z" },
+ { url = "https://files.pythonhosted.org/packages/80/45/70b39b89516ff8b96bf732fa6fded8cef20f293cb1508690101c3c07ec51/propcache-0.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3115559b8effafd63b142ea5ed53d63a16ea6469cbc63dce4ee194b42db5d853", size = 63464, upload-time = "2026-05-08T21:00:49.954Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/e2/fa59d3a89eac5534293124af4f1d0d0ada091ce4a0ab4610ce03fd2bdd8d/propcache-0.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c60462af8e6dc30c35407c7237ea908d777b22862bbee27bc4699c0d8bcdc45a", size = 61588, upload-time = "2026-05-08T21:00:51.281Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/97/efb547a55c4bc7381cfb202d6a2239ac621045277bc1ea5dfd3a7f0516c0/propcache-0.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40314bca9ac559716fe374094fc81c11dcc34b64fd6c585360f5775690505704", size = 64667, upload-time = "2026-05-08T21:00:52.602Z" },
+ { url = "https://files.pythonhosted.org/packages/92/56/f5c7d9b4b7595d5127da38974d791b2153f3d1eae6c674af3583ace92ad3/propcache-0.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cfa21e036ce1e1db2be04ba3b85d2df1bb1702fa01932d984c5464c665228ff4", size = 62463, upload-time = "2026-05-08T21:00:54.303Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/3b/484a3a65fc9f9f60c41dcd17b428bace5389544e2c680994534a20755066/propcache-0.5.2-cp313-cp313-win32.whl", hash = "sha256:f156a3529f38063b6dbaf356e15602a7f95f8055b1295a438433a6386f10463d", size = 38621, upload-time = "2026-05-08T21:00:55.808Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/fd/3f0f10dba4dabad3bf53102be007abf55481067952bde0fdddff439e7c61/propcache-0.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:dfed59d0a5aeb01e242e66ff0300bc4a265a7c05f612d30016f0b60b1017d757", size = 41649, upload-time = "2026-05-08T21:00:57.061Z" },
+ { url = "https://files.pythonhosted.org/packages/90/ec/6ce619cc32bb500a482f811f9cd509368b4e58e638d13f2c68f370d6b475/propcache-0.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:ba338430e87ceb9c8f0cf754de38a9860560261e56c00376debd628698a7364f", size = 37636, upload-time = "2026-05-08T21:00:58.646Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/82/c1d268bbbf2ef981c5bf0fbbe746db617c66e3bcefe431a1aa8943fbe23a/propcache-0.5.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a592f5f3da71c8691c788c13cb6734b6d17663d2e1cb8caddf0673d01ef8847d", size = 98872, upload-time = "2026-05-08T21:00:59.889Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/d4/52c871e73e864e6b34c0e2d58ac1ec5ccd149497ddc7ad2137ae98323a35/propcache-0.5.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:6a997d0489e9668a384fcfd5061b857aa5361de73191cac204d04b889cfbbafa", size = 56257, upload-time = "2026-05-08T21:01:01.195Z" },
+ { url = "https://files.pythonhosted.org/packages/67/f0/9b90ca2a210b3d09bcfcd96ecd0f55545c091535abce2a45de2775cfd357/propcache-0.5.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:10734b5484ea113152ee25a91dccedf81631791805d2c9ccb054958e51842c94", size = 56696, upload-time = "2026-05-08T21:01:02.941Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/0e/6e9d4ba07c8e56e21ddec1e75f12148142b21ca83a51871babce095334f4/propcache-0.5.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cafca7e56c12bb02ae16d283742bef25a61122e9dab2b5b3f2ccbe589ce32164", size = 62378, upload-time = "2026-05-08T21:01:04.475Z" },
+ { url = "https://files.pythonhosted.org/packages/65/19/c10badaa463dde8a27ce884f8ee2ec37e6035b7c9f5ff0c8f74f06f08dac/propcache-0.5.2-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f064f8d2b59177878b7615df1735cd8fe3462ed6be8c7b217d17a276489c2b7f", size = 65283, upload-time = "2026-05-08T21:01:05.959Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/b6/93bea99ca80e19cef6512a8580e5b7857bbe09422d9daa7fd4ef5723306c/propcache-0.5.2-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f78abfa8dfc32376fd1aacf597b2f2fbbe0ea751419aee718af5d4f82537ef8c", size = 66616, upload-time = "2026-05-08T21:01:07.228Z" },
+ { url = "https://files.pythonhosted.org/packages/83/e4/5c7462e50625f051f37fb38b8224f7639f667184bbd34424ec83819bb1b7/propcache-0.5.2-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f7467da8a9822bf1a55336f877340c5bcbd3c482afc43a99771169f74a26dedc", size = 63773, upload-time = "2026-05-08T21:01:08.514Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/b6/99238894047b13c823be25027e736626cd414a52a5e30d2c3347c2733529/propcache-0.5.2-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a6ddc6ac9e25de626c1f129c1b467d7ecd33ce2237d3fd0c4e429feef0a7ee1f", size = 63664, upload-time = "2026-05-08T21:01:09.874Z" },
+ { url = "https://files.pythonhosted.org/packages/85/1e/a3a1a63116a2b8edb415a8bb9a6f0c34bd03830b1e18e8ce2904e1dc1cf4/propcache-0.5.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:2f22cbbac9e26a8e864c0985ff1268d5d939d53d9d9411a9824279097e03a2cb", size = 62643, upload-time = "2026-05-08T21:01:11.132Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/03/893cf147de2fc6543c5eaa07ad833170e7e2a2385725bbebe8c0503723bb/propcache-0.5.2-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:fc76378c62a0f04d0cd82fbb1a2cd2d7e28fcb40d5873f28a6c44e388aaa2751", size = 59595, upload-time = "2026-05-08T21:01:12.387Z" },
+ { url = "https://files.pythonhosted.org/packages/86/3b/04c1a2e12c57766568ba75ba72b3bf2042818d4c1425fab6fc07155c7cff/propcache-0.5.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:acd2c8edba48e31e58a363b8cf4e5c7db3b04b3f9e371f601df30d9b0d244836", size = 65711, upload-time = "2026-05-08T21:01:13.676Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/34/80f8d0099f8d6bacc4de1624c85672681c8cd1149ca2da0e38fd120b817f/propcache-0.5.2-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:452b5065457eb9991ec5eb38ff41d6cd4c991c9ac7c531c4d5849ae473a9a13f", size = 64247, upload-time = "2026-05-08T21:01:14.936Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/1a/8b08f3a5f1037e9e370c55883ceeeee0f6dd0416fb2d2d67b8bfc91f2a79/propcache-0.5.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:3430bb2bfe1331885c427745a751e774ee679fd4344f80b97bf879815fe8fa55", size = 67102, upload-time = "2026-05-08T21:01:16.281Z" },
+ { url = "https://files.pythonhosted.org/packages/34/68/8bdb7bb7756d76e005490649d10e4a8369e610c74d619f71e1aedf889e9c/propcache-0.5.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cef6cea3922890dd6c9654971001fa797b526c16ab5e1e46c05fd6f877be7568", size = 64964, upload-time = "2026-05-08T21:01:17.57Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/aa/50fb0b5d3968b61a510926ff8b8465f1d6e976b3ab74496d7a4b9fc42515/propcache-0.5.2-cp313-cp313t-win32.whl", hash = "sha256:72d61e16dd78228b58c5d47be830ff3da7e5f139abdf0aef9d86cde1c5cf2191", size = 42546, upload-time = "2026-05-08T21:01:18.946Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/4c/0ddbae64321bd4a95bcbfc19307238016b5b1fee645c84626c8d539e5b74/propcache-0.5.2-cp313-cp313t-win_amd64.whl", hash = "sha256:0958834041a0166d343b8d2cedcd8bcbaeb4fdbe0cf08320c5379f143c3be6e7", size = 46330, upload-time = "2026-05-08T21:01:20.162Z" },
+ { url = "https://files.pythonhosted.org/packages/00/d9/9cddc8efb78d8af264c5ec9f6d10b62f57c515feda8d321595f56010fb23/propcache-0.5.2-cp313-cp313t-win_arm64.whl", hash = "sha256:6de8bd93ddde9b992cf2b2e0d796d501a19026b5b9fd87356d7d0779531a8d96", size = 40521, upload-time = "2026-05-08T21:01:21.399Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/ea/23ee535d90ce8bcc465a3028eb3cc0ce3bd1005f4bb27710b30587de798d/propcache-0.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:46088abff4cba581dea21ae0467a480526cb25aa5f3c269e909f800328bc3999", size = 94662, upload-time = "2026-05-08T21:01:22.683Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/06/c5a52f419b5d8972f8d46a7577476090d8e3263ff589ce40b5ca4968d5be/propcache-0.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fc88b26f08d634f7bc819a7852e5214f5802641ab8d9fd5326892292eee1993e", size = 53928, upload-time = "2026-05-08T21:01:23.986Z" },
+ { url = "https://files.pythonhosted.org/packages/63/b1/4260d67d6bd85e58a66b72d54ce15d5de789b6f3870cc6bedf8ff9667401/propcache-0.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97797ebb098e670a2f92dd66f32897e30d7615b14e7f59711de23e30a9072539", size = 54650, upload-time = "2026-05-08T21:01:25.305Z" },
+ { url = "https://files.pythonhosted.org/packages/70/06/2f46c318e3307cd7a6a7481def374ce838c0fe20084b39dd54b0879d0e99/propcache-0.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba57fffe4ac99c5d30076161b5866336d97600769bad35cc68f7774b15298a4e", size = 59912, upload-time = "2026-05-08T21:01:26.545Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/29/fe1aebec2ce57ab985a9c382bded1124431f85078113aa222c5d278430d4/propcache-0.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:583c19759d9eec1e5b69e2fbef36a7d9c326041be9746cb822d335c8cedc2979", size = 63300, upload-time = "2026-05-08T21:01:27.937Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/18/2334b26768b6c82be8c69e83671b767d5ef426aa09b0cba6c2ea47816774/propcache-0.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d0326e2e5e1f3163fa306c834e48e8d490e5fae607a097a40c0648109b47ba80", size = 64208, upload-time = "2026-05-08T21:01:29.484Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/76/7f1bfd6afff4c5e38e36a3c6d68eb5f4b7311ea80baf693db78d95b603c4/propcache-0.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e00820e192c8dbebcafb383ebbf99030895f09905e7a0eb2e0340a0bcc2bc825", size = 61633, upload-time = "2026-05-08T21:01:31.068Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/46/b3ff8aba2b4953a3e50de2cf72f1b5748b8eca93b15f3dc2c84339084c09/propcache-0.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c66afea89b1e43725731d2004732a046fe6fe955d51f952c3e95a7314a284a39", size = 61724, upload-time = "2026-05-08T21:01:32.374Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/01/814cfcafbcff954f94c01cf30e097ddc88a076b5440fbcf4570753437d40/propcache-0.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc37dec6c6cdad0b57881a5658fd14fbf53e333b1a86cf86559f190e1d9ec4", size = 60069, upload-time = "2026-05-08T21:01:33.67Z" },
+ { url = "https://files.pythonhosted.org/packages/da/68/5c6f7622d510cc666a300687e06fd060c1a43361c0c9b20d284f06d8096a/propcache-0.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:5570dbcc97571c15f68068e529c92715a12f8d54030e272d264b377e22bd17a5", size = 57099, upload-time = "2026-05-08T21:01:34.915Z" },
+ { url = "https://files.pythonhosted.org/packages/55/27/9cb0b4c679124085327957d42521c99dba04c88c90c3e55a6f0b633ebccc/propcache-0.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f814362777a9f841adddb200ecdf8f5cb1e5a3c4b7a86378edbd6ccb26edd702", size = 63391, upload-time = "2026-05-08T21:01:36.231Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/9d/7258aaa5bdf60fc6f27591eef6fe52768cb0beda7140be477c8b12c9794a/propcache-0.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:196913dea116aeb5a2ba95af4ddcb7ea85559ae07d8eee8751688310d09168c3", size = 61626, upload-time = "2026-05-08T21:01:37.545Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/0d/41c602003e8a9b16fe1e7eadf62c7bfba9d5474370b24200bf48b315f45f/propcache-0.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:6e7b8719005dd1175be4ab1cd25e9b98659a5e0347331506ec6760d2773a7fb5", size = 64781, upload-time = "2026-05-08T21:01:38.83Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/f3/38e66b1856e9bd079deea015bc4a55f7767c0e4db2f7dcf69e7e680ba4ce/propcache-0.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:51f96d685ab16e88cab128cd37a52c5da540809c8b879fa047731bfcb4ad35a4", size = 62570, upload-time = "2026-05-08T21:01:40.415Z" },
+ { url = "https://files.pythonhosted.org/packages/95/ca/bbfe9b910ce57dde8bb4876b4520fc02a4e89497c10de26be936758a3aaa/propcache-0.5.2-cp314-cp314-win32.whl", hash = "sha256:cc6fc3cc62e8501d3ed62894425040d2728ecddb1ed072737a5c70bd537aa9f0", size = 39436, upload-time = "2026-05-08T21:01:41.654Z" },
+ { url = "https://files.pythonhosted.org/packages/61/d2/45c9defbaa1ea297035d9d4cce9e8f80daafbf19319c6007f157c6256ea9/propcache-0.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:81e3a30b0bb60caa22033dd0f8a3618d1d67356212514f62c57db75cb0ef410c", size = 42373, upload-time = "2026-05-08T21:01:43.041Z" },
+ { url = "https://files.pythonhosted.org/packages/44/68/9ea5103f41d5217d7d6ec24db90018e23aebec070c3f9a6e54d12b841fd8/propcache-0.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:0d2c9bf8528f135dbb805ce027567e09164f7efa51a2be07458a2c0420f292d0", size = 38554, upload-time = "2026-05-08T21:01:44.336Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/81/fadf555f42d3b762eea8a53950b0489fdc0aa9da5f8ed9e10ce0a4e01b48/propcache-0.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4bc8ff1feffc6a61c7002ffe84634c41b822e104990ae009f44a0834430070bb", size = 99395, upload-time = "2026-05-08T21:01:45.883Z" },
+ { url = "https://files.pythonhosted.org/packages/f5/c9/c61e134a686949cf7971af3a390148b1156f7be81c73bc0cd12c873e2d48/propcache-0.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:79aa3ff0a9b566633b642fa9caf7e21ed1c13d6feca718187873f199e1514078", size = 56653, upload-time = "2026-05-08T21:01:47.307Z" },
+ { url = "https://files.pythonhosted.org/packages/cb/73/daf935ea7048ddd7ec8eec5345b4a40b619d2d178b3c0a0900796bc3c794/propcache-0.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1b31822f4474c4036bae62de9402710051d431a606d6a0f907fec79935a071aa", size = 56914, upload-time = "2026-05-08T21:01:48.573Z" },
+ { url = "https://files.pythonhosted.org/packages/79/9f/aba959b435ea18617edd7cf0a7ad0b9c574b8fc7e3d2cd55fb59cb255d33/propcache-0.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fef48778b5a2a756523fdb781326b028ca75e32858b04f2cdd19f394564917", size = 62567, upload-time = "2026-05-08T21:01:49.903Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/a1/859942de9a791ff42f6141736f5b37749b8f53e65edfa49638c67dd67e6a/propcache-0.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8b73ab70f1a3351fbc71f663b3e645af6dd0329100c353081cf69c37433fc6fe", size = 65542, upload-time = "2026-05-08T21:01:51.204Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/61/315bc0fd6c0fc7f80a528b8afd209e5fc4a875ea79571b91b8f50f442907/propcache-0.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5538d2c13d93e4698af7e092b57bc7298fd35d1d58e656ae18f23ee0d0378e03", size = 66845, upload-time = "2026-05-08T21:01:52.539Z" },
+ { url = "https://files.pythonhosted.org/packages/47/f7/9f8122e3132e8e354ac41975ef8f1099be7d5a16bc7ae562734e993665c0/propcache-0.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cd645f03898405cabe694fb8bc35241e3a9c332ec85627584fe3de201452b335", size = 63985, upload-time = "2026-05-08T21:01:53.847Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/54/c317819ec157cbf6f35df9df9657a6f82daf34d5faf15948b2f639c2192e/propcache-0.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a473b3440261e0c60706e732b2ed2f517857344fc21bf48fdfe211e2d98eb285", size = 63999, upload-time = "2026-05-08T21:01:55.179Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/56/387e3f7dfce0a9233df41fb888aa1c30222cb4bbbf09537c02dd9bd85fe2/propcache-0.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7afa37062e6650640e932e4cc9297d81f9f42d9944029cc386b8247dea4da837", size = 62779, upload-time = "2026-05-08T21:01:57.489Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/9c/596784cb5824ed61ee960d3f8655a3f0993e107c6e98ab6c818b7fb92ccb/propcache-0.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:8a90efd5777e996e42d568db9ac740b944d691e565cbfd31b2f7832f9184b2b8", size = 59796, upload-time = "2026-05-08T21:01:58.736Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/3d/1a6cfa1726a48542c1e8784a0761421476a5b68e09b7f36bf95eb954aaba/propcache-0.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:f19bb891234d72535764d703bfed1153cc34f4214d5bd7150aee1eec9e8f4366", size = 66023, upload-time = "2026-05-08T21:02:00.228Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/0e/05fd6990369477076e4e280bcb970de760fddf0161a46e988bc95f7940ec/propcache-0.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:32775082acd2d807ee3db715c7770d38767b817870acfa08c29e057f3c4d5b56", size = 64448, upload-time = "2026-05-08T21:02:01.888Z" },
+ { url = "https://files.pythonhosted.org/packages/cd/86/5f8da315a4309c62c10c0b2516b17492d5d3bbe1bb862b96604db67e2a37/propcache-0.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9282fb1a3bccd038da9f768b927b24a0c753e466c086b7c4f3c6982851eefb2d", size = 67329, upload-time = "2026-05-08T21:02:03.484Z" },
+ { url = "https://files.pythonhosted.org/packages/da/d3/3368efe79ab21f0cdf86ef49895811c9cc933131d4cde1f28a624e22e712/propcache-0.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cc49723e2f60d6b32a0f0b08a3fd6d13203c07f1cd9566cfce0f12a917c967a2", size = 65172, upload-time = "2026-05-08T21:02:04.745Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/07/127e8b0bacfb325396196f9d976a22453049b89b9b2b08477cc3145faa44/propcache-0.5.2-cp314-cp314t-win32.whl", hash = "sha256:2d7aa89ebca5acc98cba9d1472d976e394782f587bad6661003602a619fd1821", size = 43813, upload-time = "2026-05-08T21:02:06.025Z" },
+ { url = "https://files.pythonhosted.org/packages/88/fb/46dad6c0ae49ed230ab1b16c890c2b6314e2403e6c412976f4a72d64a527/propcache-0.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:d447bb0b3054be5818458fbb171208b1d9ff11eba14e18ca18b90cbb45767370", size = 47764, upload-time = "2026-05-08T21:02:07.353Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/c4/a47d0a63aa309d10d59ede6e9d4cff03a344a79d1f0f4cd0cd74997b53e0/propcache-0.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:fe67a3d11cd9b4efabfa45c3d00ffba2b26811442a73a581a94b67c2b5faccf6", size = 41140, upload-time = "2026-05-08T21:02:09.065Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/ed/1cdcab6ba3d6ab7feca11fc14f0eeea80755bb53ef4e892079f31b10a25f/propcache-0.5.2-py3-none-any.whl", hash = "sha256:be1ddfcbb376e3de5d2e2db1d58d6d67463e6b4f9f040c000de8e300295465fe", size = 14036, upload-time = "2026-05-08T21:02:10.673Z" },
+]
+
+[[package]]
+name = "protobuf"
+version = "7.35.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/da/01/9ef0afd7999eb9badb3a768b4aedd78c86d4c65cfaf1958ab276199e76b4/protobuf-7.35.1.tar.gz", hash = "sha256:ce115a26fe0c39a2c29973d914d327e516a6455464489fe3cd1e51a1b354f81a", size = 458717, upload-time = "2026-06-11T21:55:40.257Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/10/03/8aeeb7458d22546bf64b5250ca1daeb5ff757d900e8e4a7476c6f0db843e/protobuf-7.35.1-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:24f857477359a85c0c235261b8ba905fd51b2562f4a64ca1df5473f29850cbf6", size = 433226, upload-time = "2026-06-11T21:55:31.719Z" },
+ { url = "https://files.pythonhosted.org/packages/37/4b/dfb89eb0e652a1ff073c39a59fb5e3a83cfe9b57a2c83fa6d78270101767/protobuf-7.35.1-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:11d6b0ec246892d85215b0a13ca6e0233cf5284b68f0ac02646427f4ff88a799", size = 328847, upload-time = "2026-06-11T21:55:34.035Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/58/dc12f2cd484951524af6e3382c785869b9b3fb5e52ee95ae23add53ee8f9/protobuf-7.35.1-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:b73f9489a4b8b1c9cb1f8ed951c736392592edb24b9d6819f36d2e10b171d5b4", size = 344030, upload-time = "2026-06-11T21:55:34.941Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/be/5b3cfe508bfab6761414ff944e3366eb13be4fd71efcd69450f89ba39f43/protobuf-7.35.1-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:74758715c53d7158fb76caf4f0cfdacc5329a4b1bb994f865d6cf302d413a1c4", size = 327130, upload-time = "2026-06-11T21:55:35.921Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/bc/6d6c7ba8709c85f8f2c390b2b118d6fb08a783676a572271851bf45a7d22/protobuf-7.35.1-cp310-abi3-win32.whl", hash = "sha256:353652e4efd0bca5b5fc2656abf8307ef351f0cf938c9eba09f0e09c20a25c30", size = 428945, upload-time = "2026-06-11T21:55:37.034Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/19/8d0cb6f20a1ef7b18f1c8986ad5783f22f84cce39c6ce9a6e645ea55192e/protobuf-7.35.1-cp310-abi3-win_amd64.whl", hash = "sha256:230a75ddfc2de4806e56696ce9640c1cdfdb6543b7cfce98d42a4c0a0e7bdb87", size = 439996, upload-time = "2026-06-11T21:55:38.123Z" },
+ { url = "https://files.pythonhosted.org/packages/19/c7/5f7c636ec43e0c545e28d1f1db71990108306f7bdcb89f069ba97e428e7f/protobuf-7.35.1-py3-none-any.whl", hash = "sha256:4bc97768d8fe4ad6743c8a19403e314511ed9f6d13205b687e52421c023ac1b9", size = 171659, upload-time = "2026-06-11T21:55:39.155Z" },
+]
+
+[[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 = "pulsectl"
+version = "24.12.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f5/c5/f070a8c5f0a5742f7aebb5d90869ee1805174c03928dfafd3833de58bd57/pulsectl-24.12.0.tar.gz", hash = "sha256:288d6715232ac6f3dcdb123fbecaa2c0b9a50ea4087e6e87c3f841ab0a8a07fc", size = 41200, upload-time = "2024-12-26T13:22:57.389Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/62/a9/5b119f86dd1a053c55da7d0355fca2ad215bae6f7f4777d46b307a8cc3e9/pulsectl-24.12.0-py2.py3-none-any.whl", hash = "sha256:13a60be940594f03ead3245b3dfe3aff4a3f9a792af347674bde5e716d4f76d2", size = 35133, upload-time = "2024-12-26T13:22:53.395Z" },
+]
+
+[[package]]
+name = "pycairo"
+version = "1.29.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/d9/1728840a22a4ef8a8f479b9156aa2943cd98c3907accd3849fb0d5f82bfd/pycairo-1.29.0.tar.gz", hash = "sha256:f3f7fde97325cae80224c09f12564ef58d0d0f655da0e3b040f5807bd5bd3142", size = 665871, upload-time = "2025-11-11T19:13:01.584Z" }
+
+[[package]]
+name = "pycaw"
+version = "20251023"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "comtypes" },
+ { name = "psutil" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/81/19181e3118a503f94d8689fbbed60616e85d08cee3a295c11245ae73018f/pycaw-20251023.tar.gz", hash = "sha256:19935b92eb5efc3f3ea5ee8a2d37ca49009e9dc00f83d067b74b9922e84b5b3b", size = 23421, upload-time = "2025-10-23T18:26:45.087Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ff/bc/f60c1622da5c53770c2d62457b5b6fc9623ab41b9d276269b857cd337e22/pycaw-20251023-py3-none-any.whl", hash = "sha256:ef06d234a2fe3c175925a2a8c7ed8824e450851014fdb7d900af1b56ce422d4e", size = 25849, upload-time = "2025-10-23T18:26:43.955Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.13.4"
+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/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fd/7b/122376b1fd3c62c1ed9dc80c931ace4844b3c55407b6fb2d199377c9736f/pydantic-2.13.4-py3-none-any.whl", hash = "sha256:45a282cde31d808236fd7ea9d919b128653c8b38b393d1c4ab335c62924d9aba", size = 472262, upload-time = "2026-05-06T13:43:02.641Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/ce/8c/af022f0af448d7747c5154288d46b5f2bc5f17366eaa0e23e9aa04d59f3b/pydantic_core-2.46.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:3245406455a5d98187ec35530fd772b1d799b26667980872c8d4614991e2c4a2", size = 2106158, upload-time = "2026-05-06T13:38:57.215Z" },
+ { url = "https://files.pythonhosted.org/packages/19/95/6195171e385007300f0f5574592e467c568becce2d937a0b6804f218bc49/pydantic_core-2.46.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:962ccbab7b642487b1d8b7df90ef677e03134cf1fd8880bf698649b22a69371f", size = 1951724, upload-time = "2026-05-06T13:37:02.697Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/bc/f47d1ff9cbb1620e1b5b697eef06010035735f07820180e74178226b27b3/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8233f2947cf85404441fd7e0085f53b10c93e0ee78611099b5c7237e36aacbf7", size = 1975742, upload-time = "2026-05-06T13:37:09.448Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/11/9b9a5b0306345664a2da6410877af6e8082481b5884b3ddd78d47c6013ce/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a233125ac121aa3ffba9a2b59edfc4a985a76092dc8279586ab4b71390875e7", size = 2052418, upload-time = "2026-05-06T13:37:38.234Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/b7/a65fec226f5d78fc39f4a13c4cc0c768c22b113438f60c14adc9d2865038/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b712b53160b79a5850310b912a5ef8e57e56947c8ad690c227f5c9d7e561712", size = 2232274, upload-time = "2026-05-06T13:38:27.753Z" },
+ { url = "https://files.pythonhosted.org/packages/68/f0/92039db98b907ef49269a8271f67db9cb78ae2fc68062ef7e4e77adb5f61/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9401557acd873c3a7f3eb9383edef8ac4968f9510e340f4808d427e75667e7b4", size = 2309940, upload-time = "2026-05-06T13:38:05.353Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/97/2aab507d3d00ca626e8e57c1eac6a79e4e5fbcc63eb99733ff55d1717f65/pydantic_core-2.46.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:926c9541b14b12b1681dca8a0b75feb510b06c6341b70a8e500c2fdcff837cce", size = 2094516, upload-time = "2026-05-06T13:39:10.577Z" },
+ { url = "https://files.pythonhosted.org/packages/22/37/a8aca44d40d737dde2bc05b3c6c07dff0de07ce6f82e9f3167aeaf4d5dea/pydantic_core-2.46.4-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:56cb4851bcaf3d117eddcef4fe66afd750a50274b0da8e22be256d10e5611987", size = 2136854, upload-time = "2026-05-06T13:40:22.59Z" },
+ { url = "https://files.pythonhosted.org/packages/24/99/fcef1b79238c06a8cbec70819ac722ba76e02bc8ada9b0fd66eba40da01b/pydantic_core-2.46.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:c68fcd102d71ea85c5b2dfac3f4f8476eff42a9e078fd5faefff6d145063536b", size = 2180306, upload-time = "2026-05-06T13:40:10.666Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/6c/fc44000918855b42779d007ae63b0532794739027b2f417321cddbc44f6a/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b2f69dec1725e79a012d920df1707de5caf7ed5e08f3be4435e25803efc47458", size = 2190044, upload-time = "2026-05-06T13:40:43.231Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/65/d9cadc9f1920d7a127ad2edba16c1db7916e59719285cd6c94600b0080ba/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8d0820e8192167f80d88d64038e609c31452eeca865b4e1d9950a27a4609b00b", size = 2329133, upload-time = "2026-05-06T13:39:57.365Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/cf/c873d91679f3a30bcf5e7ac280ce5573483e72295307685120d0d5ad3416/pydantic_core-2.46.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:fbdb89b3e1c94a30cc5edfce477c6e6a5dc4d8f84665b455c27582f211a1c72c", size = 2374464, upload-time = "2026-05-06T13:38:06.976Z" },
+ { url = "https://files.pythonhosted.org/packages/47/bd/6f2fc8188f31bf10590f1e98e7b306336161fac930a8c514cd7bd828c7dc/pydantic_core-2.46.4-cp312-cp312-win32.whl", hash = "sha256:9aa768456404a8bf48a4406685ac2bec8e72b62c69313734fa3b73cf33b3a894", size = 1974823, upload-time = "2026-05-06T13:40:47.985Z" },
+ { url = "https://files.pythonhosted.org/packages/40/8c/985c1d41ea1107c2534abd9870e4ed5c8e7669b5c308297835c001e7a1c4/pydantic_core-2.46.4-cp312-cp312-win_amd64.whl", hash = "sha256:e9c26f834c65f5752f3f06cb08cb86a913ceb7274d0db6e267808a708b46bc89", size = 2072919, upload-time = "2026-05-06T13:39:21.153Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/ba/f463d006e0c47373ca7ec5e1a261c59dc01ef4d62b2657af925fb0deee3a/pydantic_core-2.46.4-cp312-cp312-win_arm64.whl", hash = "sha256:4fc73cb559bdb54b1134a706a2802a4cddd27a0633f5abb7e53056268751ac6a", size = 2027604, upload-time = "2026-05-06T13:39:03.753Z" },
+ { url = "https://files.pythonhosted.org/packages/51/a2/5d30b469c5267a17b39dec53208222f76a8d351dfac4af661888c5aee77d/pydantic_core-2.46.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:5d5902252db0d3cedf8d4a1bc68f70eeb430f7e4c7104c8c476753519b423008", size = 2106306, upload-time = "2026-05-06T13:37:48.029Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/81/4fa520eaffa8bd7d1525e644cd6d39e7d60b1592bc5b516693c7340b50f1/pydantic_core-2.46.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:c94f0688e7b8d0a67abf40e57a7eaaecd17cc9586706a31b76c031f63df052b4", size = 1951906, upload-time = "2026-05-06T13:37:17.012Z" },
+ { url = "https://files.pythonhosted.org/packages/03/d5/fd02da45b659668b05923b17ba3a0100a0a3d5541e3bd8fcc4ecb711309e/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f027324c56cd5406ca49c124b0db10e56c69064fec039acc571c29020cc87c76", size = 1976802, upload-time = "2026-05-06T13:37:35.113Z" },
+ { url = "https://files.pythonhosted.org/packages/21/f2/95727e1368be3d3ed485eaab7adbd7dda408f33f7a36e8b48e0144002b91/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e739fee756ba1010f8bcccb534252e85a35fe45ae92c295a06059ce58b74ccd3", size = 2052446, upload-time = "2026-05-06T13:37:12.313Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/86/5d99feea3f77c7234b8718075b23db11532773c1a0dbd9b9490215dc2eeb/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9d56801be94b86a9da183e5f3766e6310752b99ff647e38b09a9500d88e46e76", size = 2232757, upload-time = "2026-05-06T13:39:01.149Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/3a/508ac615935ef7588cf6d9e9b91309fdc2da751af865e02a9098de88258c/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2412e734dcb48da14d4e4006b82b46b74f2518b8a26ee7e58c6844a6cd6d03c4", size = 2309275, upload-time = "2026-05-06T13:37:41.406Z" },
+ { url = "https://files.pythonhosted.org/packages/07/f8/41db9de19d7987d6b04715a02b3b40aea467000275d9d758ffaa31af7d50/pydantic_core-2.46.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9551187363ffc0de2a00b2e47c25aeaeb1020b69b668762966df15fc5659dd5a", size = 2094467, upload-time = "2026-05-06T13:39:18.847Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/e2/f35033184cb11d0052daf4416e8e10a502ea2ac006fc4f459aee872727d1/pydantic_core-2.46.4-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:0186750b482eefa11d7f435892b09c5c606193ef3375bcf94aa00ae6bfb66262", size = 2134417, upload-time = "2026-05-06T13:40:17.944Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/7b/6ceeb1cc90e193862f444ebe373d8fdf613f0a82572dde03fb10734c6c71/pydantic_core-2.46.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:5855698a4856556d86e8e6cd8434bc3ac0314ee8e12089ae0e143f64c6256e4e", size = 2179782, upload-time = "2026-05-06T13:40:32.618Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/f2/c8d7773ede6af08036423a00ae0ceffce266c3c52a096c435d68c896083f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:cbaf13819775b7f769bf4a1f066cb6df7a28d4480081a589828ef190226881cd", size = 2188782, upload-time = "2026-05-06T13:36:51.018Z" },
+ { url = "https://files.pythonhosted.org/packages/59/31/0c864784e31f09f05cdd87606f08923b9c9e7f6e51dd27f20f62f975ce9f/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:633147d34cf4550417f12e2b1a0383973bdf5cdfde212cb09e9a581cf10820be", size = 2328334, upload-time = "2026-05-06T13:40:37.764Z" },
+ { url = "https://files.pythonhosted.org/packages/c2/eb/4f6c8a41efa30baa755590f4141abf3a8c370fab610915733e74134a7270/pydantic_core-2.46.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:82cf5301172168103724d49a1444d3378cb20cdee30b116a1bd6031236298a5d", size = 2372986, upload-time = "2026-05-06T13:39:34.152Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/24/b375a480d53113860c299764bfe9f349a3dc9108b3adc0d7f0d786492ebf/pydantic_core-2.46.4-cp313-cp313-win32.whl", hash = "sha256:9fa8ae11da9e2b3126c6426f147e0fba88d96d65921799bb30c6abd1cb2c97fb", size = 1973693, upload-time = "2026-05-06T13:37:55.072Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/e8/cff247591966f2d22ec8c003cd7587e27b7ba7b81ab2fb888e3ab75dc285/pydantic_core-2.46.4-cp313-cp313-win_amd64.whl", hash = "sha256:6b3ace8194b0e5204818c92802dcdca7fc6d88aabbb799d7c795540d9cd6d292", size = 2071819, upload-time = "2026-05-06T13:38:49.139Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/1a/f4aee670d5670e9e148e0c82c7db98d780be566c6e6a97ee8035528ca0b3/pydantic_core-2.46.4-cp313-cp313-win_arm64.whl", hash = "sha256:184c081504d17f1c1066e430e117142b2c77d9448a97f7b65c6ac9fd9aee238d", size = 2027411, upload-time = "2026-05-06T13:40:45.796Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/74/228a26ddad29c6672b805d9fd78e8d251cd04004fa7eed0e622096cd0250/pydantic_core-2.46.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:428e04521a40150c85216fc8b85e8d39fece235a9cf5e383761238c7fa9b96fb", size = 2102079, upload-time = "2026-05-06T13:38:41.019Z" },
+ { url = "https://files.pythonhosted.org/packages/ad/1f/8970b150a4b4365623ae00fc88603491f763c627311ae8031e3111356d6e/pydantic_core-2.46.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:23ace664830ee0bfe014a0c7bc248b1f7f25ed7ad103852c317624a1083af462", size = 1952179, upload-time = "2026-05-06T13:36:59.812Z" },
+ { url = "https://files.pythonhosted.org/packages/95/30/5211a831ae054928054b2f79731661087a2bc5c01e825c672b3a4a8f1b3e/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce5c1d2a8b27468f433ca974829c44060b8097eedc39933e3c206a90ee49c4a9", size = 1978926, upload-time = "2026-05-06T13:37:39.933Z" },
+ { url = "https://files.pythonhosted.org/packages/57/e9/689668733b1eb67adeef047db3c2e8788fcf65a7fd9c9e2b46b7744fe245/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7283d57845ecf5a163403eb0702dfc220cc4fbdd18919cb5ccea4f95ee1cdab4", size = 2046785, upload-time = "2026-05-06T13:38:01.995Z" },
+ { url = "https://files.pythonhosted.org/packages/60/d9/6715260422ff50a2109878fd24d948a6c3446bb2664f34ee78cd972b3acd/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8daafc69c93ee8a0204506a3b6b30f586ef54028f52aeeeb5c4cfc5184fd5914", size = 2228733, upload-time = "2026-05-06T13:40:50.371Z" },
+ { url = "https://files.pythonhosted.org/packages/18/ae/fdb2f64316afca925640f8e70bb1a564b0ec2721c1389e25b8eb4bf9a299/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd2213145bcc2ba85884d0ac63d222fece9209678f77b9b4d76f054c561adb28", size = 2307534, upload-time = "2026-05-06T13:37:21.531Z" },
+ { url = "https://files.pythonhosted.org/packages/89/1d/8eff589b45bb8190a9d12c49cfad0f176a5cbd1534908a6b5125e2886239/pydantic_core-2.46.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a5f930472650a82629163023e630d160863fce524c616f4e5186e5de9d9a49b", size = 2099732, upload-time = "2026-05-06T13:39:31.942Z" },
+ { url = "https://files.pythonhosted.org/packages/06/d5/ee5a3366637fee41dee51a1fc91562dcf12ddbc68fda34e6b253da2324bb/pydantic_core-2.46.4-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:c1b3f518abeca3aa13c712fd202306e145abf59a18b094a6bafb2d2bbf59192c", size = 2129627, upload-time = "2026-05-06T13:37:25.033Z" },
+ { url = "https://files.pythonhosted.org/packages/94/33/2414be571d2c6a6c4d08be21f9292b6d3fdb08949a97b6dfe985017821db/pydantic_core-2.46.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1a7dd0b3ee80d90150e3495a3a13ac34dbcbfd4f012996a6a1d8900e91b5c0fb", size = 2179141, upload-time = "2026-05-06T13:37:14.046Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/79/7daa95be995be0eecc4cf75064cb33f9bbbfe3fe0158caf2f0d4a996a5c7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:3fb702cd90b0446a3a1c5e470bfa0dd23c0233b676a9099ddcc964fa6ca13898", size = 2184325, upload-time = "2026-05-06T13:36:53.615Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/cb/d0a382f5c0de8a222dc61c65348e0ce831b1f68e0a018450d31c2cace3a5/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b8458003118a712e66286df6a707db01c52c0f52f7db8e4a38f0da1d3b94fc4e", size = 2323990, upload-time = "2026-05-06T13:40:29.971Z" },
+ { url = "https://files.pythonhosted.org/packages/05/db/d9ba624cc4a5aced1598e88c04fdbd8310c8a69b9d38b9a3d39ce3a61ed7/pydantic_core-2.46.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:372429a130e469c9cd698925ce5fc50940b7a1336b0d82038e63d5bbc4edc519", size = 2369978, upload-time = "2026-05-06T13:37:23.027Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/20/d15df15ba918c423461905802bfd2981c3af0bfa0e40d05e13edbfa48bc3/pydantic_core-2.46.4-cp314-cp314-win32.whl", hash = "sha256:85bb3611ff1802f3ee7fdd7dbff26b56f343fb432d57a4728fdd49b6ef35e2f4", size = 1966354, upload-time = "2026-05-06T13:38:03.499Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/b6/6b8de4c0a7d7ab3004c439c80c5c1e0a3e8d78bbae19379b01960383d9e5/pydantic_core-2.46.4-cp314-cp314-win_amd64.whl", hash = "sha256:811ff8e9c313ab425368bcbb36e5c4ebd7108c2bbf4e4089cfbb0b01eff63fac", size = 2072238, upload-time = "2026-05-06T13:39:40.807Z" },
+ { url = "https://files.pythonhosted.org/packages/32/36/51eb763beec1f4cf59b1db243a7dcc39cbb41230f050a09b9d69faaf0a48/pydantic_core-2.46.4-cp314-cp314-win_arm64.whl", hash = "sha256:bfec22eab3c8cc2ceec0248aec886624116dc079afa027ecc8ad4a7e62010f8a", size = 2018251, upload-time = "2026-05-06T13:37:26.72Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/91/855af51d625b23aa987116a19e231d2aaef9c4a415273ddc189b79a45fee/pydantic_core-2.46.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:af8244b2bef6aaad6d92cda81372de7f8c8d36c9f0c3ea36e827c60e7d9467a0", size = 2099593, upload-time = "2026-05-06T13:39:47.682Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/1b/8784a54c65edb5f49f0a14d6977cf1b209bba85a4c77445b255c2de58ab3/pydantic_core-2.46.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5a4330cdbc57162e4b3aa303f588ba752257694c9c9be3e7ebb11b4aca659b5d", size = 1935226, upload-time = "2026-05-06T13:40:40.428Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/e7/1955d28d1afc56dd4b3ad7cc0cf39df1b9852964cf16e5d13912756d6d6b/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29c61fc04a3d840155ff08e475a04809278972fe6aef51e2720554e96367e34b", size = 1974605, upload-time = "2026-05-06T13:37:32.029Z" },
+ { url = "https://files.pythonhosted.org/packages/93/e2/3fedbf0ba7a22850e6e9fd78117f1c0f10f950182344d8a6c535d468fdd8/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c50f2528cf200c5eed56faf3f4e22fcd5f38c157a8b78576e6ba3168ec35f000", size = 2030777, upload-time = "2026-05-06T13:38:55.239Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/61/46be275fcaaba0b4f5b9669dd852267ce1ff616592dccf7a7845588df091/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0cbe8b01f948de4286c74cdd6c667aceb38f5c1e26f0693b3983d9d74887c65e", size = 2236641, upload-time = "2026-05-06T13:37:08.096Z" },
+ { url = "https://files.pythonhosted.org/packages/60/db/12e93e46a8bac9988be3c016860f83293daea8c716c029c9ace279036f2f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:617d7e2ca7dcb8c5cf6bcb8c59b8832c94b36196bbf1cbd1bfb56ed341905edd", size = 2286404, upload-time = "2026-05-06T13:40:20.221Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/4a/4d8b19008f38d31c53b8219cfedc2e3d5de5fe99d90076b7e767de29274f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7027560ee92211647d0d34e3f7cd6f50da56399d26a9c8ad0da286d3869a53f3", size = 2109219, upload-time = "2026-05-06T13:38:12.153Z" },
+ { url = "https://files.pythonhosted.org/packages/88/70/3cbc40978fefb7bb09c6708d40d4ad1a5d70fd7213c3d17f971de868ec1f/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:f99626688942fb746e545232e7726926f3be91b5975f8b55327665fafda991c7", size = 2110594, upload-time = "2026-05-06T13:40:02.971Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/20/b8d36736216e29491125531685b2f9e61aa5b4b2599893f8268551da3338/pydantic_core-2.46.4-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fc3e9034a63de20e15e8ade85358bc6efc614008cab72898b4b4952bea0509ff", size = 2159542, upload-time = "2026-05-06T13:39:27.506Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/a2/367df868eb584dacf6bf82a389272406d7178e301c4ac82545ab98bc2dd9/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:97e7cf2be5c77b7d1a9713a05605d49460d02c6078d38d8bef3cbe323c548424", size = 2168146, upload-time = "2026-05-06T13:38:31.93Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/b8/4460f77f7e201893f649a29ab355dddd3beee8a97bcb1a320db414f9a06e/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:3bf92c5d0e00fefaab325a4d27828fe6b6e2a21848686b5b60d2d9eeb09d76c6", size = 2306309, upload-time = "2026-05-06T13:37:44.717Z" },
+ { url = "https://files.pythonhosted.org/packages/64/c4/be2639293acd87dc8ddbcec41a73cee9b2ebf996fe6d892a1a74e88ad3f7/pydantic_core-2.46.4-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:3ecbc122d18468d06ca279dc26a8c2e2d5acb10943bb35e36ae92096dc3b5565", size = 2369736, upload-time = "2026-05-06T13:37:05.645Z" },
+ { url = "https://files.pythonhosted.org/packages/30/a6/9f9f380dbb301f67023bf8f707aaa75daadf84f7152d95c410fd7e81d994/pydantic_core-2.46.4-cp314-cp314t-win32.whl", hash = "sha256:e846ae7835bf0703ae43f534ab79a867146dadd59dc9ca5c8b53d5c8f7c9ef02", size = 1955575, upload-time = "2026-05-06T13:38:51.116Z" },
+ { url = "https://files.pythonhosted.org/packages/40/1f/f1eb9eb350e795d1af8586289746f5c5677d16043040d63710e22abc43c9/pydantic_core-2.46.4-cp314-cp314t-win_amd64.whl", hash = "sha256:2108ba5c1c1eca18030634489dc544844144ee36357f2f9f780b93e7ddbb44b5", size = 2051624, upload-time = "2026-05-06T13:38:21.672Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/d2/42dd53d0a85c27606f316d3aa5d2869c4e8470a5ed6dec30e4a1abe19192/pydantic_core-2.46.4-cp314-cp314t-win_arm64.whl", hash = "sha256:4fcbe087dbc2068af7eda3aa87634eba216dbda64d1ae73c8684b621d33f6596", size = 2017325, upload-time = "2026-05-06T13:40:52.723Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/1d/8987ad40f65ae1432753072f214fb5c74fe47ffbd0698bb9cbbb585664f8/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:1d8ba486450b14f3b1d63bc521d410ec7565e52f887b9fb671791886436a42f7", size = 2095527, upload-time = "2026-05-06T13:39:52.283Z" },
+ { url = "https://files.pythonhosted.org/packages/64/d3/84c282a7eee1d3ac4c0377546ef5a1ea436ce26840d9ac3b7ed54a377507/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:3009f12e4e90b7f88b4f9adb1b0c4a3d58fe7820f3238c190047209d148026df", size = 1936024, upload-time = "2026-05-06T13:40:15.671Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/ca/eac61596cdeb4d7e174d3dc0bd8a6238f14f75f97a24e7b7db4c7e7340a0/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad785e92e6dc634c21555edc8bd6b64957ab844541bcb96a1366c202951ae526", size = 1990696, upload-time = "2026-05-06T13:38:34.717Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/c3/7c8b240552251faf6b3a957db200fcfbbcec36763c050428b601e0c9b83b/pydantic_core-2.46.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00c603d540afdd6b80eb39f078f33ebd46211f02f33e34a32d9f053bba711de0", size = 2147590, upload-time = "2026-05-06T13:39:29.883Z" },
+]
+
+[[package]]
+name = "pydantic-settings"
+version = "2.14.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pydantic" },
+ { name = "python-dotenv" },
+ { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5c/b5/8f48e906c3e0205276e8bd8cb7512217a87b2685304d64be27cad5b3019f/pydantic_settings-2.14.2.tar.gz", hash = "sha256:c19dd64b19097f1de80184f0cc7b0272a13ae6e170cbf240a3e27e381ed14a5f", size = 237700, upload-time = "2026-06-19T13:44:56.324Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/77/c1/6e422f34e569cf8e18df68d1939c81c099d2b61e4f7d9621c8a77560799c/pydantic_settings-2.14.2-py3-none-any.whl", hash = "sha256:a20c97b37910b6550d5ea50fbcc2d4187defe58cd57070b73863d069419c9440", size = 61715, upload-time = "2026-06-19T13:44:55.02Z" },
+]
+
+[[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 = "pygobject"
+version = "3.46.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pycairo" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/4a/f24ddf1d20cc4b56affc7921e29928559a06c922eb60077448392792b914/PyGObject-3.46.0.tar.gz", hash = "sha256:481437b05af0a66b7c366ea052710eb3aacbb979d22d30b797f7ec29347ab1e6", size = 723367, upload-time = "2023-09-10T09:56:26.737Z" }
+
+[[package]]
+name = "pyjwt"
+version = "2.13.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3b/81/58d0ac84e1ef3a3843791d6954d94c0b33d526c75eeb1efbce9d0a4c4077/pyjwt-2.13.0.tar.gz", hash = "sha256:41571c89ca91598c79e8ef18a2d07367d4810fbbd6f637794879baf1b7703423", size = 107515, upload-time = "2026-05-21T19:54:36.618Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a3/5e/ecf12fdb62546d64385c158514e9b2b671f7832108ef2ecd2020ce0af2d1/pyjwt-2.13.0-py3-none-any.whl", hash = "sha256:66adcc2aff09b3f1bbd95fc1e1577df8ac8723c978552fd43304c8a290ac5728", size = 31274, upload-time = "2026-05-21T19:54:35.362Z" },
+]
+
+[package.optional-dependencies]
+crypto = [
+ { name = "cryptography" },
+]
+
+[[package]]
+name = "pyproject-hooks"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" },
+]
+
+[[package]]
+name = "pyserial"
+version = "3.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1e/7d/ae3f0a63f41e4d2f6cb66a5b57197850f919f59e558159a4dd3a818f5082/pyserial-3.5.tar.gz", hash = "sha256:3c77e014170dfffbd816e6ffc205e9842efb10be9f58ec16d3e8675b4925cddb", size = 159125, upload-time = "2020-11-23T03:59:15.045Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/07/bc/587a445451b253b285629263eb51c2d8e9bcea4fc97826266d186f96f558/pyserial-3.5-py2.py3-none-any.whl", hash = "sha256:c4451db6ba391ca6ca299fb3ec7bae67a5c55dde170964c7a14ceefec02f2cf0", size = 90585, upload-time = "2020-11-23T03:59:13.41Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+ { name = "iniconfig" },
+ { name = "packaging" },
+ { name = "pluggy" },
+ { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pytest" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
+[[package]]
+name = "pytest-timeout"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/82/4c9ecabab13363e72d880f2fb504c5f750433b2b6f16e99f4ec21ada284c/pytest_timeout-2.4.0.tar.gz", hash = "sha256:7e68e90b01f9eff71332b25001f85c75495fc4e3a836701876183c4bcfd0540a", size = 17973, upload-time = "2025-05-05T19:44:34.99Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fa/b6/3127540ecdf1464a00e5a01ee60a1b09175f6913f0644ac748494d9c4b21/pytest_timeout-2.4.0-py3-none-any.whl", hash = "sha256:c42667e5cdadb151aeb5b26d114aff6bdf5a907f176a007a30b940d3d865b5c2", size = 14382, upload-time = "2025-05-05T19:44:33.502Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.32"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/5b/42/55c32bb9b12693c092ad250a0e82edb5b31ddeda6eb772de5f308b3804ad/python_multipart-0.0.32.tar.gz", hash = "sha256:be54b7f3fa167bb83e4fcd936b887b708f4e57fe75911c02aebf53efaf8d938e", size = 46881, upload-time = "2026-06-04T16:18:58.647Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e1/04/e8135ebd1ad02c56ec633277529b2602ff99ff634be76cdba5744cf554fd/python_multipart-0.0.32-py3-none-any.whl", hash = "sha256:ff6d3f776f16878c894e52e107296ffc890e913c611b1a4ec6c44e2821fe2e23", size = 30042, upload-time = "2026-06-04T16:18:57.319Z" },
+]
+
+[[package]]
+name = "pyusb"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/00/6b/ce3727395e52b7b76dfcf0c665e37d223b680b9becc60710d4bc08b7b7cb/pyusb-1.3.1.tar.gz", hash = "sha256:3af070b607467c1c164f49d5b0caabe8ac78dbed9298d703a8dbf9df4052d17e", size = 77281, upload-time = "2025-01-08T23:45:01.866Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/28/b8/27e6312e86408a44fe16bd28ee12dd98608b39f7e7e57884a24e8f29b573/pyusb-1.3.1-py3-none-any.whl", hash = "sha256:bf9b754557af4717fe80c2b07cc2b923a9151f5c08d17bdb5345dac09d6a0430", size = 58465, upload-time = "2025-01-08T23:45:00.029Z" },
+]
+
+[[package]]
+name = "pywin32"
+version = "312"
+source = { registry = "https://pypi.org/simple" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/83/ff/32aa7d2ed0ab12b323aaa64f9b75e6ad4f8fd09f9ccfc28c79414d46838d/pywin32-312-cp312-cp312-win32.whl", hash = "sha256:dab4f65ac9c4e48400a2a0530c46c3c579cd5905ecd11b80692373915269208b", size = 6371877, upload-time = "2026-06-04T07:49:28.836Z" },
+ { url = "https://files.pythonhosted.org/packages/03/d9/77040d3b43df3f3be32ea289433d660d2727f5ba327bc73be835127d9d60/pywin32-312-cp312-cp312-win_amd64.whl", hash = "sha256:b457f6d628a47e8a7346ce22acb7e1a46a4a78b52e1d17e1af56871bd19a93bc", size = 6914841, upload-time = "2026-06-04T07:49:31.85Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/cc/7b1ec671775756020a0ee7f4feeaf3c568f0ab86bd3900088cf986937a92/pywin32-312-cp312-cp312-win_arm64.whl", hash = "sha256:6017c58e12f6809fbb0555b75df144c2922a9ffd18e4b9b5afa863b6c1a9d950", size = 6727901, upload-time = "2026-06-04T07:49:34.244Z" },
+ { url = "https://files.pythonhosted.org/packages/2d/41/12fbfd7f36ed2146d8bc9de96c2741296bf0d490b98508496cff322e274c/pywin32-312-cp313-cp313-win32.whl", hash = "sha256:7a27df850933d16a8eabfbaeb73d52b273e2da667f80d70b01a89d1f6828d02c", size = 6370184, upload-time = "2026-06-04T07:49:36.253Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/db/36a78e3403099d31d9746d13fdcde5accc43c1155f375a34d15983a479a7/pywin32-312-cp313-cp313-win_amd64.whl", hash = "sha256:c53e878d15a1c44788082bfe712a905433473aa38f86375b7cf8b45e3acbaaf9", size = 6914298, upload-time = "2026-06-04T07:49:38.876Z" },
+ { url = "https://files.pythonhosted.org/packages/84/37/c1697194092b76de9ed47ca124323f02c57ffc8a45c06f88a3d5acaf01eb/pywin32-312-cp313-cp313-win_arm64.whl", hash = "sha256:59aba5d5940842075343a5ddc6b11f1cdf0d1567fe745290359dfbcc7c2eb831", size = 6727640, upload-time = "2026-06-04T07:49:41.083Z" },
+ { url = "https://files.pythonhosted.org/packages/fc/2b/1f3cded5822fd49c02f40544cbb5f58c7cfd6b1694869fd476cb6170ee97/pywin32-312-cp314-cp314-win32.whl", hash = "sha256:a77a90fbb6881238d2ca9c6fd797b25817f3768fe78d214a90137ff055a75f5b", size = 6468928, upload-time = "2026-06-04T07:49:43.188Z" },
+ { url = "https://files.pythonhosted.org/packages/21/82/3bf86d2e2808902013132e1ce905a7da0da53790f3836c64bf44d55e24f3/pywin32-312-cp314-cp314-win_amd64.whl", hash = "sha256:a4dd3a848290ef724347b19f301045831d8e802fa4464f491b98b1e0a081432e", size = 7024157, upload-time = "2026-06-04T07:49:45.34Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/0e/73f6d6800b4f27655abd9e9f6aaeaefcddb2b946e4674efa2bab184a7f7b/pywin32-312-cp314-cp314-win_arm64.whl", hash = "sha256:9fce94568364e0155e6dfb781ac5d95903be8baf28670632beab1b523f300daa", size = 6839598, upload-time = "2026-06-04T07:49:47.613Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/61/caa39686032d2ebdd04ff0ab5cbe163126c0066d98e00c9018646e42393b/pywin32-312-cp315-cp315-win32.whl", hash = "sha256:5c1fbe4a937a73ae9297384a3da38518cbc694c68ad8a809b2e19acd350f03ed", size = 6471159, upload-time = "2026-06-04T07:49:50.035Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/cd/7e1de64a4a6f69c04214169657ccab0d93a670ea50e35eb8f489d7378249/pywin32-312-cp315-cp315-win_amd64.whl", hash = "sha256:c2f03a0f73f804a13c2735b99392b0cd426bb4f2c4d0178e5ac966a0f21618d5", size = 7025293, upload-time = "2026-06-04T07:49:54.857Z" },
+ { url = "https://files.pythonhosted.org/packages/23/ed/4532e9388e65fa16b46776ef47ad631a64eda1631884488af707666350ed/pywin32-312-cp315-cp315-win_arm64.whl", hash = "sha256:a8597d28f267b39074aef51fa593530082b39cbe5a074226096857b1fed2dfb9", size = 6840337, upload-time = "2026-06-04T07:49:57.531Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" },
+ { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" },
+ { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" },
+ { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" },
+ { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" },
+ { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" },
+ { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+ { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+ { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+ { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+ { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+ { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+ { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+ { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+ { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+ { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+ { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+ { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+ { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+ { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
+[[package]]
+name = "questionary"
+version = "2.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "prompt-toolkit" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f6/45/eafb0bba0f9988f6a2520f9ca2df2c82ddfa8d67c95d6625452e97b204a5/questionary-2.1.1.tar.gz", hash = "sha256:3d7e980292bb0107abaa79c68dd3eee3c561b83a0f89ae482860b181c8bd412d", size = 25845, upload-time = "2025-08-28T19:00:20.851Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3c/26/1062c7ec1b053db9e499b4d2d5bc231743201b74051c973dadeac80a8f43/questionary-2.1.1-py3-none-any.whl", hash = "sha256:a51af13f345f1cdea62347589fbb6df3b290306ab8930713bfae4d475a7d4a59", size = 36753, upload-time = "2025-08-28T19:00:19.56Z" },
+]
+
+[[package]]
+name = "reachy-mini"
+version = "1.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "aiohttp" },
+ { name = "asgiref" },
+ { name = "fastapi" },
+ { name = "gstreamer-bundle", marker = "sys_platform != 'linux'" },
+ { name = "huggingface-hub" },
+ { name = "jinja2" },
+ { name = "libusb-package" },
+ { name = "log-throttling" },
+ { name = "numpy" },
+ { name = "onnxruntime" },
+ { name = "pip" },
+ { name = "platformdirs" },
+ { name = "psutil" },
+ { name = "pulsectl", marker = "sys_platform == 'linux'" },
+ { name = "pycaw", marker = "sys_platform == 'win32'" },
+ { name = "pydantic" },
+ { name = "pygobject", marker = "sys_platform == 'linux'" },
+ { name = "pyserial" },
+ { name = "python-multipart" },
+ { name = "pyusb" },
+ { name = "pyyaml" },
+ { name = "questionary" },
+ { name = "reachy-mini-motor-controller" },
+ { name = "reachy-mini-rust-kinematics" },
+ { name = "requests" },
+ { name = "rich" },
+ { name = "rustypot" },
+ { name = "scipy" },
+ { name = "starlette" },
+ { name = "toml" },
+ { name = "uvicorn", extra = ["standard"] },
+ { name = "websockets" },
+ { name = "zeroconf" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0e/ae/da44c9dd1d7c67715fef69b0a78c22ec21384fbcc3a63300b1da821acf94/reachy_mini-1.9.0.tar.gz", hash = "sha256:3a7e022cd585396c4b5ba7dbf356f93509cba9211bb1e06d90417dec7a3ee7cf", size = 23496378, upload-time = "2026-07-09T15:53:05.795Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/50/06/c27a17a3d922e419d83cb7427c47cf5a95dba94578a16374f642d3df26f3/reachy_mini-1.9.0-py3-none-any.whl", hash = "sha256:9d3f8551c42bd12b43f47a1f3fe5e8c39ca0c2ff6d02c27b094ed0f5586c7655", size = 23577272, upload-time = "2026-07-09T15:53:01.96Z" },
+]
+
+[[package]]
+name = "reachy-mini-dances-library"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "reachy-mini" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/0e/7b26c96caf905e8e0cedff57251da4f953b1c2b97a611c86aee76318f5d1/reachy_mini_dances_library-0.2.1.tar.gz", hash = "sha256:f63fbb0e27f97c547f4e4487e8491495365b24c6f0d063780ef1da9fa5b1daf1", size = 14022, upload-time = "2025-10-15T16:09:00.965Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e2/52/69d2d0434019e72811f77bfe408e6781a8bee10639e480d9d6ac1b745f81/reachy_mini_dances_library-0.2.1-py3-none-any.whl", hash = "sha256:b3b2028dd92648b70c262535e9b77aa481a0a3dcf6f2ceece84c08b725cbbddf", size = 16159, upload-time = "2025-10-15T16:08:59.673Z" },
+]
+
+[[package]]
+name = "reachy-mini-motor-controller"
+version = "1.5.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0a/d6/56ea0dc75f8d578cb7522df6e662a5efce32308276c16db1ac65b63228cc/reachy_mini_motor_controller-1.5.6.tar.gz", hash = "sha256:98cb6e9e48dbcb3e4c3649aef418ca8cafea9056a00501c35dea7e86a3a3ec65", size = 29494, upload-time = "2026-06-12T09:31:10.783Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/74/a3/16a365e978d844eb7e5e07343959fe62052c5d898d41a43b4925116e0549/reachy_mini_motor_controller-1.5.6-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:5b30fb45b5068d9bf119bdd39aa475e64dc41e9a1fb229fc70b4a4fdf7d48374", size = 570893, upload-time = "2026-06-12T09:30:41.107Z" },
+ { url = "https://files.pythonhosted.org/packages/31/99/d7b704e513735f55f1e0ba8022e310cdd1a660240cb8959eb9fc6034efe6/reachy_mini_motor_controller-1.5.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2a0fa22b0ac5ba40556c6b94f886fd9128735b009725d082efa7728a6d12bc76", size = 558962, upload-time = "2026-06-12T09:30:35.274Z" },
+ { url = "https://files.pythonhosted.org/packages/bc/7b/014bdb133c0ea47eb5627962900ec66c030be6cd8e32af6bc839e01b3e5e/reachy_mini_motor_controller-1.5.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:86f9232a38e7b15a7dd83b724dfad18f9ea1a86392a71f5015b3a562dac407bc", size = 632687, upload-time = "2026-06-12T09:30:15.081Z" },
+ { url = "https://files.pythonhosted.org/packages/61/fa/42db5e9f559bba6cd6ce0ca0458cd46beacc2e3fb0efdb10a114b4cae6bc/reachy_mini_motor_controller-1.5.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a24681f63a897b9d16fc5071c7c6cb8340dffbbd903285703c16957525fbdc50", size = 643821, upload-time = "2026-06-12T09:30:20.329Z" },
+ { url = "https://files.pythonhosted.org/packages/12/f5/9703a01df0baa6d730f9d9fbc7d76ac87a465a40849b0c4f528886170910/reachy_mini_motor_controller-1.5.6-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a38e92b789d1d42b7db3b207ad52d8adb7d6767e0d6db949583572fba352763", size = 690360, upload-time = "2026-06-12T09:30:24.955Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/2c/1bf0b7b5a8442e5e12ba10e8813fc6c14095bda981a8436b3459e5194d9f/reachy_mini_motor_controller-1.5.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:22d8c63971e3c45a70fda2aab1a1c0515ddf9c08c9b4f63ebe83ab0ac14a774f", size = 645374, upload-time = "2026-06-12T09:30:30.152Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/8d/f0f45568d410787adbb94301ca255444f02d3fc1613bb3b42d5571c2c5d9/reachy_mini_motor_controller-1.5.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:28b1010e7f3ce6791c9d0ffa383cda45b9bf0856ffb8c92aadee620427ea9f35", size = 807217, upload-time = "2026-06-12T09:30:46.739Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/09/0f99a0cc6b2f19528eb6d88879eee83c7aeae5f16c1b0645488a2bf19570/reachy_mini_motor_controller-1.5.6-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:23decce256d1bf60ecfe71bda6dbb92d0a28483eef72e60a383211dddfc4580e", size = 909726, upload-time = "2026-06-12T09:30:53.442Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/95/dfaa7e832565a51d92802e49c77d11a352d0680bf29984ed5bfb49a72f37/reachy_mini_motor_controller-1.5.6-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:79c9ed6821f32726d7c8b47513d72abc894af38809d9075ec6c257fc7e82d34b", size = 886033, upload-time = "2026-06-12T09:31:00.805Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/51/d6c2b7e65533de969d67b4a191ccee3af9270702bfa5ae1408b925f3c01a/reachy_mini_motor_controller-1.5.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82aa50018b85af48505d5eaec38736ec7b6c42777f7b9050e5d0c739dcc6287", size = 840278, upload-time = "2026-06-12T09:31:07.066Z" },
+ { url = "https://files.pythonhosted.org/packages/1a/61/f3cd6eec54fcecb12846c3887ed6aa63132ff38cc9a67a6bc411263e3c6e/reachy_mini_motor_controller-1.5.6-cp312-cp312-win32.whl", hash = "sha256:e9e298da19bd5870911928947942b572784c2d2c3326f23e7ffc950af00abcf4", size = 372996, upload-time = "2026-06-12T09:31:20.931Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/4e/ff8d9cdf3a7fa3f1080f90508c3cddb2721be69aa6bd791eca2f7463ae17/reachy_mini_motor_controller-1.5.6-cp312-cp312-win_amd64.whl", hash = "sha256:cf54f2cba84ce7cd9c75e6829c640d68b79c55874913465ba9000b0ba3d19480", size = 396894, upload-time = "2026-06-12T09:31:13.903Z" },
+ { url = "https://files.pythonhosted.org/packages/50/37/b700779822e1a945fcb9ffb6ad283729e175e8d462deefdb0ae6f7201d5f/reachy_mini_motor_controller-1.5.6-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:b862a6adfac86d55ef0057640f7fb51359b8291773f8af97714450778677ff38", size = 569929, upload-time = "2026-06-12T09:30:42.187Z" },
+ { url = "https://files.pythonhosted.org/packages/67/e4/2bebbeab12750cc3153c13e01d5bdc1be0c244d90d916048a194cfb35eba/reachy_mini_motor_controller-1.5.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5cc674f714814ad42e335f4a6cae44920788525850e03fb9a3cc27c598763452", size = 558219, upload-time = "2026-06-12T09:30:36.409Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/bc/915c0a0acebeb72e69973ec88ad45bcd2c9e29befadc86c497c9c46112a2/reachy_mini_motor_controller-1.5.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ba20d03cebcbe2a972a9eb5e8e24c8f45440c3ce36235eaacec20fbd90cf42f", size = 632213, upload-time = "2026-06-12T09:30:16.404Z" },
+ { url = "https://files.pythonhosted.org/packages/87/73/e08d9cbfa352908cdb5e9d13300de1b314a39290c23955995e7c7fc30fc3/reachy_mini_motor_controller-1.5.6-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:db644cefbcb84bf91bf2e9b966f4676c6cbeae21ed664d2faf6e5dbd77de9136", size = 642982, upload-time = "2026-06-12T09:30:21.466Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/60/dd58b7fe025a5281560fb680cd37c7e0d068b932826b274d3cd9dca3aa02/reachy_mini_motor_controller-1.5.6-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ba5b740906fd4deb9c5bf66b931cfaf5dd56cb16229b9a7bea174cc04d41020f", size = 689515, upload-time = "2026-06-12T09:30:26.108Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/30/03f5c98510f73bcf928222c1ec54a4ba6ac5cb56551b5d7d4f5c5213a368/reachy_mini_motor_controller-1.5.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:316619070f19b2fc16d95c9f3d66e1e894da977781e095f175461366c74a8826", size = 645291, upload-time = "2026-06-12T09:30:31.447Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/6b/e08aaaeaa93c0d3a82424a410aa827fbf1d602d5fa25d4781f0494be3ccb/reachy_mini_motor_controller-1.5.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:57d1b530e9f12a875a1a78b1904c5fcecd29ae17e1ca36919f7bee211f37a0e8", size = 806980, upload-time = "2026-06-12T09:30:48.053Z" },
+ { url = "https://files.pythonhosted.org/packages/92/72/a396fbe6664e633c859b780c2ae0bb6977ebadf2e4e137a8e4d16a5f612a/reachy_mini_motor_controller-1.5.6-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:5fa0495b928f29fb3d31e10165f27acd2ed36535401324506526741d468009d3", size = 908648, upload-time = "2026-06-12T09:30:54.692Z" },
+ { url = "https://files.pythonhosted.org/packages/54/93/0aa35a664b05a66b9407ae743dafdf6db94cd76ca144478f057892a50a45/reachy_mini_motor_controller-1.5.6-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:903e6c0cb09834204f4062610e2ab4b6cf8e48caefd67500113ed35d5f6feae6", size = 885267, upload-time = "2026-06-12T09:31:01.965Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/33/d240e292239610a08e851e36690908ebab88904f0f3f8538b750a2788222/reachy_mini_motor_controller-1.5.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ed576321d4ec1b477c2fc9d076aaef91f7371ebdabbf717755a4fe40d6da0a6d", size = 839783, upload-time = "2026-06-12T09:31:08.153Z" },
+ { url = "https://files.pythonhosted.org/packages/de/86/1a5f849dc6fafa9748ba1f979aebdce48ca1ff459aafa8fbcf7e4358f50b/reachy_mini_motor_controller-1.5.6-cp313-cp313-win32.whl", hash = "sha256:e3eeac23143f1cf109085a80a999fcc864a07d721bed8776ab942431a60cf1e8", size = 372272, upload-time = "2026-06-12T09:31:22.035Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/bf/9546a871635f3d2fe47a35a0da0e18d48c93fbc2e237768d62cfe4ed0bfa/reachy_mini_motor_controller-1.5.6-cp313-cp313-win_amd64.whl", hash = "sha256:431838552818141b0d56275617720157a1035de8333cd00a3b2b9eeeb7ae8f45", size = 396213, upload-time = "2026-06-12T09:31:15.147Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/82/a4e44395e80ec66dd9d3c877a75d317b68a82924e96a2bdd1a084d5add9e/reachy_mini_motor_controller-1.5.6-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:7bab160dcec43d2d6a623f00f178e624cf8087716fa4cac682c5c0de7c646223", size = 568323, upload-time = "2026-06-12T09:30:43.316Z" },
+ { url = "https://files.pythonhosted.org/packages/9f/b3/260aefa34f89371ace0944002c41f0f0041033c758ec03039fa5154c3f5b/reachy_mini_motor_controller-1.5.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:93148af90a25cf6d8486ff24b5fbee0f69216128ce5f1f22e9a24b7726c8c4e9", size = 557477, upload-time = "2026-06-12T09:30:37.555Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/dd/3d906de2b65b7a249edee690585059617d502c73e3abfab66ee4753cf754/reachy_mini_motor_controller-1.5.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ce26faee9da6eb17397ac601e01b3f56291f41745b41fb3092859cacf8391f03", size = 807295, upload-time = "2026-06-12T09:30:49.337Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/25/2937439d29e4d32ac3908f2515f88022ce3ee0b3931d1e2e256aea38b110/reachy_mini_motor_controller-1.5.6-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:aaf657c2d69cf27936db0301dc558424535a9c4108556b311db4bd79ac81be61", size = 906731, upload-time = "2026-06-12T09:30:56.214Z" },
+ { url = "https://files.pythonhosted.org/packages/49/de/f0f4845a862ab2ee85e51e0250113a4157a2036d5bae5a2339ec71aadf59/reachy_mini_motor_controller-1.5.6-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ddeac7dd000778950baa60fba4c31374a20e8108656332937d24f897734a7c00", size = 885538, upload-time = "2026-06-12T09:31:03.116Z" },
+ { url = "https://files.pythonhosted.org/packages/03/5b/bc42869c4a4052ed5672e677a488ca3d88d3322535d26dccb4b5d2f01f95/reachy_mini_motor_controller-1.5.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7cea162753609a4b2214fb57d409ad73a3618eb59c7c039ce13a311465546e3f", size = 840320, upload-time = "2026-06-12T09:31:09.372Z" },
+ { url = "https://files.pythonhosted.org/packages/b2/f8/59dab3e04fcfca3039829bb73bcb1517c6a54403300e25b3158c9f1678ac/reachy_mini_motor_controller-1.5.6-cp314-cp314-win32.whl", hash = "sha256:9674726d6c9d9e534d4b17ea8f58063a59266bcd1a0cc1eb929a28f7f8996ff2", size = 372198, upload-time = "2026-06-12T09:31:23.253Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/d5/0e6d79354aa49ba44df71342a52c1ca8d0b0dd41dbc056e21477126d0c1c/reachy_mini_motor_controller-1.5.6-cp314-cp314-win_amd64.whl", hash = "sha256:468ceeca6970d05758e5cdba1e98a173b39caa09c9979931df311c2fd1f9e92c", size = 394670, upload-time = "2026-06-12T09:31:16.145Z" },
+]
+
+[[package]]
+name = "reachy-mini-rust-kinematics"
+version = "1.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/80/c6/3eb42a0d760ab3c9289963b8d08c1214bd84048ffb098f1ef1cb769e24c1/reachy_mini_rust_kinematics-1.0.3.tar.gz", hash = "sha256:9a01d8335854f308e88ab621bc50e0d2437f56e84c0f1e31f9aa93ae2dfcd15c", size = 16814, upload-time = "2025-12-04T11:53:46.816Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6c/db/66dfefea6cbac47eca53c098f4cc473cd6b39b9138f85a5e3f327f51e2da/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:72db0e164ca6d208feb451c71cfb3dbcaf796ac6e337f1c744c0a168a0334014", size = 304146, upload-time = "2025-12-04T11:52:41.235Z" },
+ { url = "https://files.pythonhosted.org/packages/71/1e/8ce70d974aed942a6c18dacdc574eba4962e85d70373cd004fc4ee3f9de7/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:02f2e94ffae1d4d6ebfe40f80fd332fa7d9d6c28db78ee431aeeabd022ba51d7", size = 284209, upload-time = "2025-12-04T11:52:34.253Z" },
+ { url = "https://files.pythonhosted.org/packages/22/54/3856cd785a55efa381c1f3e1df95e6e4e9a8b5605ef13e192d2754f6f115/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb8b20752e7251ac371c10f8b9d397aaa466791384e6b3393a085e4036782f4a", size = 322076, upload-time = "2025-12-04T11:51:47.469Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/58/57000b3813a28eefa8664914e90608830ac565e9f23a229baa4132f50404/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b1d33f21c2217cd4baf524002e4cd27f88fbb29b8e3541a4247d57c21fea4313", size = 328353, upload-time = "2025-12-04T11:52:01.563Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/65/c536c0511c89c1c1ff87d00721178a58d34440c2c7fbe6a212ae11f2fde8/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d534ede3f4233a834697a9819543c216c28a625a6f0b0b7c6e2bbc79629d15f9", size = 344673, upload-time = "2025-12-04T11:52:25.922Z" },
+ { url = "https://files.pythonhosted.org/packages/3f/d7/12ce7cc08a9b60779b87253c776d4703c24ba102bb58b77ee537497fe41c/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43d904426da598e4eec4cc521d417781b6f85c5d68f2ec4401e76633852f1cad", size = 358603, upload-time = "2025-12-04T11:52:16.473Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/d2/73b8f939b6a1a31800500d438ba0a3aea18cf606eb98f2c4b305967a1482/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8915a40a6deed81f703cb57b484a4aa28a08ed33f847a419f6bd712882f976f5", size = 504661, upload-time = "2025-12-04T11:52:49.545Z" },
+ { url = "https://files.pythonhosted.org/packages/10/e3/59d9fba96edb3ad105406b158125ca252e8328a05730ad1ca01f23ef0596/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:780a2282db5943b8f23d44addd63ba5eba6a2171616e95c130e6ddb28580a3f7", size = 595542, upload-time = "2025-12-04T11:53:03.503Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/11/582615d4fc4d385af45551e085c7bf5f8abf19e4d2d97a30c59fb6426267/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:8e99c64a83cecc5e865996ee57388bbe0287f0c094bfcd228c3a0b4f814151fc", size = 539319, upload-time = "2025-12-04T11:53:18.454Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/54/99632a4e68471b130e3e06831ffa8132f47b810135dfc0db50e5eca61b52/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:053afeb81f8b7a50c7b1e4656cf1f913f8edbce75b1ed8a25e7e3d0fd21a3df9", size = 510197, upload-time = "2025-12-04T11:53:33.72Z" },
+ { url = "https://files.pythonhosted.org/packages/29/9d/c780551851f708d2326417caa14f2db4f6d744d9f29e6e79f5156bfc212c/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-win32.whl", hash = "sha256:63f709c6ca89ed2ad13ef627f642d54cb62ba9f36d2b5a59ca45bdf0157a323a", size = 180088, upload-time = "2025-12-04T11:53:57.096Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/93/ba9c27b92ba5c0b88099d373fefc432743e4934fa5d04b36d8a7904ee8fc/reachy_mini_rust_kinematics-1.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:9641dfb2da62edc7d4e645ee2c0bf0a6771cf38cf5c0959723bd3741d791bc46", size = 194540, upload-time = "2025-12-04T11:53:49.53Z" },
+ { url = "https://files.pythonhosted.org/packages/63/bb/a6f0b8d79f2e9940569e15b41e95d830e6c836d9ba89050caf45d2cbde3b/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:849cdf6e0369b15266d5dacbd3764f443266fc99a92d50fb34c47ec0fd13e51f", size = 304420, upload-time = "2025-12-04T11:52:42.279Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/f7/895f4aa372063b344c371b2cbf605ef970aa7e4c929583da7ac97753f903/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9597dedeee7f7aaa12cfb5f8a6e763e5f8943a268aa70de40eba477744fbfadd", size = 284395, upload-time = "2025-12-04T11:52:35.258Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/c5/af236ce840aa330e97bf1055b9ce7ac312b6157c83a77842c2d29d3b95c7/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc1d2c9699b57369e7d567a303d8a2d6528ad8d15498bb5d0f4b99581bd3ac9e", size = 322304, upload-time = "2025-12-04T11:51:48.743Z" },
+ { url = "https://files.pythonhosted.org/packages/29/d9/d67dc39c25145c2890781014a7c1b050bfa66e1fa3608daade904dba339a/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:00836c5dd997e91f4ba619be3cd4324cbba41a2125034756e53c86b735356ff9", size = 328372, upload-time = "2025-12-04T11:52:03.237Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/cf/ff038a1792b112bdc4b917b05aa0966bb3aa40a61c9d9bdccfdddd3e6fb8/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4feb3a29e5b3496d013cd9f680278bab85b4d11f2cfd5b0c0d33d9759ff68fc0", size = 344354, upload-time = "2025-12-04T11:52:26.907Z" },
+ { url = "https://files.pythonhosted.org/packages/5a/e4/c7534b3af624838a2cbe2c82b95507e086f85f28e27e2a9ec92ced885aaa/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f867a989211f757dffb53677d805ea5ff083a386b6099e22fac5465c4e54667", size = 358493, upload-time = "2025-12-04T11:52:17.526Z" },
+ { url = "https://files.pythonhosted.org/packages/92/d8/20b9287afa428310dd2f166090ed7f0672ccfbec6d2c20ce52105e0d0ee4/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a6b18ced7ff9f8c8f8ee19a74590168ed52495b43e25681889a77840fb15ef20", size = 504808, upload-time = "2025-12-04T11:52:50.625Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/77/4935fc49a179e3d5b61d18b4cea5cc3780d5ebb40159ff2432590db8c74b/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:57f140128d410adca43a3ee2648ed36a9c071a32b40871ac46ae1fbc22cbced2", size = 595604, upload-time = "2025-12-04T11:53:04.577Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/36/bd1a4506890f2e75ebec6d8e047720b170d20c53c351d57a932c461ae152/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:3023f96041eab7c6304c27e93eface6fa62f21e35ba2993073a89711883e7da6", size = 538870, upload-time = "2025-12-04T11:53:19.485Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/08/32041210bf6b6cb53e7da19aebe14d06715ed6d427580ad7d0de6f60c954/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa8811d43cf4119cbfb9db0dbe668fd76b2f1d1a1efb1425a082cdd3a73b231e", size = 510356, upload-time = "2025-12-04T11:53:34.819Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/20/491494373bbb8f66ab8b52e5bc40543c40d1a092f8e0978fe9318cb74518/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-win32.whl", hash = "sha256:be459e5311f15c2a25dbc38b456432f5921712bb44e81a6ac8925e169f197cf5", size = 179653, upload-time = "2025-12-04T11:53:58.335Z" },
+ { url = "https://files.pythonhosted.org/packages/40/76/dedd935bb89c1a051e3a7be474289643b6b3902a7587f92adf6c961d78bb/reachy_mini_rust_kinematics-1.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:565beb1aec3546adb0088d3a88c3b2eb4a370669b467083140aab2d2727e630d", size = 194374, upload-time = "2025-12-04T11:53:50.555Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/73/06bee4942d780bf6c5ce985a3f4c1e3abbdbb64e112347d3d48a4f70c90f/reachy_mini_rust_kinematics-1.0.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd180c10f53a5db5c124b354f8ba19e1ff5dd4270885bbe8e5c9361c7ecdb514", size = 321333, upload-time = "2025-12-04T11:51:49.757Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/f5/8ccf95c3f0309b2ef9ec47565464de0e2f3407c83c8560d31e07eb8b73d7/reachy_mini_rust_kinematics-1.0.3-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:557547f2a1e92fc656dd8d089b79f7c37ecbc9dceeb860a65b0b0bb03575b9af", size = 327293, upload-time = "2025-12-04T11:52:04.25Z" },
+ { url = "https://files.pythonhosted.org/packages/51/27/330c2d1d35e860cae81b9bb0e05d8fcddbb802c49a0491e7cce1c8c6f93d/reachy_mini_rust_kinematics-1.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d51cfdcae7705b17134ad8776078efaa84864ce550ef97bff73a9b0d1388dc62", size = 503784, upload-time = "2025-12-04T11:52:51.758Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/85/6172abe4d57723721383bee0288067a0e40d1f054eca961ca8493e0193d9/reachy_mini_rust_kinematics-1.0.3-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:cf0303d853179124a0d81e2e15c893f3092a7e01b619caaac9da9ef220a88ace", size = 594467, upload-time = "2025-12-04T11:53:05.701Z" },
+ { url = "https://files.pythonhosted.org/packages/79/44/900e3d4f2d7481a541be99bb261fd1f9b26ae5b03f703db9f4fa86de8a5c/reachy_mini_rust_kinematics-1.0.3-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:81e9ead617777d465c4c8e1448e413c365007def381ae033ab4ca733e1153e8c", size = 538803, upload-time = "2025-12-04T11:53:21.88Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/c9/54b90ed6edff4cec9304c4be07e6f506f399fd8a33465ff8250ee09acd1a/reachy_mini_rust_kinematics-1.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ffb37ff2e1a2eba7309aaa2094ac087f653567ec69032091296c26f52ec98a8f", size = 509904, upload-time = "2025-12-04T11:53:36.178Z" },
+ { url = "https://files.pythonhosted.org/packages/88/f2/4eea50be5c971a7adbfce8608fd75b0366f82852b563f33390dee44ff441/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:740e360bc6fd8399319b397eda669295fb9bd666f0e57cd031a268c803512f5d", size = 284416, upload-time = "2025-12-04T11:52:36.268Z" },
+ { url = "https://files.pythonhosted.org/packages/26/46/2d72ae898519011ce75d9d55c4dd79735585815915efb1ae986e4d35455a/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b31dcd9fc5cc57a8de5a6e5e7e638e903bd46940376d085a049da0abde409a9", size = 322375, upload-time = "2025-12-04T11:51:50.729Z" },
+ { url = "https://files.pythonhosted.org/packages/db/65/8214814b87a269622d4583bdfe883f15d1cf238ebfd70ddb4fb1d6dfd6e4/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:82b150dedfbb2b426cd57d3e7a0db67198d406e98cdf45dfbca8942eee770336", size = 328925, upload-time = "2025-12-04T11:52:05.273Z" },
+ { url = "https://files.pythonhosted.org/packages/0b/cf/21fc44ddf938a43a9bab1e63f582858e8d320ad7a064b42d5c45a007099f/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b3dd2b08ac16f9cd9625e14cfab93468e76e52d1d3480af4891cfa4eaa26e52c", size = 344727, upload-time = "2025-12-04T11:52:27.959Z" },
+ { url = "https://files.pythonhosted.org/packages/e0/68/580b194ce9a069ba5e606c5d902c05ffc34ef5fd786107fa457e75d02db5/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0da3a8cfef64be173a38835975ca5f9154435340ebaa114ddd0e3bf257aafed4", size = 359619, upload-time = "2025-12-04T11:52:18.958Z" },
+ { url = "https://files.pythonhosted.org/packages/b0/b9/f8d0412d5d9895ecdb27f15f2724a7207f594298c5bac4deba229d1fb394/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8faa37c93e8e102734cd849326a1499707e3d7d1d06692c1a0b23dd16bc57b7", size = 505000, upload-time = "2025-12-04T11:52:52.99Z" },
+ { url = "https://files.pythonhosted.org/packages/fe/72/193e0d801ce2ea1ac30f7e0b195f586fcb0ae8c1c59c2553ef1eb70226f9/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:692427b71e4f58de2a6775d9692f57dac4b20e5a59b7d6e10f0441de749cc282", size = 596009, upload-time = "2025-12-04T11:53:06.894Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/3c/9462608f1553ebac976fe1020f3cb4fd1ee254c10984737814b1fad61700/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:29acbdad8a806a1a6d41739577e377b5f21d06230428c619702a46e351e8f23e", size = 539688, upload-time = "2025-12-04T11:53:22.994Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/28/7e643650fb785320554c316bba73728bfa2a9f8c733966ae3990774c612e/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6f107dbe88903160c6b76b65b618d455efbd6ddee288bea6ed0cc908e9d922a1", size = 510771, upload-time = "2025-12-04T11:53:37.227Z" },
+ { url = "https://files.pythonhosted.org/packages/13/00/69b75b717270f4371a8f65e784a8069f96341a5f7efcd295aac6ba5818df/reachy_mini_rust_kinematics-1.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:eaaa8b18899792382208eadaa900f069b52ccdac7716ba66c247f3569210e65d", size = 194458, upload-time = "2025-12-04T11:53:51.894Z" },
+ { url = "https://files.pythonhosted.org/packages/56/47/d86244d32847d9ec2980d2dfdd9d023e49dc35ae1e4204b2a80ccba15bcc/reachy_mini_rust_kinematics-1.0.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d038b9a1e93cc6be40d0922a3cf2f43956134e9e47f4bd849d8bf18ccf7951fa", size = 321536, upload-time = "2025-12-04T11:51:52.063Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/c4/f1c4bec367f5191fa3b33ed4bf0931c58fe3029adc4e58887c3dc39be39f/reachy_mini_rust_kinematics-1.0.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:814cf062f3a9ffc5f0236e5ac7a20d85661b663b6f1f9c24672d76a6b2484cbf", size = 327597, upload-time = "2025-12-04T11:52:06.512Z" },
+ { url = "https://files.pythonhosted.org/packages/11/3d/95245794ff28358321bb4a65070598c19c836c42f37752e568efd2f5e6a7/reachy_mini_rust_kinematics-1.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ab43f162fbb35bb0a9ef2af3cca7bb26236b68cef701c740a7fe26ea9ae70b4c", size = 504014, upload-time = "2025-12-04T11:52:54.138Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/11/4f64945a4e3765d2a5f0259eba5c724e55287f68526e4f0fe6ac61196c8f/reachy_mini_rust_kinematics-1.0.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:f388d5dd9353ef65dcad32000c1a6c1c86587d7f04449d559476310be955b6b6", size = 595139, upload-time = "2025-12-04T11:53:08.047Z" },
+ { url = "https://files.pythonhosted.org/packages/a8/80/720a3e29baee0a38ee69641f16aff58217fadea4693613795bad893e5f7e/reachy_mini_rust_kinematics-1.0.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:50076bc0c75a766e99e984686eaaec36e1b6fb27fba25b58f2f77262df326da9", size = 538654, upload-time = "2025-12-04T11:53:24.349Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/43/77df8f4446309af9c5a9d1c886d72a2a80ebb0e07169573b34feb62307ea/reachy_mini_rust_kinematics-1.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a0757d99af12cfeb84bd039e9f4b42679b688ff0fd58b0ec89b8f6c787add55e", size = 510099, upload-time = "2025-12-04T11:53:39.303Z" },
+]
+
+[[package]]
+name = "reachy-mini-toolbox"
+version = "1.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/30/b18ab0771b276ab9ba4e0071f5f8f81818b362574644e95bacd9eae2a4c2/reachy_mini_toolbox-1.1.2.tar.gz", hash = "sha256:0f9d7591e40cc9a5a19e01a32301b67a04e7dcc5af49e7b45adb85065ec37e56", size = 9789, upload-time = "2025-12-07T09:34:26.154Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e5/74/3507b27191937b013184e2e4bfc7868c8ab0d91e1578d22a0243b19754bc/reachy_mini_toolbox-1.1.2-py3-none-any.whl", hash = "sha256:ee9c4de4428292e19a90e02cc2d3b6e36c26538ef4dfccbfb7cbbd89a656071b", size = 10601, upload-time = "2025-12-07T09:34:24.824Z" },
+]
+
+[[package]]
+name = "referencing"
+version = "0.37.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "attrs" },
+ { name = "rpds-py" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/2c/58/ca301544e1fa93ed4f80d724bf5b194f6e4b945841c5bfd555878eea9fcb/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231", size = 26766, upload-time = "2025-10-13T15:30:47.625Z" },
+]
+
+[[package]]
+name = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "certifi" },
+ { name = "charset-normalizer" },
+ { name = "idna" },
+ { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[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 = "rpds-py"
+version = "2026.6.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/2a/9618a122aeb2a169a28b03889a2995fe297588964333d4a7d67bdf46e147/rpds_py-2026.6.3.tar.gz", hash = "sha256:1cebd1337c242e4ec2293e541f712b2da849b29f48f0c293684b71c0632625d4", size = 64051, upload-time = "2026-06-30T07:17:53.009Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5c/be/2e8974163072e7bab7df1a5acd54c4498e75e35d6d18b864d3a9d5dadc92/rpds_py-2026.6.3-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a0811d33247c3d6128a3001d763f2aa056bb3425204335400ac54f89eec3a0d0", size = 343691, upload-time = "2026-06-30T07:15:14.96Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/73/319dfa745dd668efe89309141ded489126461fcecd2b8f3a3cda185129b6/rpds_py-2026.6.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:538949e262e46caa31ac01bdb3c1e8f642622922cacbabbae6a8445d9dc33eaf", size = 338542, upload-time = "2026-06-30T07:15:16.267Z" },
+ { url = "https://files.pythonhosted.org/packages/21/63/4239893be1c4d09b709b1a8f6be4188f0870084ff547f46606b8a75f1b03/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55927d532399c2c646100ff7feb48eaa940ad70f42cd68e1328f3ded9f81ca24", size = 368180, upload-time = "2026-06-30T07:15:17.62Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/ca/9c5de382225234ceb37b1844ebdb140db12b2a278bb9efe2fcd19f6c82ce/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f56f1695bc5c0871cbc33dc0130fcf503aab0c57dcc5a6700a4f49eba4f2652e", size = 375067, upload-time = "2026-06-30T07:15:18.952Z" },
+ { url = "https://files.pythonhosted.org/packages/87/dc/863f69d1bf04ade34b7fe0d59b9fdf6f0135fe2d7cbca74f1d665589559d/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:270b293dae9058fc9fcedab50f13cebf46fb8ed1d1d54e0521a9da5d6b211975", size = 490509, upload-time = "2026-06-30T07:15:20.434Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/ef/eac16a12048b45ec7c7fa94f2be3438a5f26bf9cc8580b18a1cfd609b7f6/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:127565fead0a10943b282957bd5447804ff3160ad79f2ad2635e6d249e380680", size = 382754, upload-time = "2026-06-30T07:15:21.831Z" },
+ { url = "https://files.pythonhosted.org/packages/04/8f/d2f3f532616be4d06c316ef119683e832bd3d41e112bf3a88f4151c95b17/rpds_py-2026.6.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecabd69db66de867690f9797f2f8fa27ba501bbc24540cbdbdc649cd15888ba6", size = 366189, upload-time = "2026-06-30T07:15:23.371Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/29/41a7b0e98a4b44cd676ab7598419623373eb43b20be68c084935c1a8cf88/rpds_py-2026.6.3-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:58eadac9cd119677b60e1cf8ac4052f35949d71b8a9e5556efccbe82533cf22a", size = 377750, upload-time = "2026-06-30T07:15:24.659Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/05/ecda0bec46f9a1565090bcdc941d023f6a25aff85fda28f89f8d19878152/rpds_py-2026.6.3-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:7491ee23305ac3eb59e492b6945881f5cd77a6f731061a3f25b77fd40f9e99a4", size = 395576, upload-time = "2026-06-30T07:15:25.987Z" },
+ { url = "https://files.pythonhosted.org/packages/68/a8/6ed52f03ee6cb854ce78785cc9a9a672eb880e83fd7224d471f667d151f1/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2c99f7e8ccb3dd6e3e4bfeac657a7b208c9bac8075f4b078c02d7404c34107fa", size = 543807, upload-time = "2026-06-30T07:15:27.356Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/d6/156c0d3eea27ba09b92562ba2364ba124c0a061b199e17eac637cd25a5e2/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:62698275682bf121181861295c9181e789030a2d516071f5b8f3c23c170cd0fc", size = 611187, upload-time = "2026-06-30T07:15:28.931Z" },
+ { url = "https://files.pythonhosted.org/packages/f1/31/774212ed989c62f7f310220089f9b0a3fb8f40f5443d1727abd5d9f52bc9/rpds_py-2026.6.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a214c993455f99a89aaeadc9b21241900037adc9d97203e374d75513c5911822", size = 573030, upload-time = "2026-06-30T07:15:30.553Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/50/22f73127a41f1ce4f87fe39aadfb9a126345801c274aa93ae88456249327/rpds_py-2026.6.3-cp312-cp312-win32.whl", hash = "sha256:501f9f04a588d6a09179368c57071301445191767c64e4b52a6aa9871f1ef5ed", size = 202185, upload-time = "2026-06-30T07:15:32.027Z" },
+ { url = "https://files.pythonhosted.org/packages/04/3a/f0ee4d4dde9d3b69dedf1b5f74e7a40017046d55052d173e418c6a94f960/rpds_py-2026.6.3-cp312-cp312-win_amd64.whl", hash = "sha256:2c958bf94822e9290a40aaf2a822d4bc5c88099093e3948ad6c571eca9272e5f", size = 220394, upload-time = "2026-06-30T07:15:33.359Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/83/3382fe37f809b59f02aac04dbc4e765b480b46ee0227ed516e3bdc4d3dfc/rpds_py-2026.6.3-cp312-cp312-win_arm64.whl", hash = "sha256:22bffe6042b9bcb0822bcd1955ec00e245daf17b4344e4ed8e9551b976b63e96", size = 215753, upload-time = "2026-06-30T07:15:34.778Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/9e/b818ee580026ec578138e961027a68820c40afeb1ec8f6819b54fb99e196/rpds_py-2026.6.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:3cfe765c1da0072636ca06628261e0ea05688e160d5c8a03e0217c3854037223", size = 343012, upload-time = "2026-06-30T07:15:36.005Z" },
+ { url = "https://files.pythonhosted.org/packages/f3/6b/686d9dc4359a8f163cfbbf89ee0b4e586431de22fe8248edb63a8cf50d49/rpds_py-2026.6.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f4d78253f6996be4901669ad25319f842f740eccf4d58e3c7f3dd39e6dde1d8f", size = 338203, upload-time = "2026-06-30T07:15:37.462Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/9b/069aa329940f8207615e091f5eedbbd40e1e15eac68a0790fd05ccdf796c/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:54f45a148e28767bf343d33a684693c70e451c6f4c0e9904709a723fafbdfc1f", size = 367984, upload-time = "2026-06-30T07:15:39.008Z" },
+ { url = "https://files.pythonhosted.org/packages/14/db/34c203e4becff3703e4d3bc121842c00b8689197f398161203a880052f4e/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:842e7b070435622248c7a2c44ae53fa1440e073cc3023bc919fed570884097a7", size = 374815, upload-time = "2026-06-30T07:15:40.253Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/7d/8071067d2cc453d916ad836e828c943f575e8a44612537759002a1e07381/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8020133a74bd81b4572dd8e4be028a6b1ebcd70e6726edc3918008c08bee6ee6", size = 490545, upload-time = "2026-06-30T07:15:41.729Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/42/da06c5aa8f0484ff07f270787434204d9f4535e2f8c3b51ed402267e63c3/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cdc7e35386f3847df728fbcb5e887e2d79c19e2fa1eba9e51b6621d23e3243af", size = 382828, upload-time = "2026-06-30T07:15:43.327Z" },
+ { url = "https://files.pythonhosted.org/packages/57/d7/fe978efc2ae50abe48eb7464668ea99f53c010c60aeebb7b35ad27f23661/rpds_py-2026.6.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acac386b453c2516111b50985d60ce46e7fadb5ea71ae7b25f4c946935bf27cf", size = 365678, upload-time = "2026-06-30T07:15:44.992Z" },
+ { url = "https://files.pythonhosted.org/packages/69/9d/1d8922e1990b2a6eb532b6ff53d3e73d2b3bbffc84116c75826bee73dfc6/rpds_py-2026.6.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:425560c6fa0415f27261727bb20bd097568485e5eb0c121f1949417d1c516885", size = 377811, upload-time = "2026-06-30T07:15:46.523Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/3d/198dceafb4fb034a6a47347e1b0735d34e0bd4a50be4e898d408ee66cb14/rpds_py-2026.6.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a550fb4950a06dde3beb4721f5ad4b25bf4513784665b0a8522c792e2bd822a4", size = 395382, upload-time = "2026-06-30T07:15:47.955Z" },
+ { url = "https://files.pythonhosted.org/packages/1f/f1/13968e49655d40b6b19d8b9140296bbc6f1d86b3f0f6c346cf9f1adddf4b/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4f4bca01b63096f606e095734dd56e74e175f94cfbf24ff3d63281cec61f7bb7", size = 543832, upload-time = "2026-06-30T07:15:49.33Z" },
+ { url = "https://files.pythonhosted.org/packages/ac/ab/289bcb1b90bd3e40a2900c561fa0e2087345ecbb094f0b870f2345142b7c/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ccffae9a092a00deb7efd545fe5e2c33c33b88e7c054337e9a74c179347d0b7d", size = 611011, upload-time = "2026-06-30T07:15:50.847Z" },
+ { url = "https://files.pythonhosted.org/packages/1e/16/5043105e679436ccfbc8e5e0dd2d663ed18a8b8113515fd06a5e5d77c83e/rpds_py-2026.6.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1cf01971c4f2c5553b772a542e4aaf191789cd331bc2cd4ff0e6e65ba49e1e97", size = 572431, upload-time = "2026-06-30T07:15:52.394Z" },
+ { url = "https://files.pythonhosted.org/packages/85/ed/adab103321c0a6565d5ae1c2998349bc3ee175b82ccc5ae8fc04cc413075/rpds_py-2026.6.3-cp313-cp313-win32.whl", hash = "sha256:8c3d1e9c15b9d51ca0391e13da1a25a0a4df3c58a37c9dc368e0736cf7f69df0", size = 201710, upload-time = "2026-06-30T07:15:53.894Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/ed/a03b09668e74e5dabbf2e211f6468e1820c0552f7b0500082da31841bf7b/rpds_py-2026.6.3-cp313-cp313-win_amd64.whl", hash = "sha256:9250a9a0a6fd4648b3f868da8d91a4c52b5811a62df58e753d50ae4454a36f80", size = 219454, upload-time = "2026-06-30T07:15:55.25Z" },
+ { url = "https://files.pythonhosted.org/packages/27/17/b8642c12930b71bc2b25831f6708ccf0f75abcd11883932ec9ce54ba3a78/rpds_py-2026.6.3-cp313-cp313-win_arm64.whl", hash = "sha256:900a67df3fd1660b035a4761c4ce73c382ea6b35f90f9863c36c6fd8bf8b09bb", size = 215063, upload-time = "2026-06-30T07:15:56.573Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/36/7fbe9dcdaf857fb3f63c2a2284b62492d95f5e8334e947e5fb6e7f68c9be/rpds_py-2026.6.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:931908d9fc855d8f74783377822be318edb6dcb19e47169dc038f9a1bf60b06e", size = 344510, upload-time = "2026-06-30T07:15:57.921Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/54/f785cc3d3f60839ca57a5af4927a9f347b07b2799c373fc20f7949f87c7e/rpds_py-2026.6.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d7469697dce35be237db177d42e2a2ee26e6dcc5fc052078a6fefabd288c6edd", size = 339495, upload-time = "2026-06-30T07:15:59.238Z" },
+ { url = "https://files.pythonhosted.org/packages/63/ef/d4cdaf309e6b095b43597103cf8c0b951d6cca2acce68c474f75ec12e0c7/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bcfbcf66006befb9fd2aeaa9e01feaf881b4dc330a02ba07d2322b1c11be7b5d", size = 369454, upload-time = "2026-06-30T07:16:01.021Z" },
+ { url = "https://files.pythonhosted.org/packages/96/4a/9559a68b7ee15db09d7981212e8c2e219d2a1d6d4faa0391d813c3496a36/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:847927daf4cffbd4e90e42bc890069897101edd015f956cb8721b3473372edda", size = 374583, upload-time = "2026-06-30T07:16:02.287Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/75/8964aa7d2c6e8ac43eba8eb6e6b0fdda1f46d39f2fc3e6aa9f2cb17f485d/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aca6c1ef08a82bfe327cc156da694660f599923e2e6665b6d81c9c2d0ac9ffc8", size = 492919, upload-time = "2026-06-30T07:16:03.723Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/97/6908094ac804115e65aedfd90f1b5fee4eebebd3f6c4cfc5419939267565/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ae50181a047c871561212bb97f7932a2d45fb53e947bd9b57ebad85b529cbc53", size = 383725, upload-time = "2026-06-30T07:16:05.305Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/9c/0d1fdc2e7aba23e290d603bc494e97bd205bae262ce33c6b32a69768ed5e/rpds_py-2026.6.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc319e5a1de4b6913aac94bf6a2f9e847371e0a140a43dd4991db1a09bc2d504", size = 367255, upload-time = "2026-06-30T07:16:07.086Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/fe/f0209ca4a9ed074bc8acb44dfd0e81c3122e94c9689f5645b7973a866719/rpds_py-2026.6.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e4316bf32babbed84e691e352faf967ce2f0f024174a8643c37c94a1080374fc", size = 379060, upload-time = "2026-06-30T07:16:08.525Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/8d/f1cc54c616b9d8897de8738aac148d20afca93f68187475fe194d09a71b9/rpds_py-2026.6.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:8c6e5a2f750cc71c3e3b11d71661f21d6f9bc6cebc6564b1466417a1ec03ec77", size = 395960, upload-time = "2026-06-30T07:16:09.989Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/04/aafff00f73aeca2945f734f1d483c64ab8f472d0864ab02377fd8e89c3b2/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4470ce197d4090875cf6affbf1f853338387428df97c4fb7b7106317b8214698", size = 545356, upload-time = "2026-06-30T07:16:11.816Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/cc/e229663b9e4ddac5a4acbe9085dd80a71af2a5d356b8b39d6bff233f24b0/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ea964164cc9afa72d4d9b23cc28dafae93693c0a53e0b42acbff15b22c3f9ddd", size = 612319, upload-time = "2026-06-30T07:16:13.586Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/7a/8a0e6d3e6cd066af108b71b43122c3fe158dd9eb86acac626593a2582eb1/rpds_py-2026.6.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:639c8929aa0afe81be836b04de888460d6bed38b9c54cfc18da8f6bfabf5af5d", size = 573508, upload-time = "2026-06-30T07:16:15.23Z" },
+ { url = "https://files.pythonhosted.org/packages/87/03/2a69ab618a789cf6cf85c86bb844c62d090e700ab1a2aa676b3741b6c516/rpds_py-2026.6.3-cp314-cp314-win32.whl", hash = "sha256:882076c00c0a608b131187055ddc5ae29f2e7eaf870d6168980420d58528a5c8", size = 202504, upload-time = "2026-06-30T07:16:16.893Z" },
+ { url = "https://files.pythonhosted.org/packages/85/62/a3892ba945f4e24c78f352e5de3c7620d8479f73f211406a97263d13c7d2/rpds_py-2026.6.3-cp314-cp314-win_amd64.whl", hash = "sha256:0be972be84cfcaf46c8c6edf690ca0f154ac17babf1f6a955a51579b34ad2dc5", size = 220380, upload-time = "2026-06-30T07:16:18.108Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/e7/c2bd44dc831931815ad11ebb5f430b5a0a4d3caa9de837107876c30c3432/rpds_py-2026.6.3-cp314-cp314-win_arm64.whl", hash = "sha256:2a9c6f195058cb45335e8cc3802745c603d716eb96bc9625950c1aac71c0c703", size = 215976, upload-time = "2026-06-30T07:16:19.654Z" },
+ { url = "https://files.pythonhosted.org/packages/79/9c/fff7b74bce9a091ec9a012a03f9ff5f69364eaf9451060dfc4486da2ffdd/rpds_py-2026.6.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:f90938e92afda60266da758ee7d363447f7f0138c9559f9e1811629580582d90", size = 346840, upload-time = "2026-06-30T07:16:21.268Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/44/77bcb1168b33704908295533d27f10eb811e9e3e193e8993dc99572211d3/rpds_py-2026.6.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ec829541c45bca16e61c7ae50c20501f213605beb75d1aba91a6ee37fbbb56a4", size = 340282, upload-time = "2026-06-30T07:16:22.875Z" },
+ { url = "https://files.pythonhosted.org/packages/87/3c/7a9081c7c9e645b39efe19e4ffbeccd80add246327cd9b888aecffd72317/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afd70d95892096cdb26f15a00c45907b17817577aa8d1c76b2dcc2788391f9e9", size = 370403, upload-time = "2026-06-30T07:16:24.415Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/69/af47021eb7dad6ff3396cb001c08f0f3c4d06c20253f75be6421a59fe6b7/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:29dfa0533a5d4c94d4dfa1b694fcb56c9c63aad8330ffdd816fd225d0a7a162f", size = 376055, upload-time = "2026-06-30T07:16:26.111Z" },
+ { url = "https://files.pythonhosted.org/packages/81/fc/a3bcf517084396a6dd258c592567a3c011ba4557f2fde23dceaf26e74f2e/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:af05d726809bff6b141be124d4c7ce998f9c9c7f30edb1f46c07aa103d540b41", size = 494419, upload-time = "2026-06-30T07:16:27.596Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/eb/13d529d1788135425c7bf207f8463458ca5d92e43f3f701365b83e9dffc1/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9826217f048f620d9a712672818bf231442c1b35d96b227a07eabd11b4bb6945", size = 384848, upload-time = "2026-06-30T07:16:29.183Z" },
+ { url = "https://files.pythonhosted.org/packages/8e/f4/b7ac49f30013aba8f7b9566b1dd07e81de95e708c1374b7bacc5b9bc5c9c/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:536bceea4fa4acf7e1c61da2b5786304367c816c8895be71b8f537c480b0ea1f", size = 371369, upload-time = "2026-06-30T07:16:30.912Z" },
+ { url = "https://files.pythonhosted.org/packages/31/86/6260bafa622f788b07ddec0e52d810305c8b9b0b8c27f58a2ab04bf62b4f/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:bc0011654b91cc4fb2ae701bec0a0ba1e552c0714247fa7af6c59e0ccfa3a4e1", size = 379673, upload-time = "2026-06-30T07:16:32.486Z" },
+ { url = "https://files.pythonhosted.org/packages/19/c3/03f1ee79a047b48daeca157c89a18509cde22b6b951d642b9b0af1be660a/rpds_py-2026.6.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:539d75de9e0d536c84ff18dfeb805398e58227001ce09231a26a08b9aed1ee0e", size = 397500, upload-time = "2026-06-30T07:16:34.471Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/95/8ed0cd8c377dca12aea498f119fe639fc474d1461545c39d2b5872eb1c0f/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:166cf54d9f44fc6ceb53c7860258dde44a81406646de79f8ed3234fca3b6e538", size = 545978, upload-time = "2026-06-30T07:16:36.45Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/f2/0eb57f0eaa83f8fc152a7e03de968ab77e1f00732bebc892b190c6eebde7/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d34c20167764fbcf927194d532dd7e0c56772f0a5f943fa5ef9e9afbba8fb9db", size = 613350, upload-time = "2026-06-30T07:16:38.213Z" },
+ { url = "https://files.pythonhosted.org/packages/5b/de/e0674bdbc3ef7634989b3f854c3f34bc1f587d36e5bfdc5c378d57034619/rpds_py-2026.6.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ea7bb13b7c9a29791f87a0387ba7d3ad3a6d783d827e4d3f27b40a0ff44495e2", size = 576486, upload-time = "2026-06-30T07:16:39.797Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/f6/21101359743cd136ada781e8210a85769578422ba460672eea0e29739200/rpds_py-2026.6.3-cp314-cp314t-win32.whl", hash = "sha256:6de4744d05bd1aa1be4ed7ea1189e3979196808008113bbbf899a460966b925e", size = 201068, upload-time = "2026-06-30T07:16:41.316Z" },
+ { url = "https://files.pythonhosted.org/packages/a6/b2/9574d4d44f7760c2aa32d92a0a4f41698e33f5b204a0bf5c9758f52c79d5/rpds_py-2026.6.3-cp314-cp314t-win_amd64.whl", hash = "sha256:c7b9a2f8f4d8e90af72571d3d495deebdd7e3c75451f5b41719aee166e940fc2", size = 220600, upload-time = "2026-06-30T07:16:43.091Z" },
+ { url = "https://files.pythonhosted.org/packages/08/ae/f23a2697e6ee6340a578b0f136be6483657bef0c6f9497b752bb5c0964bb/rpds_py-2026.6.3-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:e059c5dde6452b44424bd1834557556c226b57781dee1227af23518459722b13", size = 344726, upload-time = "2026-06-30T07:16:44.5Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/63/e7b3a1a5358dd32c930a1062d8e15b67fd6e8922e81df9e91706d66ee5c8/rpds_py-2026.6.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2f7c26fbc5acd2522b95d4177fe4710ffd8e9b20529e703ffbf8db4d93903f05", size = 339587, upload-time = "2026-06-30T07:16:46.255Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/64/10a85681916ca55fffb91b0a211f84e34297c109243484dd6394660a8a7c/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3086b538543802f84c843911242db20447de00d8752dd0efc936dbcf02218ba", size = 369585, upload-time = "2026-06-30T07:16:48.101Z" },
+ { url = "https://files.pythonhosted.org/packages/76/c2/baf95c7c38823e12ba34407c5f5767a89e5cf2233895e56f608167ae9493/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8f2e5c5ee828d42cb11760761c0af6507927bec42d0ad5458f97c9203b054617", size = 375479, upload-time = "2026-06-30T07:16:49.93Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/94/0aad06c72d65101e11d33528d438cda99a39ce0da99466e156158f2541d3/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ed0c1e5d10cdc7135537988c74a0188da68e2f3c30813ba3744ab1e42e0480f9", size = 492418, upload-time = "2026-06-30T07:16:51.641Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/17/de3f5a479a1f056535d7489819639d8cd591ea6281d700390b43b1abd745/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8c2642a7603ec0b16ed77da4555db3b4b472341904873788327c0b0d7b95f1bb", size = 384123, upload-time = "2026-06-30T07:16:53.622Z" },
+ { url = "https://files.pythonhosted.org/packages/46/7d/bf09bd1b145bb2671c03e1e6d1ab8651858d90d8c7dfeadd85a37a934fd8/rpds_py-2026.6.3-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8e4320744c1ffdd95a603def63344bfab2d33edeab301c5007e7de9f9f5b3885", size = 367351, upload-time = "2026-06-30T07:16:55.241Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/ea/1bb734f314b8be319149ddee80b18bd41372bdcfbdf88d28131c0cd37719/rpds_py-2026.6.3-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:a9f4645593036b81bbdb36b9c8e0ea0d1c3fee968c4d59db0344c14087ef143a", size = 378827, upload-time = "2026-06-30T07:16:56.841Z" },
+ { url = "https://files.pythonhosted.org/packages/4b/93/d9611e5b25e26df9a3649813ed66193ace9347a7c7fc4ab7cf70e94851c0/rpds_py-2026.6.3-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:e55d236be29255554da47abe5c577637db7c24a02b8b46f0ca9524c855801868", size = 395966, upload-time = "2026-06-30T07:16:58.557Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/cb/99d77e16e5534ae1d90629bbe419ba6ee170833a6a85e3aa1cc41726fbbc/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:24e9c5386e16669b674a69c156c8eeefcb578f3b3397b713b08e6d60f3c7b187", size = 545680, upload-time = "2026-06-30T07:17:00.164Z" },
+ { url = "https://files.pythonhosted.org/packages/59/15/11a29755f790cef7a2f755e8e14f4f0c33f39489e1893a632a2eee59672b/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:c60924535c75f1566b6eb75b5c31a48a43fef04fa2d0d201acbad8a9969c6107", size = 611853, upload-time = "2026-06-30T07:17:01.962Z" },
+ { url = "https://files.pythonhosted.org/packages/68/86/0c27547e21644da938fb530f7e1a8148dd24d02db07e7a5f2567a17ce710/rpds_py-2026.6.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:38a2fea2787428f811719ceb9114cb78964a3138838320c29ac39526c79c16ba", size = 573715, upload-time = "2026-06-30T07:17:03.693Z" },
+ { url = "https://files.pythonhosted.org/packages/29/71/4d8fcf700931815594bce892255bbd973b94efaf0fc1932b0590df18d886/rpds_py-2026.6.3-cp315-cp315-win32.whl", hash = "sha256:d483fe17f01ad64b7bf7cc38fcefff1ca9fb83f8c2b2542b68f97ffe0611b369", size = 202864, upload-time = "2026-06-30T07:17:05.746Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/62/b577562de0edbb55b2be85ce5fd09c33e386b9b13eee09833af4240fd5c4/rpds_py-2026.6.3-cp315-cp315-win_amd64.whl", hash = "sha256:67e3a721ffc5d8d2210d3671872298c4a84e4b8035cfe42ffd7cde35d772b146", size = 220430, upload-time = "2026-06-30T07:17:07.471Z" },
+ { url = "https://files.pythonhosted.org/packages/c8/95/d6d0b2509825141eef60669a5739eec88dbc6a48053d6c92993a5704defe/rpds_py-2026.6.3-cp315-cp315-win_arm64.whl", hash = "sha256:6e84adbcf4bf841aed8116a8264b9f50b4cb3e7bd89b516122e616ac56ca269e", size = 215877, upload-time = "2026-06-30T07:17:09.008Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/bf/f3ea278f0afd615c1d0f19cb69043a41526e2bb600c2b536eb192218eb27/rpds_py-2026.6.3-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:ae6dd8f10bd17aad820876d24caec9efdafd80a318d16c0a48edb5e136902c6b", size = 346933, upload-time = "2026-06-30T07:17:10.762Z" },
+ { url = "https://files.pythonhosted.org/packages/9d/29/9907bdf1c5346763cf10b7f6852aad86652168c259def904cbe0082c5864/rpds_py-2026.6.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bdbd97738551fca3917c1bd7188bec1920bb520104f28e7e1007f9ceb17b7690", size = 340274, upload-time = "2026-06-30T07:17:12.266Z" },
+ { url = "https://files.pythonhosted.org/packages/6f/2c/8e03767b5778ef25cebf74a7a91a2c3806f8eced4c92cb7406bbe060756d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b95977e7211527ab0ba576e286d023389fbeeb32a6b7b771665d333c60e5342", size = 370763, upload-time = "2026-06-30T07:17:14.107Z" },
+ { url = "https://files.pythonhosted.org/packages/2e/e1/df2a7e1ba2efd796af26194250b8d42c821b46592311595162af9ef0528d/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15fde0e6fb0d88a60d221204873743e5d9f0b7d29165e62cd86d0413ad74ba6", size = 376467, upload-time = "2026-06-30T07:17:15.76Z" },
+ { url = "https://files.pythonhosted.org/packages/6b/de/8a0814d1946af29cb068fb259aa8622f856df1d0bab58429448726b537f5/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a136d453475ac0fcbda502ef1e6504bd28d6d904700915d278deeab0d00fe140", size = 496689, upload-time = "2026-06-30T07:17:17.308Z" },
+ { url = "https://files.pythonhosted.org/packages/df/f3/f19e0c852ba13694f5a79f3b719331051573cb5693feacf8a88ffffc3a71/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f826877d462181e5eb1c26a0026b8d0cab05d99844ecb6d8bf3627a2ca0c0442", size = 385340, upload-time = "2026-06-30T07:17:18.928Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/ae/7ec3a9d2d4351f99e37bcb06b6b6f954512646bfdbf9742e1de727865daf/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79486287de1730dbaff3dbd124d0ca4d2ef7f9d29bf2544f1f93c09b5bcbbd12", size = 372179, upload-time = "2026-06-30T07:17:20.539Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/ac/9cee911dff2aaa9a5a8354f6610bf2e6a616de9197c5fff4f54f82585f1e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:808345f53cb952433ca2816f1604ff3515608a81784954f38d4452acfe8e61d5", size = 379993, upload-time = "2026-06-30T07:17:22.212Z" },
+ { url = "https://files.pythonhosted.org/packages/83/6b/7c2a07ba88d1e9a936612f7a5d067467ed03d971d5a06f7d309dff044a7e/rpds_py-2026.6.3-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1967debc37f64f2c4dc90a7f563aec558b471966e12adcac4e1c4240496b6ebf", size = 398909, upload-time = "2026-06-30T07:17:23.66Z" },
+ { url = "https://files.pythonhosted.org/packages/97/0b/776ffcb66783637b0031f6d58d6fb55913c8b5abf00aeecd46bf933fb477/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:f0840b5b17057f7fd918b76183a4b5a0635f43e14eb2ce60dce1d4ee4707ea00", size = 546584, upload-time = "2026-06-30T07:17:25.264Z" },
+ { url = "https://files.pythonhosted.org/packages/55/33/ba3bc04d7092bd553c9b2b195624992d2cc4f3de1f380b7b93cbee67bd79/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:faa679d19a6696fd54259ad321251ad77a13e70e03dd834daa762a44fb6196ef", size = 614357, upload-time = "2026-06-30T07:17:26.888Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/71/14edf065f04630b1a8472f7653cad03f6c478bcf95ea0e6aed55451e33ea/rpds_py-2026.6.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:23a439f31ccbeff1574e24889128821d1f7917470e830cf6544dced1c662262a", size = 576533, upload-time = "2026-06-30T07:17:28.546Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/76/65002b08596c389105720a8c0d22298b8dc25a4baf89b2ce431343c8b1de/rpds_py-2026.6.3-cp315-cp315t-win32.whl", hash = "sha256:913ca42ccad3f8cc6e292b587ae8ae49c8c823e5dce51a736252fc7c7cdfa577", size = 201204, upload-time = "2026-06-30T07:17:30.193Z" },
+ { url = "https://files.pythonhosted.org/packages/8c/97/d855d6b3c322d1f27e26f5241c42016b56cf01377ea8ed348285f54652f0/rpds_py-2026.6.3-cp315-cp315t-win_amd64.whl", hash = "sha256:ae3d4fe8c0b9213624fdce7279d70e3b148b682ca20719ebd193a23ebfa47324", size = 220719, upload-time = "2026-06-30T07:17:31.788Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.12.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/24/90/5255432602c0b196a0da6720f6f76b93eb50baef46d3c9b0025e2f9acbf3/ruff-0.12.0.tar.gz", hash = "sha256:4d047db3662418d4a848a3fdbfaf17488b34b62f527ed6f10cb8afd78135bc5c", size = 4376101, upload-time = "2025-06-17T15:19:26.217Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e6/fd/b46bb20e14b11ff49dbc74c61de352e0dc07fb650189513631f6fb5fc69f/ruff-0.12.0-py3-none-linux_armv6l.whl", hash = "sha256:5652a9ecdb308a1754d96a68827755f28d5dfb416b06f60fd9e13f26191a8848", size = 10311554, upload-time = "2025-06-17T15:18:45.792Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/d3/021dde5a988fa3e25d2468d1dadeea0ae89dc4bc67d0140c6e68818a12a1/ruff-0.12.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:05ed0c914fabc602fc1f3b42c53aa219e5736cb030cdd85640c32dbc73da74a6", size = 11118435, upload-time = "2025-06-17T15:18:49.064Z" },
+ { url = "https://files.pythonhosted.org/packages/07/a2/01a5acf495265c667686ec418f19fd5c32bcc326d4c79ac28824aecd6a32/ruff-0.12.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:07a7aa9b69ac3fcfda3c507916d5d1bca10821fe3797d46bad10f2c6de1edda0", size = 10466010, upload-time = "2025-06-17T15:18:51.341Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/57/7caf31dd947d72e7aa06c60ecb19c135cad871a0a8a251723088132ce801/ruff-0.12.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e7731c3eec50af71597243bace7ec6104616ca56dda2b99c89935fe926bdcd48", size = 10661366, upload-time = "2025-06-17T15:18:53.29Z" },
+ { url = "https://files.pythonhosted.org/packages/e9/ba/aa393b972a782b4bc9ea121e0e358a18981980856190d7d2b6187f63e03a/ruff-0.12.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:952d0630eae628250ab1c70a7fffb641b03e6b4a2d3f3ec6c1d19b4ab6c6c807", size = 10173492, upload-time = "2025-06-17T15:18:55.262Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/50/9349ee777614bc3062fc6b038503a59b2034d09dd259daf8192f56c06720/ruff-0.12.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c021f04ea06966b02614d442e94071781c424ab8e02ec7af2f037b4c1e01cc82", size = 11761739, upload-time = "2025-06-17T15:18:58.906Z" },
+ { url = "https://files.pythonhosted.org/packages/04/8f/ad459de67c70ec112e2ba7206841c8f4eb340a03ee6a5cabc159fe558b8e/ruff-0.12.0-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7d235618283718ee2fe14db07f954f9b2423700919dc688eacf3f8797a11315c", size = 12537098, upload-time = "2025-06-17T15:19:01.316Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/50/15ad9c80ebd3c4819f5bd8883e57329f538704ed57bac680d95cb6627527/ruff-0.12.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0c0758038f81beec8cc52ca22de9685b8ae7f7cc18c013ec2050012862cc9165", size = 12154122, upload-time = "2025-06-17T15:19:03.727Z" },
+ { url = "https://files.pythonhosted.org/packages/76/e6/79b91e41bc8cc3e78ee95c87093c6cacfa275c786e53c9b11b9358026b3d/ruff-0.12.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:139b3d28027987b78fc8d6cfb61165447bdf3740e650b7c480744873688808c2", size = 11363374, upload-time = "2025-06-17T15:19:05.875Z" },
+ { url = "https://files.pythonhosted.org/packages/db/c3/82b292ff8a561850934549aa9dc39e2c4e783ab3c21debe55a495ddf7827/ruff-0.12.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68853e8517b17bba004152aebd9dd77d5213e503a5f2789395b25f26acac0da4", size = 11587647, upload-time = "2025-06-17T15:19:08.246Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/42/d5760d742669f285909de1bbf50289baccb647b53e99b8a3b4f7ce1b2001/ruff-0.12.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3a9512af224b9ac4757f7010843771da6b2b0935a9e5e76bb407caa901a1a514", size = 10527284, upload-time = "2025-06-17T15:19:10.37Z" },
+ { url = "https://files.pythonhosted.org/packages/19/f6/fcee9935f25a8a8bba4adbae62495c39ef281256693962c2159e8b284c5f/ruff-0.12.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b08df3d96db798e5beb488d4df03011874aff919a97dcc2dd8539bb2be5d6a88", size = 10158609, upload-time = "2025-06-17T15:19:12.286Z" },
+ { url = "https://files.pythonhosted.org/packages/37/fb/057febf0eea07b9384787bfe197e8b3384aa05faa0d6bd844b94ceb29945/ruff-0.12.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:6a315992297a7435a66259073681bb0d8647a826b7a6de45c6934b2ca3a9ed51", size = 11141462, upload-time = "2025-06-17T15:19:15.195Z" },
+ { url = "https://files.pythonhosted.org/packages/10/7c/1be8571011585914b9d23c95b15d07eec2d2303e94a03df58294bc9274d4/ruff-0.12.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:1e55e44e770e061f55a7dbc6e9aed47feea07731d809a3710feda2262d2d4d8a", size = 11641616, upload-time = "2025-06-17T15:19:17.6Z" },
+ { url = "https://files.pythonhosted.org/packages/6a/ef/b960ab4818f90ff59e571d03c3f992828d4683561095e80f9ef31f3d58b7/ruff-0.12.0-py3-none-win32.whl", hash = "sha256:7162a4c816f8d1555eb195c46ae0bd819834d2a3f18f98cc63819a7b46f474fb", size = 10525289, upload-time = "2025-06-17T15:19:19.688Z" },
+ { url = "https://files.pythonhosted.org/packages/34/93/8b16034d493ef958a500f17cda3496c63a537ce9d5a6479feec9558f1695/ruff-0.12.0-py3-none-win_amd64.whl", hash = "sha256:d00b7a157b8fb6d3827b49d3324da34a1e3f93492c1f97b08e222ad7e9b291e0", size = 11598311, upload-time = "2025-06-17T15:19:21.785Z" },
+ { url = "https://files.pythonhosted.org/packages/d0/33/4d3e79e4a84533d6cd526bfb42c020a23256ae5e4265d858bd1287831f7d/ruff-0.12.0-py3-none-win_arm64.whl", hash = "sha256:8cd24580405ad8c1cc64d61725bca091d6b6da7eb3d36f72cc605467069d7e8b", size = 10724946, upload-time = "2025-06-17T15:19:23.952Z" },
+]
+
+[[package]]
+name = "rustypot"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/5d/dec9f5fc87bc0dc10f851e8d26ad27dc7680a69d1b69024f8091ddc4ebb3/rustypot-1.5.0.tar.gz", hash = "sha256:8e2a49c6d5562c8e5fb05b032a48f11afcf20fd244d42c956294d3b4bbdd6c91", size = 61436, upload-time = "2026-05-27T08:43:43.271Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/c5/d3/5462bda708c9c53ca472a5add4a0f3bf73f986081031077e277344ff2c42/rustypot-1.5.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:e975ccfd0023db621ad5d828ba55ccdd0e3f36dc480ffefbc98bc1cbe2ddfed3", size = 1778207, upload-time = "2026-05-27T08:43:09.762Z" },
+ { url = "https://files.pythonhosted.org/packages/09/18/fc8d16fa7aca3167edbf866f84eb45f1896a4a7235d8f3861bf05be1236e/rustypot-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5a799242f606d7635e4bf9668e1a149dede6ff16f4534ee3909bcb6ae9edf704", size = 1624935, upload-time = "2026-05-27T08:43:01.293Z" },
+ { url = "https://files.pythonhosted.org/packages/2c/34/f3f353a52564bb38c064ff0bab23c0f0f854d38d6f2298fffb31ade34200/rustypot-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37238a2c939686fc0a81ab95f881b8b21b638348862ece25a8bed4c3098883de", size = 1782882, upload-time = "2026-05-27T08:42:31.004Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/fe/8804268ad80ab9d07a921dbb2635743541f9ddce432dc24a3ec428b1d55e/rustypot-1.5.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1f1392d122d43cc74662c3ecef0e0a77a24210bc8870f115a5eeeae25491f099", size = 1807283, upload-time = "2026-05-27T08:42:38.305Z" },
+ { url = "https://files.pythonhosted.org/packages/33/05/bf8da9131bf450b00105e20ff382faa3fc6f4adce6c845d873354fbabba4/rustypot-1.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ed7d0183e9b32c8f17deeef6ea631612289624bfec1e55ceaf9b8d570462ae3", size = 1888155, upload-time = "2026-05-27T08:42:53.787Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/3a/ae8cfc67e4cb3768dd624ef611e47aeec526c38440052138a9cfa2827a97/rustypot-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:933a584ac28ab4312d0923fe41ee32db7ea675e7c0c5ec8e0c4f4b9a8ba2ff39", size = 1865288, upload-time = "2026-05-27T08:42:46.038Z" },
+ { url = "https://files.pythonhosted.org/packages/29/1e/08e0b3cf5c31129f244de9fe76b4f2d26fba85027735afa9bd2283aa5ade/rustypot-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6a8b0d601122b0ad27dba97c94c3c6877c708e5b8948a4e79a275d288caf1237", size = 1959107, upload-time = "2026-05-27T08:43:18.15Z" },
+ { url = "https://files.pythonhosted.org/packages/12/19/c4a04c1a46f64be7d3a573ebbd9bb6ecd770e8eb24f014c0f35aa71b9238/rustypot-1.5.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:66dee66038792849959897b43668cff07509efbc62db7d6c4f1b1edc79ede284", size = 2084102, upload-time = "2026-05-27T08:43:25.481Z" },
+ { url = "https://files.pythonhosted.org/packages/27/ee/66161eb1ca80cc89235ef4cc569ce0c20d6e0e009c3424c0393ba8640a31/rustypot-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:b6c1992034b1bec6fdec48f67f744ba67ad9f8d725a94d84c32c983a6e1019aa", size = 2009318, upload-time = "2026-05-27T08:43:32.917Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/e1/6ac262a96d50d99313a84b4753cf3dd80e8f92c0ccbec874037a2d7c8a3b/rustypot-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed43ef7697f12a47e6dd2c5c53a6d362958f95e6b1fdf6708ad735553ac0935f", size = 2106960, upload-time = "2026-05-27T08:43:39.894Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/c1/31956b8dfe4742b245e70a53dd6bcad9d5d57f02bcb181f96313ebcd4c55/rustypot-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f82e63076abbf1ac86a46d6f56630eff2875d03e566e6440b7060cfc5645ce5c", size = 1840806, upload-time = "2026-05-27T08:43:47.771Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/06/156d3e2d7d273a4e7802ef944a3a5744c25f15546979162f5edb56a237b6/rustypot-1.5.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:66d598b1a6d12743685c0806705ebe8e16bd24c8c9860cad53e1e04b5c117d67", size = 1777033, upload-time = "2026-05-27T08:43:11.379Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/be/af426df01a70d02ba610e24c6fffb549ec6ed47253d2650e42a902c41490/rustypot-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e390ef9a2bfde07ab47485ba9eeda318369b070c460c27318df4213cd38d22fe", size = 1623593, upload-time = "2026-05-27T08:43:02.912Z" },
+ { url = "https://files.pythonhosted.org/packages/00/b4/252a6c4f03d30a523fa9477751fd6475a14bcb544f59b12c5d9eeea38e47/rustypot-1.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fbfef6aef6bf871a58f07668fedd7f754c81e955ab4046cf3d7cd957e6a1009", size = 1782497, upload-time = "2026-05-27T08:42:32.871Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/86/8e64e9dbdf6e7d8bd40e84cf14bdec6e2183d2f6d14d598ffe4debeda2bd/rustypot-1.5.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb96ff65c6fa0492dead51b40f824f95df741a310f146b1d2bb7a3654f783fbd", size = 1807482, upload-time = "2026-05-27T08:42:40.407Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/e2/51dd543793f7936e1efb6f09b2b0893f153e5f5966fb433a42fb8850782e/rustypot-1.5.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3ffbb332f2f1a319adf5c78bc01008270ac2b5c8a4c17dbd87029ce47c784ac", size = 1887738, upload-time = "2026-05-27T08:42:55.662Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/db/2b3ae25e9327eea790e78899676bca676e71246e9d2ffd187ce93ccb087a/rustypot-1.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe94002fb612555464642a859ca29c372f65d4c60eb2cb00d42922c6561629e4", size = 1864825, upload-time = "2026-05-27T08:42:48.173Z" },
+ { url = "https://files.pythonhosted.org/packages/77/5d/9a37379165a9b3aa1a8861a8a12b0910f7f8e27de34f88ac3ed4eef9169c/rustypot-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7f8f972cec324c555ef6622f4c3fa5e16410e90259d49f41e7b80d0017c52120", size = 1958612, upload-time = "2026-05-27T08:43:20.275Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/75/50317c6d68129c4e509f3fbb64092a9b75f7ccfad961555895def37b1d39/rustypot-1.5.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:01b5d4f4bd85e76290abc9bb2db2d5c72f302ad2f2bfaaa6986134bde5a968da", size = 2084336, upload-time = "2026-05-27T08:43:27.508Z" },
+ { url = "https://files.pythonhosted.org/packages/08/83/8939510a8c58346a619d48d28fea06159f6d542b712511bf4944b3b4f7b0/rustypot-1.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:6427503f63c6df772a5ddfbd7a7830133cd97c754bc131bf150a32909b2d0eef", size = 2008363, upload-time = "2026-05-27T08:43:34.834Z" },
+ { url = "https://files.pythonhosted.org/packages/48/b7/4161f3c7c6130425e2aab4149984a4332a812a16f11f21009b9f6cdc2902/rustypot-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:02152b92d23238f018a2f144332466df9c7062d5f48e9d3ef249f70a0af489be", size = 2106923, upload-time = "2026-05-27T08:43:41.766Z" },
+ { url = "https://files.pythonhosted.org/packages/a1/d6/f61d177f8efaf8ee838afb13dea24d19ca8a1a825b53ba981eec97e0f92f/rustypot-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:7c5110192b2c29662fbd4f17704b6031d16224c06950b4304b36e141dba0873e", size = 1839904, upload-time = "2026-05-27T08:43:49.612Z" },
+ { url = "https://files.pythonhosted.org/packages/60/1f/1d900e8eaba1e8aa2e4fd690dac3fb0a09a7275095202a245cd9a6fad244/rustypot-1.5.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b1d9e4e7b12ad8d2645b70dca818513c536f5579a489c52d1f98a4e1eb4a507d", size = 1783825, upload-time = "2026-05-27T08:43:13.086Z" },
+ { url = "https://files.pythonhosted.org/packages/77/69/0608506a45b2870872358a071ee6b1cca08c3ff8d3d4e7d36df779fdedce/rustypot-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1a5b6bdb58592bab2dc612ab821903ca3ee0635399da48b86c9004091a0790c5", size = 1638554, upload-time = "2026-05-27T08:43:04.39Z" },
+ { url = "https://files.pythonhosted.org/packages/62/e8/a43db0e38013aa5b2e751e5d24a9c6c4c240bb1a1412e4e98bd075bfc4da/rustypot-1.5.0-cp314-cp314-win32.whl", hash = "sha256:a15a37c1bc5e9d13125019defb13a2c8b26e4f30d2f9524474bcdf25f44fba3c", size = 1360578, upload-time = "2026-05-27T08:43:53.06Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/11/6be4095756e6c39f1acf329a6338c91aa8485d0e7e55fcc144103cdc0ca0/rustypot-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:7a8898099769e314759789f2a0834cfed2a3484e6e12c58be9e7ca2d271895e7", size = 1853304, upload-time = "2026-05-27T08:43:51.385Z" },
+]
+
+[[package]]
+name = "scipy"
+version = "1.18.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "numpy" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a7/25/c2700dfaf6442b4effaa91af24ebce5dc9d31bb4a69706313aae70d72cd0/scipy-1.18.0.tar.gz", hash = "sha256:67b2ad2ad54c72ca6d04975a9b2df8c3638c34ddd5b28738e94fc2b57929d378", size = 30774447, upload-time = "2026-06-19T15:01:43.456Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/6a/19/ca10ead60b0acc80b2b833c2c4a4f2ff753d0f58b811f70d911c7e94a25c/scipy-1.18.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:7bd21faaf5a1a3b2eff922d02db5f191b99a6518db9078a8fb23169f6d22259a", size = 31056519, upload-time = "2026-06-19T14:59:45.203Z" },
+ { url = "https://files.pythonhosted.org/packages/96/72/1e6442a00cd2924d361aa1b642ab6373ec35c6fabf311a760be9f76e0f13/scipy-1.18.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:265915e79107de9f946b855e50d7470d5893ec3f54b342e1aa6201cbdcd8bb6b", size = 28681889, upload-time = "2026-06-19T14:59:48.103Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/2d/11dd93d21e147a73ba22bd75c0b9208d3a2e0ec76d53170ce7d9029b1015/scipy-1.18.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9ab7b758be6940954a713ee466e2043e9f6e2ed965c1fce5c91039f4be3d90a9", size = 20423580, upload-time = "2026-06-19T14:59:50.665Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/01/93552f75e0d2a7dd115a45e59209c51e8d514daff02fc887d2623be06fe1/scipy-1.18.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:97b6cddaaee0a779ef6b5ca83c9604b27cc16b2b8fc22c142652df8793319fb8", size = 23054441, upload-time = "2026-06-19T14:59:53.564Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/23/21f5e703643d66f21faa6b4c73195bfcad70c55efcb4f1ab327cd7c4101a/scipy-1.18.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52a96e21517c7292375c0e27dd796a811f03fcea5fd4d108fdfea8145dcf17ab", size = 33968720, upload-time = "2026-06-19T14:59:56.415Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/aa/1b939f6c67ed68635bb538e6752d3dacc02f66535182e939a89581a44e9c/scipy-1.18.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f55797419e16e7f30cf88ffb3113ce0467f00cfe3f70d5c281730b21769bfc2", size = 35287115, upload-time = "2026-06-19T14:59:59.411Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/ff/eec46be7e9234208f801062b53e1983085eddebd693f6c9bfb03b459830d/scipy-1.18.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ad033410e2e0672ffdc1042110cef20e1c46f8fd0616cee1d44d8d58fad8fc11", size = 35577989, upload-time = "2026-06-19T15:00:02.235Z" },
+ { url = "https://files.pythonhosted.org/packages/84/ca/210d4759c7210bb7d269437421959b39a33434e2776b60c5cb8a763bb30a/scipy-1.18.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4a55985d54c769c872e64b7f4c8a81cc30ef700cc04296abbbf3705439c126de", size = 37421717, upload-time = "2026-06-19T15:00:05.102Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/54/9a9edb45345bd6744da5ddfb6628e5d5185920494c6a67ec45b6381004cb/scipy-1.18.0-cp312-cp312-win_amd64.whl", hash = "sha256:71ccc8faa2dd16ac310233203474a8b5cb67f10dedd54a3116d34943f4b19132", size = 36597428, upload-time = "2026-06-19T15:00:08.112Z" },
+ { url = "https://files.pythonhosted.org/packages/99/0e/33f32a2a58987e26aec0f7df252cbbad1e90ae77bdbc76f40dd4ed0cf0ea/scipy-1.18.0-cp312-cp312-win_arm64.whl", hash = "sha256:d88363fd9d8fbd3511bd273f1a49efb2a540773ddf92a91d57498ce7dd7f3e76", size = 24351481, upload-time = "2026-06-19T15:00:11.103Z" },
+ { url = "https://files.pythonhosted.org/packages/05/52/9c0136c2de7ae0779b7b366447766cec6d9f0702c56bb8ffeb04c8fd3af4/scipy-1.18.0-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:09143f676d157d9f546d663504ef9c1becb819824f1afc018814176411942446", size = 31036107, upload-time = "2026-06-19T15:00:14.03Z" },
+ { url = "https://files.pythonhosted.org/packages/02/73/0291a64843270f4efb86cdcf2ee0f2048631b65ec6b405398b2b4dbf11bf/scipy-1.18.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:5efe260f69417b97ddae455bfb5a95e8359f7f66ad7fa9522a60feb66f169520", size = 28663303, upload-time = "2026-06-19T15:00:16.819Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/0f/10ffa0b697a572f4e0d48b92a88895d366422f019f723e7e14a84c050dac/scipy-1.18.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:68363b7eaacd8b5dd426df56d782cc156468ac79a127a1b87ca597d6e2e82197", size = 20404960, upload-time = "2026-06-19T15:00:19.635Z" },
+ { url = "https://files.pythonhosted.org/packages/7e/d2/e896cea21ba8edd6c81d4c55b1ffcc717e79698dcbebf9641b4cfb4c6622/scipy-1.18.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:c5557d8be5da8e41353fcd4d21491fdbab83b062fc579e94dc09a7c8ab4f669b", size = 23034074, upload-time = "2026-06-19T15:00:22.107Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/b2/e83ea34279a52c03374477c74006256ec78df65fc877baa4617d6de1d202/scipy-1.18.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d13bca67c096d89fb95ced0d8921807300fce0275643aef9533cc63a0773468", size = 33942038, upload-time = "2026-06-19T15:00:24.964Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/af/e8fe5fb136f51e2b01678b92cb4106d10d8cd68ec147ead2e7cb0ac75398/scipy-1.18.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a46f9273dbd0eb1cefba61c9b8648b4dfe3cbc14a080176f9a73e44b8336dc7f", size = 35266390, upload-time = "2026-06-19T15:00:28.059Z" },
+ { url = "https://files.pythonhosted.org/packages/3a/49/2c5cbb907b56695fc67517811d1db234dfd83381a84814ec220aded2794d/scipy-1.18.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5aba46108853ddfc77906b6557aac839d2b52e900c1d72a1180adaaab58d265f", size = 35551324, upload-time = "2026-06-19T15:00:31.014Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/73/eda39f7a2d306ff0ffc574afd13c0bbb6d10a603d9a413998ee269487a80/scipy-1.18.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b6f758e35f12757b5d95c00bc6de2438e229c2664b7a92e96f205959d9f2dfa4", size = 37404785, upload-time = "2026-06-19T15:00:34.072Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/d2/ae881ee28d014f38e0ccbfd974a06a919ba9af34f1f74bf42b5301891d63/scipy-1.18.0-cp313-cp313-win_amd64.whl", hash = "sha256:1afac4a847207c7ff8efd321734a50b06d0280b3b2a2c0fc2f413101747ad7c7", size = 36554943, upload-time = "2026-06-19T15:00:36.903Z" },
+ { url = "https://files.pythonhosted.org/packages/70/3a/21154e2d54eb3639c6bf4dbae2e531c68356bfe95990daa30df33b30d556/scipy-1.18.0-cp313-cp313-win_arm64.whl", hash = "sha256:c5dbddf60e58c2312316d097271a8e73d40eaf2eabfa4d95ed7d3695bbf2ce7b", size = 24350911, upload-time = "2026-06-19T15:00:40.062Z" },
+ { url = "https://files.pythonhosted.org/packages/78/b5/915a19b3de2f7430062b509653563db1633ddbb6f021b06731521115d4e2/scipy-1.18.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4c256ee70c0d1a8a2ace807e199ccd4e3f57037433842abb3fb36bc17eaa9578", size = 31036253, upload-time = "2026-06-19T15:00:43.216Z" },
+ { url = "https://files.pythonhosted.org/packages/d7/88/b72def7262e150d16be13fca37a96481138d624e700340bc3362a7588929/scipy-1.18.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:2ef3abc54a4ffc53765374b0d5728532dfdd2585ed23f6b11c206a1f0b1b9af8", size = 28673758, upload-time = "2026-06-19T15:00:46.663Z" },
+ { url = "https://files.pythonhosted.org/packages/91/02/2e636a61a525632c373cf6a9c24442a3ffb79e364d38e98b32042964ac32/scipy-1.18.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f2a6af57bd9e4a75d70e4117e78a1bbee84f79ae3fbb6d0111005d6ebcc4cb8d", size = 20415514, upload-time = "2026-06-19T15:00:49.399Z" },
+ { url = "https://files.pythonhosted.org/packages/c9/b6/2135974442f6aba159d9d39d774a1c8cb19947016725d69fecc685df45bf/scipy-1.18.0-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:3f1ac564d3bf6c03d861d2cd87a1bea0da2887136f7fb1bf519c05a8971452d6", size = 23034398, upload-time = "2026-06-19T15:00:51.941Z" },
+ { url = "https://files.pythonhosted.org/packages/f6/e6/ba89ec5abf6ee9257c0d1ec985573f3ae32742c24bc03e016388a40b1b15/scipy-1.18.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40395a5fcd1abee49a5c7aaa98c29db393eedc835138560a588c47ec16156690", size = 33998032, upload-time = "2026-06-19T15:00:54.838Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/c4/bc41eb19b0fd0db868f4132920879019318d80cc522ad8f2bca4611af808/scipy-1.18.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ca01e8ae69f1b18e9a58d91afead31be3cef0dd905a10249dac559ee15460a0", size = 35283333, upload-time = "2026-06-19T15:00:58.152Z" },
+ { url = "https://files.pythonhosted.org/packages/53/a4/cbdeef6eb3830a8462a9d4ada814de5fc984345cc9ecf17cbec51a036f1e/scipy-1.18.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7a7f3b01647384dbc3a711e8c6778e0aabbe93959249fef5c7393396bcac0867", size = 35610216, upload-time = "2026-06-19T15:01:01.155Z" },
+ { url = "https://files.pythonhosted.org/packages/80/4d/b2b82502b65f661d1b789c1665dcdf315d5f12194e06fc0b37946294ebae/scipy-1.18.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6aa94e78ec192a30063a5e72e561c28af769dc311190b24fe91774eff1969709", size = 37418960, upload-time = "2026-06-19T15:01:04.155Z" },
+ { url = "https://files.pythonhosted.org/packages/93/3e/902d836831474b0ab5a37d16404f7bc5fafd9efba632890e271ba952635f/scipy-1.18.0-cp314-cp314-win_amd64.whl", hash = "sha256:2d8bbdc6c817f5b4006a54d799d4f5bab6f910193cbb9a1ff310833d4d270f61", size = 37288845, upload-time = "2026-06-19T15:01:07.822Z" },
+ { url = "https://files.pythonhosted.org/packages/b6/43/8d73b337a3bdb14daa0314f0434210747c02d79d729ce1777574a817dcf6/scipy-1.18.0-cp314-cp314-win_arm64.whl", hash = "sha256:18e9575f1569b2c54174e6159d32942e03731177f63dce7975f0a0c88d102f5b", size = 24988971, upload-time = "2026-06-19T15:01:11.076Z" },
+ { url = "https://files.pythonhosted.org/packages/b4/b4/f11918b0508a2787031a0499a03fbe3546f3bb5ca05d01038c45b278c09a/scipy-1.18.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:f351e0dd702687d12a402b867a1b4146a256923e1c38317cbc472f6372b94707", size = 31399325, upload-time = "2026-06-19T15:01:13.723Z" },
+ { url = "https://files.pythonhosted.org/packages/7b/d1/1f287b57c0ff0ee5185dff3946d92c8017d39b0e431f0ae79a3ff1859512/scipy-1.18.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:7c7a51b33ce387193c97f228320cf8e87361daa1bba750638677729598b3e677", size = 29092110, upload-time = "2026-06-19T15:01:16.908Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/1a/7b74eb6c392fdcb27d414c0e7558a6d0231eb3b6d73571f479bb81ea8794/scipy-1.18.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:84031d7b052a54fae2f8632e0ec802073d385476eb9a63079bce6e23ef9283d4", size = 20833811, upload-time = "2026-06-19T15:01:20.488Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/ad/f3941716320a7b9cb4d68734a903b45fe16eff5fb7da7e16f2e619304979/scipy-1.18.0-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:56abf29a7c067dde59be8b9a22d606a4ea1b2f2a4b756d9d903c62818f5dacce", size = 23396644, upload-time = "2026-06-19T15:01:23.364Z" },
+ { url = "https://files.pythonhosted.org/packages/22/22/1446b62ffe07f9719b7d9b1b6a4e05a772833ae8f441fe4c22c34c9b250f/scipy-1.18.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ad44305cfa24b1ba5803cbbebf033590ccbac1aa5d612d727b785325ab408b0", size = 34079318, upload-time = "2026-06-19T15:01:26.002Z" },
+ { url = "https://files.pythonhosted.org/packages/56/3b/b87da667098bb470fa30c7011b0ba351ee976dd395c78798c66e941665a3/scipy-1.18.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:945c1761b93f38d7f99ae81ae80c63e621471608c7eeead563f6df025585cd58", size = 35324320, upload-time = "2026-06-19T15:01:28.881Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/a1/c7932f91909759b0267f75fdea34e91309f96b895757534b76a90b6b4344/scipy-1.18.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:1a4441f15d620578772a49e5ab48c0ee1f7a0220e387110283062729136b2553", size = 35699541, upload-time = "2026-06-19T15:01:31.968Z" },
+ { url = "https://files.pythonhosted.org/packages/f7/86/5185061a1fcc41d18c5dc2463969b3a3964b31d9ac67b2fb05d4c7ff7670/scipy-1.18.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:9aac6192fac56bf2ca534389d24623f07b39ff83317d58287285e7fbd622ff76", size = 37472480, upload-time = "2026-06-19T15:01:35.136Z" },
+ { url = "https://files.pythonhosted.org/packages/31/8e/f04c68e39919a010d34f2ee1367fd705b0a25a02f609d755f0bfbc0a15fc/scipy-1.18.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e40baea28ae7f5475c779741e2d90b1247c78531207b49c7030e698ff81cee3f", size = 37365390, upload-time = "2026-06-19T15:01:38.091Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/19/969dc072906c84dd0a3b05dcf57ea750936087d7873549e408b35cfc3f97/scipy-1.18.0-cp314-cp314t-win_arm64.whl", hash = "sha256:368e0a705903c466aa5f08eefb39e6b1b6b2d659e7352a31fd9e2438365be0f8", size = 25279661, upload-time = "2026-06-19T15:01:40.817Z" },
+]
+
+[[package]]
+name = "setuptools"
+version = "83.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "3.4.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "starlette" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6c/10/a34c656829ffc1c4b22ef36d70d9ebb6b99c020e2aeb17cee5485099f028/sse_starlette-3.4.6.tar.gz", hash = "sha256:725f8a1bd6d26ae1b2c9610c0ef5065dfdd496f3988d28adcf8c4b49dc25c627", size = 32542, upload-time = "2026-07-20T14:16:32.201Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/49/36/e10c1d1b7ca881d2625db2ec28508578499187bb1c389952c398474e1834/sse_starlette-3.4.6-py3-none-any.whl", hash = "sha256:56217ab4c9a9f9c5db7b21e08732d3e7c2b807f45231ad23de0551a24c4a41f6", size = 16516, upload-time = "2026-07-20T14:16:30.978Z" },
+]
+
+[[package]]
+name = "starlette"
+version = "0.52.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+ { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c4/68/79977123bb7be889ad680d79a40f339082c1978b5cfcf62c2d8d196873ac/starlette-0.52.1.tar.gz", hash = "sha256:834edd1b0a23167694292e94f597773bc3f89f362be6effee198165a35d62933", size = 2653702, upload-time = "2026-01-18T13:34:11.062Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/81/0d/13d1d239a25cbfb19e740db83143e95c772a1fe10202dda4b76792b114dd/starlette-0.52.1-py3-none-any.whl", hash = "sha256:0029d43eb3d273bc4f83a08720b4912ea4b071087a3b48db01b7c839f7954d74", size = 74272, upload-time = "2026-01-18T13:34:09.188Z" },
+]
+
+[[package]]
+name = "toml"
+version = "0.10.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/be/ba/1f744cdc819428fc6b5084ec34d9b30660f6f9daaf70eead706e3203ec3c/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f", size = 22253, upload-time = "2020-11-01T01:40:22.204Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/44/6f/7120676b6d73228c96e17f1f794d8ab046fc910d781c8d151120c3f1569e/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b", size = 16588, upload-time = "2020-11-01T01:40:20.672Z" },
+]
+
+[[package]]
+name = "tqdm"
+version = "4.69.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/69/40407dfc835517f058b603dbf37a6df094d8582b015a51eddc988febbcb7/tqdm-4.69.0.tar.gz", hash = "sha256:700c5e85dcd5f009dd6222588a29180a193a748247a5d855b4d67db93d79a53b", size = 792569, upload-time = "2026-07-17T18:09:06.2Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/fe/21/99a0cdaf54eb35e77623c41b5a2c9472ee4404bba687052791fe2aba6773/tqdm-4.69.0-py3-none-any.whl", hash = "sha256:9979978912be667a6ef21fd5d8abf54e324e63d82f7f43c360792ebc2bc4e622", size = 676680, upload-time = "2026-07-17T18:09:04.172Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" },
+]
+
+[[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.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.51.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "click" },
+ { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a2/65/b7c6c443ccc58678c91e1e973bbe2a878591538655d6e1d47f24ba1c51f3/uvicorn-0.51.0.tar.gz", hash = "sha256:f6f4b69b657c312f516dd2d268ab9ae6f254b11e4bac504f37b2ab58b24dd0b0", size = 94412, upload-time = "2026-07-08T10:59:05.962Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/45/ec/dbb7e5a6b91f86bfb9eb7d2988a2730907b6a729875b949c7f022e8b88fa/uvicorn-0.51.0-py3-none-any.whl", hash = "sha256:5d38af6cd620f2ae3849fb44fd4879e0890aa1febe8d47eb355fb45d93fe6a5b", size = 73219, upload-time = "2026-07-08T10:59:04.44Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+ { name = "httptools" },
+ { name = "python-dotenv" },
+ { name = "pyyaml" },
+ { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+ { name = "watchfiles" },
+ { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/3d/ff/7f72e8170be527b4977b033239a83a68d5c881cc4775fca255c677f7ac5d/uvloop-0.22.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:fe94b4564e865d968414598eea1a6de60adba0c040ba4ed05ac1300de402cd42", size = 1359936, upload-time = "2025-10-16T22:16:29.436Z" },
+ { url = "https://files.pythonhosted.org/packages/c3/c6/e5d433f88fd54d81ef4be58b2b7b0cea13c442454a1db703a1eea0db1a59/uvloop-0.22.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:51eb9bd88391483410daad430813d982010f9c9c89512321f5b60e2cddbdddd6", size = 752769, upload-time = "2025-10-16T22:16:30.493Z" },
+ { url = "https://files.pythonhosted.org/packages/24/68/a6ac446820273e71aa762fa21cdcc09861edd3536ff47c5cd3b7afb10eeb/uvloop-0.22.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:700e674a166ca5778255e0e1dc4e9d79ab2acc57b9171b79e65feba7184b3370", size = 4317413, upload-time = "2025-10-16T22:16:31.644Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/6f/e62b4dfc7ad6518e7eff2516f680d02a0f6eb62c0c212e152ca708a0085e/uvloop-0.22.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b5b1ac819a3f946d3b2ee07f09149578ae76066d70b44df3fa990add49a82e4", size = 4426307, upload-time = "2025-10-16T22:16:32.917Z" },
+ { url = "https://files.pythonhosted.org/packages/90/60/97362554ac21e20e81bcef1150cb2a7e4ffdaf8ea1e5b2e8bf7a053caa18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e047cc068570bac9866237739607d1313b9253c3051ad84738cbb095be0537b2", size = 4131970, upload-time = "2025-10-16T22:16:34.015Z" },
+ { url = "https://files.pythonhosted.org/packages/99/39/6b3f7d234ba3964c428a6e40006340f53ba37993f46ed6e111c6e9141d18/uvloop-0.22.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:512fec6815e2dd45161054592441ef76c830eddaad55c8aa30952e6fe1ed07c0", size = 4296343, upload-time = "2025-10-16T22:16:35.149Z" },
+ { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+ { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+ { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+ { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+ { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+ { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+ { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+ { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+ { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+ { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+ { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/b8/2f/e42c992d2afda3108ea1c02acecc991b9f31d05c14adc2a7cee9ee211fc4/watchfiles-1.2.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:bc13eb17538be00c874699dc0abe4ee2bc8d50bb1166a6b9e175ef3fd7eb8f26", size = 400115, upload-time = "2026-05-18T04:32:02.06Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/8f/6af2ea19065c91d8b0ea3516fdfc8c0d349f407e8e9fbf4e5a17360de8ad/watchfiles-1.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2d95ddc1eb6914154253d239089900813f6a767e174b8e6a50e7fdacb7e4236c", size = 393659, upload-time = "2026-05-18T04:30:50.951Z" },
+ { url = "https://files.pythonhosted.org/packages/13/01/b32a967c56fb3e3e5be3db52c3d3b87fa4513aa367d8ed1ad96d42952e5f/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f70d8b291ef6e88d19b1f297a6905ddb978888d9272b0d05e6f53309856bcfc", size = 453207, upload-time = "2026-05-18T04:31:04.231Z" },
+ { url = "https://files.pythonhosted.org/packages/04/98/97557a812180338cb1abd32e1cffcc4588f59b5f23e0cb006b2ba95ba64a/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56d8641cf834c2836922899105bd3ce3d0dfc69291d52edf0b4d0436829b34c0", size = 459273, upload-time = "2026-05-18T04:31:50.377Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/a8/b4b08dcb7653b8087c6586f7ce649505900e866bbcfe40dc9587af02e686/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2581a94056e55d7d0a31a823ea92bf73749c489ca2285bfdc0fbe6b2bb49d50c", size = 489927, upload-time = "2026-05-18T04:31:42.485Z" },
+ { url = "https://files.pythonhosted.org/packages/50/94/3dceea03545d2e5ddfd839f0ddd5e1cecbf1697b5a428d5ba11cef6af95d/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:41bc1199f7523b3f82843c88cbb979180c949caef0342cf90968f178e5d49b01", size = 570476, upload-time = "2026-05-18T04:31:03.071Z" },
+ { url = "https://files.pythonhosted.org/packages/cc/f2/d39a5450c3532092b91f81d274360e613c2371bc874a89c7a1a3c5e8d138/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7571e4464cb6e434958f867f7f730b8ab0b75e3f8e5eac0499168486ab3c33a8", size = 465650, upload-time = "2026-05-18T04:30:12.701Z" },
+ { url = "https://files.pythonhosted.org/packages/22/24/ed72f68cbc1333ca9b9f2200aa048bb6658ae41709bc1caad4310f4bdffd/watchfiles-1.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e53a384f76b631c3ae5334ce6a52f0baa3a911eb94a4eac7f160079868b716d5", size = 456398, upload-time = "2026-05-18T04:30:13.784Z" },
+ { url = "https://files.pythonhosted.org/packages/0d/64/982ef4a4e5bab5b6e5b6becc8cd5e732f6130a78b855f0abec6439a9a135/watchfiles-1.2.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:d20029a60a71a052a24c4db7673bc4de39ab89adbaccbfb5d67987c5d73f424d", size = 465140, upload-time = "2026-05-18T04:31:52.111Z" },
+ { url = "https://files.pythonhosted.org/packages/a0/0c/95282abf4ed680b6096010bcfc30c5fa7a041fc5aa5a2ad17a2cc6c75bba/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:2cb93af48550faf1cea04c303107c8b75833de7013e57ce27d3b8d21d8d0f58c", size = 630259, upload-time = "2026-05-18T04:31:25.676Z" },
+ { url = "https://files.pythonhosted.org/packages/30/45/607c1de1530c4bdcf2cf1d1ecc2505ddba5d96bd43ba9f2b0e79876f850f/watchfiles-1.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:2995c176de7692b86a2e4c58d9ec718f753150a979cb4a754e2b4ffa38e70906", size = 659859, upload-time = "2026-05-18T04:30:24.333Z" },
+ { url = "https://files.pythonhosted.org/packages/fa/08/d9e2e0f9e8e6791d33aefc694ad7eefa7f901f63caff84a81ded38692f9c/watchfiles-1.2.0-cp312-cp312-win32.whl", hash = "sha256:7a2cffd17d27d2ecbb310c2b1d8174f222a5495b1a721894afa88ec11e25b898", size = 275480, upload-time = "2026-05-18T04:30:31.307Z" },
+ { url = "https://files.pythonhosted.org/packages/1c/e6/9d42569c0102645cc8cea5d8c7d8a1e9d4ada2cb7f05f75e554b8aa2202a/watchfiles-1.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:f155b3a1b2a5fc89cdc70d47ee5d54e3b75e88efa34982028a35daef9ba00379", size = 288718, upload-time = "2026-05-18T04:32:10.745Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/26/88e0dc6ee3898169d7fa22bb6a69cabf2502d2ee25cb8c876d1262d204f8/watchfiles-1.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:8fa585ede612ee9f9e91b18bebf9ba11b9ae29a4e3a0d0cf6fca3e382133f0d5", size = 281026, upload-time = "2026-05-18T04:30:22.23Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/4d/70a7feced9f87e2ff26dba42667290f41694fc64646c67261fbb8cab5d5c/watchfiles-1.2.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:01ea8d66f0693b9b60a6541c8d10263091ca9a9060d242f3c1f3143f9aad2c98", size = 399730, upload-time = "2026-05-18T04:31:38.162Z" },
+ { url = "https://files.pythonhosted.org/packages/31/3a/0da302f2307aee316922806ebd5726c542cbd787c938271cf14a074c7daf/watchfiles-1.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ba0480b9a74af058f43b337e937a451e109295c420916d68ad24e3dc02f5e44", size = 392842, upload-time = "2026-05-18T04:30:27.051Z" },
+ { url = "https://files.pythonhosted.org/packages/db/ef/d5bdb705c224dbc256aa0c1ec47bf4e61ec52558f2afb44a71a1fe4d7015/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4f34e26a19f91f710c08e0183429f0d1d15df734e6bc78c31e77b9ea9c433658", size = 452989, upload-time = "2026-05-18T04:31:11.945Z" },
+ { url = "https://files.pythonhosted.org/packages/71/29/5495f2c1661949ef7a35e4d71111d129cfe7606414a26887a919d0a55406/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b4e77f6a55f858504069abd35d336a637555c09bca453dde1ee1e5ada8a6a1fb", size = 458978, upload-time = "2026-05-18T04:30:52.606Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/8c/7f9c07c433811c2fffd93e13fdfb7135de9aab5f2ae41be08960fa0047dc/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0cb4d80e212f116474a545c21c912b445f16bb0cef9e6a73a498164223e14e2f", size = 490248, upload-time = "2026-05-18T04:31:36.003Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/11/d93632febc52fbc21be90231bb7c17fd5387f46c9076fd40a5f9c2ae6910/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b974946a10af379d425e2eef5b62f5c6ebeaccf91d45eaad6f5b27ecd4f91aa0", size = 571847, upload-time = "2026-05-18T04:31:10.862Z" },
+ { url = "https://files.pythonhosted.org/packages/55/b4/383173e73aabb07ad1d9c7aa859d95437ac46a6d6a1e11005facda0c9d19/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:86bc13c25a8d1fcd70b51d0ce7c9b65e90de5666fcbfd3e34957cc73ee19aeb5", size = 465974, upload-time = "2026-05-18T04:30:17.006Z" },
+ { url = "https://files.pythonhosted.org/packages/a7/6c/89b1a230a78f57c52dd8893adb1f92f94411721b6ec12596c56d98c74356/watchfiles-1.2.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca148d73dea36c9763aaa351e4d7a51780ec1584217c45276f4fe8239c768b71", size = 454782, upload-time = "2026-05-18T04:30:35.656Z" },
+ { url = "https://files.pythonhosted.org/packages/24/62/1732118367cfff0a9fce3bf62ff4bfded09ef5df21d9d446b858b3f70a96/watchfiles-1.2.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:c525543d91961c6955b2636b308569e84a1d1c5f5f2932041ab9ef46422f43e3", size = 465182, upload-time = "2026-05-18T04:30:20.846Z" },
+ { url = "https://files.pythonhosted.org/packages/28/96/716f7e5f51339bf22963f3345f9f27d7f3b30e2eadc597e257c881dd3c53/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:a204794696ffb8f9b10fba6f7cb5216d42f3b2b71860ccac6b6e42f5f10973b0", size = 629841, upload-time = "2026-05-18T04:31:05.397Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/fe/c40783950fd771ccf66ab3ec2722d188a9af1c7f96c6e811f36e40c6e03f/watchfiles-1.2.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:10d86db20695afe7997ac9e1717637d6714a8d0220458c33f3d2061f54cec427", size = 658028, upload-time = "2026-05-18T04:31:48.22Z" },
+ { url = "https://files.pythonhosted.org/packages/71/72/4508db1856d1d87fcbb3b63f4839bab1b5682cb0e8d224d122263c09654a/watchfiles-1.2.0-cp313-cp313-win32.whl", hash = "sha256:eb283ee99e21ad6443c8cdb06ac5b34b1308c329cbdf03fa02b445363714c799", size = 275183, upload-time = "2026-05-18T04:30:59.57Z" },
+ { url = "https://files.pythonhosted.org/packages/f9/36/14b76ca57652e5cc5fd1c11f32a261292c08a0d19a00351013c2549cbfb2/watchfiles-1.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:a0f27f01bee51861392bb6b7c4fdb290b27d1eb194e9e28788d68102a0e898d9", size = 288059, upload-time = "2026-05-18T04:32:07.937Z" },
+ { url = "https://files.pythonhosted.org/packages/1b/8d/0a85e395398d8d20fadfe5c5d32c726eee17a519e78fb356f2cf7531bffe/watchfiles-1.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:3651aa7058595e9cfb75d35dd5ada2bf9f48a5b8a0f3562821d3e210c507e077", size = 280186, upload-time = "2026-05-18T04:31:54.484Z" },
+ { url = "https://files.pythonhosted.org/packages/37/68/36db056f1fdcc5f07302f56e631774d6835bcd6fa3ace402304621d5f9e5/watchfiles-1.2.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:faea288b6f0ab1902ef08f4ca6de005dccf856c4e0c4f21b8c5fce02d90a1b08", size = 399031, upload-time = "2026-05-18T04:30:44.576Z" },
+ { url = "https://files.pythonhosted.org/packages/c1/64/01a9d6f66a82a5c101ce939274106cc72759d62427e153f01edd2b9f87c2/watchfiles-1.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:01859b11fd9fbca670f4d5da00fbac282cfea9bd67a2125d8b2833a3b5617ea9", size = 391205, upload-time = "2026-05-18T04:30:25.413Z" },
+ { url = "https://files.pythonhosted.org/packages/84/2c/0a44fe058cb4bb7b8ede6b6670698bbb7c0400740e378d00022189b7b31d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fff610d7bb2256a317bb1e96f0d7862c7aa8076733ee5df0fd41bbe76a24a4f4", size = 451892, upload-time = "2026-05-18T04:32:14.005Z" },
+ { url = "https://files.pythonhosted.org/packages/67/a1/351e0d56cd35e6488b5c8b4fb11a809a5bc923e8fe8fed9faf8920be0c89/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b141a4891c995a039cd89e9a49e62df1dc8a559a5d1a6e4c7106d16c12777a55", size = 458867, upload-time = "2026-05-18T04:31:22.279Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/7d/9d09605187f1b838998624049fcf8bf47b73c1a3b76901fcac1782f62277/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f22943b7770483f6ea0721c6b11d022947a98eb0acae14694de034f4d0d38925", size = 490217, upload-time = "2026-05-18T04:31:43.657Z" },
+ { url = "https://files.pythonhosted.org/packages/60/5d/a17a16eccb182f04188cd308ec24b1a71a9b5c4e7098269cf35d9fa56d02/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1bc6195825b7dcd217968bb1f801a60fd4c16e8eeab5bedc7fe917d7d5995ab4", size = 571458, upload-time = "2026-05-18T04:32:11.875Z" },
+ { url = "https://files.pythonhosted.org/packages/d3/3d/4dd457062083ab1938e5dfd45032eb425cee2ac817287ca8ff4356183e5d/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d4a4b147f5dca2a5d325a06a832fb43f345751adfbc63204aec30e0d9ca965a2", size = 464707, upload-time = "2026-05-18T04:30:43.492Z" },
+ { url = "https://files.pythonhosted.org/packages/c6/71/ea8c57b128f5383de74d0c7d2d9c57ad7c9a65a930c451bd25d524b295b7/watchfiles-1.2.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4543579a9bdb0c9560039b4ffddbdb39545707659fbc430ce4c10f3f68d557f9", size = 454663, upload-time = "2026-05-18T04:30:16.061Z" },
+ { url = "https://files.pythonhosted.org/packages/53/fd/2e812bf938406d7db351f0703ddd3fc6c061cf30d96153a77bc79a943a44/watchfiles-1.2.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:20aa0e708b920bde876a4aa82dc7dd6ebea228a63a67cda6632c2fc87b787efa", size = 463537, upload-time = "2026-05-18T04:31:44.9Z" },
+ { url = "https://files.pythonhosted.org/packages/86/56/d17a7f1dd1bc3035f1072694a551301272f1739c2d8e319c927cb9e29b38/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:d413349d565dab74297f2a63e84a097936be69bf8f3b3801f27f380e32040f44", size = 629194, upload-time = "2026-05-18T04:31:14.141Z" },
+ { url = "https://files.pythonhosted.org/packages/be/06/f1ff66bf5cae50aa4062779a0ecd0bbaf15e466195719074078947d9a17d/watchfiles-1.2.0-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f28b2725eb8cce327b9b3ab02415c853011dc55c95832fe90de6bc56f5315f72", size = 656194, upload-time = "2026-05-18T04:31:47.14Z" },
+ { url = "https://files.pythonhosted.org/packages/e7/54/a9c7ea9a82a4ac65e7004c0a03920b5cdd2f9c3b678757d9cd425aa51d53/watchfiles-1.2.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:b8c8358484d5fa12ef34f05b7f4168eaf1932f408725ff6d023c33ec17bd79d4", size = 400205, upload-time = "2026-05-18T04:32:05.153Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/5d/c9ab3534374a4a67450696905d6ef16a04405448b8dc52bd752ae50423d4/watchfiles-1.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f04b092229ad2c50126dd3c922c8822e51e605993764a33058d4a791ab42281", size = 392508, upload-time = "2026-05-18T04:30:54.849Z" },
+ { url = "https://files.pythonhosted.org/packages/26/ca/1ad30103535cf0cecd7b993e8d50edc5351b1820e38f2d22e3df58962feb/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7a7ce236284f002a156f70add88efe5c70879cccbb658be0822c54b1306fc09d", size = 452448, upload-time = "2026-05-18T04:30:53.727Z" },
+ { url = "https://files.pythonhosted.org/packages/37/a1/ceee2cdf2afbd715fa07758d39c9859513eae411b23196f7fd039e5feedd/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b9909cc2b48468b575eefa944919e1fe8a36c5849d5c7c168f80a8c1db69398e", size = 459605, upload-time = "2026-05-18T04:30:23.312Z" },
+ { url = "https://files.pythonhosted.org/packages/e8/f6/421e30fd1cb3907a84ed92ab3f1983e37ba2dca015e9a894a048418417a2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a37faaed405c67e28e6be45a1fa4f206ef5a2860f27c237db9fa30704c38242", size = 490757, upload-time = "2026-05-18T04:30:47.358Z" },
+ { url = "https://files.pythonhosted.org/packages/41/b0/55ed1b97ed08be7bba6f9a541cac15f2a858e1d74d2b07b6da70a82aab00/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9649193aa27bd9ff2e80ff29bfaa93085496c7a3a377592823cc58b77ee88add", size = 568672, upload-time = "2026-05-18T04:30:38.915Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/cf/d8ae8a80dd7bafab395ea7681c10237311bbf34d37704a8c744e7cf31fc7/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e4ff8e37f99cf1da89e255e07c9c4b37c214038c4283707bdec308cb1b0ea1f", size = 464197, upload-time = "2026-05-18T04:30:09.914Z" },
+ { url = "https://files.pythonhosted.org/packages/7c/8a/3076c496ca8dafe0e8cd03fcebdfc47be4b1174b4e5b24ff6e396e6b3af2/watchfiles-1.2.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:054dc20fd2e3132b4c3883b4a00d72fd6e1f56fdaf89fccd12e8057d74cd74d7", size = 453181, upload-time = "2026-05-18T04:30:14.829Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/10/9745e17c98e7b8a86454df0a3c7b5686bd650383f1e9f26e4ebcbd6cc0c0/watchfiles-1.2.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:e140ed30ebde76796b686e67c182cff10ea2fbab186fafd1560f74bb5a473a6e", size = 465109, upload-time = "2026-05-18T04:30:28.123Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/95/8ef4a95481d3e0cb52d62a06fa6e972e81424be2d9698b91a2fecca9904c/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:bb7e52ecf68ba46d22df23467b87cffeb2146908aa523ebfe803019618cfda06", size = 630653, upload-time = "2026-05-18T04:31:49.304Z" },
+ { url = "https://files.pythonhosted.org/packages/fd/e4/3b3bf36b0f829b50c6ebcb8d031583863c59f923d6a6af3d485e470d0fac/watchfiles-1.2.0-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:23282a321c8baf9b3a3c4afff673f9fe65eb7fdc2338d765ccad9d3d1916a5ba", size = 657838, upload-time = "2026-05-18T04:31:06.497Z" },
+ { url = "https://files.pythonhosted.org/packages/21/b1/6cbbb50c1f3002ab568777d44aa21206dfb8807a840990c4037523b51812/watchfiles-1.2.0-cp314-cp314-win32.whl", hash = "sha256:c0db965c5f79aa49fe672d297cf1febc5ad149b658594944f49a54a2b96270a7", size = 275108, upload-time = "2026-05-18T04:30:06.891Z" },
+ { url = "https://files.pythonhosted.org/packages/92/45/190ce6db8dcb4536682cf75d3889ff1a27182a58cb519d343cb6d9ea63d8/watchfiles-1.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:71283b39fd17e5408eb123bd37aeecfd9d54c81fc184421943208aadb879d103", size = 288441, upload-time = "2026-05-18T04:32:12.901Z" },
+ { url = "https://files.pythonhosted.org/packages/74/0d/3eae1c2313ab08378431d907c3f8095ecca00f3eda33111cf4f0f2591799/watchfiles-1.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:c5c19526f4e54a00f2666a6c0e9e40d582c09e865055ea7378bf0009aab857b3", size = 280684, upload-time = "2026-05-18T04:31:26.902Z" },
+ { url = "https://files.pythonhosted.org/packages/b1/75/fb64e6c25d6b5ca636d03df34ffb1c6e9873303e76d27967e045f8df088f/watchfiles-1.2.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d73a585accffa5ae39c17264c36ec3166d2fad7000c780f5ef83b2722afb9dd2", size = 398857, upload-time = "2026-05-18T04:32:17.108Z" },
+ { url = "https://files.pythonhosted.org/packages/73/4e/9f7adf01754cbf81843722ccfec169d8f26c69778281a302855cecd2ee08/watchfiles-1.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ae99b14c5f21e026e0e9d96f40e07d8570ebee6cafd9d8fc318354606daa7a28", size = 392413, upload-time = "2026-05-18T04:31:07.911Z" },
+ { url = "https://files.pythonhosted.org/packages/47/c8/bec626bcc2d69f44b9acb24ce7d60ed7b16b73628eea747fcbd169d8edda/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4429f3b105524a10b72c3a819b091c495d2811d419c1e1e8df773a5a5974f831", size = 452409, upload-time = "2026-05-18T04:31:20.142Z" },
+ { url = "https://files.pythonhosted.org/packages/00/b7/b6362068e81e7c556d155a34c35d40ac3ef42d747b06d7f6e5bf58e359c2/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:43d818978d06062d9b22c4fab2ebe44cf5213d42dc8e62bda8c2760cfa2eeb33", size = 458827, upload-time = "2026-05-18T04:32:06.219Z" },
+ { url = "https://files.pythonhosted.org/packages/67/f8/9a813fa42afb1e0b4625e75f0479826644d3ee8dc287e093799bc01f390c/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b9f732dc58b2dbe69e464ccf8fff7a03b0dd0be439da4c0720d3558527d3d6b4", size = 490104, upload-time = "2026-05-18T04:31:56.034Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/bf/27dfb6094ca4c9aad21298b5525b6c53cb36121ee454331d05161e58d130/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8f200104103feb097de4cab8fe4f5dd18a2026934c7dea98c55a2f5fd6d5a33b", size = 571360, upload-time = "2026-05-18T04:31:57.133Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/39/44a096d67270ea93df91d33877dbe91fbda3aa4f8ec2edf799d93eda8736/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:63ac26eefbf4af1741247d6fb68b11c49a25b2f7413fbd318a83a12aaa9cf666", size = 464644, upload-time = "2026-05-18T04:30:57.33Z" },
+ { url = "https://files.pythonhosted.org/packages/0e/80/c7472203bad6268e3ef1ad260739704847898938ad7ea8b63a5131f46b50/watchfiles-1.2.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c4997d4e4a55f0d02b6cde327322daf3a0400e5df6c6b15948994bf72497925", size = 454771, upload-time = "2026-05-18T04:30:48.736Z" },
+ { url = "https://files.pythonhosted.org/packages/51/cf/3b10b268b4b7f0fc26e9debb5eef1998b515887840f444cd3ec80c688755/watchfiles-1.2.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:4c887eba18b7945ac73067a8b4a66f21cd46c2539b2bc68588f7be6c7eb6d26b", size = 463494, upload-time = "2026-05-18T04:31:33.826Z" },
+ { url = "https://files.pythonhosted.org/packages/3d/3e/a4302545cd589262a0dc7d140e86f7688eba3f9c72776c27f7e23b8864c4/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3416ff151bb6b5a8d8d11664974fbef4d9305b9b2957839ab5a270468fd8df30", size = 629383, upload-time = "2026-05-18T04:31:15.596Z" },
+ { url = "https://files.pythonhosted.org/packages/db/99/d5649df0a9a410d45b7c882304d0b790903ac9b6e8f2cfd12114e0c6b9f2/watchfiles-1.2.0-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:0e831a271c035d89789cffc386b6aa1375f39f1cd25eb7ca0997e4970d152fc5", size = 656093, upload-time = "2026-05-18T04:31:58.707Z" },
+ { url = "https://files.pythonhosted.org/packages/92/b9/362702539275019a54dd2e94511b31a9b89c5f9e6a21966de7eb692549fc/watchfiles-1.2.0-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:37a6721cdf3f65dbb13aa9503510ccb4451603ac837e44d265d7992a597e1374", size = 400109, upload-time = "2026-05-18T04:31:16.879Z" },
+ { url = "https://files.pythonhosted.org/packages/8f/75/71d5ba62db781e5587bded1d944c675374bc4aa37ff33d5018d98e8b6538/watchfiles-1.2.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2b37d10b5a63bd4d87e18472d80fa525bd670586fae62e5dd580452764879b65", size = 392167, upload-time = "2026-05-18T04:31:28.058Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/01/c66dd95d0423fe30d31820e2d1d5bda773764131bbb6ac0cb1cf303ac328/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a105bc2283f67e8fbec74253ec2d94925de92ed72c0393f1206bf326b7b7b69", size = 452372, upload-time = "2026-05-18T04:31:00.836Z" },
+ { url = "https://files.pythonhosted.org/packages/91/15/2fe99557e72f85627c6a8eed50d889e8d101623e060a22ad75b875cb932d/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5327989a465505f05cfe06f04fa9d0c2fd5432bb243e10e6f012b1bdca3c8579", size = 459596, upload-time = "2026-05-18T04:31:34.96Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/23/d4acfa0023367428ed48351b3b9b267893037b6cadae55620c61c24bcfd4/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ecb47f183a8025b2aa18b546725c3657e542112ae9c0613a2af79b4fa8d04ad7", size = 490869, upload-time = "2026-05-18T04:31:59.923Z" },
+ { url = "https://files.pythonhosted.org/packages/a4/5f/3164cbdce06c9fb95c4f7b9e2f9760b5e2797af43a9ecc317ef42a23a278/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8520a4ab0e37f770afc34459c4f8f7019e153f9124dc101c15538365875d1ab2", size = 571641, upload-time = "2026-05-18T04:32:00.948Z" },
+ { url = "https://files.pythonhosted.org/packages/41/e6/85d3731c55e65cd7690f3f803d24c139588aaf863e4bf2148fe7a7fa1a19/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:71cd71740ed2c15211ebb237ced4e39a1cdf6f80566e5fe95428da1626f4fde6", size = 464444, upload-time = "2026-05-18T04:30:34.298Z" },
+ { url = "https://files.pythonhosted.org/packages/f4/7d/562641012b8b09872742c3b8adf9629ec479fd78f8d68ae4a0c13da8add6/watchfiles-1.2.0-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f88af53d6ddaf72179ef613ddc905e6f4785f712b49b80b3bef9f3525e6194b4", size = 453593, upload-time = "2026-05-18T04:31:23.464Z" },
+ { url = "https://files.pythonhosted.org/packages/56/fe/cb8ef3d6f929d14158fdaaad9925985b7310abc9384dcd4d82dd0016fb59/watchfiles-1.2.0-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:cee9d5efd929efdac5f7e58f72b3376f676b64050a91c5b99a7094c5b2317488", size = 465096, upload-time = "2026-05-18T04:31:30.384Z" },
+ { url = "https://files.pythonhosted.org/packages/25/91/80908e835e100527a9267147b08c0eee1fa6ab0ffec15edc04d1d44885f7/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:b718bf356bbc15e559bd8ef41782b573b8ae0e3f177ab244b440568d7ea02cfb", size = 630638, upload-time = "2026-05-18T04:30:49.89Z" },
+ { url = "https://files.pythonhosted.org/packages/46/4b/95ab2f256bb4af3cb2eb23b9317bda984ee6e0f11733a5c004a6c95b06e3/watchfiles-1.2.0-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:922c0e019fe68b3ae392965a766b02a71ba1168c932cebc3733cd52c5fe5b377", size = 657684, upload-time = "2026-05-18T04:31:32.027Z" },
+]
+
+[[package]]
+name = "wcwidth"
+version = "0.8.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/74/c6428f875774288bec1396f5bfcbc2d925700a4dad61727fd5f2b12f249d/wcwidth-0.8.2.tar.gz", hash = "sha256:91fbef97204b96a3d4d421609b80340b760cf33e26da123ff243d76b1fda8dda", size = 1466253, upload-time = "2026-06-29T18:11:11.601Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/96/42/3e5985a0a7e57de470b320c6d6a1a67c844f6737a587f3d44dd13d1819e7/wcwidth-0.8.2-py3-none-any.whl", hash = "sha256:d63947694a0539a1d51e01eda7caf800c291020e6cdd7e28ad7b14dd33ad4f85", size = 323166, upload-time = "2026-06-29T18:11:09.888Z" },
+]
+
+[[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/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.24.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "idna" },
+ { name = "multidict" },
+ { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/31/33/ebe9e3d1f86c7a0b51094c0a146392045ca1631d2664889539dec8088a33/yarl-1.24.5.tar.gz", hash = "sha256:e81b83143bee16329c23db3c1b2d82b29892fcbcb849186d2f6e98a5abe9a57f", size = 228679, upload-time = "2026-07-20T02:07:45.435Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/1b/84/71d051c850b5af41d168c679d9eb67eb7c55283ac4ee131673edf134bc4e/yarl-1.24.5-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d693396e5aea78db03decd60aec9ece16c9b40ba00a587f089615ff4e718a81d", size = 136035, upload-time = "2026-07-20T02:05:25.489Z" },
+ { url = "https://files.pythonhosted.org/packages/03/4d/8ad27f9a1b7e69313cca5d695b925b48efe51208d3490e0844bae97cabc0/yarl-1.24.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3363fcc96e665878946ad7a106b9a13eac0541766a690ef287c0232ac768b6ec", size = 97642, upload-time = "2026-07-20T02:05:27.429Z" },
+ { url = "https://files.pythonhosted.org/packages/ea/b4/05b4131c407006cd1e410e9c6539f16a0945724677e5364447313c15ea3e/yarl-1.24.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9d399bdcfb4a0f659b9b3788bbc89babe63d9a6a65aacdf4d4e7065ff2e6316c", size = 97323, upload-time = "2026-07-20T02:05:29.441Z" },
+ { url = "https://files.pythonhosted.org/packages/20/16/e618c875c73e0e39611f20a581b3d5e8d59b8857bf001bee3263044c6deb/yarl-1.24.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90333fd89b43c0d08ac85f3f1447593fc2c66de18c3d6378d7125ea118dc7a54", size = 107741, upload-time = "2026-07-20T02:05:31.367Z" },
+ { url = "https://files.pythonhosted.org/packages/d9/9a/c4defeaf3ed33fcb346aacf9c6e971a8d4e2bde04a0310e79abb208e7965/yarl-1.24.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:665b0a2c463cc9423dd647e0bfd9f4ccc9b50f768c55304d5e9f80b177c1de12", size = 103570, upload-time = "2026-07-20T02:05:33.303Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/e7/0e0e0de5865ebd5914537ef486f36c727a59865c3ac0cf5ff1b32aececbf/yarl-1.24.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e006d3a974c4ee19512e5f058abedb6eef36a5e553c14812bdeba1758d812e6d", size = 115815, upload-time = "2026-07-20T02:05:35.292Z" },
+ { url = "https://files.pythonhosted.org/packages/2b/27/ca56b700cb170aba25a3893b75355b213935657dc5714d2383354a270e62/yarl-1.24.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e7d42c531243450ef0d4d9c172e7ed6ef052640f195629065041b5add4e058d1", size = 116025, upload-time = "2026-07-20T02:05:37.503Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/d0/d56c859b8222116f5d68459199f48359e0bf121b6f65a69bf329b3602ba0/yarl-1.24.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f08c7513ecef5aad65687bfdf6bc601ae9fccd04a42904501f8f7141abad9eb9", size = 109835, upload-time = "2026-07-20T02:05:39.506Z" },
+ { url = "https://files.pythonhosted.org/packages/70/a2/3a35557e4d1a79425040eba202ccaf08bdc8717680fc77e2498a1ad2e0a5/yarl-1.24.5-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6c95b17fe34ed802f17e205112e6e10db92275c34fee290aa9bdc55a9c724027", size = 108884, upload-time = "2026-07-20T02:05:41.584Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/35/ef4c26356b7913c68983bac2d72a4212b3347af551cb8d250b99b5ed7b7f/yarl-1.24.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:56b149b22de33b23b0c6077ab9518c6dcb538ad462e1830e68d06591ccf6e38b", size = 107308, upload-time = "2026-07-20T02:05:43.697Z" },
+ { url = "https://files.pythonhosted.org/packages/d5/91/ff0dc66c2ccf3e0153ab97ff61eabab4400e6a5264af427ab30cd69f1857/yarl-1.24.5-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a8fe66b8f300da93798025a785a5b90b42f3810dc2b72283ff84a41aaaebc293", size = 103646, upload-time = "2026-07-20T02:05:45.895Z" },
+ { url = "https://files.pythonhosted.org/packages/74/f0/33b9271c7f881766359d58266fa0811d2e5210ed860e28da7dc6d7786344/yarl-1.24.5-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:377fe3732edbaf78ee74efdf2c9f49f6e99f20e7f9d2649fda3eb4badd77d76e", size = 115305, upload-time = "2026-07-20T02:05:47.832Z" },
+ { url = "https://files.pythonhosted.org/packages/ef/65/fd79fb1868c4a80db8661091de525bf430f63c3bea1b20e8b6a84fc7d359/yarl-1.24.5-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e8ffa78582120024f476a611d7befc123cee59e47e8309d470cf667d806e613b", size = 108404, upload-time = "2026-07-20T02:05:49.604Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/ba/dbabe6b262f17a816c70cfc09558dbf03ece3ec76684d02f911a3d3a189c/yarl-1.24.5-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:daba5e594f06114e37db186efd2dd916609071e59daca901a0a2e71f02b142ce", size = 115940, upload-time = "2026-07-20T02:05:51.741Z" },
+ { url = "https://files.pythonhosted.org/packages/a5/43/fab2d1dad9d340a268cdde63756a123d069723efff6a372d123fa74a9517/yarl-1.24.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:65be18ec59496c13908f02a2472751d9ef840b4f3fb5726f129306bf6a2a7bba", size = 110006, upload-time = "2026-07-20T02:05:53.554Z" },
+ { url = "https://files.pythonhosted.org/packages/c4/27/41eb51bbd1b8d89546b83897cfb0164f1e109304fd408dbb151b639eec0f/yarl-1.24.5-cp312-cp312-win_amd64.whl", hash = "sha256:a929d878fec099030c292803b31e5d5540a7b6a31e6a3cc76cb4685fc2a2f51b", size = 97618, upload-time = "2026-07-20T02:05:55.57Z" },
+ { url = "https://files.pythonhosted.org/packages/3c/25/b2553764b3d65db711d8f45416351ec4f420847558eb669edcbcaadf5780/yarl-1.24.5-cp312-cp312-win_arm64.whl", hash = "sha256:7ce27823052e2013b597e0c738b13e7e36b8ccb9400df8959417b052ab0fd92c", size = 93018, upload-time = "2026-07-20T02:05:57.554Z" },
+ { url = "https://files.pythonhosted.org/packages/e1/63/64ef361967cc983573149dc1515d531db5da8a4c92d22bb833d59e01b313/yarl-1.24.5-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:79af890482fc94648e8cde4c68620378f7fef60932710fa17a66abc039244da2", size = 135075, upload-time = "2026-07-20T02:05:59.671Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/89/55920fd853ce43e608adbc3962456f0d649d6bb15250dc2988321da0fe1c/yarl-1.24.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:46c2f213e23a04b93a392942d782eb9e413e6ef6bf7c8c53884e599a5c174dcb", size = 97225, upload-time = "2026-07-20T02:06:01.769Z" },
+ { url = "https://files.pythonhosted.org/packages/15/f0/7688d3f2cfff7590df2af38ec46d969f4281a4dddb08a9ad2eafbcdddf98/yarl-1.24.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92ab3e11448f2ff7bf53c5a26eff0edc086898ec8b21fb154b85839ce1d88075", size = 96751, upload-time = "2026-07-20T02:06:03.676Z" },
+ { url = "https://files.pythonhosted.org/packages/05/1a/a851a0f94aaaf379dd4f901bfc80f634280bec51eb260b47363e2a4cd62e/yarl-1.24.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ebb0ec7f17803063d5aeb982f3b1bd2b2f4e4fae6751226cbd6ba1fcfe9e63ff", size = 107960, upload-time = "2026-07-20T02:06:05.699Z" },
+ { url = "https://files.pythonhosted.org/packages/6c/a8/faea066c12f9c77ca0de90641f1655f9dd7b412477bf28c76d692f3aecff/yarl-1.24.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:82632daed195dcc8ea664e8556dc9bdbd671960fb3776bd92806ce05792c2448", size = 103500, upload-time = "2026-07-20T02:06:07.556Z" },
+ { url = "https://files.pythonhosted.org/packages/fb/9c/1e67084c2a6e2f2db0e3be798328cb3be42c0119b621d25461479a224d21/yarl-1.24.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:53e549287ef628fecba270045c9701b0c564563a9b0577d24a4ec75b8ab8040f", size = 115780, upload-time = "2026-07-20T02:06:09.599Z" },
+ { url = "https://files.pythonhosted.org/packages/58/86/1f94664e147474337e3359f52012cf3d02f825f694317b178bfba1078c62/yarl-1.24.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:fcd3b77e2f17bbe4ca56ec7bcb07992647d19d0b9c05d84886dcd6f9eb810afd", size = 115308, upload-time = "2026-07-20T02:06:11.352Z" },
+ { url = "https://files.pythonhosted.org/packages/0a/43/8e55ae7538ba5f28ccb3c845c6dd4549cf7016d5992e5326512519107cdd/yarl-1.24.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d46b86567dd4e248c6c159fcbcdcce01e0a5c8a7cd2334a0fff759d0fa075b16", size = 110574, upload-time = "2026-07-20T02:06:13.129Z" },
+ { url = "https://files.pythonhosted.org/packages/ce/ba/a889ec8765cedcf2ac44dcb02d6a21e4861399b243b263c5f2dde27ee740/yarl-1.24.5-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7f72c74aa99359e27a2ee8d6613fefa28b5f76a983c083074dfc2aaa4ab46213", size = 109914, upload-time = "2026-07-20T02:06:15.243Z" },
+ { url = "https://files.pythonhosted.org/packages/9c/c3/e45f821af67b791c2dbbe4a9f4137a1d33f8d386654a05a0c3f47bdfa25d/yarl-1.24.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:3f45789ce415a7ec0820dc4f82925f9b5f7732070be1dec1f5f23ec381435a24", size = 107712, upload-time = "2026-07-20T02:06:17.443Z" },
+ { url = "https://files.pythonhosted.org/packages/02/00/2ab0f42c9857fcb490bfaa6647b14540b53d241ab209f23220b958cc5832/yarl-1.24.5-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:6e73e7fe93f17a7b191f52ec9da9dd8c06a8fe735a1ecbd13b97d1c723bff385", size = 104251, upload-time = "2026-07-20T02:06:19.259Z" },
+ { url = "https://files.pythonhosted.org/packages/7a/70/709d9a286e98af2c7fd8e4e6cada658b5c0e30d87dd7e2a63c2fb5767217/yarl-1.24.5-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4a36f9becdd4c5c52a20c3e9484128b070b1dcfc8944c006f3a528295a359a9c", size = 115319, upload-time = "2026-07-20T02:06:21.207Z" },
+ { url = "https://files.pythonhosted.org/packages/5c/6c/3eaa515142991fe84cfc483ff986492211f1978f90161ccefdbec919d09b/yarl-1.24.5-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:7bcbe0fcf850eae67b6b01749815a4f7161c560a844c769ad7b48fcd99f791c4", size = 109163, upload-time = "2026-07-20T02:06:23.006Z" },
+ { url = "https://files.pythonhosted.org/packages/bb/64/711dafce66c323a3144d470547a71c5384c57623308ac8bb5e4b903ac148/yarl-1.24.5-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:24e861e9630e0daddcb9191fb187f60f034e17a4426f8101279f0c475cd74144", size = 115435, upload-time = "2026-07-20T02:06:24.923Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/f3/9b9d0e6d84bea851eb1ba99e4bdc755b86fd813e49ec86dfe42f26befdef/yarl-1.24.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9335a099ad87287c37fe5d1a982ff392fa5efe5d14b40a730b1ec1d6a41382b4", size = 110691, upload-time = "2026-07-20T02:06:26.973Z" },
+ { url = "https://files.pythonhosted.org/packages/86/e4/62a06b7e87c4246ac76b7c2da136f972eb4a3a1fc94abb07e7022d6fdb0a/yarl-1.24.5-cp313-cp313-win_amd64.whl", hash = "sha256:2dbe06fc16bc91502bca713704022182e5729861ae00277c3a23354b40929740", size = 97454, upload-time = "2026-07-20T02:06:29.163Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/c9/5fc8025b318ab10db413b61056bd0d95c557a70e8df4210c7511f866329c/yarl-1.24.5-cp313-cp313-win_arm64.whl", hash = "sha256:6b8536851f9f65e7f00c7a1d49ba7f2be0ffe2c11555367fc9f50d9f842410a1", size = 92813, upload-time = "2026-07-20T02:06:31.113Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/08/5f3085fef9564217074db9dd8573de1795bc82cde61a7ad10b6a7234a569/yarl-1.24.5-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:2729fcfc4f6a596fb0c50f32090400aa9367774ac296a00387e65098c0befa76", size = 135680, upload-time = "2026-07-20T02:06:33.273Z" },
+ { url = "https://files.pythonhosted.org/packages/98/35/ba9436e579bd48a8801f2021d842d9ab4994c26e4c7dd3a4c1f1bcb57a9e/yarl-1.24.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ff330d3c30db4eb6b01d79e29d2d0b407a7ecad39cfd9ec993ece57396a2ec0d", size = 97395, upload-time = "2026-07-20T02:06:35.259Z" },
+ { url = "https://files.pythonhosted.org/packages/18/a9/a07f76f3c44e02b25cc743af5ef93eef27f7013eadca770451b6a6ccb5db/yarl-1.24.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e42d75862735da90e7fc5a7b23db0c976f737113a54b3c9777a9b665e9cbff75", size = 97223, upload-time = "2026-07-20T02:06:37.216Z" },
+ { url = "https://files.pythonhosted.org/packages/77/f7/a9a1d6fa7dd9e388f95b30f6ad3ec4e285f6c8f61f44ce16070c3fcfe414/yarl-1.24.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a3732e66413163e72508da9eff9ce9d2846fde51fae45d3605393d3e6cd303e9", size = 108777, upload-time = "2026-07-20T02:06:39.292Z" },
+ { url = "https://files.pythonhosted.org/packages/2f/44/e0b86c302471fabd6f02808ecf2ac52b8412b624787849d4bf2cdb466f6f/yarl-1.24.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5b8ee53be440a0cffc991a27be3057e0530122548dbe7c0892df08822fce5ede", size = 103119, upload-time = "2026-07-20T02:06:41.456Z" },
+ { url = "https://files.pythonhosted.org/packages/d1/16/9c16d180bf8faaf223225eb50e1245870ff1ae0e302a27153988e65c51fd/yarl-1.24.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:af3aefa655adb5869491fa907e652290386800ae99cc50095cba71e2c6aefdca", size = 116471, upload-time = "2026-07-20T02:06:43.696Z" },
+ { url = "https://files.pythonhosted.org/packages/d2/8d/b219b9df28a02ce95cfbdd41d2f7caa5669d0ff979c1c9975697145e33c5/yarl-1.24.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2120b96872df4a117cde97d270bac96aea7cc52205d305cf4611df694a487027", size = 115974, upload-time = "2026-07-20T02:06:45.874Z" },
+ { url = "https://files.pythonhosted.org/packages/9b/e8/f20557aca240d88e69850ad1ee91756821d094bb1310565c04d25c6682a2/yarl-1.24.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:66410eb6345d467151934b49bfa70fb32f5b35a6140baa40ad97d6436abea2e9", size = 110830, upload-time = "2026-07-20T02:06:47.852Z" },
+ { url = "https://files.pythonhosted.org/packages/db/18/199b85109a53eeca64ee19c9cca228287e8e4ab0cc1a09b28f530e65cce0/yarl-1.24.5-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4af7b7e1be0a69bee8210735fe6dcfc38879adfac6d62e789d53ba432d1ffa41", size = 110054, upload-time = "2026-07-20T02:06:49.84Z" },
+ { url = "https://files.pythonhosted.org/packages/aa/2f/ed28147f8cd7f48c49367c90713b30a555284b6105a6a56f3a05568da795/yarl-1.24.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa139875ff98ab97da323cfadfaff08900d1ad42f1b5087b0b812a55c5a06373", size = 108312, upload-time = "2026-07-20T02:06:51.835Z" },
+ { url = "https://files.pythonhosted.org/packages/c5/c5/55e16ae0a5c227cea8df1c6871ba57d614a34243146c05729caf2a1bd9c5/yarl-1.24.5-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:0055afc45e864b92729ac7600e2d102c17bef060647e74bca75fa84d66b9ff36", size = 103662, upload-time = "2026-07-20T02:06:54.061Z" },
+ { url = "https://files.pythonhosted.org/packages/8d/ea/dbd7c2caec459c9a426f18b02688ecbfb58620d0f6a3422d24769fbaf8ab/yarl-1.24.5-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f0e466ed7511fe9d459a819edbc6c2585c0b6eabde9fa8a8947552468a7a6ef0", size = 116090, upload-time = "2026-07-20T02:06:56.015Z" },
+ { url = "https://files.pythonhosted.org/packages/06/84/39ce4ce3059e07fece5fbdbee8c4053406af9aca911ce9fa5f8548aab6af/yarl-1.24.5-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f141474e85b7e54998ec5180530a7cda99ab29e282fa50e0756d89981a9b43c5", size = 109523, upload-time = "2026-07-20T02:06:57.926Z" },
+ { url = "https://files.pythonhosted.org/packages/a9/8b/71ff44137b405c64a7788075669c24010019f57a7464b78c3a6cbee539d9/yarl-1.24.5-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:e2935f8c39e3b03e83519292d78f075189978f3f4adc15a78144c7c8e2a1cba5", size = 116084, upload-time = "2026-07-20T02:06:59.868Z" },
+ { url = "https://files.pythonhosted.org/packages/62/c0/423078fdd4042e1862c11f0ffd977a0ffa393783c12bee94685923bc189e/yarl-1.24.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9d1216a7f6f77836617dba35687c5b78a4170afc3c3f18fc788f785ba26565c4", size = 111006, upload-time = "2026-07-20T02:07:01.907Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/52/6daa2ee9d95e5c98b8128f8df91eb692eb423ab274b8cf08db52152fad26/yarl-1.24.5-cp314-cp314-win_amd64.whl", hash = "sha256:5ba4f78df2bcc19f764a4b26a8a4f5049c110090ad5825993aacb052bf8003ad", size = 99215, upload-time = "2026-07-20T02:07:03.852Z" },
+ { url = "https://files.pythonhosted.org/packages/ec/0e/464a847d7359e0da75dd9fc5c1d1aa35d0159ea31e5f8e66a3c1c29ff3d0/yarl-1.24.5-cp314-cp314-win_arm64.whl", hash = "sha256:9e4e16c73d717c5cf27626c524d0a2e261ad20e46932b2670f64ad5dde23e26f", size = 94566, upload-time = "2026-07-20T02:07:06.074Z" },
+ { url = "https://files.pythonhosted.org/packages/e2/55/e03acc4446772660bc335e86e41ef31e4d0d838fd641531a11a5ee33b493/yarl-1.24.5-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e1ae548a9d901adca07899a4147a7c826bbcc06239d3ce9a59f57886a28a4c88", size = 142533, upload-time = "2026-07-20T02:07:08.284Z" },
+ { url = "https://files.pythonhosted.org/packages/ae/71/4acd3a1fc7cf14345cdb302665ecd2097f62c365b4f14ca17d4f37775cf9/yarl-1.24.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:ff405d91509d88e8d44129cd87b18d70acd1f0c1aeabd7bc3c46792b1fe2acba", size = 100776, upload-time = "2026-07-20T02:07:10.197Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/0b/cfb76b7fe99686db264bff829779a539d923e7564ffd7ef18da6c54c3774/yarl-1.24.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:47e98aab9d8d82ff682e7b0b5dded33bf138a32b817fcf7fa3b27b2d7c412928", size = 100913, upload-time = "2026-07-20T02:07:12.357Z" },
+ { url = "https://files.pythonhosted.org/packages/8b/3f/7116e782992abbd4fb6948488aec72078895e929a23078290739e8396fce/yarl-1.24.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0a658a6d3fafee5c6f63c58f3e785c8c43c93fbc02bf9f2b6663f8185e0971f", size = 106507, upload-time = "2026-07-20T02:07:14.173Z" },
+ { url = "https://files.pythonhosted.org/packages/33/90/d4d2d73ee78229cc889872eb8e085d8f5c6f51abdb178409fd9b23cf74fd/yarl-1.24.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4377407001ca3c057773f44d8ddd6358fa5f691407c1ba92210bd3cf8d9e4c95", size = 99219, upload-time = "2026-07-20T02:07:16.019Z" },
+ { url = "https://files.pythonhosted.org/packages/3e/fa/a6df1a9bccd644eec00abee0dff4277416222cec435330fd1f2858523ec1/yarl-1.24.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7c0494a31a1ac5461a226e7947a9c9b78c44e1dc7185164fa7e9651557a5d9bc", size = 111804, upload-time = "2026-07-20T02:07:18.141Z" },
+ { url = "https://files.pythonhosted.org/packages/8a/9e/7b2a1f4bcc20e9447156dd2b1c4d01f70d9df0759025ee7d09a84ffae134/yarl-1.24.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a7cff474ab7cd149765bb784cf6d78b32e18e20473fb7bda860bce98ab58e9da", size = 110943, upload-time = "2026-07-20T02:07:20.06Z" },
+ { url = "https://files.pythonhosted.org/packages/08/ff/22c92affb0f9b623ca753d27d968b5625b868f12c6378d049d55ae247643/yarl-1.24.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cbb833ccacdb5519eff9b8b71ee618cc2801c878e77e288775d77c3a2ced858a", size = 108251, upload-time = "2026-07-20T02:07:22.217Z" },
+ { url = "https://files.pythonhosted.org/packages/45/44/5769b96298c1e195fb412997b6090af2a84105cf59c17613558a2d011d1f/yarl-1.24.5-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:82f75e05912e84b7a0fe57075d9c59de3cb352b928330f2eb69b2e1f54c3e1f0", size = 106025, upload-time = "2026-07-20T02:07:24.083Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/40/009e8e791fd9762c0e1567e69248acb4f49064597e1680874c16dd8bb798/yarl-1.24.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:16a2f5010280020e90f5330257e6944bc33e73593b136cc5a241e6c1dc292498", size = 106573, upload-time = "2026-07-20T02:07:26.248Z" },
+ { url = "https://files.pythonhosted.org/packages/20/c6/b7480578f8a0a80946f36ad6df547ecec704f9ba69d2de60f8aa6f1c1cbf/yarl-1.24.5-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:ffcd54362564dc1a30fb74d8b8a6e5a6b11ebd5e27266adc3b7427a21a6c9104", size = 100751, upload-time = "2026-07-20T02:07:28.098Z" },
+ { url = "https://files.pythonhosted.org/packages/d4/27/4476f3360b91a48c5cf125e91f59a3bd35299d84a431a258d57f5977bb11/yarl-1.24.5-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0465ec8cedc2349b97a6b595ace64084a50c6e839eca40aa0626f38b8350e331", size = 111643, upload-time = "2026-07-20T02:07:30.88Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/4b/5cdd3e5ee944e8af31e52f6cd3d3af5fd7b937e036ccbbba2c9ffebede95/yarl-1.24.5-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4db9aecb141cb7a5447171b57aa1ed3a8fee06af40b992ffc31206c0b0121550", size = 106312, upload-time = "2026-07-20T02:07:33.06Z" },
+ { url = "https://files.pythonhosted.org/packages/18/86/f406b0c2a6f99575de2da671ef47aa06f89a5be83a27a46971c3b86cecdb/yarl-1.24.5-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:f540c013589084679a6c7fac07096b10159737918174f5dfc5e11bf5bca4dfe6", size = 110379, upload-time = "2026-07-20T02:07:35.155Z" },
+ { url = "https://files.pythonhosted.org/packages/f0/6c/9f3adfbd3b30b4fa0f7ccb3a83eba2c1152d3fff554d535e640ba0f7ba2b/yarl-1.24.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a61834fb15d81322d872eaafd333838ae7c9cea84067f232656f75965933d047", size = 108497, upload-time = "2026-07-20T02:07:37.35Z" },
+ { url = "https://files.pythonhosted.org/packages/dd/37/91eb2e5ca883a529c1b390348a74cd9fc0512171727f547ce70bfe02be5c/yarl-1.24.5-cp314-cp314t-win_amd64.whl", hash = "sha256:5c88e5815a49d289e599f3513aa7fde0bc2092ff188f99c940f007f90f53d104", size = 102450, upload-time = "2026-07-20T02:07:39.578Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/f4/ed5c402ac8fde4403ed3366c2716bfddc8a6677ebd59f3d62772cc7fe468/yarl-1.24.5-cp314-cp314t-win_arm64.whl", hash = "sha256:cf139c02f5f23ef6532040a30ff662c00a318c952334f211046b8e60b7f17688", size = 97222, upload-time = "2026-07-20T02:07:41.55Z" },
+ { url = "https://files.pythonhosted.org/packages/61/02/962c1cbfc401a30c1d034dc67ff395f64b52302c6d62de556c1fca99acc0/yarl-1.24.5-py3-none-any.whl", hash = "sha256:a33700d13d9b7d84fd10947b09ff69fb9a792e519c8cb9764a3ca70baa6c23a7", size = 58612, upload-time = "2026-07-20T02:07:43.461Z" },
+]
+
+[[package]]
+name = "zeroconf"
+version = "0.150.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+ { name = "ifaddr" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/09/ea/34bb185645ecaa18d34e5883bffea71aa9bffbbb994634884e8b2f3ad0c4/zeroconf-0.150.0.tar.gz", hash = "sha256:a5fe7feab1de6ef5e541e0a3d07e534fd91629b813fc27281593584100f63164", size = 213634, upload-time = "2026-06-22T17:52:37.982Z" }
+wheels = [
+ { url = "https://files.pythonhosted.org/packages/63/a4/49a46fcf1afe8f96bec6751e4fe761ce2cd9c124f0d01748f69fa5566013/zeroconf-0.150.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1aba87b6c1cdb6859d0c2291c67dc7d3ac06612250fddd95f68b7632e1e89a79", size = 1684292, upload-time = "2026-06-22T18:24:08.468Z" },
+ { url = "https://files.pythonhosted.org/packages/17/f4/520eccd6156c066efc03ff41130ce5119ec69b70de90d47b5b69282f9993/zeroconf-0.150.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e17a3adc2e4e425c59a1f2a72e289706ec6655fead4d5287f23e1748663df7dc", size = 2088058, upload-time = "2026-06-22T18:24:10.084Z" },
+ { url = "https://files.pythonhosted.org/packages/39/b6/0103805657b4656ff026e74ca5591189b53c49c35a86a54289c9376639ed/zeroconf-0.150.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:00fa39069437e68fe7c32856f7d041f46cd57f4f5a13ca75ae8f1c49e39932be", size = 1884499, upload-time = "2026-06-22T18:24:11.691Z" },
+ { url = "https://files.pythonhosted.org/packages/37/41/32b19f3bd7a615f67d0157cef6cfbeb432ea3a16a42d8fbf104706677567/zeroconf-0.150.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e50a7b3d5922ac9bb53129c4dbc381b0af2f49067670f35eb9c9b4ad341bde28", size = 2185601, upload-time = "2026-06-22T18:24:13.852Z" },
+ { url = "https://files.pythonhosted.org/packages/e3/44/0fcaf6e1ffea86d685e200de3597c13322552e53aecdf35ea135c1f685b4/zeroconf-0.150.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b93e7cc90a150e6e0a706251c745f2425782cdbc3a7a8b8a12123b96d167960e", size = 2116173, upload-time = "2026-06-22T18:24:16.072Z" },
+ { url = "https://files.pythonhosted.org/packages/ca/9e/c61025e2cf9d4f436130c2db18c118452c7372c0c1076e08720ccfa36c4f/zeroconf-0.150.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8cd46be1653a194ffb583012ffdf284a5042a1dacd7f44b7befc5de1e8491ba8", size = 2114605, upload-time = "2026-06-22T18:24:17.804Z" },
+ { url = "https://files.pythonhosted.org/packages/87/5d/76c4f2f2253e2acbc857c521827902cd11fb82d8300088e8ee7174176d21/zeroconf-0.150.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:e4f973c9f284031bcc698f1357a44900254ba7f6488c3b9a18541f0221b3f091", size = 1974248, upload-time = "2026-06-22T18:24:19.722Z" },
+ { url = "https://files.pythonhosted.org/packages/1d/a0/43692be8525f7908979a8d7955563f64e01489e8986b6baf3614f1fa784f/zeroconf-0.150.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:626d057f5a65b2126a6799e538ad78b329cb366c3a5fb9f69757ee23ee06ce5f", size = 2120678, upload-time = "2026-06-22T18:24:21.589Z" },
+ { url = "https://files.pythonhosted.org/packages/6d/b7/5ecbdad936a8670a15771a0d2ff54d9675ea1d53d49ce427fe4352ae97e7/zeroconf-0.150.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1ddb105722ac7dfdd7b6e0880ef52f955e679fd37a5f3247c6050c74259bda96", size = 2207205, upload-time = "2026-06-22T18:24:23.335Z" },
+ { url = "https://files.pythonhosted.org/packages/ee/45/77891ee52b8d2e992fb3ac67e3178b419f57e795c631bf1445f01f61cf30/zeroconf-0.150.0-cp312-cp312-win32.whl", hash = "sha256:191972a56d69cb1c6dd472d6af9813730c1937e2e6f89c01e5373df9ab878e11", size = 1277139, upload-time = "2026-06-22T18:24:24.945Z" },
+ { url = "https://files.pythonhosted.org/packages/cf/9c/e98b18a621055833433f95342aa7cfba052695f6dcd086853d35c0ffd914/zeroconf-0.150.0-cp312-cp312-win_amd64.whl", hash = "sha256:e68cb166f6b535c42550a554ed00939256045e18df8b998f8af3a3bd50506e99", size = 1514592, upload-time = "2026-06-22T18:24:26.699Z" },
+ { url = "https://files.pythonhosted.org/packages/37/61/635e7e6405855afa85a424cc0549f74ba077690287776ad45a11d78b7cdc/zeroconf-0.150.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4f79d9ce9cc40e14d2f7b8e4af9dcc893b7f7793be91d14a61a77ccb1ab5c90b", size = 1670236, upload-time = "2026-06-22T18:24:28.471Z" },
+ { url = "https://files.pythonhosted.org/packages/84/78/83b5825eb1d7fd4d32b7acbff5f3becca11c544403fc7f05835d9b3aa3f3/zeroconf-0.150.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f9ba6980ad92820f56a02a5035e21338c116145db44749462fc46f8f50028bb", size = 2080139, upload-time = "2026-06-22T18:24:30.158Z" },
+ { url = "https://files.pythonhosted.org/packages/bf/68/8e764531d395acaf69f382e252a5e02b9841e417e30c53019442c9e9daee/zeroconf-0.150.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1a67dfae0d99b4f29f34721c7bbb2f3529507c64089addec9a565dc791524688", size = 1881686, upload-time = "2026-06-22T18:24:32.184Z" },
+ { url = "https://files.pythonhosted.org/packages/43/2d/60a04c3cf7e243e47d60152394a5e29a4839ea8fd1c260868ff7af08240d/zeroconf-0.150.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:489a51320d20e7f07b2f447cd515f3645d17ceced0212f7249a83ce6d3b748e0", size = 2179819, upload-time = "2026-06-22T18:24:34.051Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/d6/1bb519d2843f383a625ad82e76d0dd8c185eab77b6d11f08e68fd3e04a09/zeroconf-0.150.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc160b8ba6a2420d665fb677c37fd2ab006141344bbf92abea72328bfd38bd3b", size = 2115584, upload-time = "2026-06-22T18:24:35.777Z" },
+ { url = "https://files.pythonhosted.org/packages/e4/ce/4cd36bfc74f7cf41cfef83333771cfa69ebab95f357ce605fc049b727f1d/zeroconf-0.150.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33843e0317bff2e03e56e246c3f25aab72ddb0a704f05bd792a4e78bdb5db801", size = 2111253, upload-time = "2026-06-22T18:24:37.911Z" },
+ { url = "https://files.pythonhosted.org/packages/d6/a2/ad3179888582ad22fd8c7c640e66a834669510deb24b1dedd9bfe6d6b0c5/zeroconf-0.150.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:024b00e64aae022ac6bdd7fe5afdabae570937c10d1242438ca04a4c62dfcd17", size = 1975576, upload-time = "2026-06-22T18:24:39.622Z" },
+ { url = "https://files.pythonhosted.org/packages/87/5b/44d5dc609037a2d4b1ca53ff44d22c2cec4a5b2cff81c7b75e99136679a0/zeroconf-0.150.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2ee2297e383ac21193d84982e714029eafec470926315ab78b27a024858e4e5d", size = 2124978, upload-time = "2026-06-22T18:24:41.315Z" },
+ { url = "https://files.pythonhosted.org/packages/0f/9b/d4ff809d86280e756599fd712624376731aef6928be15f98e8834c3f45d2/zeroconf-0.150.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2a03d493c3e9c4b4a5aaaf0408da7c025ed014f3c3df639cdd2c6cb518c42b4b", size = 2202468, upload-time = "2026-06-22T18:24:44.154Z" },
+ { url = "https://files.pythonhosted.org/packages/43/3a/d0ca371828acebc7cab64d8460832b9bca7e9cbecefebd130bd8f3068f68/zeroconf-0.150.0-cp313-cp313-win32.whl", hash = "sha256:dc054a6b7772ec97fe215e8f8f35f43509cc9f1bf909791fe003acbaa78fd9b2", size = 1274140, upload-time = "2026-06-22T18:24:46.456Z" },
+ { url = "https://files.pythonhosted.org/packages/d8/43/46bcbf3260c4726242042b69ebab13878bf14c167530bde56b6df267b55b/zeroconf-0.150.0-cp313-cp313-win_amd64.whl", hash = "sha256:122c6bec1f462c0feaa7f8fe4a4bc605f5c0d8f8e82e2ebd5aeae48a24da4564", size = 1511540, upload-time = "2026-06-22T18:24:48.43Z" },
+ { url = "https://files.pythonhosted.org/packages/18/08/22ccf6d3ba5f29d343dc8f9d45e2d8adbfc80b780c55a601fa7811d30d6f/zeroconf-0.150.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:dcfba6f9d344ade1f60aa8b5621a2fa8f65fbe740edc40b05627516bc55eec8f", size = 1686768, upload-time = "2026-06-22T18:24:50.421Z" },
+ { url = "https://files.pythonhosted.org/packages/de/4a/f4df1ee10bf74cff25c8825d3490b8b71f57d7ec559c84b76bae42ee3444/zeroconf-0.150.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:31832790ed1bcf829b91d4697c6497fade20dbe1094c35d10d5af456cd0e8360", size = 2105247, upload-time = "2026-06-22T18:24:52.283Z" },
+ { url = "https://files.pythonhosted.org/packages/ed/d6/8af2192c3ffd8d67c36a369cdbf1ab388b672ef1a94e5baf73c8f003f08f/zeroconf-0.150.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9ed611401d1e39f7d27e9cec8ef0b06fffad06955cc3c54714075b037d7b6a8b", size = 1859144, upload-time = "2026-06-22T18:24:54.615Z" },
+ { url = "https://files.pythonhosted.org/packages/52/d8/09ae5f45ad6bde1decf246152c5a3c5183829ab3966d90cec2b06e9dc468/zeroconf-0.150.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0aac92f26cfe8075d6e210e5edb8194cc0b1d16eecdcdb04f31056a14cbc6466", size = 2191079, upload-time = "2026-06-22T18:24:56.439Z" },
+ { url = "https://files.pythonhosted.org/packages/60/78/3d46201c05a22b3eae1e48e82540590c8689a7646183f9f2c28b70e6edfa/zeroconf-0.150.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:2fdaffee6f71432c64b609ade44e48763484b6084c7954eafeeff0cf4dbc4aef", size = 2125023, upload-time = "2026-06-22T18:24:58.322Z" },
+ { url = "https://files.pythonhosted.org/packages/4d/d9/65bf08d612551306227cc0843d0d468678d88dc1b101fdc2861c6938c40b/zeroconf-0.150.0-cp314-cp314-manylinux_2_41_x86_64.whl", hash = "sha256:2bce10cb490119ad051f3caf74088317fec9f5e9acbe36e3690abe8d3de2ac31", size = 2187807, upload-time = "2026-06-22T17:52:35.597Z" },
+ { url = "https://files.pythonhosted.org/packages/4c/a6/fa1f712409f438d6a5b8f61c6592747f54894ae770841f8a2d659d79c638/zeroconf-0.150.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:048533286135c467a3bb90a268a9ca3ee3b98c3809d0106359e4d4c0e375e8ad", size = 2136974, upload-time = "2026-06-22T18:25:00.098Z" },
+ { url = "https://files.pythonhosted.org/packages/35/a4/e8075345b6a61cbc8c7d75ef4d6bb58d0055dbb75887c6f3789f64214b60/zeroconf-0.150.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:12f14afb42c08b8365d638ba2a01e5a73641dc8d5433fcdf8751d636210db053", size = 1944626, upload-time = "2026-06-22T18:25:02.376Z" },
+ { url = "https://files.pythonhosted.org/packages/c7/b7/417e588bb208d9298e081f00aa41134becf6d05738169f67f68f9a0faa0f/zeroconf-0.150.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:cf19d67827af63c54175ef76a62a004734c0d18ac67ff383a5df36c26049707e", size = 2133245, upload-time = "2026-06-22T18:25:04.358Z" },
+ { url = "https://files.pythonhosted.org/packages/7f/b9/6de53f203e36275f2ea97566c36af7ad28e0def6a84da639ad4eef84910d/zeroconf-0.150.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:49ae4f9109b2b7aa04fd75677ce33d552bb3db6f9e757acc6e2f6a547cbe26b2", size = 2213535, upload-time = "2026-06-22T18:25:06.239Z" },
+ { url = "https://files.pythonhosted.org/packages/32/2d/e3509c21b146048759ea63af392972d5d3b39a218db58415ae84fbf3cfce/zeroconf-0.150.0-cp314-cp314-win32.whl", hash = "sha256:afad9aae3a10c4e54a0b55925c29b9d82d1e807f996e5e106a2b2fade6a9e3cc", size = 1306214, upload-time = "2026-06-22T18:25:08.291Z" },
+ { url = "https://files.pythonhosted.org/packages/eb/97/d0d1221906963596d59f7a76086d22392a530f5851278fbe093db46809bf/zeroconf-0.150.0-cp314-cp314-win_amd64.whl", hash = "sha256:cd09bf1242af33769c88e1f0236ce52f6c74144a741c848fe38a79e68df80414", size = 1549661, upload-time = "2026-06-22T18:25:11.245Z" },
+ { url = "https://files.pythonhosted.org/packages/81/4f/631f56f09dbe1aad76a3dd38bb92d4e5cce50a6630064590926d578d21da/zeroconf-0.150.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fed39ccd107ee219ad805ee4c38dca253effc1c96541b4954dee3c70dca13a71", size = 3362888, upload-time = "2026-06-22T18:25:13.066Z" },
+ { url = "https://files.pythonhosted.org/packages/5f/9a/53d1111468a69f395272531cb292c09e7b03ecf6186476d2c4a6dbe78198/zeroconf-0.150.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:55d0c37be291364268688fe5dcd33bd5156f669289bb9b71a23b041ca53c9017", size = 4023043, upload-time = "2026-06-22T18:25:15.023Z" },
+ { url = "https://files.pythonhosted.org/packages/ba/d7/4ce3504120afa854fb55799b4f0e36c27b8d3def3d41f2d1731179bd7c19/zeroconf-0.150.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b97234eda197d4243d859b64004d175de76353dbca17527d11705f841fb02977", size = 3560681, upload-time = "2026-06-22T18:25:17.158Z" },
+ { url = "https://files.pythonhosted.org/packages/82/60/5804e6362e4e3dae64923423b46c0fcc291a341d1e8ed50fec7af1cd73e7/zeroconf-0.150.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01a31f0ec4bc3f125ae541fb96259a081f3f83d201f1fca59929155b90185df4", size = 4178405, upload-time = "2026-06-22T18:25:19.735Z" },
+ { url = "https://files.pythonhosted.org/packages/2a/2c/502e92caa81a7932fca22f78778e622ddca318f8d2243eddcf24d24ec0e7/zeroconf-0.150.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7ee162b43e455043e22753cdc1fae0f2990d3fe3767f2e88695fb92273d7229b", size = 4044586, upload-time = "2026-06-22T18:25:21.812Z" },
+ { url = "https://files.pythonhosted.org/packages/45/a3/a37dd7fc0b22e0c2e13b279611ae8060fb046d3712a7d33313c8b7b556a9/zeroconf-0.150.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:178b6141e34a777593a16b8bf986b2d7ae806e47849a3ad517597f63bcaade47", size = 4089064, upload-time = "2026-06-22T18:25:24.169Z" },
+ { url = "https://files.pythonhosted.org/packages/41/7f/c2e7aeb8feb1a6ef3474d66774fad1c7b6040ac1bc48b188110d3c9d17a2/zeroconf-0.150.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:410e30a80db9b73bfdee3c54dfe306ebb140e053dfe3b28cefd54756a19a73fe", size = 3717837, upload-time = "2026-06-22T18:25:26.305Z" },
+ { url = "https://files.pythonhosted.org/packages/f2/ee/b6b5b5f4f51296b7c686f57642003369478fe60a33a917f4421a6e20fc85/zeroconf-0.150.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c539950bba739bc3980dd0f01187637e6237ada8bd70d64f93d8eb5eb2837a7b", size = 4072641, upload-time = "2026-06-22T18:25:28.356Z" },
+ { url = "https://files.pythonhosted.org/packages/54/77/3c292c091b636c3a0af5c69e1d1ffe83261737d34075efc889fe25380b32/zeroconf-0.150.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c8ccc9e1772ce0030f77e6a49542e9b7ca4e8ae9ce1bef84a3a983be68ddf81c", size = 4225357, upload-time = "2026-06-22T18:25:30.468Z" },
+ { url = "https://files.pythonhosted.org/packages/e5/5b/54758b003fe687757f9d8313a8ceaa7560e1c392ac109890782283ba1840/zeroconf-0.150.0-cp314-cp314t-win32.whl", hash = "sha256:576e72a9e9140d96ae110ceb0935f06fa41eeea8b2be53e442a6a00c84035194", size = 2599274, upload-time = "2026-06-22T18:25:32.463Z" },
+ { url = "https://files.pythonhosted.org/packages/ff/be/9eb576ae5eeede25cd1e59f0be1ce6b2fcf7aa5a4ab4d6d05de2d30efc4a/zeroconf-0.150.0-cp314-cp314t-win_amd64.whl", hash = "sha256:bdae152e80b848117691ab59aa8b16bf15323c0e9f3ddc38c6345af95a700a84", size = 3106484, upload-time = "2026-06-22T18:25:34.89Z" },
+]