diff --git a/.env.example b/.env.example deleted file mode 100644 index 0e5b862..0000000 --- a/.env.example +++ /dev/null @@ -1,28 +0,0 @@ -# OpenAI API Configuration (Optional - only needed for translation and response generation) -# Transcription now works locally for free! -OPENAI_API_KEY=your_openai_api_key_here - -# Optional: Google Translate API (alternative to OpenAI for translation) -GOOGLE_TRANSLATE_API_KEY=your_google_translate_api_key_here - -# Whisper Model Settings (Local transcription) -WHISPER_MODEL_SIZE=base -# Options: tiny, base, small, medium, large-v2, large-v3 -# Smaller = faster but less accurate, Larger = slower but more accurate -WHISPER_DEVICE=auto -# Options: cpu, cuda, auto - -# User Preferences -USER_LANGUAGE=en -AUTO_DETECT_SOURCE_LANGUAGE=true - -# Audio Settings -AUDIO_DEVICE_ID= -SAMPLE_RATE=16000 -CHUNK_DURATION_SECONDS=5 - -# Window Settings -WINDOW_OPACITY=0.9 -WINDOW_X=100 -WINDOW_Y=100 - diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..a33f870 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,140 @@ +name: CI + +on: + push: + pull_request: + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: ci-${{ github.ref }} + cancel-in-progress: true + +jobs: + # Keeps uv.lock in sync with pyproject.toml. On feature branches it also applies + # ruff's safe autofixes and formatting, and commits them; on main it only checks. + housekeeping: + name: Lockfile and formatting + runs-on: ubuntu-latest + permissions: + contents: write + outputs: + sha: ${{ steps.commit.outputs.sha }} + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.sha || github.ref }} + - uses: astral-sh/setup-uv@v6 + - name: Resolve dependencies + run: uv lock + - name: Autofix (feature branches only) + if: github.event_name == 'push' && github.ref != 'refs/heads/main' + run: | + uvx ruff@0.14.0 check --fix --exit-zero . + uvx ruff@0.14.0 format . + - name: Commit changes + id: commit + shell: bash + run: | + if [ -n "$(git status --porcelain)" ]; then + if [ "${{ github.event_name }}" != "push" ]; then + git status --porcelain + echo "::error title=Out of date::uv.lock or formatting is out of date; run 'uv lock' and 'ruff format'" + exit 1 + fi + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git add -A + git commit -m "chore(ci): update uv.lock and apply ruff fixes" + git push + fi + echo "sha=$(git rev-parse HEAD)" >> "$GITHUB_OUTPUT" + + test: + name: Test (${{ matrix.os }}, py${{ matrix.python }}) + needs: housekeeping + strategy: + fail-fast: false + matrix: + os: [ubuntu-latest, windows-latest, macos-latest] + python: ["3.10", "3.12"] + runs-on: ${{ matrix.os }} + env: + # Native windows on Windows so the real capture-shield API is exercised. + QT_QPA_PLATFORM: ${{ matrix.os == 'windows-latest' && 'windows' || 'offscreen' }} + PYTHONUTF8: "1" + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.housekeeping.outputs.sha }} + - uses: astral-sh/setup-uv@v6 + with: + python-version: ${{ matrix.python }} + - name: System libraries (Linux) + if: runner.os == 'Linux' + run: | + sudo apt-get update + sudo apt-get install -y --no-install-recommends libegl1 libgl1 libxkbcommon0 \ + libxkbcommon-x11-0 libfontconfig1 libdbus-1-3 libportaudio2 + - name: Install (locked) + id: install + run: uv sync --locked + - name: Lint + shell: bash + run: uv run ruff check --output-format=concise . | uv run python scripts/ci_annotate.py lines ruff + - name: Type check + if: ${{ !cancelled() && steps.install.outcome == 'success' }} + shell: bash + run: uv run mypy | uv run python scripts/ci_annotate.py lines mypy + - name: Tests + id: tests + if: ${{ !cancelled() && steps.install.outcome == 'success' }} + shell: bash + run: uv run pytest -q --junitxml=junit.xml --cov=polyglot --cov-report=term-missing:skip-covered + - name: Real capture shield on Windows + if: ${{ runner.os == 'Windows' && !cancelled() && steps.install.outcome == 'success' }} + shell: bash + run: uv run python scripts/shield_check.py + - name: Annotate test failures + if: failure() + shell: bash + run: test -f junit.xml && uv run python scripts/ci_annotate.py junit junit.xml || true + - name: Diagnose a crashed test run + if: ${{ failure() && steps.tests.outcome == 'failure' }} + shell: bash + run: | + uv run pytest -v -p no:cacheprovider -o addopts="" -m "not slow" 2>&1 \ + | uv run python scripts/ci_annotate.py tail "crashed test run (last lines)" || true + + models: + name: Real models (Whisper tiny, Silero) + needs: housekeeping + runs-on: ubuntu-latest + env: + QT_QPA_PLATFORM: offscreen + steps: + - uses: actions/checkout@v4 + with: + ref: ${{ needs.housekeeping.outputs.sha }} + - uses: astral-sh/setup-uv@v6 + with: + python-version: "3.12" + - name: System libraries + run: | + sudo apt-get update + sudo apt-get install -y --no-install-recommends espeak-ng libportaudio2 libegl1 \ + libgl1 libxkbcommon0 libfontconfig1 libdbus-1-3 + - uses: actions/cache@v4 + with: + path: ~/.cache/huggingface + key: hf-whisper-tiny + - run: uv sync --locked + - name: Slow tests + shell: bash + run: uv run pytest -m slow -q --junitxml=junit.xml + - name: Annotate test failures + if: failure() + shell: bash + run: test -f junit.xml && uv run python scripts/ci_annotate.py junit junit.xml || true diff --git a/.gitignore b/.gitignore index 8c6fa59..d395afe 100644 --- a/.gitignore +++ b/.gitignore @@ -1,48 +1,34 @@ -# Python -__pycache__/ -*.py[cod] -*$py.class -*.so -.Python -build/ -develop-eggs/ -dist/ -downloads/ -eggs/ -.eggs/ -lib/ -lib64/ -parts/ -sdist/ -var/ -wheels/ -*.egg-info/ -.installed.cfg -*.egg - -# Virtual Environment -venv/ -env/ -ENV/ -.venv - -# Environment variables -.env -.env.local - -# IDE -.vscode/ -.idea/ -*.swp -*.swo -*~ - -# OS -.DS_Store -Thumbs.db - -# Application specific -.polyglot/ -*.log -dumps/ - +# Python +__pycache__/ +*.py[cod] +*.egg-info/ +build/ +dist/ +.venv/ +venv/ + +# Tooling caches +.pytest_cache/ +.mypy_cache/ +.ruff_cache/ +.coverage +coverage.xml +junit*.xml +htmlcov/ + +# Secrets and local config (v1 keeps keys in the OS keyring; never commit these) +.env +.env.* +config.toml + +# Recorded audio (v0 dumps, local test recordings) +dumps/ +*.wav +!tests/fixtures/**/*.wav + +# Editors / OS +.vscode/ +.idea/ +.cursor/ +.DS_Store +Thumbs.db diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..4d0cd97 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Yousef Alhashemi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md index 1a8f664..c690953 100644 --- a/README.md +++ b/README.md @@ -1,104 +1,106 @@ -# Polyglot - Real-time Interview Translation Assistant - -A cross-platform desktop application that captures audio from video call services (Zoom, Microsoft Teams, Google Meet, etc.) and provides real-time transcription, translation, and AI-generated response suggestions. - -## Features - -- **Real-time Audio Capture**: Captures system audio from any call service -- **Live Transcription**: Uses local Whisper model (free, no API costs!) -- **Instant Translation**: Translates between multiple languages in real-time (requires API key) -- **AI Response Suggestions**: Generates contextually appropriate responses in both languages (requires OpenAI API key) -- **Transparent Overlay**: Non-intrusive floating window that stays on top -- **Screen Share Invisible**: Window visible to you but invisible in screen shares -- **Cross-platform**: Works on Windows and macOS - -## Installation - -1. Clone this repository -2. Install dependencies: - ```bash - pip install -r requirements.txt - ``` -3. Copy `.env.example` to `.env` (optional - only needed for translation/response features): - ```bash - cp .env.example .env - ``` -4. (Optional) Edit `.env` and add API keys: - - **Transcription works locally for free!** No API key needed. - - Add `OPENAI_API_KEY` only if you want translation and response generation - - Or add `GOOGLE_TRANSLATE_API_KEY` for translation only - -## Usage - -### List Available Audio Devices -First, check what audio devices are available: -```bash -python list_audio_devices.py -``` - -### Run the Application -Run the application from the project root: -```bash -python src/main.py -``` - -Or run as a module: -```bash -python -m src.main -``` - -The application will: -- Start capturing system audio -- Display a transparent overlay window -- Show original text, translations, and response suggestions -- Automatically hide when screen sharing is detected - -## Audio Device Setup - -**Important for Windows users**: Capturing system audio requires a loopback device or virtual audio cable. - -### Option 1: Use Windows WASAPI Loopback (if available) -Some Windows systems have built-in loopback devices. Run `python list_audio_devices.py` to see available devices. - -### Option 2: Install a Virtual Audio Device (Recommended) -Install one of these free tools: -- **VB-Audio Cable**: https://vb-audio.com/Cable/ -- **OBS Virtual Audio**: Comes with OBS Studio -- **Voicemeeter**: https://vb-audio.com/Voicemeeter/ - -After installation: -1. Set your call application (Zoom, Teams, etc.) to output to the virtual device -2. Run `python list_audio_devices.py` to find the device ID -3. Set `AUDIO_DEVICE_ID=` in your `.env` file - -## Configuration - -Edit the `.env` file to configure: -- API keys (OpenAI required, Google Translate optional) -- Source and target languages -- Audio device selection (use `list_audio_devices.py` to find device IDs) -- Window position and opacity - -## Requirements - -- Python 3.8+ -- **No API key needed for transcription!** (runs locally) -- OpenAI API key (optional - only for translation and response generation) -- Windows 10+ or macOS 10.14+ - -## Model Sizes - -The local Whisper model can be configured in `.env`: -- `tiny` - Fastest, least accurate (~39MB) -- `base` - Good balance (default, ~74MB) -- `small` - Better accuracy (~244MB) -- `medium` - High accuracy (~769MB) -- `large-v2` - Best accuracy (~1.5GB) -- `large-v3` - Latest best accuracy (~1.5GB) - -First run will download the model automatically. - -## License - -MIT - +# Polyglot + +A small always-on-top window that listens to the other side of a call, transcribes it +locally, translates it into your language, and suggests replies in theirs when you +press a hotkey. + +* **Local speech recognition** with [faster-whisper](https://github.com/SYSTRAN/faster-whisper). + Audio never leaves your machine. +* **Sentence-aware**: voice-activity detection (Silero VAD) cuts audio at the speaker's + pauses, not every N seconds, so Whisper and the translator see whole sentences. +* **Translation** (OpenAI or Google) and **reply suggestions** (OpenAI) are opt-in. + Only text is sent, and only once you enable them. +* **Hidden from screen sharing on Windows 10 2004+**: the window stays visible to you + but is left out of captures. Not possible on macOS 15+ (see + [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md#platform-layer)), so the window shows a + "visible in screen share" indicator there. + +> Status: v1 rewrite (`1.0.0.dev0`). The v0 prototype is tagged `v0.1.0`. + +## Quick start + +Requires Python 3.10+ and [uv](https://docs.astral.sh/uv/). + +```bash +uv sync # creates .venv and installs the exact locked versions +uv run polyglot --demo # try the UI with synthetic audio: no models, keys or network +uv run polyglot # the real thing +``` + +On first real run Whisper downloads its model (`base` is about 150 MB). + +### Hotkeys (system-wide) + +| Action | Default | +| --- | --- | +| Suggest replies to the last sentence | `Ctrl+Alt+S` | +| Show / hide the window | `Ctrl+Alt+H` | + +Inside the window: `Ctrl+Enter` suggests, `Esc` hides. Click a suggestion to copy it. + +### Audio source + +* **Windows**: captures system audio directly (WASAPI loopback). No virtual cable is needed. +* **macOS**: install [BlackHole](https://github.com/ExistentialAudio/BlackHole), route + the call's output to it (a Multi-Output Device lets you still hear it), and pick it in + Settings → Audio. + +`uv run polyglot --list-devices` lists input and loopback devices. + +### API keys + +Settings → Translation stores keys in the OS keychain (Windows Credential Manager or +macOS Keychain), never in a file. For development, `POLYGLOT_OPENAI_API_KEY` / +`OPENAI_API_KEY` and `POLYGLOT_GOOGLE_API_KEY` override the keychain. + +### Models + +Settings → Translation and Settings → Suggestions each have a model dropdown. It starts +with a short built-in list and, once an OpenAI key is set, loads the chat models your key +can actually use (Refresh reloads it). Any model ID can also be typed in. Defaults: +`gpt-4o-mini` for translation and `gpt-4.1-mini` for suggestions. OpenAI retires both on +2027-01-14 and names `gpt-6-luna` as the replacement. + +Older models get a `temperature`; reasoning models get the lowest `reasoning_effort` +that fits the job instead (`none` for translation, `low` for suggestions). If a model +rejects a parameter or value, the request is retried once without it, and that is +remembered for the session. + +## Configuration + +Settings are saved to `config.toml` in your user config directory +(`%LOCALAPPDATA%\polyglot` on Windows, `~/Library/Application Support/polyglot` on +macOS). [`config.example.toml`](config.example.toml) lists every option with its +default. Precedence, lowest to highest: defaults, then `config.toml`, then +`POLYGLOT_
__` environment variables (e.g. `POLYGLOT_ASR__MODEL=small`), +then changes made in the settings dialog. + +## Headless use + +```bash +uv run polyglot --file recording.wav --fast # transcribe (and translate) a WAV file +uv run polyglot --headless # listen live, print to the terminal +``` + +## Development + +```bash +uv sync # dev tools included +uv run pytest # fast suite: no models, devices or network +uv run pytest -m slow # real Whisper tiny + Silero (needs espeak-ng) +uv run ruff check . && uv run ruff format . +uv run mypy +``` + +Dependencies are declared in `pyproject.toml` and pinned in `uv.lock`. Add one with +`uv add ` (or `uv add --dev` for tooling) and commit both files. + +CI (GitHub Actions) runs lint, type checks and tests on Windows, macOS and Linux with +Python 3.10 and 3.12, plus a real-model job. On feature branches it also commits lockfile +updates and ruff autofixes. + +Architecture, the pipeline and design decisions: [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md). + +## License + +MIT diff --git a/config.example.toml b/config.example.toml new file mode 100644 index 0000000..fa6da18 --- /dev/null +++ b/config.example.toml @@ -0,0 +1,55 @@ +# Polyglot configuration. API keys are stored in the OS keyring, not here. + +[audio] +source = "auto" +ring_seconds = 30.0 +gap_fill = true + +[vad] +engine = "silero" +start_threshold = 0.5 +end_threshold = 0.35 +start_frames = 3 +end_silence_ms = 600 +pre_roll_ms = 300 +max_utterance_s = 15.0 +min_utterance_ms = 300 +partial_interval_ms = 0 + +[asr] +model = "base" +device = "auto" +compute_type = "auto" # auto | int8 | float16 | float32 | ... (auto: int8 on CPU, float16 on GPU) +beam_size = 5 +lock_after = 2 +lock_min_probability = 0.8 +queue_size = 8 + +[translation] +enabled = false +provider = "openai" +target_language = "en" +model = "gpt-4o-mini" # any OpenAI chat model ID; Settings lists the ones your key can use +timeout_s = 3.0 + +[suggestions] +enabled = false +model = "gpt-4.1-mini" # gpt-4o-mini and gpt-4.1-mini retire 2027-01-14 (replacement: gpt-6-luna) +timeout_s = 6.0 +conversation_type = "meeting" +history = 6 +options = 2 + +[ui] +opacity = 0.92 +x = 100 +y = 100 +width = 420 +height = 640 +hide_from_capture = true +hotkey_suggest = "++s" +hotkey_toggle = "++h" + +[privacy] +log_content = false +dump_audio = false diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md new file mode 100644 index 0000000..aa7d3b7 --- /dev/null +++ b/docs/ARCHITECTURE.md @@ -0,0 +1,192 @@ +# Polyglot v1 architecture + +Polyglot v1 is a pipeline of single-purpose stages around a pure-Python core. Imports +point inward only, there is one thread bridge to the UI, and only the coordinator writes +conversation state. This document describes what is built. The design rationale and the +critique of v0 that motivated it are in the "Polyglot v1 — Architecture Design" doc. + +## Layers + +![Layers](v1-layers.png) + +(Sources: `v1-layers.mmd`, `v1-pipeline.mmd`; render with `mmdc -i -o `.) + +| Layer | Package | May import | Knows about | +| --- | --- | --- | --- | +| Core | `polyglot.core` | stdlib, numpy | nothing outside itself | +| Adapters | `polyglot.adapters` | core + its own library (lazily) | one technology each | +| Platform | `polyglot.platform` | core, ctypes | the OS | +| Config | `polyglot.config` | core, pydantic, platformdirs | settings and secrets | +| Presentation | `polyglot.ui` | core (`presenter` is Qt-free; `ui.qt` adds PyQt6) | view model, widgets | +| Composition | `wiring`, `controller`, `app`, `__main__` | everything | which concrete class goes where | + +**The dependency rule is a test.** `tests/unit/test_architecture.py` parses every module's +imports and fails the build if the core imports anything but the standard library and +numpy, if an adapter or the platform layer imports the UI, or if the UI reaches into +adapters. OS checks (`sys.platform ==`) outside `polyglot.platform` also fail it. + +### Module map + +``` +src/polyglot/ + __main__.py CLI: GUI, --demo, --headless, --file, --list-devices + app.py Qt composition root: window, presenter, bridge, tray, hotkeys + wiring.py config -> adapters -> Pipeline (Qt-free); build_demo() for fakes + controller.py pipeline lifecycle; applies settings; rebuilds keeping the conversation + config.py AppConfig (pydantic), TOML load/save, env overrides, Secrets + logging_setup.py rotating file + stderr; no transcript text by default + core/ + models.py Utterance, SpeechSegment, Transcript, Suggestion, ReplyOption, IdSource + errors.py ProviderTimeout, ProviderUnavailable, QuotaExceeded, AuthError, ... + events.py UtteranceUpdated, SuggestionsReady, PipelineStatus, StageError, EventBus + ports.py AudioSource, Resampler, VoiceActivityModel, Transcriber, Translator, + Suggester, WindowShield, SecretStore + ringbuffer.py preallocated SPSC audio ring buffer with overrun accounting + segmenter.py VAD endpointing state machine (pure) + session.py conversation state + language lock policy + languages.py code <-> name + pipeline.py FrontEnd, AsrQueue, AsrWorker, Coordinator, Pipeline + adapters/ + audio/ wasapi_loopback, sounddevice_source, playback (WAV/array), resample (soxr) + vad/ silero (onnxruntime), energy + asr/ faster_whisper + translate/ openai, google + suggest/ openai (JSON-schema structured output) + http.py stdlib HTTPS client + status -> typed error mapping + secrets.py keyring store, memory store + fakes.py a working fake for every port + dump.py optional per-utterance WAV dumps + platform/ WindowsShield (SetWindowDisplayAffinity), UnsupportedShield + ui/ + presenter.py Presenter, RowVM, SuggestionVM, StatusVM, ViewPort, Commands + qt/ overlay, settings_dialog, bridge, shield_filter, hotkeys, theme.qss +``` + +## Domain model + +`Utterance` is the unit of work: one continuous stretch of the other person's speech. +It is a frozen dataclass. Every change makes a new copy, so a snapshot handed to +another thread can never change underneath it. + +| Status | Meaning | +| --- | --- | +| `LISTENING` | speech started, no text yet | +| `PARTIAL` | provisional text (only when partials are enabled) | +| `FINAL` | endpoint reached, text fixed; `error` set if translation failed | +| `TRANSLATED` | translation attached | +| `FAILED` | transcription failed or the utterance was dropped under overload | + +Utterance IDs come from one monotonic `IdSource` and define spoken order. Results are +placed by ID, never by arrival time. + +## Pipeline + +![Pipeline](v1-pipeline.png) + +| Thread | Job | Must never | +| --- | --- | --- | +| audio library callback | downmix and copy the block into the ring buffer | allocate per sample, log, touch disk | +| `polyglot-frontend` | resample to 16 kHz, cut 32 ms frames, VAD, segmenter, route | transcribe | +| `polyglot-asr` (exactly one) | load the model, transcribe segments in ID order | run in parallel with itself | +| `polyglot-net-*` (4) | translation and suggestion calls with timeouts | write state | +| `polyglot-coord` | own `Session`; apply results; dispatch; publish events | block on I/O | +| Qt main thread | receive events through `EventBridge`; presenter; view | (not part of the pipeline) | + +### Endpointing (`core/segmenter.py`) + +| Rule | Default | Config | +| --- | --- | --- | +| start: probability ≥ start threshold for N frames | 0.5 × 3 frames (~100 ms) | `vad.start_threshold`, `vad.start_frames` | +| pre-roll kept before the start | 300 ms | `vad.pre_roll_ms` | +| end: probability < end threshold for this long | 0.35 for 600 ms | `vad.end_threshold`, `vad.end_silence_ms` | +| force-cut at the quietest frame of the last 2 s | 15 s | `vad.max_utterance_s` | +| discard if less speech than | 300 ms | `vad.min_utterance_ms` | +| partial transcripts every | off | `vad.partial_interval_ms` | + +**Gap fill.** WASAPI loopback delivers no data at all while nothing is playing. Without +help, an utterance whose speaker stops talking would never see its 600 ms of silence. The +front end therefore feeds real-time-equivalent silence while an utterance is open and no +audio has arrived for 250 ms (`audio.gap_fill`). + +### Ordering, staleness and backpressure + +* Every result carries its utterance ID; the coordinator places it by ID. +* Nothing is dropped for being late. A late translation fills its own row. +* Suggestions run only on the hotkey, for the latest final utterance, with the last 6 + final utterances as context. A reply stays linked to the sentence it answers. If newer + sentences arrive first, the presenter marks it "newer sentences since". Pressing the + hotkey again supersedes an in-flight request: its result is ignored, since the newer + request wins. +* Older partials are skipped (a newer partial or the final covers the same audio). +* Ring buffer: 30 s; on overrun the oldest audio is overwritten, counted, and a + `FALLING_BEHIND` status is published. +* ASR queue: at most 8 waiting finals. When full, the oldest is dropped, marked + `FAILED(overloaded)`, and `FALLING_BEHIND` is published. Latency stays bounded instead of + growing for the whole session. +* Network: hard timeouts (translation 3 s, suggestions 6 s) and one retry with jitter + for retryable errors. + +### Lifecycle + +`Pipeline.start/stop` control listening (source, front end, ASR worker). The coordinator +and session outlive them, so suggestions and language commands keep working while +stopped. `stop` finishes and transcribes the utterance in progress. When a settings change +needs a new pipeline, the controller passes the old `session` and `ids` to the new one, +so the conversation continues and IDs keep increasing. + +## Presentation + +Model–View–Presenter with a passive view: + +* `EventBridge` is the only thread bridge. It subscribes to the bus and re-emits each event + as a queued Qt signal, so delivery happens on the GUI thread. +* `Presenter` (pure Python, unit-tested) keeps the view model, formats it (language names, + error wording, "translating…", "Replying to: …") and turns clicks and hotkeys into + `Commands`. +* `OverlayWindow` draws rows by ID, the suggestion panel, a status strip and the capture + indicator. It emits intent signals and holds no logic. + +## Platform layer + +| Concern | Windows | macOS | Linux | +| --- | --- | --- | --- | +| System audio | WASAPI loopback (PyAudioWPatch), follows the default output | BlackHole via `SoundDeviceSource` | any input device | +| Hide from screen capture | `SetWindowDisplayAffinity(WDA_EXCLUDEFROMCAPTURE)` on every top-level window, on show and on handle change, read back with `GetWindowDisplayAffinity` | not attempted (ScreenCaptureKit ignores `NSWindow.sharingType` on macOS 15+) | not attempted | + +On Windows builds before 19041 the same call would put a black box in the share, so it is +skipped. Whenever the window is not hidden, the footer says "Visible in screen share". + +## Errors, logging, privacy + +* Ports raise typed errors (`core/errors.py`). Failures show as failures (row note, status + strip) and are never replaced with made-up text. +* No modal dialogs mid-conversation; the only modal dialog is the quit confirmation while listening. +* Logs: module loggers, rotating file in the user log directory. INFO carries IDs and + timings (`utt=3 final asr_ms=412`), never transcript text. +* Translation and suggestions are off until enabled. Only text is sent to providers. + Keys live in the OS keyring. Audio dumps are off by default and go to the user data + directory. + +## Testing + +| Suite | What | Needs | +| --- | --- | --- | +| `tests/unit` | segmenter rules, ring buffer, session, events, AsrQueue, config, presenter, controller, architecture rule | nothing | +| `tests/pipeline` | the threaded pipeline end to end with fakes: pairing under out-of-order completion, single ASR worker, language lock, retries, overload, suggestions (supersede, late, failure), clear, stop/restart, gap fill, resampled stereo input, error reporting | nothing | +| `tests/adapters` | HTTP error mapping, OpenAI/Google/suggester request and response handling, WAV I/O, playback, resampling, VAD, Windows shield (fake user32), keyring store | soxr/Silero tests skip if absent | +| `tests/ui` | overlay rows and panels, bridge delivers on the GUI thread, shield filter covers dialogs, settings dialog, demo-mode app smoke test; real shield on Windows | PyQt6 + pytest-qt (offscreen) | +| `tests/integration` (`-m slow`) | Silero and Whisper `tiny` on espeak-synthesized speech, end to end | faster-whisper, espeak-ng | + +## Implementation decisions beyond the design doc + +| Decision | Why | +| --- | --- | +| HTTP via the standard library behind an `HttpClient` interface, not the OpenAI SDK or httpx | Two REST calls do not justify the SDK's dependency tree; tests inject a fake transport | +| Config via plain pydantic models plus a small TOML writer, not pydantic-settings / tomli-w | The precedence rules are ~30 lines; fewer dependencies | +| Resampling behind a `Resampler` port, built per source rate | Keeps the core numpy-only and lets tests resample without soxr | +| Silero loaded from faster-whisper's bundled model, both v4 and v5 interfaces detected | No extra download; falls back to the energy VAD with a visible warning if it cannot load | +| Coordinator outlives start/stop | Suggestions and language commands work while not listening | +| Gap fill in the front end | Loopback delivers nothing during silence; utterances must still end | +| Suggest requests supersede each other (generation counter) | One request at a time; the newest press wins | +| OpenAI model per feature, from a built-in list plus the account's live list (`adapters/openai_models.py`) | Model lineups change faster than releases; the dialog gets the list through an injected catalog, so the UI never imports an adapter | +| Request options chosen per model family, with a one-step fallback on HTTP 400 naming a parameter | Older models take `temperature`; reasoning models reject it and take `reasoning_effort`, whose accepted values differ by family | diff --git a/docs/architecture.md b/docs/v0-architecture.md similarity index 98% rename from docs/architecture.md rename to docs/v0-architecture.md index c9588ce..8cf595c 100644 --- a/docs/architecture.md +++ b/docs/v0-architecture.md @@ -1,6 +1,6 @@ # Architecture (v0 prototype) -![Architecture](architecture.png) +![Architecture](v0-architecture.png) ```mermaid flowchart TB diff --git a/docs/architecture.mmd b/docs/v0-architecture.mmd similarity index 100% rename from docs/architecture.mmd rename to docs/v0-architecture.mmd diff --git a/docs/architecture.png b/docs/v0-architecture.png similarity index 100% rename from docs/architecture.png rename to docs/v0-architecture.png diff --git a/docs/v1-layers.mmd b/docs/v1-layers.mmd new file mode 100644 index 0000000..1a52833 --- /dev/null +++ b/docs/v1-layers.mmd @@ -0,0 +1,30 @@ +flowchart TB + ROOT["Composition root
app.py (Qt) · wiring.py · controller.py
config → adapters → pipeline → presenter"] + + subgraph UI["Presentation · polyglot.ui"] + PRES["Presenter + view model
(pure Python)"] + QT["Qt views · ui/qt
overlay · settings · hotkeys
EventBridge · CaptureShieldFilter"] + end + + subgraph CORE["Core · polyglot.core (stdlib + numpy only)"] + MODEL["Domain model
Utterance · SpeechSegment · Suggestion"] + PORTS["Ports (Protocols)
AudioSource · Resampler · VoiceActivityModel
Transcriber · Translator · Suggester
WindowShield · SecretStore"] + PIPE["Pipeline · Segmenter · Session
EventBus · RingBuffer"] + end + + subgraph AD["Adapters · polyglot.adapters"] + A1["WASAPI loopback · sounddevice · WAV
soxr resampler"] + A2["Silero VAD · energy VAD
faster-whisper"] + A3["OpenAI / Google (stdlib HTTP)
keyring · fakes"] + end + + PLAT["Platform · polyglot.platform
WindowsShield (SetWindowDisplayAffinity)
UnsupportedShield (macOS/Linux)"] + CFG["Config · polyglot.config
typed AppConfig · TOML · env · keyring"] + + ROOT -.builds.-> UI + ROOT -.builds.-> AD + ROOT -.reads.-> CFG + UI --> CORE + AD --> CORE + PLAT --> CORE + CFG --> CORE diff --git a/docs/v1-layers.png b/docs/v1-layers.png new file mode 100644 index 0000000..3979fc9 Binary files /dev/null and b/docs/v1-layers.png differ diff --git a/docs/v1-pipeline.mmd b/docs/v1-pipeline.mmd new file mode 100644 index 0000000..2643f0a --- /dev/null +++ b/docs/v1-pipeline.mmd @@ -0,0 +1,11 @@ +flowchart TB + SRC(("Audio source
(library thread)")) -->|"downmix + copy only"| RB[["RingBuffer
30 s, overwrite oldest"]] + RB --> FE["Front end thread
resample → 32 ms frames
→ VAD → Segmenter
gap-fill when loopback is silent"] + FE -->|"finals ≤ 8 (drop oldest → FAILED overloaded)
partials: latest only"| AQ[["AsrQueue"]] + AQ --> ASR["ASR worker
exactly one thread
faster-whisper, ID order"] + FE -->|"started / discarded"| CO + ASR -->|"transcripts"| CO["Coordinator
sole owner of Session
places results by utterance ID"] + CO <-->|"translate (3 s)
suggest (6 s, on hotkey)"| NET["Network pool
4 threads, 1 retry"] + CO -->|"immutable events"| BUS[["EventBus"]] + BUS --> BR["EventBridge
queued Qt signal"] + BR -->|"GUI thread"| PR["Presenter"] --> VIEW["Overlay (passive view)"] diff --git a/docs/v1-pipeline.png b/docs/v1-pipeline.png new file mode 100644 index 0000000..beb3968 Binary files /dev/null and b/docs/v1-pipeline.png differ diff --git a/list_audio_devices.py b/list_audio_devices.py deleted file mode 100644 index f432522..0000000 --- a/list_audio_devices.py +++ /dev/null @@ -1,46 +0,0 @@ -"""Utility script to list available audio devices""" - -import sounddevice as sd -import platform - -def list_devices(): - """List all available audio devices""" - print("=" * 80) - print("Available Audio Devices") - print("=" * 80) - print(f"Platform: {platform.system()}\n") - - devices = sd.query_devices() - - for i, device in enumerate(devices): - print(f"\nDevice {i}: {device['name']}") - print(f" Host API: {device.get('hostapi_name', 'Unknown')}") - print(f" Max Input Channels: {device.get('max_input_channels', 0)}") - print(f" Max Output Channels: {device.get('max_output_channels', 0)}") - print(f" Default Sample Rate: {device.get('default_samplerate', 'Unknown')} Hz") - - # Highlight loopback devices - if 'loopback' in device['name'].lower(): - print(" *** LOOPBACK DEVICE (good for system audio capture) ***") - - # Highlight virtual audio devices - name_lower = device['name'].lower() - if any(keyword in name_lower for keyword in ['vb-audio', 'virtual', 'blackhole', 'soundflower', 'obs']): - print(" *** VIRTUAL AUDIO DEVICE (good for system audio capture) ***") - - print("\n" + "=" * 80) - print("Tips for Windows:") - print("- Look for devices with 'loopback' in the name") - print("- Or install a virtual audio device like:") - print(" - VB-Audio Cable (free)") - print(" - OBS Virtual Audio") - print(" - Voicemeeter") - print("\nThen route your call audio through that device and select it in Polyglot.") - print("=" * 80) - -if __name__ == "__main__": - try: - list_devices() - except Exception as e: - print(f"Error listing devices: {e}") - diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..5f89705 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,91 @@ +[project] +name = "polyglot" +version = "1.0.0.dev0" +description = "Live transcription, translation and reply suggestions in a small always-on-top window." +readme = "README.md" +license = "MIT" +requires-python = ">=3.10" +authors = [{ name = "Yousef Alhashemi" }] +dependencies = [ + "numpy>=1.26", + "soxr>=0.5", + "onnxruntime>=1.17", + "faster-whisper>=1.1", + "sounddevice>=0.5", + "PyAudioWPatch>=0.2.12; sys_platform == 'win32'", + "PyQt6>=6.7", + "pydantic>=2.7", + "platformdirs>=4.2", + "keyring>=25.0", + "tomli>=2.0; python_version < '3.11'", + "pynput>=1.7", +] + +[project.scripts] +polyglot = "polyglot.__main__:main" + +[dependency-groups] +dev = [ + "pytest>=8.2", + "pytest-qt>=4.4", + "pytest-timeout>=2.3", + "pytest-cov>=5.0", + "ruff==0.14.0", + "mypy>=1.11", +] + +[build-system] +requires = ["hatchling>=1.27"] +build-backend = "hatchling.build" + +[tool.hatch.build.targets.wheel] +packages = ["src/polyglot"] + +[tool.uv] +default-groups = ["dev"] + +# ---------------------------------------------------------------- pytest +[tool.pytest.ini_options] +testpaths = ["tests"] +pythonpath = ["src"] +addopts = "-ra --strict-markers -m 'not slow'" +timeout = 60 +markers = [ + "slow: needs real models (Whisper/Silero); deselected by default, run with -m slow", + "ui: needs Qt (runs offscreen)", +] +qt_api = "pyqt6" + +# ---------------------------------------------------------------- ruff +[tool.ruff] +line-length = 100 +target-version = "py310" +src = ["src", "tests"] + +[tool.ruff.lint] +select = ["E", "F", "W", "I", "B", "UP", "SIM", "RUF", "PT", "C4", "N"] +ignore = [ + "E501", # line length is the formatter's job + "N818", # exception names describe the condition (ProviderTimeout) + "PT018", # compound asserts are fine in tests + "N802", # Qt overrides use camelCase + "RUF001", # ambiguous unicode in UI strings is intentional + "RUF002", + "RUF003", +] + +[tool.ruff.lint.per-file-ignores] +"tests/**" = ["PT011", "E402"] + +# ---------------------------------------------------------------- mypy +[tool.mypy] +python_version = "3.10" +plugins = ["pydantic.mypy"] +warn_unused_ignores = true +warn_redundant_casts = true +ignore_missing_imports = true +files = ["src/polyglot"] + +[[tool.mypy.overrides]] +module = ["polyglot.core.*", "polyglot.config"] +strict = true diff --git a/requirements.txt b/requirements.txt deleted file mode 100644 index ca0bb21..0000000 --- a/requirements.txt +++ /dev/null @@ -1,9 +0,0 @@ -PyQt6>=6.6.0 -sounddevice>=0.4.6 -numpy>=1.24.0 -openai>=1.3.0 -python-dotenv>=1.0.0 -requests>=2.31.0 -psutil>=5.9.0 -faster-whisper>=1.0.0 - diff --git a/scripts/ci_annotate.py b/scripts/ci_annotate.py new file mode 100644 index 0000000..e301281 --- /dev/null +++ b/scripts/ci_annotate.py @@ -0,0 +1,71 @@ +"""Turn tool output into GitHub annotations, grouped per file. + +GitHub shows at most 10 error annotations per step, so messages are grouped by file: +one annotation carries every problem in that file. + + mypy | python scripts/ci_annotate.py lines # "path:line: error: msg" + ruff check --output-format=concise | ... lines # "path:line:col: CODE msg" + python scripts/ci_annotate.py junit junit.xml # pytest failures +""" + +from __future__ import annotations + +import re +import sys +import xml.etree.ElementTree as ET +from collections import defaultdict + +LINE = re.compile(r"^(?P[^:\s][^:]*\.py):(?P\d+):(?:\d+:)?\s*(?P.*)$") + + +def esc(s: str) -> str: + return s.replace("%", "%25").replace("\r", "%0D").replace("\n", "%0A") + + +def emit(groups: dict[str, list[tuple[int, str]]], title: str) -> int: + for path, items in sorted(groups.items()): + first = min(line for line, _ in items) + body = "\n".join(f"L{line}: {msg}" for line, msg in sorted(items))[:20000] + print(f"::error file={path},line={first},title={title} ({len(items)})::{esc(body)}") + return sum(len(v) for v in groups.values()) + + +def lines() -> int: + groups: dict[str, list[tuple[int, str]]] = defaultdict(list) + for raw in sys.stdin: + sys.stdout.write(raw) + m = LINE.match(raw.strip()) + if m and "note:" not in m["msg"][:6]: + groups[m["path"].replace("\\", "/")].append((int(m["line"]), m["msg"])) + return emit(groups, sys.argv[2] if len(sys.argv) > 2 else "problems") + + +def junit(path: str) -> int: + groups: dict[str, list[tuple[int, str]]] = defaultdict(list) + root = ET.parse(path).getroot() + for case in root.iter("testcase"): + for tag in ("failure", "error"): + node = case.find(tag) + if node is None: + continue + file = case.get("file") or case.get("classname", "").replace(".", "/") + ".py" + text = (node.get("message") or "") + "\n" + (node.text or "") + groups[file].append((int(case.get("line") or 1), f"{case.get('name')}: {text[-3000:]}")) + return emit(groups, "test failures") + + +def tail(title: str, n: int = 60) -> None: + text = sys.stdin.read() + sys.stdout.write(text) + last = "\n".join(text.splitlines()[-n:]) + print(f"::error title={title}::{esc(last)}") + + +if __name__ == "__main__": + mode = sys.argv[1] + if mode == "tail": + tail(sys.argv[2] if len(sys.argv) > 2 else "output") + elif mode == "lines": + lines() + elif mode == "junit": + junit(sys.argv[2]) diff --git a/scripts/shield_check.py b/scripts/shield_check.py new file mode 100644 index 0000000..41a358d --- /dev/null +++ b/scripts/shield_check.py @@ -0,0 +1,35 @@ +"""Show a real window and report what the capture shield did (CI notice annotation). + +Usage: python scripts/shield_check.py (Windows; native Qt platform) +""" + +from __future__ import annotations + +import sys + +from PyQt6.QtWidgets import QApplication, QWidget + +from polyglot.core.ports import ShieldStatus +from polyglot.platform import window_shield + + +def main() -> int: + app = QApplication(sys.argv) + w = QWidget() + w.resize(200, 100) + w.show() + app.processEvents() + shield = window_shield() + status = shield.exclude_from_capture(int(w.winId())) + detail = getattr(shield, "detail", "") + build = getattr(shield, "build", "?") + level = "notice" if status is ShieldStatus.HIDDEN else "error" + print( + f"::{level} title=Capture shield::{status.value} on {app.platformName()} build {build} {detail}" + ) + w.close() + return 0 if status is ShieldStatus.HIDDEN else 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/__init__.py b/src/__init__.py deleted file mode 100644 index 51c0a83..0000000 --- a/src/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -"""Polyglot - Real-time Interview Translation Assistant""" - -__version__ = "1.0.0" - diff --git a/src/audio/__init__.py b/src/audio/__init__.py deleted file mode 100644 index a133a27..0000000 --- a/src/audio/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""Audio capture and processing module""" - diff --git a/src/audio/buffer.py b/src/audio/buffer.py deleted file mode 100644 index 07ccd46..0000000 --- a/src/audio/buffer.py +++ /dev/null @@ -1,72 +0,0 @@ -"""Audio buffering and chunking utilities""" - -import numpy as np -from collections import deque -from typing import Optional, Callable - - -class AudioBuffer: - """Manages audio buffering and chunking for real-time processing""" - - def __init__(self, sample_rate: int = 16000, chunk_duration_seconds: float = 5.0): - """ - Initialize audio buffer - - Args: - sample_rate: Audio sample rate in Hz - chunk_duration_seconds: Duration of each chunk in seconds - """ - self.sample_rate = sample_rate - self.chunk_duration_seconds = chunk_duration_seconds - self.chunk_size = int(sample_rate * chunk_duration_seconds) - self.buffer = deque(maxlen=self.chunk_size * 2) # Keep some overlap - self.chunk_callback: Optional[Callable[[np.ndarray], None]] = None - - def add_audio(self, audio_data: np.ndarray): - """ - Add audio data to buffer and trigger callback when chunk is ready - - Args: - audio_data: Audio samples as numpy array - """ - # Convert to float32 if needed - if audio_data.dtype != np.float32: - if audio_data.dtype == np.int16: - audio_data = audio_data.astype(np.float32) / 32768.0 - elif audio_data.dtype == np.int32: - audio_data = audio_data.astype(np.float32) / 2147483648.0 - else: - audio_data = audio_data.astype(np.float32) - - # Ensure mono channel - if len(audio_data.shape) > 1: - audio_data = np.mean(audio_data, axis=1) - - # Add to buffer - self.buffer.extend(audio_data) - - # Check if we have enough data for a chunk - if len(self.buffer) >= self.chunk_size: - chunk = np.array(list(self.buffer)[:self.chunk_size], dtype=np.float32) - # Remove processed samples (keep some overlap) - overlap = self.chunk_size // 4 # 25% overlap - for _ in range(self.chunk_size - overlap): - if self.buffer: - self.buffer.popleft() - - # Trigger callback if set - if self.chunk_callback: - self.chunk_callback(chunk) - - def set_chunk_callback(self, callback: Callable[[np.ndarray], None]): - """Set callback function to be called when a chunk is ready""" - self.chunk_callback = callback - - def clear(self): - """Clear the buffer""" - self.buffer.clear() - - def get_current_buffer(self) -> np.ndarray: - """Get current buffer contents as numpy array""" - return np.array(list(self.buffer), dtype=np.float32) - diff --git a/src/audio/capture.py b/src/audio/capture.py deleted file mode 100644 index a174f73..0000000 --- a/src/audio/capture.py +++ /dev/null @@ -1,206 +0,0 @@ -"""System audio capture module with cross-platform support""" - -import sounddevice as sd -import numpy as np -import platform -from typing import Optional, Callable, List -from .buffer import AudioBuffer - - -class AudioCapture: - """Captures system audio using platform-specific loopback""" - - def __init__(self, sample_rate: int = 16000, chunk_duration_seconds: float = 5.0): - """ - Initialize audio capture - - Args: - sample_rate: Audio sample rate in Hz - chunk_duration_seconds: Duration of each chunk in seconds - """ - self.sample_rate = sample_rate - self.chunk_duration_seconds = chunk_duration_seconds - self.buffer = AudioBuffer(sample_rate, chunk_duration_seconds) - self.stream: Optional[sd.InputStream] = None - self.is_capturing = False - self.device_id: Optional[int] = None - - def list_devices(self) -> List[dict]: - """List available audio devices""" - devices = sd.query_devices() - result = [] - for i, device in enumerate(devices): - result.append({ - 'id': i, - 'name': device.get('name', f'Device {i}'), - 'max_input_channels': device.get('max_input_channels', 0), - 'max_output_channels': device.get('max_output_channels', 0), - 'sample_rate': device.get('default_samplerate', 44100), - 'is_input': device.get('max_input_channels', 0) > 0 - }) - return result - - def find_loopback_device(self) -> Optional[int]: - """ - Find the appropriate loopback device for system audio capture - - Returns: - Device ID if found, None otherwise - """ - system = platform.system() - devices = sd.query_devices() - - if system == "Windows": - # On Windows, look for WASAPI loopback devices - # WASAPI loopback devices are typically named with "(loopback)" suffix - for i, device in enumerate(devices): - name = device['name'].lower() - hostapi = device.get('hostapi', 0) - - # Check if it's a WASAPI device with loopback in the name - if 'loopback' in name: - # Verify it has input channels (loopback devices show as input) - if device.get('max_input_channels', 0) > 0: - return i - - # Also check for WASAPI devices that might be loopback-capable - # WASAPI hostapi is typically 3 - if hostapi == 3 and device.get('max_input_channels', 0) > 0: - # Check if it's a loopback by checking the name pattern - if '(loopback)' in device['name'] or 'loopback' in name: - return i - - # Try to find default WASAPI output and see if there's a corresponding loopback - try: - default_output = sd.query_devices(kind='output') - if default_output: - # Look for a loopback version of the default output - default_name = default_output['name'].lower() - for i, device in enumerate(devices): - if 'loopback' in device['name'].lower() and default_name.split('(')[0].strip() in device['name'].lower(): - if device.get('max_input_channels', 0) > 0: - return i - except: - pass - - elif system == "Darwin": # macOS - # On macOS, look for CoreAudio devices that support loopback - for i, device in enumerate(devices): - name = device['name'].lower() - # macOS loopback devices might be named differently - if 'blackhole' in name or 'soundflower' in name or 'loopback' in name: - if device.get('max_input_channels', 0) > 0: - return i - # Note: macOS requires special virtual audio devices for loopback - # Users may need to install BlackHole or similar - - # Fallback: return None to use default - # Note: On Windows, this might not work for system audio capture - # Users may need to install a virtual audio cable or use OBS Virtual Audio - return None - - def start_capture(self, device_id: Optional[int] = None, - chunk_callback: Optional[Callable[[np.ndarray], None]] = None): - """ - Start capturing audio - - Args: - device_id: Audio device ID (None for auto-detect) - chunk_callback: Callback function for audio chunks - """ - if self.is_capturing: - self.stop_capture() - - # Set up chunk callback - if chunk_callback: - self.buffer.set_chunk_callback(chunk_callback) - - # Determine device - if device_id is not None: - self.device_id = device_id - else: - self.device_id = self.find_loopback_device() - - # Get device info to determine channel count - device_info = None - if self.device_id is not None: - try: - device_info = sd.query_devices(self.device_id) - except: - pass - - # Determine number of channels to use - # For loopback devices, we typically need to use the output channels as input - if device_info: - # Try to use input channels if available, otherwise use output channels - max_input_channels = device_info.get('max_input_channels', 0) - max_output_channels = device_info.get('max_output_channels', 0) - - # For loopback, we often need to use output channels - # Start with 2 (stereo) as most devices support it, fallback to 1 (mono) - channels = 2 if max_output_channels >= 2 or max_input_channels >= 2 else 1 - else: - # Default to stereo (most common) - channels = 2 - - # Create audio stream - try: - self.stream = sd.InputStream( - device=self.device_id, - channels=channels, - samplerate=self.sample_rate, - dtype=np.float32, - callback=self._audio_callback, - blocksize=int(self.sample_rate * 0.1) # 100ms blocks - ) - self.stream.start() - self.is_capturing = True - print(f"Audio capture started with {channels} channel(s) on device {self.device_id}") - except Exception as e: - # Try with mono if stereo failed - if channels == 2: - try: - print(f"Failed with {channels} channels, trying mono...") - self.stream = sd.InputStream( - device=self.device_id, - channels=1, - samplerate=self.sample_rate, - dtype=np.float32, - callback=self._audio_callback, - blocksize=int(self.sample_rate * 0.1) - ) - self.stream.start() - self.is_capturing = True - print(f"Audio capture started with 1 channel on device {self.device_id}") - except Exception as e2: - print(f"Error starting audio capture: {e2}") - raise e2 - else: - print(f"Error starting audio capture: {e}") - raise - - def _audio_callback(self, indata: np.ndarray, frames: int, time, status): - """Callback function for audio stream""" - if status: - print(f"Audio callback status: {status}") - - # Add audio data to buffer - self.buffer.add_audio(indata) - - def stop_capture(self): - """Stop capturing audio""" - if self.stream: - self.stream.stop() - self.stream.close() - self.stream = None - self.is_capturing = False - self.buffer.clear() - - def is_active(self) -> bool: - """Check if audio capture is active""" - return self.is_capturing and self.stream is not None and self.stream.active - - def get_current_audio(self) -> np.ndarray: - """Get current buffered audio""" - return self.buffer.get_current_buffer() - diff --git a/src/config/__init__.py b/src/config/__init__.py deleted file mode 100644 index c910e71..0000000 --- a/src/config/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""Configuration management module""" - diff --git a/src/config/settings.py b/src/config/settings.py deleted file mode 100644 index f0baf81..0000000 --- a/src/config/settings.py +++ /dev/null @@ -1,241 +0,0 @@ -"""Configuration management for Polyglot application""" - -import os -import json -from pathlib import Path -from typing import Optional, Dict, Any - -CONFIG_DIR = Path.home() / ".polyglot" -CONFIG_FILE = CONFIG_DIR / "config.json" - - -class Settings: - """Manages application settings and configuration""" - - def __init__(self): - """Initialize settings from environment and config file""" - self.config_dir = CONFIG_DIR - self.config_file = CONFIG_FILE - self._ensure_config_dir() - self._load_config() - - def _ensure_config_dir(self): - """Create config directory if it doesn't exist""" - self.config_dir.mkdir(exist_ok=True) - - def _load_config(self): - """Load configuration from file or create default""" - if self.config_file.exists(): - try: - with open(self.config_file, 'r') as f: - self._config = json.load(f) - except (json.JSONDecodeError, IOError): - self._config = {} - else: - self._config = {} - - def _save_config(self): - """Save configuration to file""" - try: - with open(self.config_file, 'w') as f: - json.dump(self._config, f, indent=2) - except IOError as e: - print(f"Error saving config: {e}") - - # API Keys - @property - def openai_api_key(self) -> Optional[str]: - """Get OpenAI API key from environment or config""" - return os.getenv("OPENAI_API_KEY") or self._config.get("openai_api_key") - - @openai_api_key.setter - def openai_api_key(self, value: str): - """Set OpenAI API key""" - self._config["openai_api_key"] = value - self._save_config() - - @property - def google_translate_api_key(self) -> Optional[str]: - """Get Google Translate API key from environment or config""" - return os.getenv("GOOGLE_TRANSLATE_API_KEY") or self._config.get("google_translate_api_key") - - @google_translate_api_key.setter - def google_translate_api_key(self, value: str): - """Set Google Translate API key""" - self._config["google_translate_api_key"] = value - self._save_config() - - # Language Settings - @property - def user_language(self) -> str: - """Get user's target language""" - return self._config.get("user_language", "en") - - @user_language.setter - def user_language(self, value: str): - """Set user's target language""" - self._config["user_language"] = value - self._save_config() - - @property - def auto_detect_source_language(self) -> bool: - """Check if source language should be auto-detected""" - return self._config.get("auto_detect_source_language", True) - - @auto_detect_source_language.setter - def auto_detect_source_language(self, value: bool): - """Set auto-detect source language flag""" - self._config["auto_detect_source_language"] = value - self._save_config() - - # Audio Settings - @property - def audio_device_id(self) -> Optional[int]: - """Get audio device ID (None for default)""" - return self._config.get("audio_device_id") - - @audio_device_id.setter - def audio_device_id(self, value: Optional[int]): - """Set audio device ID""" - self._config["audio_device_id"] = value - self._save_config() - - @property - def sample_rate(self) -> int: - """Get audio sample rate""" - return self._config.get("sample_rate", 16000) - - @sample_rate.setter - def sample_rate(self, value: int): - """Set audio sample rate""" - try: - self._config["sample_rate"] = int(value) - self._save_config() - except (ValueError, TypeError): - pass - - @property - def chunk_duration_seconds(self) -> float: - """Get audio chunk duration in seconds""" - return self._config.get("chunk_duration_seconds", 5.0) - - @chunk_duration_seconds.setter - def chunk_duration_seconds(self, value: float): - """Set audio chunk duration in seconds""" - try: - self._config["chunk_duration_seconds"] = float(value) - self._save_config() - except (ValueError, TypeError): - pass - - # Window Settings - @property - def window_opacity(self) -> float: - """Get window opacity (0.0 to 1.0)""" - opacity = self._config.get("window_opacity", 0.9) - return max(0.0, min(1.0, opacity)) - - @window_opacity.setter - def window_opacity(self, value: float): - """Set window opacity""" - self._config["window_opacity"] = max(0.0, min(1.0, value)) - self._save_config() - - @property - def window_position(self) -> tuple[int, int]: - """Get window position (x, y)""" - x = self._config.get("window_x", 100) - y = self._config.get("window_y", 100) - return (x, y) - - @window_position.setter - def window_position(self, value: tuple[int, int]): - """Set window position""" - x, y = value - self._config["window_x"] = x - self._config["window_y"] = y - self._save_config() - - # Whisper Model Settings - @property - def whisper_model_size(self) -> str: - """Get Whisper model size""" - return self._config.get("whisper_model_size", "base") - - @whisper_model_size.setter - def whisper_model_size(self, value: str): - """Set Whisper model size""" - valid_sizes = ["tiny", "base", "small", "medium", "large-v2", "large-v3"] - if value not in valid_sizes: - value = "base" - self._config["whisper_model_size"] = value - self._save_config() - - @property - def whisper_device(self) -> str: - """Get Whisper device (cpu, cuda, or auto)""" - return self._config.get("whisper_device", "auto") - - @whisper_device.setter - def whisper_device(self, value: str): - """Set Whisper device""" - valid_devices = ["cpu", "cuda", "auto"] - if value not in valid_devices: - value = "auto" - self._config["whisper_device"] = value - self._save_config() - - # Debug Settings - @property - def dump_audio_chunks(self) -> bool: - """Get dump audio chunks setting""" - return self._config.get("dump_audio_chunks", False) - - @dump_audio_chunks.setter - def dump_audio_chunks(self, value: bool): - """Set dump audio chunks setting""" - self._config["dump_audio_chunks"] = bool(value) - self._save_config() - - @property - def transcript_only_mode(self) -> bool: - """Get transcript-only mode setting""" - return self._config.get("transcript_only_mode", False) - - @transcript_only_mode.setter - def transcript_only_mode(self, value: bool): - """Set transcript-only mode setting""" - self._config["transcript_only_mode"] = bool(value) - self._save_config() - - @property - def debug_logging(self) -> bool: - """Get debug logging setting""" - return self._config.get("debug_logging", False) - - @debug_logging.setter - def debug_logging(self, value: bool): - """Set debug logging setting""" - self._config["debug_logging"] = bool(value) - self._save_config() - - @property - def mock_mode(self) -> bool: - """Get mock mode setting""" - return self._config.get("mock_mode", False) - - @mock_mode.setter - def mock_mode(self, value: bool): - """Set mock mode setting""" - self._config["mock_mode"] = bool(value) - self._save_config() - - def get(self, key: str, default: Any = None) -> Any: - """Get a configuration value""" - return self._config.get(key, default) - - def set(self, key: str, value: Any): - """Set a configuration value""" - self._config[key] = value - self._save_config() - diff --git a/src/detection/__init__.py b/src/detection/__init__.py deleted file mode 100644 index 761e696..0000000 --- a/src/detection/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""Detection modules for screen sharing and other features""" - diff --git a/src/detection/screen_share.py b/src/detection/screen_share.py deleted file mode 100644 index 3a00259..0000000 --- a/src/detection/screen_share.py +++ /dev/null @@ -1,162 +0,0 @@ -"""Screen sharing detection for Windows and macOS""" - -import platform -import subprocess -import psutil -from typing import List - - -class ScreenShareDetector: - """Detects if screen sharing is active""" - - # Common screen recording/sharing processes - SCREEN_SHARING_PROCESSES = [ - 'zoom', 'Zoom', - 'teams', 'Teams', 'ms-teams', - 'chrome', 'Google Chrome', # For Google Meet - 'firefox', 'Firefox', - 'obs', 'OBS Studio', - 'obs64', 'obs32', - 'streamlabs', 'Streamlabs', - 'xsplit', 'XSplit', - 'nvidia', 'NVIDIA Share', # ShadowPlay - 'dxtory', - 'bandicam', - 'fraps', - 'quicktime', 'QuickTime Player', - 'screenflow', - 'camtasia', - 'screencast', - 'screenrecorder', - 'sharex', - 'greenshot', - 'snagit' - ] - - def __init__(self): - """Initialize screen share detector""" - self.system = platform.system() - - def is_screen_sharing(self) -> bool: - """ - Check if screen sharing is currently active - - Returns: - True if screen sharing is detected, False otherwise - """ - if self.system == "Windows": - return self._check_windows() - elif self.system == "Darwin": # macOS - return self._check_macos() - else: - # Linux - similar to Windows approach - return self._check_linux() - - def _check_windows(self) -> bool: - """Check for screen sharing on Windows""" - try: - # Get all running processes - for proc in psutil.process_iter(['pid', 'name']): - try: - proc_name = proc.info['name'].lower() - # Check if any screen sharing process is running - for sharing_process in self.SCREEN_SHARING_PROCESSES: - if sharing_process.lower() in proc_name: - # Additional check: verify it's actually sharing - # For Zoom, Teams, etc., we assume if the process is running, - # screen sharing might be active - # This is a heuristic - not perfect but reasonable - return True - except (psutil.NoSuchProcess, psutil.AccessDenied): - continue - - # Check for screen recording via Windows API (more advanced) - # This would require additional Windows-specific libraries - # For now, we rely on process detection - - return False - - except Exception as e: - print(f"Error checking Windows screen sharing: {e}") - return False - - def _check_macos(self) -> bool: - """Check for screen sharing on macOS""" - try: - # Method 1: Check for screen recording processes - for proc in psutil.process_iter(['pid', 'name']): - try: - proc_name = proc.info['name'].lower() - for sharing_process in self.SCREEN_SHARING_PROCESSES: - if sharing_process.lower() in proc_name: - return True - except (psutil.NoSuchProcess, psutil.AccessDenied): - continue - - # Method 2: Check screen recording status via system_profiler - # macOS has a system-level indicator for screen recording - try: - result = subprocess.run( - ['system_profiler', 'SPApplicationsDataType'], - capture_output=True, - text=True, - timeout=2 - ) - # This is a basic check - more sophisticated detection would - # require Objective-C bindings or checking system preferences - except: - pass - - # Method 3: Check for specific macOS screen sharing indicators - # Check if Screen Recording permission is being used - # This is harder to detect without native code - - return False - - except Exception as e: - print(f"Error checking macOS screen sharing: {e}") - return False - - def _check_linux(self) -> bool: - """Check for screen sharing on Linux""" - try: - # Similar to Windows approach - for proc in psutil.process_iter(['pid', 'name']): - try: - proc_name = proc.info['name'].lower() - for sharing_process in self.SCREEN_SHARING_PROCESSES: - if sharing_process.lower() in proc_name: - return True - except (psutil.NoSuchProcess, psutil.AccessDenied): - continue - - return False - - except Exception as e: - print(f"Error checking Linux screen sharing: {e}") - return False - - def get_active_sharing_processes(self) -> List[str]: - """ - Get list of active screen sharing processes - - Returns: - List of process names that might be sharing screen - """ - active_processes = [] - - try: - for proc in psutil.process_iter(['pid', 'name']): - try: - proc_name = proc.info['name'] - for sharing_process in self.SCREEN_SHARING_PROCESSES: - if sharing_process.lower() in proc_name.lower(): - active_processes.append(proc_name) - break - except (psutil.NoSuchProcess, psutil.AccessDenied): - continue - except Exception as e: - print(f"Error getting active processes: {e}") - - return list(set(active_processes)) # Remove duplicates - diff --git a/src/main.py b/src/main.py deleted file mode 100644 index 8c56711..0000000 --- a/src/main.py +++ /dev/null @@ -1,639 +0,0 @@ -"""Main application entry point for Polyglot""" - -import os -import sys -from pathlib import Path - -# Load .env into environment before any other project imports -from dotenv import load_dotenv -load_dotenv(Path(__file__).resolve().parent.parent / ".env") - -import numpy as np -from typing import Optional -from PyQt6.QtWidgets import QApplication, QSystemTrayIcon, QMenu, QMessageBox -from PyQt6.QtCore import pyqtSignal, QObject -from PyQt6.QtGui import QIcon, QPixmap -from concurrent.futures import ThreadPoolExecutor - -# Add project root to path -project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) -if project_root not in sys.path: - sys.path.insert(0, project_root) - -from src.config.settings import Settings -from src.audio.capture import AudioCapture -from src.services.transcription import TranscriptionService -from src.services.translation import TranslationService -from src.services.response import ResponseGenerationService -from src.ui.overlay_window import OverlayWindow -from src.ui.settings_dialog import SettingsDialog -from src.utils.audio_dump import AudioDumper -from src.detection.screen_share import ScreenShareDetector - - -class AudioProcessor(QObject): - """Handles audio processing in background threads""" - - transcription_ready = pyqtSignal(dict) # Emits {'text': str, 'language': str} - - def __init__(self, transcription_service: TranscriptionService): - super().__init__() - self.transcription_service = transcription_service - self.executor = ThreadPoolExecutor(max_workers=2) # Allow parallel processing to prevent backlog - self.processing_queue = [] - self.is_processing = False - - def process_audio_chunk(self, audio_data: np.ndarray): - """Process audio chunk in background thread""" - # Submit for processing - executor will handle queueing - future = self.executor.submit(self._transcribe_sync, audio_data) - future.add_done_callback(self._on_transcription_done) - - def _transcribe_sync(self, audio_data: np.ndarray) -> dict: - """Synchronous transcription wrapper""" - try: - return self.transcription_service.transcribe(audio_data) - except Exception as e: - print(f"Error in transcription: {e}") - return {'text': '', 'language': None, 'error': str(e)} - - def _on_transcription_done(self, future): - """Handle transcription completion""" - try: - result = future.result() - self.transcription_ready.emit(result) - except Exception as e: - print(f"Error getting transcription result: {e}") - - -class PolyglotApp: - """Main application class""" - - def __init__(self): - """Initialize the application""" - self.app = QApplication(sys.argv) - self.settings = Settings() - - # Initialize transcription service (local, no API key needed) - self.transcription_service = TranscriptionService( - model_size=self.settings.whisper_model_size, - device=self.settings.whisper_device - ) - - # Translation and response services need OpenAI API key - # Check if we have at least one API key for translation/response - if not self.settings.openai_api_key and not self.settings.google_translate_api_key: - self._show_api_key_warning() - # Continue anyway - user can still use transcription - - # Initialize translation service (OpenAI or Google) - self.translation_service = TranslationService( - openai_api_key=self.settings.openai_api_key, - google_api_key=self.settings.google_translate_api_key, - debug_logging=self.settings.debug_logging, - mock_mode=self.settings.mock_mode - ) - - # Response service - allow creation even without API key if mock mode is enabled - if self.settings.openai_api_key or self.settings.mock_mode: - self.response_service = ResponseGenerationService( - self.settings.openai_api_key or "", # Empty string if mock mode - debug_logging=self.settings.debug_logging, - mock_mode=self.settings.mock_mode - ) - else: - print("Warning: OpenAI API key not set. Response generation will be disabled.") - self.response_service = None - - # Initialize audio capture - self.audio_capture = AudioCapture( - sample_rate=self.settings.sample_rate, - chunk_duration_seconds=self.settings.chunk_duration_seconds - ) - - # Initialize audio processor - self.audio_processor = AudioProcessor(self.transcription_service) - self.audio_processor.transcription_ready.connect(self._on_transcription_ready) - - # Thread pool for translation and response generation - self.translation_executor = ThreadPoolExecutor(max_workers=2) - - # Initialize audio dumper - self.audio_dumper = AudioDumper( - dump_folder="dumps", - enabled=self.settings.dump_audio_chunks - ) - - # Initialize UI - self.overlay_window = OverlayWindow(opacity=self.settings.window_opacity) - window_x, window_y = self.settings.window_position - self.overlay_window.set_position(window_x, window_y) - - # Set initial status - device_id = self.settings.audio_device_id - if device_id is not None: - self.overlay_window.set_capture_status(False, f"Ready - Device: {device_id}") - else: - self.overlay_window.set_capture_status(False, "Configure settings and press Start") - - self.overlay_window.show() - - # Set up system tray - self._setup_system_tray() - - # Connect settings button - self.overlay_window.settings_btn.clicked.connect(self._show_settings) - - # Connect quit button and signal - self.overlay_window.close_btn.clicked.connect(self.quit) - self.overlay_window.quit_requested.connect(self.quit) - - # Connect start/stop button - self.overlay_window.start_stop_requested.connect(self._toggle_capture) - - # Connect audio capture callback - self.audio_capture.buffer.set_chunk_callback(self._on_audio_chunk) - - # State - self.current_source_language = None - self.last_transcription = "" - self.is_capturing = False - - def _show_api_key_warning(self): - """Show warning message about missing API keys""" - msg = QMessageBox() - msg.setIcon(QMessageBox.Icon.Information) - msg.setWindowTitle("API Keys Not Set") - msg.setText("Translation and response features require API keys") - msg.setInformativeText( - "Transcription will work locally (free).\n\n" - "For translation and response generation, set one of:\n" - "- OPENAI_API_KEY (for translation + responses)\n" - "- GOOGLE_TRANSLATE_API_KEY (for translation only)\n\n" - "You can still use transcription without API keys." - ) - msg.exec() - - def _setup_system_tray(self): - """Set up system tray icon""" - if not QSystemTrayIcon.isSystemTrayAvailable(): - print("System tray is not available") - return - - self.tray_icon = QSystemTrayIcon(self.app) - - # Create a simple icon (you can replace this with an actual icon file) - pixmap = QPixmap(16, 16) - pixmap.fill(self.app.palette().color(self.app.palette().ColorRole.Window)) - self.tray_icon.setIcon(QIcon(pixmap)) - - # Create menu - menu = QMenu() - - show_action = menu.addAction("Show Window") - show_action.triggered.connect(self.overlay_window.show) - - hide_action = menu.addAction("Hide Window") - hide_action.triggered.connect(self.overlay_window.hide) - - menu.addSeparator() - - settings_action = menu.addAction("Settings") - settings_action.triggered.connect(self._show_settings) - - menu.addSeparator() - - quit_action = menu.addAction("Quit") - quit_action.triggered.connect(lambda: self.quit(confirm=True)) - - self.tray_icon.setContextMenu(menu) - self.tray_icon.setToolTip("Polyglot - Interview Translation Assistant") - self.tray_icon.show() - - def _on_audio_chunk(self, audio_data: np.ndarray): - """Handle audio chunk from capture""" - # Dump audio chunk if enabled - if self.settings.dump_audio_chunks: - self.audio_dumper.dump_audio_chunk(audio_data, self.settings.sample_rate) - - # Process audio in background - self.audio_processor.process_audio_chunk(audio_data) - - def _on_transcription_ready(self, result: dict): - """Handle transcription result""" - # Check for errors - if 'error' in result: - error_msg = result.get('error', 'Unknown error') - # Show error message for quota issues - if 'quota' in error_msg.lower() or '429' in error_msg: - msg = QMessageBox() - msg.setIcon(QMessageBox.Icon.Warning) - msg.setWindowTitle("API Quota Exceeded") - msg.setText("OpenAI API quota has been exceeded") - msg.setInformativeText( - "Please check your OpenAI billing and plan details.\n\n" - "You can:\n" - "1. Upgrade your OpenAI plan\n" - "2. Wait for your quota to reset\n" - "3. Check your usage at https://platform.openai.com/usage" - ) - msg.exec() - return - - text = result.get('text', '').strip() - language = result.get('language') - - if not text: - return - - # Update source language if detected - if language: - self.current_source_language = language - - # Improved duplicate detection - allow similar but not identical text - # This handles continuous speech where chunks may overlap - if text and text == self.last_transcription: - return - # Also check if text is just a substring of last (likely duplicate) - if text and self.last_transcription and text in self.last_transcription: - return - - self.last_transcription = text - - # Update UI with original text (transcription signal is already thread-safe) - lang_display = self.current_source_language or "Unknown" - self.overlay_window.update_original_text(text, lang_display) - - # Check if transcript-only mode is enabled - if self.settings.transcript_only_mode: - # Skip translation and response generation - NO API CALLS - print("Transcript-only mode: Skipping translation and response generation") - self.overlay_window.update_translated_text("(Transcript-only mode)") - self.overlay_window.update_response_original("(Transcript-only mode)") - self.overlay_window.update_response_translated("(Transcript-only mode)") - return - - # Translate and generate responses in background - target_lang = self.settings.user_language - source_lang = self.current_source_language if self.current_source_language else None - - future = self.translation_executor.submit( - self._process_translation_and_response, - text, target_lang, source_lang - ) - future.add_done_callback(self._on_translation_done) - - def _process_translation_and_response(self, text: str, target_lang: str, source_lang: str) -> dict: - """Process translation and response generation (runs in background thread)""" - # Double-check transcript-only mode to prevent any API calls - if self.settings.transcript_only_mode: - return { - 'translated': '(Transcript-only mode)', - 'responses': { - 'original_response': '(Transcript-only mode)', - 'translated_response': '(Transcript-only mode)' - } - } - - try: - translated = self.translation_service.translate(text, target_lang, source_lang) - - # Generate responses (if service is available) - if self.response_service: - responses = self.response_service.generate_response( - text, translated, source_lang or "auto", target_lang - ) - # Add to conversation history - self.response_service.add_to_history(text, translated, source_lang or "auto", target_lang) - else: - responses = { - 'original_response': '(Requires OpenAI API key)', - 'translated_response': '(Requires OpenAI API key)' - } - - return { - 'translated': translated, - 'responses': responses - } - except Exception as e: - print(f"Error in translation/response generation: {e}") - return { - 'translated': '', - 'responses': {'original_response': '', 'translated_response': ''} - } - - def _on_translation_done(self, future): - """Handle translation and response completion (thread-safe UI updates)""" - try: - result = future.result() - translated_text = result.get('translated', '') - responses = result.get('responses', {}) - original_response = responses.get('original_response', '') - translated_response = responses.get('translated_response', '') - # Emit signal on OverlayWindow — Qt auto-connection detects the - # cross-thread call and queues delivery to the main/GUI thread. - self.overlay_window.translation_result_ready.emit( - translated_text, original_response, translated_response - ) - except Exception as e: - print(f"Error getting translation result: {e}") - - - def _show_settings(self): - """Show settings dialog""" - # Get available audio devices - devices = self.audio_capture.list_devices() - - # Get current settings - current_device_id = self.settings.audio_device_id - current_target_language = self.settings.user_language - current_auto_detect = self.settings.auto_detect_source_language - current_sample_rate = self.settings.sample_rate - current_chunk_duration = self.settings.chunk_duration_seconds - current_whisper_model_size = self.settings.whisper_model_size - current_whisper_device = self.settings.whisper_device - current_window_opacity = self.settings.window_opacity - current_dump_audio = self.settings.dump_audio_chunks - current_transcript_only = self.settings.transcript_only_mode - current_debug_logging = self.settings.debug_logging - current_mock_mode = self.settings.mock_mode - - # Create and show settings dialog - dialog = SettingsDialog( - audio_devices=devices, - current_device_id=current_device_id, - current_target_language=current_target_language, - current_auto_detect=current_auto_detect, - current_sample_rate=current_sample_rate, - current_chunk_duration=current_chunk_duration, - current_whisper_model_size=current_whisper_model_size, - current_whisper_device=current_whisper_device, - current_window_opacity=current_window_opacity, - current_dump_audio=current_dump_audio, - current_transcript_only=current_transcript_only, - current_debug_logging=current_debug_logging, - current_mock_mode=current_mock_mode, - parent=self.overlay_window - ) - - # Connect settings changed signal - dialog.settings_changed.connect(self._on_settings_changed) - - dialog.exec() - - def _on_settings_changed(self, device_id: Optional[int], target_language: str, - auto_detect: bool, sample_rate: int, chunk_duration: float, - whisper_model_size: str, whisper_device: str, window_opacity: float, - dump_audio: bool, transcript_only: bool, debug_logging: bool, mock_mode: bool): - """Handle settings changes""" - # Update language settings - self.settings.user_language = target_language - self.settings.auto_detect_source_language = auto_detect - - # Update audio settings - sample_rate_changed = sample_rate != self.settings.sample_rate - chunk_duration_changed = chunk_duration != self.settings.chunk_duration_seconds - self.settings.sample_rate = sample_rate - self.settings.chunk_duration_seconds = chunk_duration - - # Update whisper model settings - whisper_model_changed = whisper_model_size != self.settings.whisper_model_size - whisper_device_changed = whisper_device != self.settings.whisper_device - self.settings.whisper_model_size = whisper_model_size - self.settings.whisper_device = whisper_device - - # Update window settings - self.settings.window_opacity = window_opacity - self.overlay_window.set_opacity(window_opacity) - - # Update debug settings - self.settings.dump_audio_chunks = dump_audio - self.settings.transcript_only_mode = transcript_only - self.settings.debug_logging = debug_logging - self.settings.mock_mode = mock_mode - - # Update audio dumper - self.audio_dumper.set_enabled(dump_audio) - - # Update debug logging in services - if hasattr(self.translation_service, 'debug_logging'): - self.translation_service.debug_logging = debug_logging - if self.response_service and hasattr(self.response_service, 'debug_logging'): - self.response_service.debug_logging = debug_logging - - # Update mock mode in services - if hasattr(self.translation_service, 'mock_mode'): - self.translation_service.mock_mode = mock_mode - if self.response_service and hasattr(self.response_service, 'mock_mode'): - self.response_service.mock_mode = mock_mode - - # Handle settings that require restart - needs_restart = False - restart_reasons = [] - - if whisper_model_changed or whisper_device_changed: - needs_restart = True - restart_reasons.append("Whisper model settings") - # Reinitialize transcription service (will reload model on next use) - self.transcription_service = TranscriptionService( - model_size=whisper_model_size, - device=whisper_device - ) - self.audio_processor.transcription_service = self.transcription_service - - if sample_rate_changed or chunk_duration_changed: - needs_restart = True - restart_reasons.append("audio settings") - # Reinitialize audio capture with new settings - if self.is_capturing: - self.audio_capture.stop_capture() - self.audio_capture = AudioCapture( - sample_rate=sample_rate, - chunk_duration_seconds=chunk_duration - ) - # Reconnect callback - self.audio_capture.buffer.set_chunk_callback(self._on_audio_chunk) - - if needs_restart and self.is_capturing: - msg = QMessageBox() - msg.setIcon(QMessageBox.Icon.Information) - msg.setWindowTitle("Settings Changed") - msg.setText("Some settings require restarting audio capture") - msg.setInformativeText( - f"The following settings have changed: {', '.join(restart_reasons)}\n\n" - "Audio capture will be restarted. Please press Start again." - ) - msg.exec() - # Stop capture - user will need to press Start again - if self.is_capturing: - self._stop_capture() - - # Update status message - if transcript_only: - status_msg = "Transcript-only mode enabled (NO API calls)" - else: - device_name = "Default" if device_id is None else f"Device {device_id}" - status_msg = f"Ready - Device: {device_name}" - - if not self.is_capturing: - self.overlay_window.set_capture_status(False, status_msg) - - # Update audio device if changed - if device_id != self.settings.audio_device_id: - self.settings.audio_device_id = device_id - - # If currently capturing, restart with new device - if self.is_capturing: - try: - self.audio_capture.stop_capture() - self.audio_capture.start_capture(device_id=device_id) - device_name = "Default" if device_id is None else f"Device {device_id}" - self.overlay_window.set_capture_status(True, f"Using {device_name}") - print(f"Audio capture restarted with {device_name}") - except Exception as e: - print(f"Error restarting audio capture: {e}") - self.is_capturing = False - self.overlay_window.set_capture_status(False, "Error - Check device") - msg = QMessageBox() - msg.setIcon(QMessageBox.Icon.Warning) - msg.setWindowTitle("Audio Device Error") - msg.setText(f"Could not switch to selected audio device: {e}") - msg.setInformativeText("Audio capture has been stopped. Please press Start again after fixing the device.") - msg.exec() - else: - # Just update the status message - device_name = "Default" if device_id is None else f"Device {device_id}" - self.overlay_window.set_capture_status(False, f"Ready - Device: {device_name}") - - def _toggle_capture(self): - """Toggle audio capture on/off""" - if self.is_capturing: - self._stop_capture() - else: - self._start_capture() - - def _start_capture(self): - """Start audio capture""" - # Check if device is configured - device_id = self.settings.audio_device_id - - try: - # Start audio capture - self.audio_capture.start_capture(device_id=device_id) - self.is_capturing = True - - # Update UI - device_name = "Default" if device_id is None else f"Device {device_id}" - self.overlay_window.set_capture_status(True, f"Using {device_name}") - print("Audio capture started") - except Exception as e: - print(f"Error starting audio capture: {e}") - self.is_capturing = False - - # List available devices for debugging - try: - devices = self.audio_capture.list_devices() - device_list = "\n".join([ - f" - Device {d['id']}: {d['name']}" - for d in devices[:10] # Show first 10 devices - ]) - device_info = f"\n\nAvailable audio devices:\n{device_list}" - except: - device_info = "" - - msg = QMessageBox() - msg.setIcon(QMessageBox.Icon.Warning) - msg.setWindowTitle("Audio Capture Error") - msg.setText(f"Could not start audio capture: {e}") - msg.setInformativeText( - "Please configure your audio device in Settings first.\n\n" - "Make sure your audio device is available and you have the necessary permissions." - f"{device_info}\n\n" - "On Windows, you may need to use a loopback device or virtual audio cable." - ) - msg.exec() - - # Update UI to show error - self.overlay_window.set_capture_status(False, "Error - Check settings") - - def _stop_capture(self): - """Stop audio capture""" - try: - self.audio_capture.stop_capture() - self.is_capturing = False - self.overlay_window.set_capture_status(False, "Stopped") - print("Audio capture stopped") - except Exception as e: - print(f"Error stopping audio capture: {e}") - self.overlay_window.set_capture_status(False, "Error stopping") - - def start(self): - """Start the application""" - # Don't start audio capture automatically - wait for user to press Start - - # Save window position on close - self.app.aboutToQuit.connect(self._save_window_position) - - # Run application - return self.app.exec() - - def _save_window_position(self): - """Save window position to settings""" - if self.overlay_window.isVisible(): - x, y = self.overlay_window.get_position() - self.settings.window_position = (x, y) - - def quit(self, confirm: bool = True): - """ - Quit the application - - Args: - confirm: If True, show confirmation dialog - """ - if confirm: - reply = QMessageBox.question( - self.overlay_window, - 'Quit Polyglot', - 'Are you sure you want to quit?', - QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, - QMessageBox.StandardButton.No - ) - if reply != QMessageBox.StandardButton.Yes: - return - - print("Shutting down Polyglot...") - # Stop capture if running - if self.is_capturing: - self._stop_capture() - try: - self.audio_capture.stop_capture() - except: - pass - - try: - self.audio_processor.executor.shutdown(wait=False) - except: - pass - - try: - self.translation_executor.shutdown(wait=False) - except: - pass - - # Save window position before quitting - self._save_window_position() - - # Quit the application - self.app.quit() - sys.exit(0) - - -def main(): - """Main entry point""" - app = PolyglotApp() - sys.exit(app.start()) - - -if __name__ == "__main__": - main() - diff --git a/src/polyglot/__init__.py b/src/polyglot/__init__.py new file mode 100644 index 0000000..1ccb5a4 --- /dev/null +++ b/src/polyglot/__init__.py @@ -0,0 +1,3 @@ +"""Polyglot: live transcription, translation and reply suggestions.""" + +__version__ = "1.0.0.dev0" diff --git a/src/polyglot/__main__.py b/src/polyglot/__main__.py new file mode 100644 index 0000000..dfdbc06 --- /dev/null +++ b/src/polyglot/__main__.py @@ -0,0 +1,140 @@ +"""Command line entry point: ``polyglot`` / ``python -m polyglot``.""" + +from __future__ import annotations + +import argparse +import signal +import sys +import threading +from pathlib import Path + +from polyglot import __version__ + + +def _parser() -> argparse.ArgumentParser: + p = argparse.ArgumentParser(prog="polyglot", description=__doc__) + p.add_argument("--config", type=Path, help="config file (default: user config dir)") + p.add_argument("--demo", action="store_true", help="run with synthetic audio and fakes") + p.add_argument("--headless", action="store_true", help="no window; print events") + p.add_argument("--file", type=Path, help="headless: transcribe this WAV file") + p.add_argument("--fast", action="store_true", help="headless --file: do not pace in real time") + p.add_argument("--list-devices", action="store_true", help="list audio input devices") + p.add_argument("--log-level", default="INFO") + p.add_argument("--version", action="version", version=f"polyglot {__version__}") + return p + + +def list_devices() -> int: + from polyglot import platform + from polyglot.core.errors import PolyglotError + + try: + from polyglot.adapters.audio.sounddevice_source import list_input_devices + + for d in list_input_devices(): + flag = " (virtual)" if d["virtual"] else "" + print(f"[{d['id']:>3}] {d['name']} {d['rate']} Hz{flag}") + except PolyglotError as exc: + print(f"input devices unavailable: {exc}", file=sys.stderr) + if platform.current().has_loopback: + from polyglot.adapters.audio.wasapi_loopback import list_loopback_devices + + print("\nLoopback (system audio):") + for d in list_loopback_devices(): + print(f"[{d['id']:>3}] {d['name']} {d['rate']} Hz") + return 0 + + +def run_headless(config_path: Path | None, wav: Path | None, *, demo: bool, fast: bool) -> int: + from polyglot.adapters.secrets import KeyringSecretStore + from polyglot.config import Secrets, load_config + from polyglot.core.errors import PolyglotError + from polyglot.core.events import ( + Event, + EventBus, + PipelineStatus, + StageError, + SuggestionsReady, + UtteranceUpdated, + ) + from polyglot.core.models import UtteranceStatus + from polyglot.wiring import build, build_demo + + cfg = load_config(config_path) + if wav is not None: + cfg = cfg.model_copy( + update={"audio": cfg.audio.model_copy(update={"source": "file", "file": str(wav)})} + ) + bus = EventBus() + + def show(ev: Event) -> None: + if isinstance(ev, UtteranceUpdated): + u = ev.utterance + if u.status in ( + UtteranceStatus.FINAL, + UtteranceStatus.TRANSLATED, + UtteranceStatus.FAILED, + ): + extra = f" -> {u.translation}" if u.translation else "" + err = f" [{u.error.value}]" if u.error else "" + print(f"#{u.id} ({u.source_lang or '?'}) {u.text}{extra}{err}", flush=True) + elif isinstance(ev, SuggestionsReady): + for o in ev.suggestion.options: + print(f" suggest: {o.source_text} ({o.user_text})", flush=True) + elif isinstance(ev, (PipelineStatus, StageError)): + print(f"-- {ev}", file=sys.stderr, flush=True) + + bus.subscribe(show) + try: + if demo: + built = build_demo(cfg, bus) + else: + secrets = Secrets(KeyringSecretStore()) + source = None + if wav is not None and fast: + from polyglot.adapters.audio.playback import WavFileSource + + source = WavFileSource(wav, realtime=False) + ring = min(600.0, source.duration_s + 5) + cfg = cfg.model_copy( + update={"audio": cfg.audio.model_copy(update={"ring_seconds": ring})} + ) + built = build(cfg, secrets, bus, source=source) + except PolyglotError as exc: + print(f"error: {exc}", file=sys.stderr) + return 2 + for w in built.warnings: + print(f"warning: {w}", file=sys.stderr) + + done = threading.Event() + signal.signal(signal.SIGINT, lambda *_: done.set()) + built.pipeline.start() + if wav is not None or demo: + while not done.is_set(): + if built.pipeline.source_ended and built.pipeline.wait_idle(timeout=0.5): + break + done.wait(0.1) + else: + done.wait() + built.pipeline.close() + return 0 + + +def main(argv: list[str] | None = None) -> int: + args = _parser().parse_args(argv) + from polyglot import config, logging_setup + + logging_setup.configure( + args.log_level, None if args.headless else config.log_dir() / "polyglot.log" + ) + if args.list_devices: + return list_devices() + if args.headless or args.file: + return run_headless(args.config, args.file, demo=args.demo, fast=args.fast) + from polyglot.app import run_gui + + return run_gui(args.config, demo=args.demo) + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/src/polyglot/adapters/__init__.py b/src/polyglot/adapters/__init__.py new file mode 100644 index 0000000..ef50483 --- /dev/null +++ b/src/polyglot/adapters/__init__.py @@ -0,0 +1,2 @@ +"""Concrete implementations of the core's ports. Heavy libraries are imported lazily, +inside the adapter that needs them, so importing this package is cheap.""" diff --git a/src/polyglot/adapters/asr/__init__.py b/src/polyglot/adapters/asr/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/polyglot/adapters/asr/__init__.py @@ -0,0 +1 @@ + diff --git a/src/polyglot/adapters/asr/faster_whisper.py b/src/polyglot/adapters/asr/faster_whisper.py new file mode 100644 index 0000000..d8e4e55 --- /dev/null +++ b/src/polyglot/adapters/asr/faster_whisper.py @@ -0,0 +1,81 @@ +"""Local speech recognition with faster-whisper (CTranslate2).""" + +from __future__ import annotations + +import logging +from typing import Any + +from polyglot.core.errors import ConfigError, TranscriptionFailed +from polyglot.core.models import Transcript +from polyglot.core.ports import RawAudio + +log = logging.getLogger(__name__) + +MODEL_SIZES = ("tiny", "base", "small", "medium", "large-v3", "large-v3-turbo") + + +class FasterWhisperTranscriber: + def __init__( + self, + model: str = "base", + *, + device: str = "auto", + compute_type: str = "auto", + beam_size: int = 5, + download_root: str | None = None, + ) -> None: + self.model_name, self.device, self.compute_type = model, device, compute_type + self.beam_size, self.download_root = beam_size, download_root + self._model: Any = None + self.effective_device: str | None = None # what CTranslate2 chose, after load() + self.effective_compute_type: str | None = None + + def load(self) -> None: + if self._model is not None: + return + try: + from faster_whisper import WhisperModel # lazy: heavy native dependency + except ImportError as exc: + raise ConfigError("faster-whisper is not installed") from exc + log.info("loading Whisper %s on %s (%s)", self.model_name, self.device, self.compute_type) + try: + self._model = WhisperModel( + self.model_name, + device=self.device, + compute_type=self.compute_type, + download_root=self.download_root, + ) + except Exception as exc: + raise TranscriptionFailed( + f"could not load Whisper model {self.model_name!r}: {exc}" + ) from exc + inner = getattr(self._model, "model", None) # the CTranslate2 model + self.effective_device = str(getattr(inner, "device", self.device)) + self.effective_compute_type = str(getattr(inner, "compute_type", self.compute_type)) + log.info( + "Whisper %s loaded on %s as %s", + self.model_name, + self.effective_device, + self.effective_compute_type, + ) + + def transcribe(self, audio: RawAudio, language: str | None) -> Transcript: + if self._model is None: + raise TranscriptionFailed("model not loaded") + try: + segments, info = self._model.transcribe( + audio, + language=language, + beam_size=self.beam_size, + vad_filter=False, # the pipeline already segmented on speech + condition_on_previous_text=False, # each utterance stands alone + without_timestamps=True, + ) + text = " ".join(s.text.strip() for s in segments).strip() + except Exception as exc: + raise TranscriptionFailed(f"transcription failed: {exc}") from exc + return Transcript( + text=text, + language=getattr(info, "language", None), + language_probability=float(getattr(info, "language_probability", 0.0) or 0.0), + ) diff --git a/src/polyglot/adapters/audio/__init__.py b/src/polyglot/adapters/audio/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/polyglot/adapters/audio/__init__.py @@ -0,0 +1 @@ + diff --git a/src/polyglot/adapters/audio/playback.py b/src/polyglot/adapters/audio/playback.py new file mode 100644 index 0000000..030f4a0 --- /dev/null +++ b/src/polyglot/adapters/audio/playback.py @@ -0,0 +1,127 @@ +"""Sources that play back recorded audio: a WAV file, or an in-memory array. + +Used for tests, for the headless CLI, and for replaying recorded sessions while tuning +the segmenter. ``realtime=True`` paces blocks like a live device; ``False`` delivers as +fast as possible (size the pipeline's ring buffer to the recording when doing that). +""" + +from __future__ import annotations + +import threading +import time +import wave +from pathlib import Path + +import numpy as np + +from polyglot.core.errors import AudioSourceError +from polyglot.core.ports import AudioSink, RawAudio + + +class ArraySource: + def __init__( + self, + samples: RawAudio, + sample_rate: int, + *, + realtime: bool = False, + block_ms: int = 100, + ) -> None: + data = np.asarray(samples, dtype=np.float32) + if data.ndim not in (1, 2): + raise ValueError("samples must be (frames,) or (frames, channels)") + self._data = data + self._rate = sample_rate + self._realtime = realtime + self._block = max(1, int(sample_rate * block_ms / 1000)) + self._stop = threading.Event() + self._thread: threading.Thread | None = None + + @property + def sample_rate(self) -> int: + return self._rate + + @property + def duration_s(self) -> float: + return float(self._data.shape[0] / self._rate) + + def start(self, sink: AudioSink) -> None: + self._stop.clear() + self._thread = threading.Thread( + target=self._play, args=(sink,), name="polyglot-playback", daemon=True + ) + self._thread.start() + + def _play(self, sink: AudioSink) -> None: + period = self._block / self._rate + next_t = time.monotonic() + for i in range(0, self._data.shape[0], self._block): + if self._stop.is_set(): + return + sink.on_audio(self._data[i : i + self._block]) + if self._realtime: + next_t += period + delay = next_t - time.monotonic() + if delay > 0: + time.sleep(delay) + if not self._stop.is_set(): + sink.on_end() + + def stop(self) -> None: + self._stop.set() + if self._thread is not None and self._thread is not threading.current_thread(): + self._thread.join(timeout=2.0) + + +def read_wav(path: str | Path) -> tuple[RawAudio, int]: + """Read a PCM WAV file as float32 in [-1, 1]; shape (frames,) or (frames, channels).""" + try: + with wave.open(str(path), "rb") as wf: + channels, width, rate = wf.getnchannels(), wf.getsampwidth(), wf.getframerate() + raw = wf.readframes(wf.getnframes()) + except (OSError, wave.Error) as exc: + raise AudioSourceError(f"cannot read WAV file {path}: {exc}") from exc + # Truncate a partial last frame (a cut-off recording) instead of failing. + frame_bytes = width * channels + raw = raw[: len(raw) - len(raw) % frame_bytes] if frame_bytes else raw + try: + if width == 1: + data = (np.frombuffer(raw, dtype=np.uint8).astype(np.float32) - 128.0) / 128.0 + elif width == 2: + data = np.frombuffer(raw, dtype=" 1: + data = data.reshape(-1, channels) + except ValueError as exc: + raise AudioSourceError(f"cannot decode WAV file {path}: {exc}") from exc + return data, rate + + +def write_wav(path: str | Path, samples: RawAudio, sample_rate: int) -> None: + """Write mono float32 samples as 16-bit PCM.""" + scaled = np.round(np.asarray(samples, dtype=np.float64) * 32768.0) # inverse of read_wav + pcm = np.clip(scaled, -32768, 32767).astype(" None: + data, rate = read_wav(path) + super().__init__(data, rate, realtime=realtime, block_ms=block_ms) + self.path = Path(path) diff --git a/src/polyglot/adapters/audio/resample.py b/src/polyglot/adapters/audio/resample.py new file mode 100644 index 0000000..5ad3327 --- /dev/null +++ b/src/polyglot/adapters/audio/resample.py @@ -0,0 +1,41 @@ +"""Resampler adapters: device rate -> 16 kHz, streaming (state kept across blocks).""" + +from __future__ import annotations + +import numpy as np + +from polyglot.core.models import SAMPLE_RATE +from polyglot.core.ports import RawAudio, Resampler + + +class IdentityResampler: + """For sources that already deliver 16 kHz.""" + + def process(self, block: RawAudio) -> RawAudio: + return np.asarray(block, dtype=np.float32).reshape(-1) + + def flush(self) -> RawAudio: + return np.zeros(0, dtype=np.float32) + + +class SoxrResampler: + """High-quality streaming resampler (libsoxr).""" + + def __init__(self, in_rate: int, out_rate: int = SAMPLE_RATE) -> None: + import soxr # lazy: native library + + self._stream = soxr.ResampleStream(in_rate, out_rate, 1, dtype="float32", quality="HQ") + + def process(self, block: RawAudio) -> RawAudio: + data = np.ascontiguousarray(block, dtype=np.float32).reshape(-1) + return np.asarray(self._stream.resample_chunk(data), dtype=np.float32) + + def flush(self) -> RawAudio: + tail = self._stream.resample_chunk(np.zeros(0, dtype=np.float32), last=True) + return np.asarray(tail, dtype=np.float32) + + +def make_resampler(in_rate: int) -> Resampler: + if in_rate == SAMPLE_RATE: + return IdentityResampler() + return SoxrResampler(in_rate) diff --git a/src/polyglot/adapters/audio/sounddevice_source.py b/src/polyglot/adapters/audio/sounddevice_source.py new file mode 100644 index 0000000..6a56741 --- /dev/null +++ b/src/polyglot/adapters/audio/sounddevice_source.py @@ -0,0 +1,107 @@ +"""Any input device through PortAudio (sounddevice): microphones, BlackHole on macOS, +VB-Cable/Voicemeeter on Windows.""" + +from __future__ import annotations + +import logging +from typing import Any + +from polyglot.core.errors import AudioSourceError +from polyglot.core.ports import AudioSink + +log = logging.getLogger(__name__) + + +def _sd() -> Any: + try: + import sounddevice as sd + except OSError as exc: # PortAudio missing + raise AudioSourceError(f"PortAudio is not available: {exc}") from exc + return sd + + +class SoundDeviceSource: + def __init__(self, device: int | str | None = None, *, block_ms: int = 20) -> None: + sd = _sd() + try: + info = sd.query_devices(device, kind="input") + except (ValueError, sd.PortAudioError) as exc: + raise AudioSourceError(f"input device {device!r} not found: {exc}") from exc + self.device = device + self.device_name: str = str(info["name"]) + self._rate = int(info["default_samplerate"]) + self._channels = max(1, min(2, int(info["max_input_channels"]))) + self._block = max(1, int(self._rate * block_ms / 1000)) + self._stream: Any = None + self._stopping = False + + @property + def sample_rate(self) -> int: + return self._rate + + def start(self, sink: AudioSink) -> None: + sd = _sd() + self._stopping = False + + def callback(indata: Any, frames: int, time_info: Any, status: Any) -> None: + if status: + log.debug("input status: %s", status) + sink.on_audio(indata) # the sink copies synchronously + + def finished() -> None: + if not self._stopping: + sink.on_error(AudioSourceError(f"input stream from {self.device_name!r} stopped")) + + try: + self._stream = sd.InputStream( + device=self.device, + channels=self._channels, + samplerate=self._rate, + dtype="float32", + blocksize=self._block, + callback=callback, + finished_callback=finished, + ) + self._stream.start() + except sd.PortAudioError as exc: + if self._stream is not None: + self._stream.close() + self._stream = None + raise AudioSourceError(f"cannot open {self.device_name!r}: {exc}") from exc + log.info("listening on %s at %d Hz x%d", self.device_name, self._rate, self._channels) + + def stop(self) -> None: + self._stopping = True + if self._stream is not None: + try: + self._stream.stop() + self._stream.close() + finally: + self._stream = None + + +def list_input_devices() -> list[dict[str, Any]]: + sd = _sd() + out: list[dict[str, Any]] = [] + for idx, dev in enumerate(sd.query_devices()): + if int(dev["max_input_channels"]) > 0: + name = str(dev["name"]) + out.append( + { + "id": idx, + "name": name, + "rate": int(dev["default_samplerate"]), + "virtual": any( + k in name.lower() + for k in ( + "blackhole", + "vb-audio", + "cable", + "voicemeeter", + "loopback", + "soundflower", + ) + ), + } + ) + return out diff --git a/src/polyglot/adapters/audio/wasapi_loopback.py b/src/polyglot/adapters/audio/wasapi_loopback.py new file mode 100644 index 0000000..dcf5208 --- /dev/null +++ b/src/polyglot/adapters/audio/wasapi_loopback.py @@ -0,0 +1,175 @@ +"""Windows: capture what the computer is playing (WASAPI loopback) via PyAudioWPatch. + +No virtual audio cable is needed. Follows the default output device: when it changes +(headphones plugged in), the stream is reopened on the new device's loopback. + +Note: WASAPI loopback delivers no data while nothing is playing. The pipeline's front end +fills such gaps with silence so utterances still end (``PipelineConfig.gap_fill``). +""" + +from __future__ import annotations + +import contextlib +import logging +import threading +from typing import Any + +import numpy as np + +from polyglot.core.errors import AudioSourceError +from polyglot.core.ports import AudioSink + +log = logging.getLogger(__name__) + + +def _pyaudio() -> Any: + try: + import pyaudiowpatch as pyaudio + except ImportError as exc: + raise AudioSourceError("PyAudioWPatch is required for loopback capture on Windows") from exc + return pyaudio + + +def find_default_loopback(pa: Any, pyaudio: Any) -> dict[str, Any]: + """The loopback twin of the current default output device.""" + try: + wasapi = pa.get_host_api_info_by_type(pyaudio.paWASAPI) + speakers = pa.get_device_info_by_index(wasapi["defaultOutputDevice"]) + except OSError as exc: # no WASAPI, or no output device at all + raise AudioSourceError(f"no default output device to capture: {exc}") from exc + if speakers.get("isLoopbackDevice"): + return dict(speakers) + for loopback in pa.get_loopback_device_info_generator(): + if speakers["name"] in loopback["name"]: + return dict(loopback) + raise AudioSourceError(f"no loopback device found for {speakers['name']!r}") + + +def list_loopback_devices() -> list[dict[str, Any]]: + pyaudio = _pyaudio() + pa = pyaudio.PyAudio() + try: + return [ + {"id": int(d["index"]), "name": str(d["name"]), "rate": int(d["defaultSampleRate"])} + for d in pa.get_loopback_device_info_generator() + ] + finally: + pa.terminate() + + +class WasapiLoopbackSource: + def __init__(self, *, block_ms: int = 20, follow_default: bool = True) -> None: + self._pyaudio = _pyaudio() + self._pa = self._pyaudio.PyAudio() + self._device = find_default_loopback(self._pa, self._pyaudio) + self._rate = int(self._device["defaultSampleRate"]) + self._channels = max(1, int(self._device["maxInputChannels"])) + self._block_ms = block_ms + self._follow = follow_default + self._stream: Any = None + self._sink: AudioSink | None = None + self._watch_stop = threading.Event() + self._watcher: threading.Thread | None = None + self._lock = threading.Lock() + + @property + def sample_rate(self) -> int: + return self._rate + + @property + def device_name(self) -> str: + return str(self._device["name"]) + + def start(self, sink: AudioSink) -> None: + self._sink = sink + self._open() + if self._follow: + self._watch_stop.clear() + self._watcher = threading.Thread( + target=self._watch, name="polyglot-loopback-watch", daemon=True + ) + self._watcher.start() + + def _open(self) -> None: + pyaudio, sink, channels = self._pyaudio, self._sink, self._channels + assert sink is not None + + def callback( + in_data: bytes, frame_count: int, time_info: Any, status: int + ) -> tuple[None, int]: + sink.on_audio(np.frombuffer(in_data, dtype=np.float32).reshape(-1, channels)) + return None, pyaudio.paContinue + + try: + self._stream = self._pa.open( + format=pyaudio.paFloat32, + channels=channels, + rate=self._rate, + input=True, + input_device_index=int(self._device["index"]), + frames_per_buffer=max(1, int(self._rate * self._block_ms / 1000)), + stream_callback=callback, + ) + except OSError as exc: + raise AudioSourceError(f"cannot open loopback on {self.device_name!r}: {exc}") from exc + log.info("loopback capture on %s at %d Hz x%d", self.device_name, self._rate, channels) + + def _close(self) -> None: + if self._stream is not None: + try: + self._stream.stop_stream() + self._stream.close() + except OSError: + log.debug("error closing loopback stream", exc_info=True) + self._stream = None + + def _watch(self) -> None: + # PortAudio fixes its device list and defaults when it initialises, so asking + # the existing instance would never see a change: probe with a fresh instance. + while not self._watch_stop.wait(2.0): + probe = self._pyaudio.PyAudio() + try: + current = find_default_loopback(probe, self._pyaudio) + except (AudioSourceError, OSError): + probe.terminate() + continue + if current["name"] == self._device["name"]: + probe.terminate() + continue + with self._lock: + if ( + int(current["defaultSampleRate"]) != self._rate + or int(current["maxInputChannels"]) != self._channels + ): + probe.terminate() + # The pipeline's buffers were sized for the old format: ask for a restart. + if self._sink is not None: + self._sink.on_error( + AudioSourceError( + f"default output changed to {current['name']!r} with a different " + "format; press Start to listen again" + ) + ) + return + log.info("default output changed to %s; following it", current["name"]) + self._close() + old, self._pa = self._pa, probe # device indices belong to the new instance + old.terminate() + self._device = current + try: + self._open() + except AudioSourceError as exc: + if self._sink is not None: + self._sink.on_error(exc) + return + + def stop(self) -> None: + self._watch_stop.set() + if self._watcher is not None and self._watcher is not threading.current_thread(): + self._watcher.join(timeout=3.0) + with self._lock: + self._close() + + def __del__(self) -> None: # pragma: no cover - best effort + with contextlib.suppress(Exception): + self._pa.terminate() diff --git a/src/polyglot/adapters/dump.py b/src/polyglot/adapters/dump.py new file mode 100644 index 0000000..139a70a --- /dev/null +++ b/src/polyglot/adapters/dump.py @@ -0,0 +1,27 @@ +"""Optional debugging aid: save each final utterance's audio as a WAV file. + +Off by default (``privacy.dump_audio``). Files go to the user data directory, never the +repository, and are named by utterance ID so they line up with the logs. +""" + +from __future__ import annotations + +import logging +import time +from pathlib import Path + +from polyglot.adapters.audio.playback import write_wav +from polyglot.core.models import SAMPLE_RATE, SpeechSegment + +log = logging.getLogger(__name__) + + +class SegmentDumper: + def __init__(self, folder: Path) -> None: + self.folder = folder / time.strftime("%Y%m%d-%H%M%S") + self.folder.mkdir(parents=True, exist_ok=True) + + def __call__(self, segment: SpeechSegment) -> None: + path = self.folder / f"utt-{segment.utterance_id:05d}.wav" + write_wav(path, segment.audio, SAMPLE_RATE) + log.debug("dumped %s", path) diff --git a/src/polyglot/adapters/fakes.py b/src/polyglot/adapters/fakes.py new file mode 100644 index 0000000..fb1ea1e --- /dev/null +++ b/src/polyglot/adapters/fakes.py @@ -0,0 +1,171 @@ +"""Working fake implementations of every port, chosen by wiring rather than flags. + +Used by the tests and by ``polyglot --demo`` (run the whole app with no models, keys or +network). +""" + +from __future__ import annotations + +import threading +import time +from collections.abc import Callable, Iterable, Sequence + +import numpy as np + +from polyglot.core.errors import PolyglotError +from polyglot.core.models import ( + FRAME_SAMPLES, + SAMPLE_RATE, + ReplyOption, + SuggestionContext, + Transcript, +) +from polyglot.core.ports import RawAudio, ShieldStatus + + +class ScriptedVad: + """Returns a fixed sequence of probabilities, then ``default``.""" + + def __init__(self, probs: Iterable[float], default: float = 0.0) -> None: + self._script = list(probs) + self._i = 0 + self.default = default + + def speech_prob(self, frame: RawAudio) -> float: + if self._i < len(self._script): + p = self._script[self._i] + self._i += 1 + return p + return self.default + + def reset(self) -> None: + """A script is a one-off: reset does not rewind it.""" + + +class AmplitudeVad: + """Speech iff the frame's peak exceeds ``threshold``. Deterministic for synthetic audio.""" + + def __init__(self, threshold: float = 0.05) -> None: + self.threshold = threshold + + def speech_prob(self, frame: RawAudio) -> float: + return 1.0 if frame.size and float(np.max(np.abs(frame))) > self.threshold else 0.0 + + def reset(self) -> None: + pass + + +class ScriptedTranscriber: + """Returns canned transcripts, in order; optional delay or failure per call.""" + + def __init__( + self, + texts: Sequence[str] | Callable[[RawAudio], str] = (), + *, + language: str = "es", + probability: float = 0.95, + delay_s: float = 0.0, + fail_on: Iterable[int] = (), + error: PolyglotError | None = None, + load_error: PolyglotError | None = None, + ) -> None: + self._texts = texts + self.language, self.probability, self.delay_s = language, probability, delay_s + self._fail_on = set(fail_on) + self._error = error or PolyglotError("scripted failure") + self._load_error = load_error + self.calls: list[tuple[int, str | None]] = [] # (audio samples, language hint) + self.loaded = False + self._lock = threading.Lock() + self.max_concurrency = 0 + self._active = 0 + + def load(self) -> None: + if self._load_error is not None: + raise self._load_error + self.loaded = True + + def transcribe(self, audio: RawAudio, language: str | None) -> Transcript: + with self._lock: + n = len(self.calls) + self.calls.append((int(audio.shape[0]), language)) + self._active += 1 + self.max_concurrency = max(self.max_concurrency, self._active) + try: + if self.delay_s: + time.sleep(self.delay_s) + if n in self._fail_on: + raise self._error + if callable(self._texts): + text = self._texts(audio) + else: + text = self._texts[n] if n < len(self._texts) else f"utterance {n + 1}" + return Transcript(text, language or self.language, self.probability) + finally: + with self._lock: + self._active -= 1 + + +class EchoTranslator: + """``"[es→en] hola"``; optional per-text delay or error.""" + + def __init__( + self, + delays: dict[str, float] | None = None, + errors: dict[str, PolyglotError] | None = None, + ) -> None: + self.delays = delays or {} + self.errors = errors or {} + self.calls: list[tuple[str, str | None, str]] = [] + + def translate(self, text: str, source: str | None, target: str, *, timeout: float) -> str: + self.calls.append((text, source, target)) + time.sleep(self.delays.get(text, 0.0)) + if text in self.errors: + raise self.errors[text] + return f"[{source or '?'}→{target}] {text}" + + +class CannedSuggester: + def __init__(self, delay_s: float = 0.0, error: PolyglotError | None = None) -> None: + self.delay_s, self.error = delay_s, error + self.contexts: list[SuggestionContext] = [] + + def suggest(self, context: SuggestionContext, *, timeout: float) -> tuple[ReplyOption, ...]: + self.contexts.append(context) + time.sleep(self.delay_s) + if self.error is not None: + raise self.error + return tuple( + ReplyOption(f"respuesta {i + 1} a: {context.target.text}", f"reply {i + 1}") + for i in range(context.max_options) + ) + + +class NoopShield: + def __init__(self, status: ShieldStatus = ShieldStatus.UNSUPPORTED) -> None: + self.status = status + self.calls: list[int] = [] + + def exclude_from_capture(self, window_id: int) -> ShieldStatus: + self.calls.append(window_id) + return self.status + + +def tone( + seconds: float, freq: float = 220.0, amp: float = 0.3, rate: int = SAMPLE_RATE +) -> RawAudio: + t = np.arange(int(seconds * rate), dtype=np.float32) / rate + return (amp * np.sin(2 * np.pi * freq * t)).astype(np.float32) + + +def silence(seconds: float, rate: int = SAMPLE_RATE) -> RawAudio: + return np.zeros(int(seconds * rate), dtype=np.float32) + + +def speech_like(pattern: Sequence[tuple[str, float]], rate: int = SAMPLE_RATE) -> RawAudio: + """Build audio from ("tone"|"silence", seconds) pairs, padded to whole frames.""" + parts = [tone(s, rate=rate) if kind == "tone" else silence(s, rate=rate) for kind, s in pattern] + audio = np.concatenate(parts) if parts else np.zeros(0, dtype=np.float32) + pad = (-audio.size) % FRAME_SAMPLES if rate == SAMPLE_RATE else 0 + return np.concatenate((audio, np.zeros(pad, dtype=np.float32))) diff --git a/src/polyglot/adapters/http.py b/src/polyglot/adapters/http.py new file mode 100644 index 0000000..71a7035 --- /dev/null +++ b/src/polyglot/adapters/http.py @@ -0,0 +1,136 @@ +"""Minimal JSON-over-HTTPS client on the standard library, behind an interface. + +Providers depend on ``HttpClient``, so tests inject a fake transport and never touch the +network. Transport failures become ``ProviderTimeout``/``ProviderUnavailable``; HTTP error +statuses are returned (not raised) so each provider maps them to its own meaning. +""" + +from __future__ import annotations + +import http.client +import json +import socket +import ssl +import urllib.error +import urllib.parse +import urllib.request +from dataclasses import dataclass +from typing import Any, Protocol + +from polyglot.core.errors import ( + AuthError, + BadResponse, + ProviderError, + ProviderTimeout, + ProviderUnavailable, + QuotaExceeded, +) + + +@dataclass(frozen=True) +class HttpResponse: + status: int + body: str + + def json(self) -> Any: + try: + return json.loads(self.body) + except json.JSONDecodeError as exc: + raise BadResponse(f"response is not JSON (HTTP {self.status})") from exc + + +class HttpClient(Protocol): + def post_json( + self, + url: str, + payload: dict[str, Any], + *, + headers: dict[str, str] | None = None, + params: dict[str, str] | None = None, + timeout: float, + ) -> HttpResponse: ... + + def get_json( + self, url: str, *, headers: dict[str, str] | None = None, timeout: float + ) -> HttpResponse: ... + + +class UrllibHttpClient: + def post_json( + self, + url: str, + payload: dict[str, Any], + *, + headers: dict[str, str] | None = None, + params: dict[str, str] | None = None, + timeout: float, + ) -> HttpResponse: + if params: + url = f"{url}?{urllib.parse.urlencode(params)}" + if not url.startswith("https://"): + raise ProviderError("refusing to send a request over plain HTTP", retryable=False) + data = json.dumps(payload).encode("utf-8") + req = urllib.request.Request( + url, + data=data, + method="POST", + headers={"Content-Type": "application/json", **(headers or {})}, + ) + return self._send(req, timeout) + + def get_json( + self, url: str, *, headers: dict[str, str] | None = None, timeout: float + ) -> HttpResponse: + if not url.startswith("https://"): + raise ProviderError("refusing to send a request over plain HTTP", retryable=False) + req = urllib.request.Request(url, method="GET", headers=dict(headers or {})) + return self._send(req, timeout) + + @staticmethod + def _send(req: urllib.request.Request, timeout: float) -> HttpResponse: + try: + with urllib.request.urlopen(req, timeout=timeout) as resp: + return HttpResponse(resp.status, resp.read().decode("utf-8", "replace")) + except urllib.error.HTTPError as exc: + try: + body = exc.read().decode("utf-8", "replace") if exc.fp else "" + except (OSError, http.client.HTTPException): + body = "" # the status is what matters; the body is detail + return HttpResponse(exc.code, body) + except http.client.HTTPException as exc: # IncompleteRead, RemoteDisconnected, ... + raise ProviderUnavailable(f"connection dropped: {exc!r}") from exc + except TimeoutError as exc: + raise ProviderTimeout(f"no response within {timeout:.1f}s") from exc + except urllib.error.URLError as exc: + if isinstance(exc.reason, (TimeoutError, socket.timeout)): + raise ProviderTimeout(f"no response within {timeout:.1f}s") from exc + if isinstance(exc.reason, ssl.SSLError): + raise ProviderUnavailable(f"TLS error: {exc.reason}", retryable=False) from exc + raise ProviderUnavailable(f"network error: {exc.reason}") from exc + except OSError as exc: + raise ProviderUnavailable(f"network error: {exc}") from exc + + +def raise_for_status(resp: HttpResponse, provider: str) -> None: + """Map HTTP status codes to typed provider errors.""" + if 200 <= resp.status < 300: + return + detail = resp.body[:300].replace("\n", " ") + body = resp.body.lower() + if resp.status == 403: + # Google returns 403 for quota and rate limits too, not only for a bad key. + if "dailylimitexceeded" in body or "quota" in body: + raise QuotaExceeded(f"{provider} quota exhausted: {detail}") + if "ratelimitexceeded" in body: # rateLimitExceeded, userRateLimitExceeded + raise ProviderUnavailable(f"{provider} rate limited (HTTP 403)") + if resp.status in (401, 403): + raise AuthError(f"{provider} rejected the API key (HTTP {resp.status})") + if resp.status == 429: + if "quota" in body or "billing" in body: + raise QuotaExceeded(f"{provider} quota exhausted: {detail}") + raise ProviderUnavailable(f"{provider} rate limited (HTTP 429)") + if resp.status in (408, 409) or resp.status >= 500: + raise ProviderUnavailable(f"{provider} unavailable (HTTP {resp.status})") + raise ProviderError( + f"{provider} request failed (HTTP {resp.status}): {detail}", retryable=False + ) diff --git a/src/polyglot/adapters/openai_models.py b/src/polyglot/adapters/openai_models.py new file mode 100644 index 0000000..7cb425d --- /dev/null +++ b/src/polyglot/adapters/openai_models.py @@ -0,0 +1,207 @@ +"""OpenAI model choice: a built-in list, the live list from the API, and the request +options each model family accepts. + +Why per-model options: older chat models (``gpt-4o``, ``gpt-4.1``) take ``temperature``; +reasoning models (``gpt-5`` onward, ``o``-series) reject it, and instead take +``reasoning_effort``, which decides most of their latency. Families differ in which +effort values they accept, so a request starts with the fastest setting for the job and, +if the API rejects a parameter or value (HTTP 400 naming the parameter), retries once +with the next fallback. What worked is remembered per model for the rest of the session. + +Built-in list and retirement dates checked against OpenAI's model and deprecation pages +on 2026-10-28. The live list (``list_chat_models``) is what an account can actually use. +""" + +from __future__ import annotations + +import json +import re +import threading +from dataclasses import dataclass +from typing import Any + +from polyglot.adapters.http import HttpClient, HttpResponse, UrllibHttpClient, raise_for_status +from polyglot.core.errors import BadResponse + +DEFAULT_BASE_URL = "https://api.openai.com/v1" + + +@dataclass(frozen=True) +class ModelInfo: + id: str + note: str = "" # shown as a tooltip in Settings + + +#: Shutdown dates announced by OpenAI (deprecations page). +RETIRING: dict[str, str] = { + "gpt-4o": "2027-01-14", + "gpt-4o-mini": "2027-01-14", + "gpt-4.1-mini": "2027-01-14", + "gpt-5-mini": "2026-12-11", +} + +_KNOWN: tuple[tuple[str, str], ...] = ( + ( + "gpt-6-luna", + "GPT-6, most efficient: fast and low cost. OpenAI's named replacement " + "for gpt-4o-mini and gpt-4.1-mini.", + ), + ("gpt-6.1-terra", "GPT-6.1 family."), + ("gpt-6.1-sol", "GPT-6.1 family, more capable; slower and costlier than luna."), + ("gpt-6-astra", "GPT-6 flagship: most capable, slowest and most expensive."), + ("gpt-4o-mini", "Fast, non-reasoning."), + ("gpt-4.1-mini", "Fast, non-reasoning."), + ("gpt-4o", "Non-reasoning."), +) + + +def _with_retirement(model_id: str, note: str) -> ModelInfo: + date = RETIRING.get(model_id) + return ModelInfo(model_id, f"{note} Retires {date}.".strip() if date else note) + + +KNOWN_MODELS: tuple[ModelInfo, ...] = tuple(_with_retirement(m, n) for m, n in _KNOWN) +_KNOWN_NOTES = {m.id: m.note for m in KNOWN_MODELS} + +# ------------------------------------------------------------------ request options +_SAMPLING_PREFIXES = ("gpt-4o", "gpt-4.1", "gpt-4-", "gpt-3.5", "chatgpt-4o") +#: A rejected effort value falls back to the next one; after the last, it is dropped. +_EFFORT_FALLBACK = {"none": "minimal", "minimal": "low", "low": None} + + +def uses_temperature(model: str) -> bool: + """Older, non-reasoning chat models take ``temperature``; reasoning models do not.""" + return model.startswith(_SAMPLING_PREFIXES) or model == "gpt-4" + + +class _Memory: + """What each model turned out to accept, learned from rejections (thread-safe).""" + + def __init__(self) -> None: + self._lock = threading.Lock() + self._dropped: dict[str, set[str]] = {} + self._effort: dict[str, str] = {} + + def apply(self, model: str, payload: dict[str, Any]) -> dict[str, Any]: + with self._lock: + out = {k: v for k, v in payload.items() if k not in self._dropped.get(model, ())} + if "reasoning_effort" in out and model in self._effort: + out["reasoning_effort"] = self._effort[model] + return out + + def adjust(self, model: str, payload: dict[str, Any], param: str) -> dict[str, Any] | None: + """The payload to retry with after ``param`` was rejected, or None to give up.""" + if param not in payload or param not in ("temperature", "reasoning_effort"): + return None + out = dict(payload) + with self._lock: + if param == "reasoning_effort": + nxt = _EFFORT_FALLBACK.get(str(payload[param])) + if nxt is not None: + out[param] = self._effort[model] = nxt + return out + self._dropped.setdefault(model, set()).add(param) + if param == "reasoning_effort": + self._effort.pop(model, None) + del out[param] + return out + + def clear(self) -> None: + with self._lock: + self._dropped.clear() + self._effort.clear() + + +MEMORY = _Memory() + + +def chat_options(model: str, *, temperature: float, effort: str) -> dict[str, Any]: + """The tuning parameters for ``model``: ``temperature`` for older chat models, + ``reasoning_effort`` for reasoning models.""" + return {"temperature": temperature} if uses_temperature(model) else {"reasoning_effort": effort} + + +def rejected_param(resp: HttpResponse) -> str | None: + """The parameter an HTTP 400 complains about, if the API names one.""" + if resp.status != 400: + return None + try: + err = json.loads(resp.body).get("error") or {} + except (json.JSONDecodeError, AttributeError): + return None + param = err.get("param") if isinstance(err, dict) else None + return param if isinstance(param, str) else None + + +# ------------------------------------------------------------------ live model list +_INCLUDE = re.compile(r"^(gpt-|chatgpt-|o\d)") +_EXCLUDE = ( + "audio", "realtime", "tts", "transcribe", "whisper", "image", "embedding", "moderation", + "search", "live", "codex", "cyber", "rosalind", "computer-use", "dall-e", "sora", + "instruct", "translate", "deep-research", "oss", +) # fmt: skip +_SNAPSHOT = re.compile(r"-\d{4}-\d{2}-\d{2}$|-\d{4}$") + + +def is_text_chat_model(model_id: str) -> bool: + """A general text model usable for translation and replies (no audio, image, + realtime or specialist models, and no dated snapshots).""" + mid = model_id.lower() + return ( + bool(_INCLUDE.match(mid)) + and not any(word in mid for word in _EXCLUDE) + and not _SNAPSHOT.search(mid) + ) + + +def sort_models(ids: list[str]) -> list[ModelInfo]: + """Built-in models first, in their order; then the rest alphabetically.""" + order = {m.id: i for i, m in enumerate(KNOWN_MODELS)} + unique = sorted(set(ids), key=lambda m: (order.get(m, len(order)), m)) + return [_with_retirement(m, _KNOWN_NOTES.get(m, "")) for m in unique] + + +def list_chat_models( + api_key: str, + *, + http: HttpClient | None = None, + base_url: str = DEFAULT_BASE_URL, + timeout: float = 5.0, +) -> list[ModelInfo]: + """The text chat models this API key can use (``GET /v1/models``, filtered).""" + resp = (http or UrllibHttpClient()).get_json( + f"{base_url.rstrip('/')}/models", + headers={"Authorization": f"Bearer {api_key}"}, + timeout=timeout, + ) + raise_for_status(resp, "OpenAI") + data = resp.json() + items = data.get("data") if isinstance(data, dict) else None + if not isinstance(items, list): + raise BadResponse("OpenAI model list has no 'data'") + ids = [m["id"] for m in items if isinstance(m, dict) and isinstance(m.get("id"), str)] + return sort_models([m for m in ids if is_text_chat_model(m)]) + + +class OpenAIModelCatalog: + """What the settings dialog shows: the built-in list at once, the live list on + request (cached for the session, per key).""" + + def __init__(self, http: HttpClient | None = None, base_url: str = DEFAULT_BASE_URL) -> None: + self._http, self._base = http, base_url + self._cache: dict[str, list[ModelInfo]] = {} + self._lock = threading.Lock() + + def known(self) -> list[ModelInfo]: + return list(KNOWN_MODELS) + + def cached(self, api_key: str) -> list[ModelInfo] | None: + with self._lock: + return self._cache.get(api_key) + + def fetch(self, api_key: str) -> list[ModelInfo]: + """Blocking; call off the GUI thread. Raises ProviderError subclasses.""" + models = list_chat_models(api_key, http=self._http, base_url=self._base) + with self._lock: + self._cache[api_key] = models + return models diff --git a/src/polyglot/adapters/secrets.py b/src/polyglot/adapters/secrets.py new file mode 100644 index 0000000..7a11053 --- /dev/null +++ b/src/polyglot/adapters/secrets.py @@ -0,0 +1,55 @@ +"""API keys in the OS keyring (Windows Credential Manager, macOS Keychain).""" + +from __future__ import annotations + +import contextlib +import logging + +log = logging.getLogger(__name__) + +SERVICE = "polyglot" + + +class KeyringSecretStore: + def __init__(self, service: str = SERVICE) -> None: + self._service = service + + def get(self, name: str) -> str | None: + try: + import keyring + from keyring.errors import KeyringError + except ImportError: + log.warning("keyring is not installed; secrets cannot be stored") + return None + try: + value = keyring.get_password(self._service, name) + except KeyringError: + log.warning("could not read %s from the OS keyring", name, exc_info=True) + return None + return value or None + + def set(self, name: str, value: str | None) -> None: + import keyring + from keyring.errors import PasswordDeleteError + + if value: + keyring.set_password(self._service, name, value) + return + with contextlib.suppress(PasswordDeleteError): # nothing stored is fine + keyring.delete_password(self._service, name) + + +class MemorySecretStore: + """In-memory store for tests and for running without a keyring.""" + + def __init__(self, values: dict[str, str] | None = None) -> None: + self.values = dict(values or {}) + + def get(self, name: str) -> str | None: + return self.values.get(name) or None + + def set(self, name: str, value: str | None) -> None: + if value: + self.values[name] = value + else: + self.values.pop(name, None) diff --git a/src/polyglot/adapters/suggest/__init__.py b/src/polyglot/adapters/suggest/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/polyglot/adapters/suggest/__init__.py @@ -0,0 +1 @@ + diff --git a/src/polyglot/adapters/suggest/openai.py b/src/polyglot/adapters/suggest/openai.py new file mode 100644 index 0000000..89082ec --- /dev/null +++ b/src/polyglot/adapters/suggest/openai.py @@ -0,0 +1,107 @@ +"""Reply suggestions with an OpenAI chat model, using structured (JSON-schema) output. + +One parse path: the response must match the schema, or it is a ``BadResponse`` error. +There is no free-text fallback and no made-up reply on failure. +""" + +from __future__ import annotations + +import json +from typing import Any + +from polyglot.adapters.http import HttpClient, UrllibHttpClient +from polyglot.adapters.openai_models import chat_options +from polyglot.adapters.translate.openai import DEFAULT_BASE_URL, chat_text +from polyglot.core.errors import BadResponse +from polyglot.core.models import ConversationType, ReplyOption, SuggestionContext + +SCHEMA: dict[str, Any] = { + "name": "reply_options", + "strict": True, + "schema": { + "type": "object", + "additionalProperties": False, + "required": ["options"], + "properties": { + "options": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": False, + "required": ["source_text", "user_text"], + "properties": { + "source_text": {"type": "string"}, + "user_text": {"type": "string"}, + }, + }, + } + }, + }, +} + +_SETTING = { + ConversationType.INTERVIEW: "a job interview, where the user is the candidate", + ConversationType.MEETING: "a work meeting", + ConversationType.CASUAL: "a casual conversation", +} + + +def build_messages(ctx: SuggestionContext) -> list[dict[str, str]]: + history = "\n".join( + f"- {u.text}" + (f" ({u.translation})" if u.translation else "") for u in ctx.history + ) + target = ctx.target.text + (f"\n({ctx.target.translation})" if ctx.target.translation else "") + system = ( + f"You help the user reply in {ctx.source_language} during {_SETTING[ctx.conversation_type]}. " + f"The user is more comfortable in {ctx.user_language}. Suggest {ctx.max_options} short, " + "natural replies (one or two sentences each) that the user could say next, each a " + "different approach. For each, give `source_text` in " + f"{ctx.source_language} (what to say) and `user_text` in {ctx.user_language} " + "(what it means). Do not invent facts about the user; if the reply needs a fact you " + "do not know, keep it general." + ) + user = ( + f"Earlier in the conversation:\n{history}\n\n" if history else "" + ) + f"They just said:\n{target}" + return [{"role": "system", "content": system}, {"role": "user", "content": user}] + + +def parse_options(content: str, max_options: int) -> tuple[ReplyOption, ...]: + try: + data = json.loads(content) + raw = data["options"] + opts = tuple( + ReplyOption(str(o["source_text"]).strip(), str(o["user_text"]).strip()) for o in raw + ) + except (json.JSONDecodeError, KeyError, TypeError) as exc: + raise BadResponse("suggestions did not match the expected format") from exc + opts = tuple(o for o in opts if o.source_text) + if not opts: + raise BadResponse("no suggestions returned") + return opts[:max_options] + + +class OpenAISuggester: + def __init__( + self, + api_key: str, + *, + model: str = "gpt-4.1-mini", + base_url: str = DEFAULT_BASE_URL, + http: HttpClient | None = None, + ) -> None: + self._key, self.model, self._base = api_key, model, base_url + self._http = http or UrllibHttpClient() + + def suggest(self, context: SuggestionContext, *, timeout: float) -> tuple[ReplyOption, ...]: + payload = { + "model": self.model, + # A little reasoning helps replies; more would not fit the 6 s budget. + **chat_options(self.model, temperature=0.7, effort="low"), + "messages": build_messages(context), + "response_format": {"type": "json_schema", "json_schema": SCHEMA}, + } + content = chat_text( + self._http, api_key=self._key, base_url=self._base, payload=payload, timeout=timeout + ) + return parse_options(content, context.max_options) diff --git a/src/polyglot/adapters/translate/__init__.py b/src/polyglot/adapters/translate/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/polyglot/adapters/translate/__init__.py @@ -0,0 +1 @@ + diff --git a/src/polyglot/adapters/translate/google.py b/src/polyglot/adapters/translate/google.py new file mode 100644 index 0000000..80e3ea4 --- /dev/null +++ b/src/polyglot/adapters/translate/google.py @@ -0,0 +1,36 @@ +"""Translation with Google Cloud Translation (Basic, v2 REST API, API key).""" + +from __future__ import annotations + +from polyglot.adapters.http import HttpClient, UrllibHttpClient, raise_for_status +from polyglot.core import languages +from polyglot.core.errors import BadResponse + +URL = "https://translation.googleapis.com/language/translate/v2" + + +class GoogleTranslator: + def __init__(self, api_key: str, *, http: HttpClient | None = None) -> None: + self._key = api_key + self._http = http or UrllibHttpClient() + + def translate(self, text: str, source: str | None, target: str, *, timeout: float) -> str: + if not text.strip(): + return "" + payload: dict[str, str] = { + "q": text, + "target": languages.primary(target) or target, + "format": "text", # without this, v2 returns HTML-escaped text (' etc.) + } + src = languages.primary(source) + if src: + payload["source"] = src + resp = self._http.post_json(URL, payload, params={"key": self._key}, timeout=timeout) + raise_for_status(resp, "Google Translate") + try: + out = resp.json()["data"]["translations"][0]["translatedText"] + except (KeyError, IndexError, TypeError) as exc: + raise BadResponse("Google Translate response has no translation") from exc + if not isinstance(out, str): + raise BadResponse("Google Translate returned a non-text translation") + return out diff --git a/src/polyglot/adapters/translate/openai.py b/src/polyglot/adapters/translate/openai.py new file mode 100644 index 0000000..71a966d --- /dev/null +++ b/src/polyglot/adapters/translate/openai.py @@ -0,0 +1,92 @@ +"""Translation with an OpenAI chat model (Chat Completions REST API).""" + +from __future__ import annotations + +import logging +from typing import Any + +from polyglot.adapters.http import HttpClient, UrllibHttpClient, raise_for_status +from polyglot.adapters.openai_models import MEMORY, chat_options, rejected_param +from polyglot.core import languages +from polyglot.core.errors import BadResponse + +DEFAULT_BASE_URL = "https://api.openai.com/v1" + +log = logging.getLogger(__name__) + + +def chat_text( + http: HttpClient, + *, + api_key: str, + base_url: str, + payload: dict[str, Any], + timeout: float, + provider: str = "OpenAI", +) -> str: + model = str(payload.get("model", "")) + payload = MEMORY.apply(model, payload) + for _ in range(4): # at most a few fallbacks (effort value steps, then dropping it) + resp = http.post_json( + f"{base_url.rstrip('/')}/chat/completions", + payload, + headers={"Authorization": f"Bearer {api_key}"}, + timeout=timeout, + ) + param = rejected_param(resp) + retry = MEMORY.adjust(model, payload, param) if param else None + if retry is None: + break + log.info("%s rejected %s for %s; retrying without it", provider, param, model) + payload = retry + raise_for_status(resp, provider) + data = resp.json() + try: + choice = data["choices"][0] + message = choice["message"] + except (KeyError, IndexError, TypeError) as exc: + raise BadResponse(f"{provider} response has no choices") from exc + if message.get("refusal"): + raise BadResponse(f"{provider} refused: {message['refusal']}") + content = message.get("content") + if not isinstance(content, str) or not content.strip(): + raise BadResponse(f"{provider} returned an empty message") + return content.strip() + + +class OpenAITranslator: + def __init__( + self, + api_key: str, + *, + model: str = "gpt-4o-mini", + base_url: str = DEFAULT_BASE_URL, + http: HttpClient | None = None, + ) -> None: + self._key, self.model, self._base = api_key, model, base_url + self._http = http or UrllibHttpClient() + + def translate(self, text: str, source: str | None, target: str, *, timeout: float) -> str: + if not text.strip(): + return "" + src = f" from {languages.name(source)}" if source else "" + payload = { + "model": self.model, + # Translation must be fast: no reasoning where the model allows it. + **chat_options(self.model, temperature=0.2, effort="none"), + "messages": [ + { + "role": "system", + "content": ( + "You are a professional interpreter. Translate the user's message" + f"{src} into {languages.name(target)}. Keep the meaning, tone and " + "register. Reply with the translation only: no quotes, notes or " + "explanations." + ), + }, + {"role": "user", "content": text}, + ], + } + return chat_text( + self._http, api_key=self._key, base_url=self._base, payload=payload, timeout=timeout + ) diff --git a/src/polyglot/adapters/vad/__init__.py b/src/polyglot/adapters/vad/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/polyglot/adapters/vad/__init__.py @@ -0,0 +1 @@ + diff --git a/src/polyglot/adapters/vad/energy.py b/src/polyglot/adapters/vad/energy.py new file mode 100644 index 0000000..cf553fc --- /dev/null +++ b/src/polyglot/adapters/vad/energy.py @@ -0,0 +1,40 @@ +"""Energy-based voice activity: no model, no dependencies. + +Tracks the background noise floor and maps loudness above it to a probability. Much less +accurate than Silero in noisy rooms or with music, but useful as a fallback when the +Silero model cannot be loaded, and as a deterministic VAD in tests. +""" + +from __future__ import annotations + +import math + +import numpy as np + +from polyglot.core.ports import RawAudio + + +class EnergyVad: + def __init__( + self, + margin_db: float = 12.0, + slope_db: float = 3.0, + initial_floor_db: float = -60.0, + adapt: float = 0.05, + ) -> None: + self.margin_db, self.slope_db = margin_db, slope_db + self.initial_floor_db, self.adapt = initial_floor_db, adapt + self.reset() + + def reset(self) -> None: + self.floor_db = self.initial_floor_db + + def speech_prob(self, frame: RawAudio) -> float: + rms = float(np.sqrt(np.mean(np.square(frame, dtype=np.float64)))) if frame.size else 0.0 + db = 20.0 * math.log10(max(rms, 1e-9)) + above = db - (self.floor_db + self.margin_db) + if db < self.floor_db: + self.floor_db = max(db, -100.0) # follow quiet rooms down immediately + elif above < 0: + self.floor_db += self.adapt * (db - self.floor_db) # drift up slowly with noise + return 1.0 / (1.0 + math.exp(-above / self.slope_db)) diff --git a/src/polyglot/adapters/vad/silero.py b/src/polyglot/adapters/vad/silero.py new file mode 100644 index 0000000..a43ffa5 --- /dev/null +++ b/src/polyglot/adapters/vad/silero.py @@ -0,0 +1,140 @@ +"""Silero VAD run directly with onnxruntime. + +By default the model bundled with faster-whisper is used, so no extra download is needed. +Silero has shipped several ONNX interfaces, so the adapter reads the interface from the +model instead of assuming one: + +* frame input ``input``: 512 new samples, plus 64 samples of context from the previous + frame when the model expects 576 (faster-whisper's bundled model) or uses a single + ``state`` tensor (Silero v5); +* recurrent state: every other input except ``sr`` (``state``, or ``h``/``c``), shaped + from the model's declared input shapes and fed back from the matching outputs; +* ``sr`` (sample rate) only if the model declares it. +""" + +from __future__ import annotations + +import logging +from pathlib import Path +from typing import Any + +import numpy as np + +from polyglot.core.errors import ConfigError +from polyglot.core.models import FRAME_SAMPLES, SAMPLE_RATE +from polyglot.core.ports import RawAudio + +log = logging.getLogger(__name__) + +_CONTEXT = 64 + + +def bundled_model_candidates() -> list[Path]: + try: + import faster_whisper + except ImportError: + return [] + assets = Path(faster_whisper.__file__).parent / "assets" + found = sorted(assets.glob("silero*.onnx")) + # Prefer the known single-model files; anything else (e.g. split encoder/decoder + # models) is tried last and must pass a test inference. + preferred = ("silero_vad_v6.onnx", "silero_vad.onnx", "silero_vad_v5.onnx") + return sorted( + found, + key=lambda p: (preferred.index(p.name) if p.name in preferred else len(preferred), p.name), + ) + + +def _concrete(shape: Any) -> tuple[int, ...]: + """Declared ONNX shape -> concrete shape; symbolic/unknown dimensions become 1.""" + return tuple(d if isinstance(d, int) and d > 0 else 1 for d in (shape or [])) + + +class _Interface: + def __init__(self, sess: Any) -> None: + inputs = {i.name: i for i in sess.get_inputs()} + if "input" not in inputs: + raise ValueError(f"no 'input' tensor (inputs: {sorted(inputs)})") + self.has_sr = "sr" in inputs + self.state_names = [n for n in inputs if n not in ("input", "sr")] + if not self.state_names: + raise ValueError("no recurrent state inputs") + self.state_shapes = {n: _concrete(inputs[n].shape) for n in self.state_names} + self.state_dtypes = {n: _np_dtype(inputs[n].type) for n in self.state_names} + shape = list(inputs["input"].shape or []) + last = shape[-1] if shape else None + if isinstance(last, int) and last > FRAME_SAMPLES: + self.context = last - FRAME_SAMPLES + elif isinstance(last, int) and last == FRAME_SAMPLES: + self.context = 0 + else: # dynamic length: v5 with a single "state" expects context; v4 does not + self.context = _CONTEXT if self.state_names == ["state"] else 0 + outputs = [o.name for o in sess.get_outputs()] + if len(outputs) < 1 + len(self.state_names): + raise ValueError(f"expected {1 + len(self.state_names)} outputs, got {outputs}") + self.rank = len(shape) or 2 + + def describe(self) -> str: + return f"states={self.state_names} context={self.context}" + + +def _np_dtype(onnx_type: str) -> Any: + return np.float16 if "float16" in (onnx_type or "") else np.float32 + + +class SileroVad: + def __init__(self, model_path: str | Path | None = None, *, threads: int = 1) -> None: + import onnxruntime as ort # lazy: native library + + candidates = [Path(model_path)] if model_path else bundled_model_candidates() + if not candidates: + raise ConfigError("no Silero VAD model found (is faster-whisper installed?)") + opts = ort.SessionOptions() + opts.inter_op_num_threads = 1 + opts.intra_op_num_threads = threads + self._sr = np.array(SAMPLE_RATE, dtype=np.int64) + errors: list[str] = [] + for path in candidates: + try: + sess = ort.InferenceSession( + str(path), sess_options=opts, providers=["CPUExecutionProvider"] + ) + iface = _Interface(sess) + self._sess, self._iface = sess, iface + self.reset() + self.speech_prob(np.zeros(FRAME_SAMPLES, dtype=np.float32)) # smoke test + except Exception as exc: + errors.append(f"{path.name}: {exc}") + continue + self.model_path = path + break + else: + raise ConfigError("no usable Silero VAD model: " + "; ".join(errors)) + log.info("Silero VAD from %s (%s)", self.model_path, self._iface.describe()) + self.reset() + + def reset(self) -> None: + i = self._iface + self._state = { + n: np.zeros(i.state_shapes[n], dtype=i.state_dtypes[n]) for n in i.state_names + } + self._context: Any = np.zeros((1, i.context), dtype=np.float32) + + def speech_prob(self, frame: RawAudio) -> float: + if frame.shape[0] != FRAME_SAMPLES: + raise ValueError(f"Silero expects {FRAME_SAMPLES}-sample frames") + i = self._iface + x: Any = np.asarray(frame, dtype=np.float32).reshape(1, -1) + if i.context: + x = np.concatenate((self._context, x), axis=1) + self._context = x[:, -i.context :] + feeds: dict[str, Any] = { + "input": x if i.rank == 2 else x.reshape((1,) * (i.rank - 1) + (-1,)) + } + feeds.update(self._state) + if i.has_sr: + feeds["sr"] = self._sr + out = self._sess.run(None, feeds) + for name, value in zip(i.state_names, out[1 : 1 + len(i.state_names)], strict=False): + self._state[name] = value + return float(np.asarray(out[0]).reshape(-1)[0]) diff --git a/src/polyglot/app.py b/src/polyglot/app.py new file mode 100644 index 0000000..627ce49 --- /dev/null +++ b/src/polyglot/app.py @@ -0,0 +1,239 @@ +"""Qt application: the composition root for the GUI. + +Creates the controller, the presenter, the view and the one thread bridge, and connects +signals. Nothing else in the app knows all of these at once. +""" + +from __future__ import annotations + +import logging +import sys +from pathlib import Path +from typing import Any + +from polyglot.config import AppConfig, ConfigStore, Secrets +from polyglot.controller import PIPELINE_SECTIONS, AppController +from polyglot.core.errors import ConfigError +from polyglot.core.events import EventBus + +log = logging.getLogger(__name__) + + +def _list_devices() -> list[dict[str, Any]]: + from polyglot.adapters.audio.sounddevice_source import list_input_devices + + return list_input_devices() + + +def _tray_icon() -> Any: + from PyQt6.QtCore import Qt + from PyQt6.QtGui import QColor, QIcon, QPainter, QPixmap + + pix = QPixmap(32, 32) + pix.fill(Qt.GlobalColor.transparent) + p = QPainter(pix) + p.setRenderHint(QPainter.RenderHint.Antialiasing) + p.setBrush(QColor("#2f7de1")) + p.setPen(Qt.PenStyle.NoPen) + p.drawEllipse(2, 2, 28, 28) + p.setPen(QColor("white")) + font = p.font() + font.setBold(True) + font.setPointSize(14) + p.setFont(font) + p.drawText(pix.rect(), Qt.AlignmentFlag.AlignCenter, "P") + p.end() + return QIcon(pix) + + +def run_gui(config_path: Path | None, *, demo: bool = False) -> int: + from PyQt6.QtCore import QTimer + from PyQt6.QtWidgets import QApplication, QMenu, QMessageBox, QSystemTrayIcon + + from polyglot import platform + from polyglot.adapters.openai_models import OpenAIModelCatalog + from polyglot.adapters.secrets import KeyringSecretStore, MemorySecretStore + from polyglot.ui.presenter import Presenter + from polyglot.ui.qt.bridge import EventBridge + from polyglot.ui.qt.hotkeys import GlobalHotkeys + from polyglot.ui.qt.overlay import OverlayWindow + from polyglot.ui.qt.settings_dialog import SettingsDialog + from polyglot.ui.qt.shield_filter import CaptureShieldFilter + + app = QApplication.instance() or QApplication(sys.argv) + assert isinstance(app, QApplication) + app.setApplicationName("Polyglot") + app.setQuitOnLastWindowClosed(False) + + _install_excepthook() + + store = ConfigStore(config_path) + config_error = "" + try: + config = store.load() + except ConfigError as exc: + config_error = str(exc) + config = AppConfig() # run on defaults; store.save() refuses, so the file is kept + + secrets = Secrets(MemorySecretStore() if demo else KeyringSecretStore()) + bus = EventBus() + controller = AppController( + config, + secrets, + bus, + demo=demo, + save=None if demo else store.save, + ) + + window = OverlayWindow(config.ui) + presenter = Presenter(window, controller, user_language=config.translation.target_language) + bridge = EventBridge(bus, presenter.handle) # the one thread bridge + + # Capture shield on every top-level window (overlay, dialogs, menus, tooltips). + shield_filter: CaptureShieldFilter | None = None + if config.ui.hide_from_capture: + shield_filter = CaptureShieldFilter(platform.window_shield()) + shield_filter.status_changed.connect(presenter.on_shield_status) + app.installEventFilter(shield_filter) + else: + presenter.on_shield_status(None) + + def refresh_flags() -> None: + built = controller.built + presenter.translation_enabled = bool(built and built.translation_enabled) + + # View intents -> presenter -> controller. + def start_stop() -> None: + presenter.on_start_stop() + refresh_flags() # the first successful build may happen here + + window.start_stop_clicked.connect(start_stop) + window.suggest_clicked.connect(presenter.on_suggest) + window.clear_clicked.connect(presenter.on_clear) + window.language_clicked.connect(presenter.on_unlock_language) + + hotkeys = GlobalHotkeys() + hotkeys.suggest.connect(presenter.on_suggest) + hotkeys.toggle_window.connect(window.toggle_visible) + hotkeys.bind(config.ui.hotkey_suggest, config.ui.hotkey_toggle) + + model_catalog = OpenAIModelCatalog() # caches the account's model list per session + + def open_settings() -> None: + nonlocal shield_filter + dialog = SettingsDialog( + controller.config, secrets, _list_devices, window, models=model_catalog + ) + accepted = bool(dialog.exec()) + new, keys_changed = dialog.result_config, dialog.keys_changed + dialog.deleteLater() + if accepted and new is not None: + changed = controller.apply_config(new) + if keys_changed and not (changed & PIPELINE_SECTIONS): + controller.rebuild() # new API keys take effect now + refresh_flags() + presenter.on_user_language(new.translation.target_language) + window.setWindowOpacity(new.ui.opacity) + hotkeys.bind(new.ui.hotkey_suggest, new.ui.hotkey_toggle) + if new.ui.hide_from_capture and shield_filter is None: + shield_filter = CaptureShieldFilter(platform.window_shield()) + shield_filter.status_changed.connect(presenter.on_shield_status) + app.installEventFilter(shield_filter) + shield_filter.shield_widget(window) + elif not new.ui.hide_from_capture and shield_filter is not None: + # Windows stay hidden (and the footer says so) until restart. + QMessageBox.information( + window, + "Restart needed", + "Windows stay hidden from screen sharing until Polyglot restarts.", + ) + + window.settings_clicked.connect(open_settings) + + def save_geometry() -> None: + g = window.geometry() + ui = controller.config.ui.model_copy( + update={"x": g.x(), "y": g.y(), "width": g.width(), "height": g.height()} + ) + controller.apply_config(controller.config.model_copy(update={"ui": ui})) + + def quit_app() -> None: + if controller.listening: + answer = QMessageBox.question(window, "Quit Polyglot", "Stop listening and quit?") + if answer != QMessageBox.StandardButton.Yes: + return + app.quit() + + window.quit_clicked.connect(quit_app) + + tray: QSystemTrayIcon | None = None + if QSystemTrayIcon.isSystemTrayAvailable(): + tray = QSystemTrayIcon(_tray_icon(), app) + menu = QMenu(window) # parented: the tray does not own its menu + menu.addAction("Show / hide", window.toggle_visible) + menu.addAction("Start / stop listening", presenter.on_start_stop) + menu.addAction("Suggest replies", presenter.on_suggest) + menu.addAction("Settings…", open_settings) + menu.addSeparator() + menu.addAction("Quit", quit_app) + tray.setContextMenu(menu) + tray.setToolTip("Polyglot") + tray.activated.connect( + lambda reason: window.toggle_visible() + if reason == QSystemTrayIcon.ActivationReason.Trigger + else None + ) + tray.show() + + def shutdown() -> None: + # Stop everything that could call into Qt from another thread, then tear down + # Qt objects in a defined order (not at interpreter exit). + save_geometry() + hotkeys.stop() + controller.shutdown() + bridge.close() + # Before any widget is deleted: destroying windows makes the shield filter + # recompute its status, which must not reach the (deleted) view. + if shield_filter is not None: + app.removeEventFilter(shield_filter) + shield_filter.close() + presenter.detach() + if tray is not None: + tray.hide() + tray.setContextMenu(None) + tray.deleteLater() + window.hide() + window.deleteLater() + + app.aboutToQuit.connect(shutdown) + + window.show() + if config_error: + presenter.view.set_status(presenter_status_error(config_error)) + + def startup() -> None: + # After the event loop starts, so the window paints before devices/models load. + controller.ensure_built() + refresh_flags() + + QTimer.singleShot(0, startup) + presenter.view.set_language( + presenter.language_label(config.asr.language, config.asr.language is not None) + ) + return int(app.exec()) + + +def _install_excepthook() -> None: + """PyQt aborts the process on an exception escaping a slot unless an excepthook is + installed. Log it and keep running instead.""" + + def hook(exc_type: Any, exc: BaseException, tb: Any) -> None: + log.critical("unhandled error", exc_info=(exc_type, exc, tb)) + + sys.excepthook = hook + + +def presenter_status_error(message: str) -> Any: + from polyglot.ui.presenter import StatusVM + + return StatusVM(f"Config error, using defaults: {message}", "error") diff --git a/src/polyglot/config.py b/src/polyglot/config.py new file mode 100644 index 0000000..acefe02 --- /dev/null +++ b/src/polyglot/config.py @@ -0,0 +1,350 @@ +"""Typed configuration with one precedence order. + +Lowest to highest: defaults -> ``config.toml`` in the user config directory -> +``POLYGLOT_
__`` environment variables -> changes saved from the settings +dialog (written back to ``config.toml``). + +API keys are not part of the config. They live in the OS keyring (see ``Secrets``); +``POLYGLOT_OPENAI_API_KEY`` / ``POLYGLOT_GOOGLE_API_KEY`` (or the conventional +``OPENAI_API_KEY``) override the keyring for development. +""" + +from __future__ import annotations + +import json +import os +import sys +import tempfile +from collections.abc import Mapping +from pathlib import Path +from typing import Any, Literal + +from pydantic import BaseModel, ConfigDict, Field, ValidationError, field_validator, model_validator + +from polyglot.core.errors import ConfigError +from polyglot.core.ports import SecretStore + +if sys.version_info >= (3, 11): + import tomllib +else: # pragma: no cover - exercised on Python 3.10 only + import tomli as tomllib + +ENV_PREFIX = "POLYGLOT_" + + +class _Section(BaseModel): + model_config = ConfigDict(extra="forbid", validate_assignment=True) + + +class AudioConfig(_Section): + #: auto = WASAPI loopback on Windows, else the default input device + source: Literal["auto", "loopback", "device", "file"] = "auto" + device: str | None = None # input device name or index, for source = "device" + + @field_validator("device", mode="before") + @classmethod + def _device_as_text(cls, value: object) -> object: + return str(value) if isinstance(value, int) and not isinstance(value, bool) else value + + file: str | None = None # WAV path, for source = "file" + ring_seconds: float = Field(30.0, ge=1.0, le=600.0) + gap_fill: bool = True + + +class VadConfig(_Section): + engine: Literal["silero", "energy"] = "silero" + model_path: str | None = None + start_threshold: float = Field(0.5, ge=0.0, le=1.0) + end_threshold: float = Field(0.35, ge=0.0, le=1.0) + start_frames: int = Field(3, ge=1, le=50) + end_silence_ms: int = Field(600, ge=100, le=5000) + pre_roll_ms: int = Field(300, ge=0, le=2000) + max_utterance_s: float = Field(15.0, ge=3.0, le=60.0) + min_utterance_ms: int = Field(300, ge=0, le=5000) + partial_interval_ms: int = Field(0, ge=0, le=10000) + + @model_validator(mode="after") + def _thresholds(self) -> VadConfig: + if self.end_threshold > self.start_threshold: + raise ValueError("vad.end_threshold must not exceed vad.start_threshold") + return self + + +class AsrConfig(_Section): + model: str = "base" + device: Literal["auto", "cpu", "cuda"] = "auto" + #: auto = the fastest type the device supports (int8 on CPU, float16 on CUDA). + #: "default" would keep the model's saved float16, which CPUs convert to slow float32. + compute_type: Literal[ + "auto", + "int8", + "int8_float16", + "int8_float32", + "int8_bfloat16", + "int16", + "float16", + "bfloat16", + "float32", + ] = "auto" + beam_size: int = Field(5, ge=1, le=10) + language: str | None = None # force a source language; None = auto-detect then lock + lock_after: int = Field(2, ge=1, le=10) + lock_min_probability: float = Field(0.8, ge=0.0, le=1.0) + queue_size: int = Field(8, ge=1, le=64) + + @field_validator("compute_type", mode="before") + @classmethod + def _legacy_default(cls, value: object) -> object: + # Older versions saved "default" without the user choosing it; it caused a + # float16 -> float32 conversion (and a CTranslate2 warning) on CPUs. + return "auto" if value == "default" else value + + +class TranslationConfig(_Section): + enabled: bool = False # cloud calls are opt-in + provider: Literal["openai", "google"] = "openai" + target_language: str = "en" + model: str = "gpt-4o-mini" + timeout_s: float = Field(3.0, gt=0.0, le=30.0) + + +class SuggestionsConfig(_Section): + enabled: bool = False # cloud calls are opt-in + model: str = "gpt-4.1-mini" + timeout_s: float = Field(6.0, gt=0.0, le=60.0) + conversation_type: Literal["interview", "meeting", "casual"] = "meeting" + history: int = Field(6, ge=0, le=30) + options: int = Field(2, ge=1, le=3) + + +class UiConfig(_Section): + opacity: float = Field(0.92, ge=0.2, le=1.0) + x: int = 100 + y: int = 100 + width: int = Field(420, ge=280) + height: int = Field(640, ge=300) + hide_from_capture: bool = True + hotkey_suggest: str = "++s" + hotkey_toggle: str = "++h" + + +class PrivacyConfig(_Section): + log_content: bool = False # transcript text in logs (DEBUG only) + dump_audio: bool = False # save each utterance as WAV in the data directory + + +class AppConfig(_Section): + audio: AudioConfig = AudioConfig() # pydantic copies model defaults per instance + vad: VadConfig = VadConfig() # pydantic copies model defaults per instance + asr: AsrConfig = AsrConfig() # pydantic copies model defaults per instance + translation: TranslationConfig = ( + TranslationConfig() + ) # pydantic copies model defaults per instance + suggestions: SuggestionsConfig = ( + SuggestionsConfig() + ) # pydantic copies model defaults per instance + ui: UiConfig = UiConfig() # pydantic copies model defaults per instance + privacy: PrivacyConfig = PrivacyConfig() # pydantic copies model defaults per instance + + +SECTIONS = tuple(AppConfig.model_fields) + + +# ----------------------------------------------------------------- paths +def config_dir() -> Path: + import platformdirs + + return Path(platformdirs.user_config_dir("polyglot", appauthor=False)) + + +def data_dir() -> Path: + import platformdirs + + return Path(platformdirs.user_data_dir("polyglot", appauthor=False)) + + +def log_dir() -> Path: + import platformdirs + + return Path(platformdirs.user_log_dir("polyglot", appauthor=False)) + + +def default_config_path() -> Path: + return config_dir() / "config.toml" + + +# ----------------------------------------------------------------- loading +def _env_overrides(environ: Mapping[str, str]) -> dict[str, dict[str, Any]]: + out: dict[str, dict[str, Any]] = {} + for key, raw in environ.items(): + if not key.startswith(ENV_PREFIX) or "__" not in key: + continue + section, _, field = key[len(ENV_PREFIX) :].lower().partition("__") + if section not in SECTIONS: + continue + # Kept as text: pydantic converts "true"/"800"/"0.5" for typed fields, and text + # fields (a device named "3") stay text. + out.setdefault(section, {})[field] = raw + return out + + +def _merge(base: dict[str, Any], over: Mapping[str, Any]) -> dict[str, Any]: + merged = dict(base) + for key, value in over.items(): + if isinstance(value, Mapping) and isinstance(merged.get(key), dict): + merged[key] = _merge(merged[key], value) + else: + merged[key] = value + return merged + + +def _read_file(path: Path) -> dict[str, Any]: + if not path.exists(): + return {} + try: + # Typed explicitly: with mypy targeting 3.10, ``tomllib`` is the ``tomli`` fallback, + # which is not installed on 3.11+ and so reads as Any. + data: dict[str, Any] = tomllib.loads(path.read_text(encoding="utf-8")) + except (OSError, tomllib.TOMLDecodeError) as exc: + raise ConfigError(f"cannot read {path}: {exc}") from exc + return data + + +def _validate(data: dict[str, Any], path: Path) -> AppConfig: + try: + return AppConfig.model_validate(data) + except ValidationError as exc: + raise ConfigError(f"invalid configuration ({path}): {exc}") from exc + + +class ConfigStore: + """Loads the layered config and saves only what belongs in the file. + + Environment overrides apply to the running app but are never written to + ``config.toml``: on save, a field still equal to its env override keeps the file's + own value. If the file could not be loaded, saving is refused, so a broken file is + never silently replaced with defaults. + """ + + def __init__(self, path: Path | None = None, environ: Mapping[str, str] | None = None) -> None: + self.path = path or default_config_path() + self._environ = os.environ if environ is None else environ + self._file: dict[str, Any] = {} + self._env: dict[str, dict[str, Any]] = {} + self._env_effective: dict[str, Any] = {} + self.loaded = False + + def load(self) -> AppConfig: + self.loaded = False + file_data = _read_file(self.path) + env = _env_overrides(self._environ) + config = _validate(_merge(file_data, env), self.path) + self._file, self._env = file_data, env + self._env_effective = config.model_dump(mode="json") + self.loaded = True + return config + + def save(self, config: AppConfig) -> Path: + if not self.loaded: + raise ConfigError(f"not saving: {self.path} could not be loaded; fix or remove it") + data = config.model_dump(mode="json") + for section, fields in self._env.items(): + for field in fields: + if field not in data.get(section, {}): + continue + if data[section][field] == self._env_effective.get(section, {}).get(field): + data[section][field] = self._file.get(section, {}).get(field) # file layer + _write_atomic(self.path, dict_to_toml(data)) + self._file = { + s: {k: v for k, v in vals.items() if v is not None} for s, vals in data.items() + } + return self.path + + +def load_config(path: Path | None = None, environ: Mapping[str, str] | None = None) -> AppConfig: + return ConfigStore(path, environ).load() + + +# ----------------------------------------------------------------- saving +def _toml_value(value: Any) -> str: + if isinstance(value, bool): + return "true" if value else "false" + if isinstance(value, (int, float)): + return repr(value) + if isinstance(value, str): + # A JSON string is a TOML basic string, except that TOML also forbids a raw DEL. + return json.dumps(value, ensure_ascii=False).replace("\x7f", "\\u007f") + raise TypeError(f"cannot write {type(value).__name__} to TOML") + + +def dict_to_toml(data: Mapping[str, Mapping[str, Any]]) -> str: + lines = ["# Polyglot configuration. API keys are stored in the OS keyring, not here.", ""] + for section, values in data.items(): + lines.append(f"[{section}]") + for key, value in values.items(): + if value is None: + continue # TOML has no null; absence means "default" + lines.append(f"{key} = {_toml_value(value)}") + lines.append("") + return "\n".join(lines) + + +def to_toml(config: AppConfig) -> str: + return dict_to_toml(config.model_dump(mode="json")) + + +def _write_atomic(path: Path, text: str) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + fd, tmp = tempfile.mkstemp(prefix=".config-", suffix=".toml", dir=path.parent) + try: + with os.fdopen(fd, "w", encoding="utf-8") as fh: + fh.write(text) + fh.flush() + os.fsync(fh.fileno()) + os.replace(tmp, path) + except BaseException: + Path(tmp).unlink(missing_ok=True) + raise + + +def save_config(config: AppConfig, path: Path | None = None) -> Path: + """Write the whole config once, atomically. (The app saves through ConfigStore, + which also keeps environment overrides out of the file.)""" + path = path or default_config_path() + _write_atomic(path, to_toml(config)) + return path + + +def changed_sections(old: AppConfig, new: AppConfig) -> set[str]: + return {s for s in SECTIONS if getattr(old, s) != getattr(new, s)} + + +# ----------------------------------------------------------------- secrets +class Secrets: + OPENAI = "openai_api_key" + GOOGLE = "google_api_key" + _ENV: Mapping[str, tuple[str, ...]] = { + OPENAI: ("POLYGLOT_OPENAI_API_KEY", "OPENAI_API_KEY"), + GOOGLE: ("POLYGLOT_GOOGLE_API_KEY", "GOOGLE_TRANSLATE_API_KEY"), + } + + def __init__(self, store: SecretStore, environ: Mapping[str, str] | None = None) -> None: + self._store = store + self._environ = os.environ if environ is None else environ + + def get(self, name: str) -> str | None: + for var in self._ENV.get(name, ()): + value = self._environ.get(var) + if value: + return value + return self._store.get(name) + + def source(self, name: str) -> str | None: + """Where the effective value comes from: an env var name, "keychain", or None.""" + for var in self._ENV.get(name, ()): + if self._environ.get(var): + return var + return "keychain" if self._store.get(name) else None + + def set(self, name: str, value: str | None) -> None: + self._store.set(name, value) diff --git a/src/polyglot/controller.py b/src/polyglot/controller.py new file mode 100644 index 0000000..f3831c7 --- /dev/null +++ b/src/polyglot/controller.py @@ -0,0 +1,157 @@ +"""Application controller: owns the pipeline's lifecycle and applies config changes. + +Qt-free, so it is unit-tested. The UI calls it through the ``Commands`` protocol the +presenter uses; it never touches widgets. +""" + +from __future__ import annotations + +import logging +from collections.abc import Callable + +from polyglot.config import AppConfig, Secrets, changed_sections, save_config +from polyglot.core.errors import ConfigError, PolyglotError +from polyglot.core.events import EventBus, PipelineState, PipelineStatus, StageError +from polyglot.core.models import ErrorKind +from polyglot.wiring import Built, build, build_demo + +log = logging.getLogger(__name__) + +#: Sections whose change requires rebuilding the pipeline (and stopping capture). +PIPELINE_SECTIONS = frozenset({"audio", "vad", "asr", "translation", "suggestions", "privacy"}) + +Builder = Callable[..., Built] + + +class AppController: + def __init__( + self, + config: AppConfig, + secrets: Secrets, + bus: EventBus, + *, + demo: bool = False, + builder: Builder | None = None, + save: Callable[[AppConfig], object] | None = save_config, + ) -> None: + self.config, self.secrets, self.bus, self.demo = config, secrets, bus, demo + self._builder: Builder = builder or ( + (lambda cfg, _secrets, bus, **kw: build_demo(cfg, bus, **kw)) if demo else build + ) + self._save = save + self.built: Built | None = None + self.warnings: list[str] = [] + # Conversation (session + ID sequence) of the last pipeline, kept so that a + # failed rebuild followed by a later successful build continues it. + self._carry_over: dict[str, object] = {} + + # ---------------------------------------------------------------- building + def ensure_built(self) -> Built | None: + if self.built is not None: + return self.built + try: + built = self._builder(self.config, self.secrets, self.bus, **self._carry_over) + except Exception as exc: + self._report_build_error(exc) + return None + self.built = built + self.warnings = list(built.warnings) + for w in self.warnings: + self.bus.publish(StageError("setup", ErrorKind.NOT_CONFIGURED, w)) + if self._carry_over: + built.pipeline.retranslate_pending() # requests the previous pipeline dropped + return built + + def _report_build_error(self, exc: Exception) -> None: + if isinstance(exc, (ConfigError, PolyglotError)): + log.warning("cannot build pipeline: %s", exc) + kind = exc.kind + else: + log.exception("unexpected error building the pipeline") + kind = ErrorKind.INTERNAL + self.bus.publish(StageError("setup", kind, str(exc))) + self.bus.publish(PipelineStatus(PipelineState.ERROR, str(exc))) + + def _carry(self, previous: Built | None) -> dict[str, object]: + if previous is None: + return {} + return {"session": previous.pipeline.session, "ids": previous.pipeline.ids} + + # ---------------------------------------------------------------- Commands + @property + def listening(self) -> bool: + return self.built is not None and self.built.pipeline.running + + def start(self) -> None: + built = self.ensure_built() + if built is not None: + built.pipeline.start() + + def stop(self) -> None: + if self.built is not None: + self.built.pipeline.stop() + + def toggle(self) -> None: + if self.listening: + self.stop() + else: + self.start() + + def request_suggestion(self) -> None: + built = self.ensure_built() + if built is not None: + built.pipeline.request_suggestion() + + def set_language(self, language: str | None) -> None: + built = self.ensure_built() + if built is not None: + built.pipeline.set_language(language) + + def clear(self) -> None: + if self.built is not None: + self.built.pipeline.clear() + + def shutdown(self) -> None: + if self.built is not None: + self.built.pipeline.close() + self.built = None + + # ---------------------------------------------------------------- settings + def apply_config(self, new: AppConfig) -> set[str]: + """Apply and persist a new config. Returns the sections that changed. + + Display-only sections apply live (the UI reads them). Pipeline sections rebuild + the pipeline, keeping the conversation; capture restarts if it was running. + """ + old = self.config + changed = changed_sections(old, new) + if not changed: + return changed + self.config = new + if self._save is not None: + try: + self._save(new) + except (OSError, PolyglotError) as exc: + self.bus.publish( + StageError("settings", ErrorKind.INTERNAL, f"could not save settings: {exc}") + ) + if changed & PIPELINE_SECTIONS: + self.rebuild() + if old.asr.language != new.asr.language and self.built is not None: + self.built.pipeline.set_language(new.asr.language) # forced language, or unlock + return changed + + def rebuild(self) -> None: + """Rebuild the pipeline from the current config and secrets, keeping the + conversation. Restarts listening if it was on. Used after settings or API keys + change. A failed build is reported; the conversation is kept for the next try.""" + if self.built is None: + return + was_listening = self.listening + previous = self.built + self._carry_over = self._carry(previous) + previous.pipeline.close() + self.built = None + if self.ensure_built() is not None and was_listening: + assert self.built is not None + self.built.pipeline.start() diff --git a/src/polyglot/core/__init__.py b/src/polyglot/core/__init__.py new file mode 100644 index 0000000..ca9ebec --- /dev/null +++ b/src/polyglot/core/__init__.py @@ -0,0 +1,4 @@ +"""Pure-Python core: domain model, ports, events, segmenter and pipeline. + +Imports only the standard library and numpy (enforced by tests/unit/test_architecture.py). +""" diff --git a/src/polyglot/core/errors.py b/src/polyglot/core/errors.py new file mode 100644 index 0000000..a0fd207 --- /dev/null +++ b/src/polyglot/core/errors.py @@ -0,0 +1,64 @@ +"""Typed errors that are part of each port's contract. + +Adapters translate vendor/library exceptions into these. The core never sees raw +``urllib``/``onnxruntime``/``ctranslate2`` exceptions. +""" + +from __future__ import annotations + +from polyglot.core.models import ErrorKind + + +class PolyglotError(Exception): + kind: ErrorKind = ErrorKind.INTERNAL + retryable: bool = False + + +class ProviderError(PolyglotError): + """A cloud/remote provider failed.""" + + def __init__( + self, message: str, *, kind: ErrorKind | None = None, retryable: bool | None = None + ) -> None: + super().__init__(message) + if kind is not None: + self.kind = kind + if retryable is not None: + self.retryable = retryable + + +class ProviderTimeout(ProviderError): + kind = ErrorKind.TIMEOUT + retryable = True + + +class ProviderUnavailable(ProviderError): + kind = ErrorKind.UNAVAILABLE + retryable = True + + +class QuotaExceeded(ProviderError): + kind = ErrorKind.QUOTA + retryable = False + + +class AuthError(ProviderError): + kind = ErrorKind.AUTH + retryable = False + + +class BadResponse(ProviderError): + kind = ErrorKind.BAD_RESPONSE + retryable = False + + +class TranscriptionFailed(PolyglotError): + kind = ErrorKind.TRANSCRIPTION + + +class AudioSourceError(PolyglotError): + kind = ErrorKind.AUDIO + + +class ConfigError(PolyglotError): + kind = ErrorKind.NOT_CONFIGURED diff --git a/src/polyglot/core/events.py b/src/polyglot/core/events.py new file mode 100644 index 0000000..0aa18d8 --- /dev/null +++ b/src/polyglot/core/events.py @@ -0,0 +1,117 @@ +"""Events the pipeline publishes, and the bus that carries them. + +Subscribers run synchronously on the publishing thread. A subscriber that touches a UI +toolkit must hand the event over to its own thread (the Qt presenter does this with a +queued signal). A failing subscriber is logged and never breaks the publisher. +""" + +from __future__ import annotations + +import logging +import threading +from collections.abc import Callable +from dataclasses import dataclass +from enum import Enum + +from polyglot.core.models import ErrorKind, Suggestion, Utterance + +log = logging.getLogger(__name__) + + +class PipelineState(str, Enum): + STOPPED = "stopped" + LOADING = "loading" + LISTENING = "listening" + FALLING_BEHIND = "falling_behind" + ERROR = "error" + + +@dataclass(frozen=True) +class UtteranceUpdated: + """An utterance was created or changed (started, partial, final, translated, failed).""" + + utterance: Utterance + + +@dataclass(frozen=True) +class UtteranceDiscarded: + """An utterance turned out not to be speech (too short, or no words). Remove its row.""" + + utterance_id: int + + +@dataclass(frozen=True) +class ConversationCleared: + """The user cleared the conversation. No event for an ID <= ``upto`` follows.""" + + upto: int + + +@dataclass(frozen=True) +class SuggestionStarted: + utterance_id: int + + +@dataclass(frozen=True) +class SuggestionsReady: + suggestion: Suggestion + + +@dataclass(frozen=True) +class LanguageChanged: + """Source language was locked, unlocked or overridden.""" + + language: str | None + locked: bool + + +@dataclass(frozen=True) +class PipelineStatus: + state: PipelineState + detail: str = "" + + +@dataclass(frozen=True) +class StageError: + stage: str + kind: ErrorKind + message: str + retryable: bool = False + + +Event = ( + UtteranceUpdated + | UtteranceDiscarded + | ConversationCleared + | SuggestionStarted + | SuggestionsReady + | LanguageChanged + | PipelineStatus + | StageError +) +Subscriber = Callable[[Event], None] + + +class EventBus: + """In-process publish/subscribe. Thread-safe.""" + + def __init__(self) -> None: + self._lock = threading.Lock() + self._subscribers: tuple[Subscriber, ...] = () + + def subscribe(self, subscriber: Subscriber) -> Callable[[], None]: + with self._lock: + self._subscribers = (*self._subscribers, subscriber) + + def unsubscribe() -> None: + with self._lock: + self._subscribers = tuple(s for s in self._subscribers if s is not subscriber) + + return unsubscribe + + def publish(self, event: Event) -> None: + for subscriber in self._subscribers: # tuple snapshot: safe without the lock + try: + subscriber(event) + except Exception: + log.exception("event subscriber failed on %s", type(event).__name__) diff --git a/src/polyglot/core/languages.py b/src/polyglot/core/languages.py new file mode 100644 index 0000000..035a6bb --- /dev/null +++ b/src/polyglot/core/languages.py @@ -0,0 +1,41 @@ +"""Language codes (as Whisper reports them) to English names, for prompts and the UI.""" + +from __future__ import annotations + +_NAMES: dict[str, str] = { + "af": "Afrikaans", "ar": "Arabic", "bg": "Bulgarian", "bn": "Bengali", "ca": "Catalan", + "cs": "Czech", "cy": "Welsh", "da": "Danish", "de": "German", "el": "Greek", + "en": "English", "es": "Spanish", "et": "Estonian", "fa": "Persian", "fi": "Finnish", + "fr": "French", "gl": "Galician", "gu": "Gujarati", "he": "Hebrew", "hi": "Hindi", + "hr": "Croatian", "hu": "Hungarian", "hy": "Armenian", "id": "Indonesian", + "is": "Icelandic", "it": "Italian", "ja": "Japanese", "ka": "Georgian", "kk": "Kazakh", + "kn": "Kannada", "ko": "Korean", "lt": "Lithuanian", "lv": "Latvian", "mk": "Macedonian", + "ml": "Malayalam", "mr": "Marathi", "ms": "Malay", "ne": "Nepali", "nl": "Dutch", + "no": "Norwegian", "pa": "Punjabi", "pl": "Polish", "pt": "Portuguese", "ro": "Romanian", + "ru": "Russian", "sk": "Slovak", "sl": "Slovenian", "sr": "Serbian", "sv": "Swedish", + "sw": "Swahili", "ta": "Tamil", "te": "Telugu", "th": "Thai", "tl": "Tagalog", + "tr": "Turkish", "uk": "Ukrainian", "ur": "Urdu", "vi": "Vietnamese", "zh": "Chinese", +} # fmt: skip + + +def primary(code: str | None) -> str | None: + """'pt-BR' -> 'pt'; None stays None.""" + if not code: + return None + return code.replace("_", "-").split("-")[0].lower() + + +def name(code: str | None) -> str: + """Human name for a language code; unknown codes are returned as given.""" + if not code: + return "Unknown" + return _NAMES.get(primary(code) or "", code) + + +def same_language(a: str | None, b: str | None) -> bool: + pa, pb = primary(a), primary(b) + return pa is not None and pa == pb + + +def known_codes() -> list[str]: + return sorted(_NAMES) diff --git a/src/polyglot/core/models.py b/src/polyglot/core/models.py new file mode 100644 index 0000000..e02da03 --- /dev/null +++ b/src/polyglot/core/models.py @@ -0,0 +1,145 @@ +"""Domain model: the concepts Polyglot works with, independent of any library or UI. + +Everything here is immutable. A change produces a new object (``dataclasses.replace``), +so a value handed to another thread can never change underneath it. +""" + +from __future__ import annotations + +import itertools +from dataclasses import dataclass, replace +from enum import Enum + +import numpy as np +import numpy.typing as npt + +#: Every stage after the front end works at this rate, mono, float32 in [-1, 1]. +SAMPLE_RATE = 16_000 +#: One VAD frame: 512 samples at 16 kHz = 32 ms (the frame size Silero VAD expects). +FRAME_SAMPLES = 512 +FRAME_SECONDS = FRAME_SAMPLES / SAMPLE_RATE + +AudioArray = npt.NDArray[np.float32] + + +class UtteranceStatus(str, Enum): + """Lifecycle of one utterance. See the design doc, "Domain model".""" + + LISTENING = "listening" # speech started, no text yet + PARTIAL = "partial" # provisional text, may still change + FINAL = "final" # endpoint reached, text fixed + TRANSLATED = "translated" # translation attached + FAILED = "failed" # a stage failed; ``error`` says which way + + +class ErrorKind(str, Enum): + """Why something failed. Shown to the user; never replaced with made-up content.""" + + TIMEOUT = "timeout" + UNAVAILABLE = "unavailable" + QUOTA = "quota" + AUTH = "auth" + BAD_RESPONSE = "bad_response" + TRANSCRIPTION = "transcription" + OVERLOADED = "overloaded" + NOT_CONFIGURED = "not_configured" + NOTHING_TO_ANSWER = "nothing_to_answer" + AUDIO = "audio" + INTERNAL = "internal" + + +@dataclass(frozen=True, eq=False) +class SpeechSegment: + """Audio for one utterance, produced by the segmenter. + + ``is_final`` segments are complete utterances. Non-final segments are partials: the + utterance so far, re-sent as it grows, each with a higher ``version``. + """ + + utterance_id: int + audio: AudioArray + t_start: float + t_end: float + is_final: bool + version: int = 0 + + @property + def duration(self) -> float: + return self.t_end - self.t_start + + +@dataclass(frozen=True) +class Transcript: + text: str + language: str | None + language_probability: float = 0.0 + + +@dataclass(frozen=True) +class Utterance: + """One continuous stretch of speech by the other person, bounded by pauses.""" + + id: int + t_start: float + t_end: float | None = None + status: UtteranceStatus = UtteranceStatus.LISTENING + text: str = "" + source_lang: str | None = None + translation: str | None = None + error: ErrorKind | None = None + partial_version: int = -1 + + def evolve(self, **changes: object) -> Utterance: + return replace(self, **changes) # type: ignore[arg-type] + + @property + def is_final(self) -> bool: + return self.status in (UtteranceStatus.FINAL, UtteranceStatus.TRANSLATED) or ( + self.status is UtteranceStatus.FAILED and self.t_end is not None + ) + + +@dataclass(frozen=True) +class ReplyOption: + """One suggested reply: what to say (their language) and what it means (yours).""" + + source_text: str + user_text: str + + +@dataclass(frozen=True) +class Suggestion: + """Replies to one utterance, kept linked to it.""" + + utterance_id: int + options: tuple[ReplyOption, ...] = () + error: ErrorKind | None = None + message: str = "" + + +class ConversationType(str, Enum): + INTERVIEW = "interview" + MEETING = "meeting" + CASUAL = "casual" + + +@dataclass(frozen=True) +class SuggestionContext: + """Everything a Suggester needs; built by the coordinator from the session.""" + + target: Utterance + history: tuple[Utterance, ...] + source_language: str # full name, e.g. "Spanish" + user_language: str # full name, e.g. "English" + conversation_type: ConversationType = ConversationType.MEETING + max_options: int = 2 + + +class IdSource: + """Monotonic utterance IDs, starting at 1. IDs define spoken order.""" + + def __init__(self, start: int = 1) -> None: + self._next = itertools.count(start) + + def __call__(self) -> int: + return next(self._next) diff --git a/src/polyglot/core/pipeline.py b/src/polyglot/core/pipeline.py new file mode 100644 index 0000000..66cbea8 --- /dev/null +++ b/src/polyglot/core/pipeline.py @@ -0,0 +1,1033 @@ +"""The pipeline: stages on their own threads, joined by bounded queues. + + audio callback -> RingBuffer -> FrontEnd (resample, VAD, segmenter) + -> AsrQueue (finals, max N; latest partial per utterance) -> AsrWorker + -> Coordinator (owns Session) <-> network pool (translate / suggest) + -> EventBus + +Rules this module enforces (see the design doc, "Pipeline"): + +* The audio callback only downmixes and copies into the ring buffer. +* Exactly one ASR worker; finals are transcribed in utterance-ID order. +* Only the coordinator thread mutates the Session. Everything else posts messages. +* Every result carries its utterance ID and is placed by it. Nothing is dropped for being + late; the only discards are superseded partials and superseded suggestion requests. +* Queues are bounded. When ASR falls behind, the oldest waiting final is dropped, marked + ``FAILED(overloaded)``, and a FALLING_BEHIND status is published. +""" + +from __future__ import annotations + +import logging +import queue +import random +import threading +import time +from collections import deque +from collections.abc import Callable +from concurrent.futures import Future, ThreadPoolExecutor +from dataclasses import dataclass, field +from typing import Any + +import numpy as np + +from polyglot.core import languages +from polyglot.core.errors import PolyglotError, ProviderError +from polyglot.core.events import ( + ConversationCleared, + EventBus, + LanguageChanged, + PipelineState, + PipelineStatus, + StageError, + SuggestionsReady, + SuggestionStarted, + UtteranceDiscarded, + UtteranceUpdated, +) +from polyglot.core.models import ( + FRAME_SAMPLES, + FRAME_SECONDS, + ConversationType, + ErrorKind, + IdSource, + ReplyOption, + SpeechSegment, + Suggestion, + SuggestionContext, + Transcript, + Utterance, + UtteranceStatus, +) +from polyglot.core.ports import ( + AudioSource, + RawAudio, + Resampler, + Suggester, + Transcriber, + Translator, + VoiceActivityModel, +) +from polyglot.core.ringbuffer import RingBuffer +from polyglot.core.segmenter import ( + Discarded, + Segmenter, + SegmenterConfig, + SegmentReady, + SpeechStarted, +) +from polyglot.core.session import LanguagePolicy, Session + +log = logging.getLogger(__name__) + + +@dataclass(frozen=True) +class PipelineConfig: + segmenter: SegmenterConfig = field(default_factory=SegmenterConfig) + target_language: str = "en" + language_policy: LanguagePolicy = field(default_factory=LanguagePolicy) + translate_timeout_s: float = 3.0 + suggest_timeout_s: float = 6.0 + suggestion_history: int = 6 + suggestion_options: int = 2 + conversation_type: ConversationType = ConversationType.MEETING + ring_seconds: float = 30.0 + finals_queue_size: int = 8 + gap_fill: bool = True + gap_fill_after_s: float = 0.25 + network_workers: int = 4 + network_retries: int = 1 + + +# ============================================================== ASR queue +class AsrQueue: + """Finals in arrival (= ID) order, bounded; plus one latest-only partial slot.""" + + def __init__(self, max_finals: int) -> None: + self._finals: deque[SpeechSegment] = deque() + self._max = max_finals + self._partials: dict[int, SpeechSegment] = {} + self._cv = threading.Condition() + self._closed = False + self._in_flight = 0 # taken by the worker, result not yet posted + + def put_final(self, seg: SpeechSegment) -> SpeechSegment | None: + """Queue a final. Returns the dropped oldest final if the queue was full.""" + with self._cv: + dropped = self._finals.popleft() if len(self._finals) >= self._max else None + self._finals.append(seg) + self._partials.pop(seg.utterance_id, None) + self._cv.notify() + return dropped + + def put_partial(self, seg: SpeechSegment) -> None: + with self._cv: + self._partials[seg.utterance_id] = seg # replaces an older, unprocessed partial + self._cv.notify() + + def get(self, timeout: float) -> SpeechSegment | None: + with self._cv: + if not self._finals and not self._partials and not self._closed: + self._cv.wait(timeout) + if self._finals: + self._in_flight += 1 + return self._finals.popleft() + if self._partials: + uid = min(self._partials) + self._in_flight += 1 + return self._partials.pop(uid) + return None + + def done(self) -> None: + """The worker has posted the result for the segment it took.""" + with self._cv: + self._in_flight -= 1 + + def depth(self) -> int: + """Queued plus in-hand segments: 0 means every result has been posted.""" + with self._cv: + return len(self._finals) + len(self._partials) + self._in_flight + + def close(self) -> None: + with self._cv: + self._closed = True + self._cv.notify_all() + + @property + def closed(self) -> bool: + return self._closed + + +# ============================================================== coordinator messages +@dataclass(frozen=True) +class _Started: + uid: int + t_start: float + + +@dataclass(frozen=True) +class _Discarded: + uid: int + + +@dataclass(frozen=True) +class _Overloaded: + uid: int + + +@dataclass(frozen=True) +class _Overrun: + samples: int + + +@dataclass(frozen=True) +class _TranscriptDone: + uid: int + is_final: bool + version: int + t_start: float + t_end: float + transcript: Transcript + asr_ms: float + + +@dataclass(frozen=True) +class _TranscriptFailed: + uid: int + is_final: bool + t_end: float + error: PolyglotError + + +@dataclass(frozen=True) +class _TranslationDone: + uid: int + text: str | None + error: PolyglotError | None + ms: float + + +@dataclass(frozen=True) +class _SuggestionDone: + generation: int + uid: int + options: tuple[ReplyOption, ...] + error: PolyglotError | None + + +@dataclass(frozen=True) +class _AsrState: + ok: bool + detail: str = "" + error: PolyglotError | None = None + + +@dataclass(frozen=True) +class _SourceEnded: + pass + + +@dataclass(frozen=True) +class _SourceError: + error: Exception + + +@dataclass(frozen=True) +class _Command: + name: str + arg: Any = None + + +@dataclass(frozen=True) +class _Stop: + pass + + +# ============================================================== front end +class FrontEnd: + """Ring buffer -> resample -> 32 ms frames -> VAD -> segmenter -> ASR queue.""" + + def __init__( + self, + ring: RingBuffer, + resampler: Resampler, + vad: VoiceActivityModel, + segmenter: Segmenter, + asr_queue: AsrQueue, + post: Callable[[object], None], + cfg: PipelineConfig, + segment_tap: Callable[[SpeechSegment], None] | None = None, + wall_clock: Callable[[], float] = time.monotonic, + ) -> None: + self._ring, self._resampler, self._vad = ring, resampler, vad + self._seg, self._q, self._post, self._cfg = segmenter, asr_queue, post, cfg + self._tap = segment_tap + self._clock = wall_clock + self._pending: RawAudio = np.zeros(0, dtype=np.float32) + self._t = 0.0 # stream time of the next frame, seconds + self._stop = threading.Event() + self._eof = threading.Event() + self._thread: threading.Thread | None = None + self._overrun_seen = 0 + self._last_data = wall_clock() + self.finished = threading.Event() + + def start(self) -> None: + self._thread = threading.Thread(target=self._run, name="polyglot-frontend", daemon=True) + self._thread.start() + + def signal_eof(self) -> None: + self._eof.set() + + def stop(self, timeout: float = 2.0) -> None: + self._stop.set() + if self._thread is not None: + self._thread.join(timeout) + + # -------------------------------------------------------------------- loop + def _run(self) -> None: + try: + while not self._stop.is_set(): + self._ring.wait(0.02) + data = self._ring.read() + self._check_overrun() + if data.size: + self._last_data = self._clock() + self._feed(self._resampler.process(data)) + elif self._eof.is_set(): + break + elif self._cfg.gap_fill and self._seg.in_speech: + self._fill_gap() + # End of stream or stop: finish the utterance in progress. + self._feed(self._resampler.flush()) + if self._pending.size: + pad = np.zeros(FRAME_SAMPLES - self._pending.size, dtype=np.float32) + self._feed(pad) + self._route(self._seg.flush()) + if self._eof.is_set(): + self._post(_SourceEnded()) + except Exception as exc: + log.exception("front end crashed") + self._post(_SourceError(exc)) + finally: + self.finished.set() + + def _feed(self, samples: RawAudio) -> None: + if samples.size == 0: + return + buf = np.concatenate((self._pending, samples)) if self._pending.size else samples + n_frames = buf.size // FRAME_SAMPLES + for i in range(n_frames): + frame = np.ascontiguousarray(buf[i * FRAME_SAMPLES : (i + 1) * FRAME_SAMPLES]) + prob = float(self._vad.speech_prob(frame)) + self._route(self._seg.push(frame, prob, self._t)) + self._t += FRAME_SECONDS + self._pending = buf[n_frames * FRAME_SAMPLES :].copy() + + def _fill_gap(self) -> None: + """Loopback devices deliver nothing while the output is silent. Without this, an + utterance whose speaker stops talking would never reach its end-of-speech + silence. Feed real-time-equivalent silence while in speech.""" + idle = self._clock() - self._last_data + if idle < self._cfg.gap_fill_after_s: + return + n = int(idle / FRAME_SECONDS) + silent = np.zeros(FRAME_SAMPLES, dtype=np.float32) + for _ in range(n): + if not self._seg.in_speech: + break + self._route(self._seg.push(silent, 0.0, self._t)) + self._t += FRAME_SECONDS + self._last_data = self._clock() + + def _check_overrun(self) -> None: + current = self._ring.overrun_samples + if current > self._overrun_seen: + self._post(_Overrun(current - self._overrun_seen)) + self._overrun_seen = current + + def _route(self, outputs: list[Any]) -> None: + for out in outputs: + if isinstance(out, SpeechStarted): + self._post(_Started(out.utterance_id, out.t_start)) + elif isinstance(out, Discarded): + self._post(_Discarded(out.utterance_id)) + elif isinstance(out, SegmentReady): + seg = out.segment + if seg.is_final: + if self._tap is not None: + try: + self._tap(seg) + except Exception: + log.exception("segment tap failed") + dropped = self._q.put_final(seg) + if dropped is not None: + self._post(_Overloaded(dropped.utterance_id)) + else: + self._q.put_partial(seg) + + +# ============================================================== ASR worker +class AsrWorker: + """The one thread that runs the Transcriber.""" + + def __init__( + self, + transcriber: Transcriber, + asr_queue: AsrQueue, + post: Callable[[object], None], + language: Callable[[], str | None], + ) -> None: + self._tr, self._q, self._post, self._language = transcriber, asr_queue, post, language + self._thread: threading.Thread | None = None + self.busy = False + + def start(self) -> None: + self._thread = threading.Thread(target=self._run, name="polyglot-asr", daemon=True) + self._thread.start() + + def join(self, timeout: float) -> None: + if self._thread is not None: + self._thread.join(timeout) + + def is_alive(self) -> bool: + return self._thread is not None and self._thread.is_alive() + + def _run(self) -> None: + try: + self._tr.load() + except PolyglotError as exc: + self._post(_AsrState(ok=False, detail=str(exc), error=exc)) + return + except Exception as exc: + log.exception("model load failed") + err = PolyglotError(f"model load failed: {exc}") + self._post(_AsrState(ok=False, detail=str(err), error=err)) + return + self._post(_AsrState(ok=True)) + while True: + seg = self._q.get(timeout=0.1) + if seg is None: + if self._q.closed: + return + continue + self.busy = True + try: + self._transcribe(seg) + finally: + self.busy = False + self._q.done() + + def _transcribe(self, seg: SpeechSegment) -> None: + t0 = time.monotonic() + try: + tr = self._tr.transcribe(seg.audio, self._language()) + except PolyglotError as exc: + self._post(_TranscriptFailed(seg.utterance_id, seg.is_final, seg.t_end, exc)) + return + except Exception as exc: + log.exception("transcriber raised an unexpected error") + err = PolyglotError(f"unexpected transcriber error: {exc}") + err.kind = ErrorKind.TRANSCRIPTION + self._post(_TranscriptFailed(seg.utterance_id, seg.is_final, seg.t_end, err)) + return + ms = (time.monotonic() - t0) * 1000 + self._post( + _TranscriptDone( + seg.utterance_id, seg.is_final, seg.version, seg.t_start, seg.t_end, tr, ms + ) + ) + + +# ============================================================== coordinator +class Coordinator: + """Owns the Session; applies results; dispatches network work; publishes events.""" + + def __init__( + self, + session: Session, + bus: EventBus, + cfg: PipelineConfig, + translator: Translator | None, + suggester: Suggester | None, + asr_queue_depth: Callable[[], int], + ) -> None: + self.session, self._bus, self._cfg = session, bus, cfg + self._translator, self._suggester = translator, suggester + self._asr_depth = asr_queue_depth + self.inbox: queue.Queue[object] = queue.Queue(maxsize=10_000) + self._pool = ThreadPoolExecutor(cfg.network_workers, thread_name_prefix="polyglot-net") + self._thread: threading.Thread | None = None + self._suggest_gen = 0 + self._ignore_upto = 0 # utterance IDs <= this were cleared by the user + self._pending_network = 0 + self.state = PipelineState.STOPPED + self.source_ended = threading.Event() + self.on_fatal: Callable[[], None] | None = None # set by Pipeline + self._count_lock = threading.Lock() + self._posted = 0 # messages accepted into the inbox + self._handled = 0 # messages fully handled (written by the coordinator thread) + self._timings: dict[int, float] = {} + + # ------------------------------------------------------------------ plumbing + def post(self, msg: object) -> None: + try: + with self._count_lock: + self.inbox.put_nowait(msg) + self._posted += 1 + except queue.Full: # pragma: no cover - would need 10k messages backed up + log.error("coordinator inbox full; dropping %s", type(msg).__name__) + + def start(self) -> None: + self._thread = threading.Thread(target=self._run, name="polyglot-coord", daemon=True) + self._thread.start() + + def stop(self, timeout: float = 2.0) -> None: + self.post(_Stop()) + if self._thread is not None: + self._thread.join(timeout) + self._pool.shutdown(wait=False, cancel_futures=True) + + def is_idle(self) -> bool: + """Every posted message handled and no network job outstanding.""" + with self._count_lock: + caught_up = self._handled >= self._posted + return caught_up and self._pending_network == 0 + + def drain(self, timeout: float) -> bool: + """Wait until every message posted before this call has been handled (network + jobs may still be in flight). Returns False on timeout.""" + with self._count_lock: + target = self._posted + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + if self._handled >= target: + return True + time.sleep(0.005) + return False + + def _run(self) -> None: + while True: + msg = self.inbox.get() + try: + if isinstance(msg, _Stop): + return + self._handle(msg) + except Exception as exc: + log.exception("coordinator failed handling %s", type(msg).__name__) + self._bus.publish(StageError("coordinator", ErrorKind.INTERNAL, str(exc))) + finally: + with self._count_lock: + self._handled += 1 + + def _set_state(self, state: PipelineState, detail: str = "") -> None: + if self.state is PipelineState.ERROR and state in ( + PipelineState.LISTENING, + PipelineState.FALLING_BEHIND, + ): + return # an error stays visible until the user stops or restarts + if state != self.state or detail: + self.state = state + self._bus.publish(PipelineStatus(state, detail)) + + def _publish(self, u: Utterance) -> None: + self.session.put(u) + self._bus.publish(UtteranceUpdated(u)) + + # ------------------------------------------------------------------ dispatch + def _handle(self, msg: object) -> None: + if isinstance(msg, _Started): + if msg.uid > self._ignore_upto: + self._publish(Utterance(id=msg.uid, t_start=msg.t_start)) + elif isinstance(msg, _Discarded): + self.session.remove(msg.uid) + self._bus.publish(UtteranceDiscarded(msg.uid)) + elif isinstance(msg, _TranscriptDone): + self._on_transcript(msg) + elif isinstance(msg, _TranscriptFailed): + self._on_transcript_failed(msg) + elif isinstance(msg, _TranslationDone): + self._pending_network -= 1 + self._on_translation(msg) + elif isinstance(msg, _SuggestionDone): + self._pending_network -= 1 + self._on_suggestion(msg) + elif isinstance(msg, _Overloaded): + self._on_overloaded(msg.uid) + elif isinstance(msg, _Overrun): + self._set_state( + PipelineState.FALLING_BEHIND, + f"audio buffer overrun: {msg.samples} samples lost", + ) + elif isinstance(msg, _AsrState): + self._on_asr_state(msg) + elif isinstance(msg, _SourceEnded): + self.source_ended.set() + elif isinstance(msg, _SourceError): + self._set_state(PipelineState.ERROR, f"audio source failed: {msg.error}") + self._bus.publish(StageError("audio", ErrorKind.AUDIO, str(msg.error))) + self.source_ended.set() + elif isinstance(msg, _Command): + self._on_command(msg) + else: # pragma: no cover + log.warning("unknown coordinator message %r", msg) + + # ------------------------------------------------------------------ ASR results + def _on_asr_state(self, msg: _AsrState) -> None: + if msg.ok: + # A model that finishes loading after the user pressed Stop must not flip + # the status back to "listening". + if self.state is PipelineState.LOADING: + self._set_state(PipelineState.LISTENING) + return + self._set_state(PipelineState.ERROR, msg.detail) + kind = msg.error.kind if msg.error else ErrorKind.TRANSCRIPTION + self._bus.publish(StageError("asr", kind, msg.detail)) + if self.on_fatal is not None: + self.on_fatal() # nothing can be transcribed: stop capturing + + def _on_transcript(self, msg: _TranscriptDone) -> None: + if msg.uid <= self._ignore_upto: + return + current = self.session.get(msg.uid) + tr = msg.transcript + if not msg.is_final: + if current is None or current.is_final or msg.version <= current.partial_version: + return # stale partial: a newer partial or the final already covers it + self._publish( + current.evolve( + status=UtteranceStatus.PARTIAL, + text=tr.text.strip(), + partial_version=msg.version, + source_lang=tr.language or current.source_lang, + ) + ) + return + + text = tr.text.strip() + if not text: # VAD heard something, Whisper found no words: not speech + self.session.remove(msg.uid) + self._bus.publish(UtteranceDiscarded(msg.uid)) + self._maybe_recover() + return + lang = self.session.locked_language or tr.language + base = current or Utterance(id=msg.uid, t_start=msg.t_start) + u = base.evolve( + status=UtteranceStatus.FINAL, text=text, source_lang=lang, t_end=msg.t_end, error=None + ) + self._publish(u) + log.info("utt=%d final asr_ms=%.0f audio_s=%.2f", u.id, msg.asr_ms, msg.t_end - msg.t_start) + if self.session.observe_language(tr.language, tr.language_probability): + self._bus.publish(LanguageChanged(self.session.locked_language, locked=True)) + self._maybe_recover() + self._dispatch_translation(u) + + def _on_transcript_failed(self, msg: _TranscriptFailed) -> None: + if not msg.is_final or msg.uid <= self._ignore_upto: + log.warning("partial transcription failed for utt=%d: %s", msg.uid, msg.error) + return + current = self.session.get(msg.uid) or Utterance(id=msg.uid, t_start=msg.t_end) + self._publish( + current.evolve(status=UtteranceStatus.FAILED, error=msg.error.kind, t_end=msg.t_end) + ) + self._bus.publish(StageError("asr", msg.error.kind, str(msg.error))) + + def _on_overloaded(self, uid: int) -> None: + current = self.session.get(uid) + if current is not None: + self._publish( + current.evolve( + status=UtteranceStatus.FAILED, + error=ErrorKind.OVERLOADED, + t_end=current.t_start, + ) + ) + self._set_state( + PipelineState.FALLING_BEHIND, + "transcription is falling behind; consider a smaller Whisper model", + ) + + def _maybe_recover(self) -> None: + if self.state is PipelineState.FALLING_BEHIND and self._asr_depth() == 0: + self._set_state(PipelineState.LISTENING) + + # ------------------------------------------------------------------ translation + def _dispatch_translation(self, u: Utterance) -> None: + target = self.session.target_language + if self._translator is None or languages.same_language(u.source_lang, target): + return + translator, timeout = self._translator, self._cfg.translate_timeout_s + text, source = u.text, u.source_lang + self._pending_network += 1 + self._timings[u.id] = time.monotonic() + + def job() -> _TranslationDone: + t0 = time.monotonic() + try: + out = self._with_retry( + lambda: translator.translate(text, source, target, timeout=timeout) + ) + return _TranslationDone(u.id, out, None, (time.monotonic() - t0) * 1000) + except PolyglotError as exc: + return _TranslationDone(u.id, None, exc, (time.monotonic() - t0) * 1000) + + self._submit(job) + + def _on_translation(self, msg: _TranslationDone) -> None: + current = self.session.get(msg.uid) + if current is None or msg.uid <= self._ignore_upto: + return + if msg.error is not None: + self._publish(current.evolve(error=msg.error.kind)) + self._bus.publish( + StageError("translate", msg.error.kind, str(msg.error), msg.error.retryable) + ) + return + self._publish( + current.evolve(status=UtteranceStatus.TRANSLATED, translation=msg.text, error=None) + ) + log.info("utt=%d translated translate_ms=%.0f", msg.uid, msg.ms) + + # ------------------------------------------------------------------ suggestions + def _request_suggestion(self) -> None: + if self._suggester is None: + self._bus.publish( + StageError("suggest", ErrorKind.NOT_CONFIGURED, "suggestions are not enabled") + ) + return + target = self.session.latest_answerable() + if target is None: + self._bus.publish( + StageError("suggest", ErrorKind.NOTHING_TO_ANSWER, "nothing has been said yet") + ) + return + self._suggest_gen += 1 + gen = self._suggest_gen + ctx = SuggestionContext( + target=target, + history=self.session.history_before(target.id, self._cfg.suggestion_history), + source_language=languages.name(target.source_lang), + user_language=languages.name(self.session.target_language), + conversation_type=self._cfg.conversation_type, + max_options=self._cfg.suggestion_options, + ) + suggester, timeout = self._suggester, self._cfg.suggest_timeout_s + self._pending_network += 1 + self._bus.publish(SuggestionStarted(target.id)) + + def job() -> _SuggestionDone: + try: + opts = self._with_retry(lambda: suggester.suggest(ctx, timeout=timeout)) + return _SuggestionDone(gen, target.id, tuple(opts), None) + except PolyglotError as exc: + return _SuggestionDone(gen, target.id, (), exc) + + self._submit(job) + + def _on_suggestion(self, msg: _SuggestionDone) -> None: + if msg.generation != self._suggest_gen: + return # the user pressed the hotkey again; that newer request wins + if msg.error is not None: + sug = Suggestion(msg.uid, (), msg.error.kind, str(msg.error)) + self._bus.publish( + StageError("suggest", msg.error.kind, str(msg.error), msg.error.retryable) + ) + else: + sug = Suggestion(msg.uid, msg.options) + self._bus.publish(SuggestionsReady(sug)) + + # ------------------------------------------------------------------ commands + def _on_command(self, cmd: _Command) -> None: + if cmd.name == "suggest": + self._request_suggestion() + elif cmd.name == "set_language": + self.session.set_language(cmd.arg) + self._bus.publish(LanguageChanged(cmd.arg, locked=cmd.arg is not None)) + elif cmd.name == "set_target": + self.session.target_language = cmd.arg + elif cmd.name == "abandon_open": + self._abandon_open() + elif cmd.name == "retranslate": + for u in self.session.ordered(): + if u.status is UtteranceStatus.FINAL and u.translation is None and u.error is None: + self._dispatch_translation(u) + elif cmd.name == "status": + state, detail = cmd.arg + self._set_state(state, detail) + elif cmd.name == "clear": + known = list(self.session.utterances) + self._ignore_upto = max([self._ignore_upto, *known]) + self.session.clear() + self._suggest_gen += 1 + self._bus.publish(ConversationCleared(self._ignore_upto)) + else: + log.warning("unknown command %s", cmd.name) + + def _abandon_open(self) -> None: + """After stopping: utterances that will never get a final transcript (the model + failed, or the worker could not finish in time) are marked failed, not left + "listening" forever.""" + for u in self.session.ordered(): + if u.status in (UtteranceStatus.LISTENING, UtteranceStatus.PARTIAL): + self._publish( + u.evolve( + status=UtteranceStatus.FAILED, + error=ErrorKind.TRANSCRIPTION, + t_end=u.t_start, + ) + ) + + # ------------------------------------------------------------------ network helpers + def _submit(self, job: Callable[[], object]) -> None: + def done(fut: Future[object]) -> None: + exc = fut.exception() + if exc is not None: # pragma: no cover - jobs catch PolyglotError themselves + log.error("network job crashed: %s", exc) + return + self.post(fut.result()) + + try: + self._pool.submit(job).add_done_callback(done) + except RuntimeError: # pool shut down during stop + self._pending_network -= 1 + + def _with_retry(self, fn: Callable[[], Any]) -> Any: + attempts = self._cfg.network_retries + 1 + for attempt in range(attempts): + try: + return fn() + except ProviderError as exc: + if not exc.retryable or attempt == attempts - 1: + raise + time.sleep(random.uniform(0.2, 0.5)) + except PolyglotError: + raise + except Exception as exc: + log.exception("provider raised an unexpected error") + raise ProviderError( + f"unexpected provider error: {exc}", kind=ErrorKind.INTERNAL, retryable=False + ) from exc + raise AssertionError("unreachable") # pragma: no cover + + +# ============================================================== facade +class _Sink: + """AudioSink for the pipeline. Runs on the audio library's thread: copy only.""" + + def __init__( + self, + ring: RingBuffer, + frontend: Callable[[], FrontEnd | None], + post: Callable[[object], None], + ) -> None: + self._ring, self._frontend, self._post = ring, frontend, post + self._errored = False + + def on_audio(self, block: RawAudio) -> None: + if block.ndim == 2: + block = block.mean(axis=1, dtype=np.float32) + self._ring.write(block) + + def on_end(self) -> None: + fe = self._frontend() + if fe is not None: + fe.signal_eof() + + def on_error(self, error: Exception) -> None: + if not self._errored: + self._errored = True + self._post(_SourceError(error)) + fe = self._frontend() + if fe is not None: + fe.signal_eof() + + +class Pipeline: + """Builds and runs the stages. All public methods are safe to call from any thread. + + ``start``/``stop`` control listening (audio source, front end, ASR worker). The + coordinator and the session outlive them, so the conversation, suggestions and + language commands keep working while stopped. ``close`` shuts everything down. + """ + + def __init__( + self, + *, + source: AudioSource, + resampler_factory: Callable[[int], Resampler], + vad: VoiceActivityModel, + transcriber: Transcriber, + translator: Translator | None, + suggester: Suggester | None, + bus: EventBus, + config: PipelineConfig | None = None, + segment_tap: Callable[[SpeechSegment], None] | None = None, + session: Session | None = None, + ids: IdSource | None = None, + ) -> None: + self.cfg = config or PipelineConfig() + self._source = source + self._resampler_factory = resampler_factory + self._vad = vad + self._transcriber = transcriber + self._bus = bus + self._tap = segment_tap + # A rebuilt pipeline (after a settings change) can continue an existing + # conversation: pass the previous pipeline's ``session`` and ``ids``. + self.session = session or Session(self.cfg.target_language, self.cfg.language_policy) + self.session.target_language = self.cfg.target_language + self.session.policy = self.cfg.language_policy # lock rules follow the new config + self.ids = ids or IdSource() + self._lock = threading.Lock() + self._running = False + self._frontend: FrontEnd | None = None + self._asr: AsrWorker | None = None + self._asr_queue: AsrQueue | None = None + self._coord = Coordinator( + self.session, bus, self.cfg, translator, suggester, self._asr_depth + ) + self._coord.on_fatal = self._stop_in_background + self._coord.start() + + def _stop_in_background(self) -> None: + # Called on the coordinator thread; stop() drains the coordinator, so it must + # not run there. + threading.Thread(target=self.stop, name="polyglot-fatal-stop", daemon=True).start() + + def _asr_depth(self) -> int: + q = self._asr_queue + return q.depth() if q is not None else 0 + + # ------------------------------------------------------------------ lifecycle + @property + def running(self) -> bool: + return self._running + + @property + def state(self) -> PipelineState: + return self._coord.state + + @property + def source_ended(self) -> bool: + """True once a finite source (file) has been fully consumed and flushed.""" + return self._coord.source_ended.is_set() + + def start(self) -> None: + with self._lock: + if self._running: + return + cfg, coord = self.cfg, self._coord + previous = self._asr + if previous is not None and previous.is_alive(): + previous.join(30.0) # never two ASR workers: wait for the old one + if previous.is_alive(): + self._bus.publish( + StageError( + "asr", + ErrorKind.INTERNAL, + "previous transcription still running; try again", + ) + ) + return + coord.source_ended.clear() + asr_q = AsrQueue(cfg.finals_queue_size) + rate = self._source.sample_rate + ring = RingBuffer(max(1, int(cfg.ring_seconds * rate))) + self._vad.reset() + frontend = FrontEnd( + ring, + self._resampler_factory(rate), + self._vad, + Segmenter(cfg.segmenter, self.ids), + asr_q, + coord.post, + cfg, + self._tap, + ) + session = self.session + asr = AsrWorker(self._transcriber, asr_q, coord.post, lambda: session.locked_language) + self._asr_queue, self._frontend, self._asr = asr_q, frontend, asr + + coord.post(_Command("status", (PipelineState.LOADING, "loading speech model"))) + asr.start() + frontend.start() + try: + self._source.start(_Sink(ring, lambda: self._frontend, coord.post)) + except Exception as exc: + log.exception("audio source failed to start") + self._teardown(flush=False) + coord.post(_SourceError(exc)) + return + self._running = True + + def stop(self, timeout: float = 10.0) -> None: + """Stop listening. The utterance in progress is finished and transcribed.""" + with self._lock: + if not self._running: + return + self._running = False + try: + self._source.stop() + except Exception: + log.exception("audio source failed to stop cleanly") + self._teardown(flush=True, timeout=timeout) + self._coord.post(_Command("abandon_open")) + self._coord.post(_Command("status", (PipelineState.STOPPED, ""))) + # When stop() returns, the last utterance's transcript has been applied. + self._coord.drain(timeout=2.0) + + def close(self) -> None: + """Stop listening and shut down the coordinator. The pipeline cannot be reused.""" + self.stop() + self._coord.stop() + + def _teardown(self, *, flush: bool, timeout: float = 5.0) -> None: + if self._frontend is not None: + if flush: + self._frontend.signal_eof() + self._frontend.stop(timeout=2.0) + if self._asr_queue is not None: + self._asr_queue.close() + if self._asr is not None: + self._asr.join(timeout) + + def wait_idle(self, timeout: float = 30.0) -> bool: + """For file sources and tests: wait until the source ended and all work finished.""" + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + fe, asr, q, coord = self._frontend, self._asr, self._asr_queue, self._coord + if ( + fe is not None + and asr is not None + and q is not None + and fe.finished.is_set() + and q.depth() == 0 + and not asr.busy + and coord.is_idle() + ): + time.sleep(0.05) # let any just-posted message land, then re-check + if q.depth() == 0 and not asr.busy and coord.is_idle(): + return True + time.sleep(0.01) + return False + + # ------------------------------------------------------------------ commands + def request_suggestion(self) -> None: + """Ask for replies to the latest final utterance (bound to the suggest hotkey).""" + self._coord.post(_Command("suggest")) + + def set_language(self, language: str | None) -> None: + """Force the source language, or ``None`` to unlock and auto-detect again.""" + self._coord.post(_Command("set_language", language)) + + def set_target_language(self, language: str) -> None: + self._coord.post(_Command("set_target", language)) + + def retranslate_pending(self) -> None: + """Translate final utterances still waiting for one (e.g. after a rebuild + dropped in-flight requests).""" + self._coord.post(_Command("retranslate")) + + def clear(self) -> None: + """Forget the conversation. Late results for cleared utterances are ignored.""" + self._coord.post(_Command("clear")) diff --git a/src/polyglot/core/ports.py b/src/polyglot/core/ports.py new file mode 100644 index 0000000..2e8194f --- /dev/null +++ b/src/polyglot/core/ports.py @@ -0,0 +1,94 @@ +"""Ports: the interfaces the core needs from the outside world. + +Each has at least one real adapter (``polyglot.adapters``/``polyglot.platform``) and one +fake (``polyglot.adapters.fakes``). The composition root picks implementations once, +from config. No implementation carries a "mock mode" flag. +""" + +from __future__ import annotations + +from enum import Enum +from typing import Protocol, runtime_checkable + +import numpy as np +import numpy.typing as npt + +from polyglot.core.models import ReplyOption, SuggestionContext, Transcript + +RawAudio = npt.NDArray[np.float32] + + +class AudioSink(Protocol): + """What an AudioSource delivers to. Implemented by the pipeline.""" + + def on_audio(self, block: RawAudio) -> None: + """Called on the audio library's thread. ``block`` is float32, shape (frames,) or + (frames, channels), at the source's ``sample_rate``. Must return quickly.""" + + def on_end(self) -> None: + """The source has no more audio (end of file). Live sources never call this.""" + + def on_error(self, error: Exception) -> None: + """The source failed (device lost). Called at most once.""" + + +@runtime_checkable +class AudioSource(Protocol): + @property + def sample_rate(self) -> int: ... + + def start(self, sink: AudioSink) -> None: ... + + def stop(self) -> None: ... + + +class Resampler(Protocol): + """Streaming mono resampler from one input rate to 16 kHz. Keeps state across calls.""" + + def process(self, block: RawAudio) -> RawAudio: ... + + def flush(self) -> RawAudio: ... + + +class VoiceActivityModel(Protocol): + """Scores 32 ms frames (512 samples at 16 kHz) for speech probability in [0, 1].""" + + def speech_prob(self, frame: RawAudio) -> float: ... + + def reset(self) -> None: ... + + +class Transcriber(Protocol): + def load(self) -> None: + """Load the model. Called once, explicitly, before listening starts.""" + + def transcribe(self, audio: RawAudio, language: str | None) -> Transcript: + """Transcribe one utterance (16 kHz mono). Raises TranscriptionFailed.""" + + +class Translator(Protocol): + def translate(self, text: str, source: str | None, target: str, *, timeout: float) -> str: + """Raises ProviderError subclasses on failure; never returns placeholder text.""" + + +class Suggester(Protocol): + def suggest(self, context: SuggestionContext, *, timeout: float) -> tuple[ReplyOption, ...]: + """Raises ProviderError subclasses on failure; never returns placeholder text.""" + + +class ShieldStatus(str, Enum): + HIDDEN = "hidden" # excluded from screen capture, still visible on the monitor + UNSUPPORTED = "unsupported" # this OS/version cannot do it (macOS 15+, Windows < 2004) + FAILED = "failed" # the OS call failed + + +class WindowShield(Protocol): + """Hides a top-level window from screen capture/sharing while keeping it visible.""" + + def exclude_from_capture(self, window_id: int) -> ShieldStatus: ... + + +class SecretStore(Protocol): + def get(self, name: str) -> str | None: ... + + def set(self, name: str, value: str | None) -> None: ... diff --git a/src/polyglot/core/ringbuffer.py b/src/polyglot/core/ringbuffer.py new file mode 100644 index 0000000..dcf76f7 --- /dev/null +++ b/src/polyglot/core/ringbuffer.py @@ -0,0 +1,94 @@ +"""Preallocated single-producer / single-consumer audio ring buffer. + +The producer is the audio library's callback thread, so ``write`` does only a bounded +numpy copy into preallocated memory. When the consumer falls behind, the oldest audio is +overwritten and counted in ``overrun_samples`` rather than growing memory or blocking the +audio thread. +""" + +from __future__ import annotations + +import threading + +import numpy as np + +from polyglot.core.ports import RawAudio + + +class RingBuffer: + def __init__(self, capacity: int) -> None: + if capacity <= 0: + raise ValueError("capacity must be positive") + self._buf = np.zeros(capacity, dtype=np.float32) + self._capacity = capacity + self._read = 0 # absolute sample index of the next sample to read + self._write = 0 # absolute sample index of the next sample to write + self._lock = threading.Lock() + self._data_ready = threading.Event() + self.overrun_samples = 0 + + @property + def capacity(self) -> int: + return self._capacity + + def available(self) -> int: + with self._lock: + return self._write - self._read + + def write(self, block: RawAudio) -> None: + """Append mono samples. Never blocks for longer than one copy.""" + data: RawAudio = np.asarray(block, dtype=np.float32).reshape(-1) + n = data.shape[0] + if n == 0: + return + if n > self._capacity: # keep only the newest `capacity` samples + dropped = n - self._capacity + data = data[dropped:] + n = self._capacity + else: + dropped = 0 + with self._lock: + start = self._write % self._capacity + first = min(n, self._capacity - start) + self._buf[start : start + first] = data[:first] + if first < n: + self._buf[: n - first] = data[first:] + self._write += n + # Samples skipped by an oversized block were never readable, and samples + # overwritten before the reader got to them are lost: both are overruns. + self._write_overrun_check() + self.overrun_samples += dropped + self._data_ready.set() + + def _write_overrun_check(self) -> None: + lag = self._write - self._read + if lag > self._capacity: + lost = lag - self._capacity + self._read += lost + self.overrun_samples += lost + + def read(self, max_samples: int | None = None) -> RawAudio: + """Return up to ``max_samples`` (default: all) available samples, oldest first.""" + with self._lock: + n = self._write - self._read + if max_samples is not None: + n = min(n, max_samples) + out = np.empty(n, dtype=np.float32) + start = self._read % self._capacity + first = min(n, self._capacity - start) + out[:first] = self._buf[start : start + first] + if first < n: + out[first:] = self._buf[: n - first] + self._read += n + if self._read == self._write: + self._data_ready.clear() + return out + + def wait(self, timeout: float) -> bool: + """Block until data may be available or ``timeout`` passes.""" + return self._data_ready.wait(timeout) + + def clear(self) -> None: + with self._lock: + self._read = self._write + self._data_ready.clear() diff --git a/src/polyglot/core/segmenter.py b/src/polyglot/core/segmenter.py new file mode 100644 index 0000000..3987fd2 --- /dev/null +++ b/src/polyglot/core/segmenter.py @@ -0,0 +1,215 @@ +"""Endpointing: turn a stream of (frame, speech probability) into utterances. + +Pure logic with no model and no threads, so every rule is unit-testable with scripted +probabilities. Rules (all configurable, see ``SegmenterConfig``): + +* start: probability >= ``start_threshold`` for ``start_frames`` frames in a row; the + utterance includes ``pre_roll_ms`` of audio from before the start. +* end: probability < ``end_threshold`` for ``end_silence_ms`` in a row (hysteresis: + the end threshold is lower than the start threshold, so noise near one value does not + flicker the state). +* force-cut: an utterance reaching ``max_utterance_s`` is cut at the least speech-like + frame in its last ``force_cut_window_s``; the remainder continues as a new utterance. +* discard: utterances with less than ``min_utterance_ms`` of speech are dropped. +* partials: optionally re-emit the growing utterance every ``partial_interval_ms``. +""" + +from __future__ import annotations + +import math +from collections import deque +from collections.abc import Callable +from dataclasses import dataclass + +import numpy as np + +from polyglot.core.models import FRAME_SAMPLES, FRAME_SECONDS, AudioArray, SpeechSegment + + +@dataclass(frozen=True) +class SegmenterConfig: + start_threshold: float = 0.5 + end_threshold: float = 0.35 + start_frames: int = 3 + end_silence_ms: int = 600 + pre_roll_ms: int = 300 + max_utterance_s: float = 15.0 + force_cut_window_s: float = 2.0 + min_utterance_ms: int = 300 + trailing_silence_keep_ms: int = 100 + partial_interval_ms: int = 0 # 0 disables partials + + def __post_init__(self) -> None: + if not 0.0 <= self.end_threshold <= self.start_threshold <= 1.0: + raise ValueError("need 0 <= end_threshold <= start_threshold <= 1") + if self.start_frames < 1: + raise ValueError("start_frames must be >= 1") + if self.max_utterance_s <= self.force_cut_window_s: + raise ValueError("max_utterance_s must exceed force_cut_window_s") + + +def _frames(ms: float) -> int: + return max(0, math.ceil(ms / 1000.0 / FRAME_SECONDS)) + + +@dataclass(frozen=True) +class SpeechStarted: + utterance_id: int + t_start: float + + +@dataclass(frozen=True) +class SegmentReady: + segment: SpeechSegment + + +@dataclass(frozen=True) +class Discarded: + utterance_id: int + + +SegmenterOutput = SpeechStarted | SegmentReady | Discarded + + +class Segmenter: + def __init__(self, config: SegmenterConfig, next_id: Callable[[], int]) -> None: + self.cfg = config + self._next_id = next_id + self._pre_roll_len = _frames(config.pre_roll_ms) + config.start_frames + self._end_frames = max(1, _frames(config.end_silence_ms)) + self._max_frames = _frames(config.max_utterance_s * 1000) + self._cut_window = max(1, _frames(config.force_cut_window_s * 1000)) + self._min_speech_frames = _frames(config.min_utterance_ms) + self._keep_tail = _frames(config.trailing_silence_keep_ms) + self._partial_every = ( + _frames(config.partial_interval_ms) if config.partial_interval_ms else 0 + ) + self.reset() + + # ------------------------------------------------------------------ state + def reset(self) -> None: + self._pre_roll: deque[tuple[AudioArray, float, float]] = deque(maxlen=self._pre_roll_len) + self._run = 0 # consecutive frames >= start threshold while idle + self._active_id: int | None = None + self._frames: list[AudioArray] = [] + self._probs: list[float] = [] + self._t0 = 0.0 # start time of the first frame in _frames + self._silence = 0 # consecutive frames < end threshold while active + self._since_partial = 0 + self._partial_version = 0 + + @property + def in_speech(self) -> bool: + return self._active_id is not None + + # ------------------------------------------------------------------ input + def push(self, frame: AudioArray, prob: float, t: float) -> list[SegmenterOutput]: + """Feed one 512-sample frame that starts at time ``t`` (seconds).""" + if frame.shape[0] != FRAME_SAMPLES: + raise ValueError(f"frame must have {FRAME_SAMPLES} samples, got {frame.shape[0]}") + if self._active_id is None: + return self._push_idle(frame, prob, t) + return self._push_active(frame, prob) + + def flush(self) -> list[SegmenterOutput]: + """End of stream: finish the utterance in progress, if any.""" + if self._active_id is None: + return [] + return self._finish(trailing_silence=self._silence) + + # ------------------------------------------------------------------ idle + def _push_idle(self, frame: AudioArray, prob: float, t: float) -> list[SegmenterOutput]: + self._pre_roll.append((frame, prob, t)) + self._run = self._run + 1 if prob >= self.cfg.start_threshold else 0 + if self._run < self.cfg.start_frames: + return [] + # Start: everything in the pre-roll (which ends with the triggering run) is speech + # context for this utterance. + self._active_id = self._next_id() + self._frames = [f for f, _, _ in self._pre_roll] + self._probs = [p for _, p, _ in self._pre_roll] + self._t0 = self._pre_roll[0][2] + self._pre_roll.clear() + self._run = 0 + self._silence = 0 + self._since_partial = 0 + self._partial_version = 0 + return [SpeechStarted(self._active_id, self._t0)] + + # ------------------------------------------------------------------ active + def _push_active(self, frame: AudioArray, prob: float) -> list[SegmenterOutput]: + self._frames.append(frame) + self._probs.append(prob) + self._silence = self._silence + 1 if prob < self.cfg.end_threshold else 0 + + if self._silence >= self._end_frames: + return self._finish(trailing_silence=self._silence) + + if len(self._frames) >= self._max_frames: + return self._force_cut() + + if self._partial_every: + self._since_partial += 1 + # Only while speech is ongoing: a partial during trailing silence would just + # repeat what the imminent final will say. + if self._since_partial >= self._partial_every and self._silence == 0: + self._since_partial = 0 + return [SegmentReady(self._segment(self._frames, is_final=False))] + return [] + + def _finish(self, trailing_silence: int) -> list[SegmenterOutput]: + assert self._active_id is not None + uid = self._active_id + drop = max(0, trailing_silence - self._keep_tail) + frames = self._frames[: len(self._frames) - drop] if drop else self._frames + # Count frames that look like speech; pre-roll and pauses do not count. + speech_frames = sum(1 for p in self._probs if p >= self.cfg.end_threshold) + out: list[SegmenterOutput] + if speech_frames < self._min_speech_frames: + out = [Discarded(uid)] + else: + out = [SegmentReady(self._segment(frames, is_final=True))] + self._active_id = None + self._frames, self._probs = [], [] + self._silence = 0 + self._pre_roll.clear() + return out + + def _force_cut(self) -> list[SegmenterOutput]: + assert self._active_id is not None + window_start = len(self._probs) - self._cut_window + window = self._probs[window_start:] + cut = window_start + int(np.argmin(window)) # last frame kept in this utterance + head, tail = self._frames[: cut + 1], self._frames[cut + 1 :] + tail_probs = self._probs[cut + 1 :] + out: list[SegmenterOutput] = [SegmentReady(self._segment(head, is_final=True))] + t_tail = self._t0 + (cut + 1) * FRAME_SECONDS + # The speaker is still talking: the remainder starts the next utterance at once. + self._active_id = self._next_id() + self._frames, self._probs = list(tail), list(tail_probs) + self._t0 = t_tail + self._silence = 0 + for p in reversed(tail_probs): + if p < self.cfg.end_threshold: + self._silence += 1 + else: + break + self._since_partial = 0 + self._partial_version = 0 + out.append(SpeechStarted(self._active_id, t_tail)) + return out + + def _segment(self, frames: list[AudioArray], *, is_final: bool) -> SpeechSegment: + assert self._active_id is not None + audio = np.concatenate(frames).astype(np.float32, copy=False) + version = self._partial_version + if not is_final: + self._partial_version += 1 + return SpeechSegment( + utterance_id=self._active_id, + audio=audio, + t_start=self._t0, + t_end=self._t0 + len(frames) * FRAME_SECONDS, + is_final=is_final, + version=version, + ) diff --git a/src/polyglot/core/session.py b/src/polyglot/core/session.py new file mode 100644 index 0000000..e250df7 --- /dev/null +++ b/src/polyglot/core/session.py @@ -0,0 +1,103 @@ +"""Conversation state. Owned and mutated by the coordinator thread only. + +Other threads receive immutable ``Utterance`` snapshots through events, so nothing here +needs a lock. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +from polyglot.core.models import Utterance, UtteranceStatus + + +@dataclass(frozen=True) +class LanguagePolicy: + """Lock the source language once ``agree`` consecutive finals agree confidently.""" + + agree: int = 2 + min_probability: float = 0.8 + forced: str | None = None # a language set in config; never auto-changed + + +class Session: + def __init__(self, target_language: str, policy: LanguagePolicy | None = None) -> None: + self.target_language = target_language + self.policy = policy or LanguagePolicy() + self.utterances: dict[int, Utterance] = {} + self.latest_final_id: int | None = None + self.locked_language: str | None = self.policy.forced + self._manual_lock = self.policy.forced is not None + self._streak_lang: str | None = None + self._streak = 0 + + # ------------------------------------------------------------- utterances + def get(self, utterance_id: int) -> Utterance | None: + return self.utterances.get(utterance_id) + + def put(self, utterance: Utterance) -> Utterance: + self.utterances[utterance.id] = utterance + if utterance.is_final and ( + self.latest_final_id is None or utterance.id > self.latest_final_id + ): + self.latest_final_id = utterance.id + return utterance + + def remove(self, utterance_id: int) -> None: + self.utterances.pop(utterance_id, None) + if self.latest_final_id == utterance_id: + finals = [u.id for u in self.utterances.values() if u.is_final] + self.latest_final_id = max(finals) if finals else None + + def latest_answerable(self) -> Utterance | None: + """The most recent final utterance that has text (failed ones are skipped).""" + for u in reversed(self.ordered()): + if u.is_final and u.text and u.status is not UtteranceStatus.FAILED: + return u + return None + + def ordered(self) -> list[Utterance]: + return [self.utterances[k] for k in sorted(self.utterances)] + + def history_before(self, utterance_id: int, limit: int) -> tuple[Utterance, ...]: + """Final utterances with text, spoken before ``utterance_id``, oldest first.""" + earlier = [ + u + for u in self.ordered() + if u.id < utterance_id + and u.is_final + and u.text + and u.status is not UtteranceStatus.FAILED + ] + return tuple(earlier[-limit:]) if limit > 0 else () + + def clear(self) -> None: + self.utterances.clear() + self.latest_final_id = None + + # --------------------------------------------------------------- language + def observe_language(self, language: str | None, probability: float) -> bool: + """Feed the detected language of a final transcript. Returns True if it locked.""" + if self.locked_language is not None or not language: + return False + if probability < self.policy.min_probability: + self._streak_lang, self._streak = None, 0 + return False + if language == self._streak_lang: + self._streak += 1 + else: + self._streak_lang, self._streak = language, 1 + if self._streak >= self.policy.agree: + self.locked_language = language + return True + return False + + def set_language(self, language: str | None) -> None: + """Manual override. ``None`` unlocks and restarts auto-detection.""" + self.locked_language = language + self._manual_lock = language is not None + self._streak_lang, self._streak = None, 0 + + @property + def language_is_manual(self) -> bool: + return self._manual_lock diff --git a/src/polyglot/logging_setup.py b/src/polyglot/logging_setup.py new file mode 100644 index 0000000..61d2e02 --- /dev/null +++ b/src/polyglot/logging_setup.py @@ -0,0 +1,32 @@ +"""Logging: one logger per module, a rotating file in the user log directory, stderr. + +Transcript text is never logged by default. INFO and above carry IDs, timings and sizes. +""" + +from __future__ import annotations + +import logging +import logging.handlers +from pathlib import Path + + +def configure(level: str = "INFO", log_file: Path | None = None) -> None: + root = logging.getLogger() + root.setLevel(level.upper()) + fmt = logging.Formatter("%(asctime)s %(levelname)-7s %(threadName)s %(name)s: %(message)s") + stream = logging.StreamHandler() + stream.setFormatter(fmt) + root.handlers[:] = [stream] + if log_file is not None: + try: + log_file.parent.mkdir(parents=True, exist_ok=True) + fh = logging.handlers.RotatingFileHandler( + log_file, maxBytes=2_000_000, backupCount=3, encoding="utf-8" + ) + except OSError as exc: + root.warning("cannot write log file %s: %s", log_file, exc) + else: + fh.setFormatter(fmt) + root.addHandler(fh) + for noisy in ("faster_whisper", "urllib3", "PIL"): + logging.getLogger(noisy).setLevel(logging.WARNING) diff --git a/src/polyglot/platform/__init__.py b/src/polyglot/platform/__init__.py new file mode 100644 index 0000000..7d5a3f8 --- /dev/null +++ b/src/polyglot/platform/__init__.py @@ -0,0 +1,38 @@ +"""OS-specific services, selected once. No other module checks the platform.""" + +from __future__ import annotations + +import sys +from dataclasses import dataclass + +from polyglot.core.ports import ShieldStatus, WindowShield + + +class UnsupportedShield: + """macOS 15+ (ScreenCaptureKit ignores NSWindow.sharingType) and Linux: by decision + the overlay is not hidden there; the UI shows a "visible in screen share" indicator.""" + + def exclude_from_capture(self, window_id: int) -> ShieldStatus: + return ShieldStatus.UNSUPPORTED + + +@dataclass(frozen=True) +class PlatformInfo: + name: str # "windows" | "macos" | "linux" + has_loopback: bool # can capture system audio without a virtual device + + +def current() -> PlatformInfo: + if sys.platform == "win32": + return PlatformInfo("windows", has_loopback=True) + if sys.platform == "darwin": + return PlatformInfo("macos", has_loopback=False) + return PlatformInfo("linux", has_loopback=False) + + +def window_shield() -> WindowShield: + if sys.platform == "win32": + from polyglot.platform.windows import WindowsShield + + return WindowsShield() + return UnsupportedShield() diff --git a/src/polyglot/platform/windows.py b/src/polyglot/platform/windows.py new file mode 100644 index 0000000..4914859 --- /dev/null +++ b/src/polyglot/platform/windows.py @@ -0,0 +1,93 @@ +"""Windows: exclude a window from screen capture while it stays visible on the monitor. + +Uses ``SetWindowDisplayAffinity(hwnd, WDA_EXCLUDEFROMCAPTURE)``. Per Microsoft's docs: + +* supported from Windows 10 version 2004 (build 19041); on older builds the same call + behaves like ``WDA_MONITOR`` and shows a black box in captures, which would obstruct + the viewer, so on old builds we do not call it at all; +* works on top-level windows only, and only while DWM composes the desktop. + +The result is read back with ``GetWindowDisplayAffinity`` before reporting success. +""" + +from __future__ import annotations + +import logging +import sys +from typing import Any + +from polyglot.core.ports import ShieldStatus + +log = logging.getLogger(__name__) + +WDA_NONE = 0x00 +WDA_EXCLUDEFROMCAPTURE = 0x11 +MIN_BUILD = 19041 + + +def _load_user32() -> Any: + import ctypes + from ctypes import wintypes + + user32 = getattr(ctypes, "WinDLL")("user32", use_last_error=True) # noqa: B009 - Windows-only attr + user32.SetWindowDisplayAffinity.argtypes = [wintypes.HWND, wintypes.DWORD] + user32.SetWindowDisplayAffinity.restype = wintypes.BOOL + user32.GetWindowDisplayAffinity.argtypes = [wintypes.HWND, ctypes.POINTER(wintypes.DWORD)] + user32.GetWindowDisplayAffinity.restype = wintypes.BOOL + return user32 + + +def _windows_build() -> int: + getver = getattr(sys, "getwindowsversion", None) + return int(getver().build) if getver else 0 + + +class WindowsShield: + def __init__( + self, user32: Any = None, build: int | None = None, last_error: Any = None + ) -> None: + self.build = _windows_build() if build is None else build + self._user32 = user32 + self._last_error = last_error + self.detail = "" # why the last call did not hide the window + + @property + def supported(self) -> bool: + return self.build >= MIN_BUILD + + def _api(self) -> Any: + if self._user32 is None: + self._user32 = _load_user32() + return self._user32 + + def _get_last_error(self) -> int: + if self._last_error is not None: + return int(self._last_error()) + import ctypes + + return int(getattr(ctypes, "get_last_error")()) # noqa: B009 - Windows-only attr + + def exclude_from_capture(self, window_id: int) -> ShieldStatus: + self.detail = "" + if not self.supported: + self.detail = f"Windows build {self.build} < {MIN_BUILD}" + log.warning("capture exclusion unsupported: %s", self.detail) + return ShieldStatus.UNSUPPORTED + api = self._api() + if not api.SetWindowDisplayAffinity(window_id, WDA_EXCLUDEFROMCAPTURE): + self.detail = f"SetWindowDisplayAffinity failed (error {self._get_last_error()})" + log.warning("hwnd=%#x: %s", window_id, self.detail) + return ShieldStatus.FAILED + import ctypes + from ctypes import wintypes + + value = wintypes.DWORD(0) + if not api.GetWindowDisplayAffinity(window_id, ctypes.byref(value)): + self.detail = f"GetWindowDisplayAffinity failed (error {self._get_last_error()})" + log.warning("hwnd=%#x: %s", window_id, self.detail) + return ShieldStatus.FAILED + if value.value != WDA_EXCLUDEFROMCAPTURE: + self.detail = f"affinity reads back as {value.value:#x}" + log.warning("hwnd=%#x: %s", window_id, self.detail) + return ShieldStatus.FAILED + return ShieldStatus.HIDDEN diff --git a/src/polyglot/ui/__init__.py b/src/polyglot/ui/__init__.py new file mode 100644 index 0000000..bb25ab7 --- /dev/null +++ b/src/polyglot/ui/__init__.py @@ -0,0 +1 @@ +"""Presentation layer. ``presenter`` is pure Python; ``qt`` holds the PyQt6 views.""" diff --git a/src/polyglot/ui/presenter.py b/src/polyglot/ui/presenter.py new file mode 100644 index 0000000..a9d576d --- /dev/null +++ b/src/polyglot/ui/presenter.py @@ -0,0 +1,329 @@ +"""Presenter (Model-View-Presenter) and view model. No Qt here, so it is unit-tested. + +The presenter receives core events on the GUI thread (the Qt bridge hands them over), +keeps a view model, formats it, and calls a passive view. It also turns user actions +into commands. The view never sees core objects and never makes decisions. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import Protocol + +from polyglot.core import languages +from polyglot.core.events import ( + ConversationCleared, + Event, + LanguageChanged, + PipelineState, + PipelineStatus, + StageError, + SuggestionsReady, + SuggestionStarted, + UtteranceDiscarded, + UtteranceUpdated, +) +from polyglot.core.models import ErrorKind, Utterance, UtteranceStatus +from polyglot.core.ports import ShieldStatus + +ERROR_TEXT: dict[ErrorKind, str] = { + ErrorKind.TIMEOUT: "timed out", + ErrorKind.UNAVAILABLE: "service unavailable", + ErrorKind.QUOTA: "quota exhausted", + ErrorKind.AUTH: "API key rejected", + ErrorKind.BAD_RESPONSE: "unexpected response", + ErrorKind.TRANSCRIPTION: "transcription failed", + ErrorKind.OVERLOADED: "skipped: transcription fell behind", + ErrorKind.NOT_CONFIGURED: "not set up", + ErrorKind.NOTHING_TO_ANSWER: "nothing to reply to yet", + ErrorKind.AUDIO: "audio problem", + ErrorKind.INTERNAL: "internal error", +} + + +# ================================================================= view model +@dataclass(frozen=True) +class RowVM: + id: int + original: str + translation: str | None = None + note: str | None = None # "listening…", "translating…", "translation failed: …" + partial: bool = False + failed: bool = False + + +@dataclass(frozen=True) +class OptionVM: + say: str # their language: what to say + means: str # your language: what it means + + +@dataclass(frozen=True) +class SuggestionVM: + reply_to: str = "" + options: tuple[OptionVM, ...] = () + loading: bool = False + message: str | None = None # an error or hint instead of options + stale: bool = False # newer sentences have been said since; offer a refresh + visible: bool = True + + +@dataclass(frozen=True) +class StatusVM: + text: str + level: str = "info" # "info" | "warn" | "error" + + +@dataclass(frozen=True) +class CaptureVM: + hidden: bool + text: str + + +class ViewPort(Protocol): + def upsert_row(self, row: RowVM) -> None: ... + def remove_row(self, utterance_id: int) -> None: ... + def clear_rows(self) -> None: ... + def show_suggestions(self, vm: SuggestionVM) -> None: ... + def set_status(self, vm: StatusVM) -> None: ... + def set_listening(self, listening: bool, busy: bool) -> None: ... + def set_language(self, text: str) -> None: ... + def set_capture(self, vm: CaptureVM) -> None: ... + + +class NullView: + """A view that ignores every call. Swapped in by ``Presenter.detach()`` so that a + signal arriving during shutdown cannot touch deleted widgets.""" + + def upsert_row(self, row: RowVM) -> None: + pass + + def remove_row(self, utterance_id: int) -> None: + pass + + def clear_rows(self) -> None: + pass + + def show_suggestions(self, vm: SuggestionVM) -> None: + pass + + def set_status(self, vm: StatusVM) -> None: + pass + + def set_listening(self, listening: bool, busy: bool) -> None: + pass + + def set_language(self, text: str) -> None: + pass + + def set_capture(self, vm: CaptureVM) -> None: + pass + + +class Commands(Protocol): + def toggle(self) -> None: ... + def request_suggestion(self) -> None: ... + def set_language(self, language: str | None) -> None: ... + def clear(self) -> None: ... + + +# ================================================================= presenter +@dataclass +class Presenter: + view: ViewPort + commands: Commands + user_language: str = "en" + translation_enabled: bool = False + rows: dict[int, Utterance] = field(default_factory=dict) + suggestion_for: int | None = None + _suggestion: SuggestionVM | None = None + _state: PipelineState = PipelineState.STOPPED + _cleared_upto: int = 0 # events about utterances <= this belong to a cleared conversation + + # ------------------------------------------------------------ events in + def handle(self, event: Event) -> None: + if self._is_cleared(event): + return + if isinstance(event, ConversationCleared): + self._cleared_upto = max(self._cleared_upto, event.upto) + self.rows.clear() + self.suggestion_for = None + self._suggestion = None + self.view.clear_rows() + self.view.show_suggestions(SuggestionVM(visible=False)) + elif isinstance(event, UtteranceUpdated): + self._on_utterance(event.utterance) + elif isinstance(event, UtteranceDiscarded): + self.rows.pop(event.utterance_id, None) + self.view.remove_row(event.utterance_id) + elif isinstance(event, SuggestionStarted): + self.suggestion_for = event.utterance_id + self._show_suggestion( + SuggestionVM(reply_to=self._text(event.utterance_id), loading=True) + ) + elif isinstance(event, SuggestionsReady): + s = event.suggestion + self.suggestion_for = s.utterance_id + if s.error is not None: + vm = SuggestionVM( + reply_to=self._text(s.utterance_id), + message=f"Suggestions failed: {ERROR_TEXT[s.error]}", + ) + else: + vm = SuggestionVM( + reply_to=self._text(s.utterance_id), + options=tuple(OptionVM(o.source_text, o.user_text) for o in s.options), + ) + self._show_suggestion(vm) + elif isinstance(event, PipelineStatus): + self._on_status(event) + elif isinstance(event, StageError): + self._on_error(event) + elif isinstance(event, LanguageChanged): + self.view.set_language(self.language_label(event.language, event.locked)) + + def _on_utterance(self, u: Utterance) -> None: + self.rows[u.id] = u + self.view.upsert_row(self.row_vm(u)) + if self._suggestion is not None and self.suggestion_for is not None: + stale = self._latest_final() > self.suggestion_for + if stale != self._suggestion.stale: + self._show_suggestion(self._suggestion, stale=stale) + + def _on_status(self, event: PipelineStatus) -> None: + self._state = event.state + busy = event.state is PipelineState.LOADING + listening = event.state in ( + PipelineState.LOADING, + PipelineState.LISTENING, + PipelineState.FALLING_BEHIND, + ) + self.view.set_listening(listening, busy) + text = { + PipelineState.STOPPED: "Stopped", + PipelineState.LOADING: "Loading speech model…", + PipelineState.LISTENING: "Listening", + PipelineState.FALLING_BEHIND: "Falling behind", + PipelineState.ERROR: "Error", + }[event.state] + if event.detail: + text = f"{text}: {event.detail}" + level = { + PipelineState.ERROR: "error", + PipelineState.FALLING_BEHIND: "warn", + }.get(event.state, "info") + self.view.set_status(StatusVM(text, level)) + + def _on_error(self, event: StageError) -> None: + if event.stage == "suggest" and event.kind in ( + ErrorKind.NOTHING_TO_ANSWER, + ErrorKind.NOT_CONFIGURED, + ): + hint = ( + "Nothing has been said yet." + if event.kind is ErrorKind.NOTHING_TO_ANSWER + else "Suggestions are off. Enable them in Settings." + ) + self._show_suggestion(SuggestionVM(message=hint)) + return + if event.stage == "setup" and event.kind is ErrorKind.NOT_CONFIGURED: + self.view.set_status(StatusVM(event.message, "warn")) + return + what = {"asr": "Transcription", "translate": "Translation", "suggest": "Suggestions", + "audio": "Audio", "setup": "Setup", "settings": "Settings"}.get(event.stage, event.stage.title()) # fmt: skip + level = "warn" if event.retryable else "error" + self.view.set_status(StatusVM(f"{what}: {ERROR_TEXT[event.kind]} — {event.message}", level)) + + # ------------------------------------------------------------ formatting + def row_vm(self, u: Utterance) -> RowVM: + failed = u.status is UtteranceStatus.FAILED + note: str | None = None + translation = u.translation + if u.status is UtteranceStatus.LISTENING: + note = "listening…" + elif u.status is UtteranceStatus.PARTIAL: + note = None + elif failed: + note = ERROR_TEXT.get(u.error or ErrorKind.INTERNAL, "failed") + elif u.status is UtteranceStatus.FINAL: + if u.error is not None: + note = f"translation failed: {ERROR_TEXT[u.error]}" + elif self.translation_enabled and not languages.same_language( + u.source_lang, self.user_language + ): + note = "translating…" + return RowVM( + id=u.id, + original=u.text, + translation=translation, + note=note, + partial=u.status is UtteranceStatus.PARTIAL, + failed=failed, + ) + + def language_label(self, language: str | None, locked: bool) -> str: + if not language: + return "Language: auto" + return f"{languages.name(language)}{' (locked)' if locked else ''}" + + def capture_vm(self, status: ShieldStatus | None) -> CaptureVM: + if status is ShieldStatus.HIDDEN: + return CaptureVM(True, "Hidden from screen share") + if status is None: + return CaptureVM(False, "Visible in screen share (hiding is off)") + if status is ShieldStatus.FAILED: + return CaptureVM(False, "Visible in screen share (hiding failed)") + return CaptureVM(False, "Visible in screen share") + + def _text(self, utterance_id: int) -> str: + u = self.rows.get(utterance_id) + return u.text if u is not None else "" + + def _latest_final(self) -> int: + finals = [u.id for u in self.rows.values() if u.is_final and u.text] + return max(finals, default=0) + + def _show_suggestion(self, vm: SuggestionVM, *, stale: bool | None = None) -> None: + if stale is None: + stale = self.suggestion_for is not None and self._latest_final() > self.suggestion_for + vm = SuggestionVM(vm.reply_to, vm.options, vm.loading, vm.message, stale, True) + self._suggestion = vm + self.view.show_suggestions(vm) + + # ------------------------------------------------------------ user actions + def on_start_stop(self) -> None: + self.commands.toggle() + + def on_suggest(self) -> None: + self.commands.request_suggestion() + + def on_clear(self) -> None: + # The view clears when the core confirms (ConversationCleared), so results + # already on their way cannot bring old rows back. + self.commands.clear() + + def _is_cleared(self, event: Event) -> bool: + if isinstance(event, UtteranceUpdated): + uid = event.utterance.id + elif isinstance(event, (UtteranceDiscarded, SuggestionStarted)): + uid = event.utterance_id + elif isinstance(event, SuggestionsReady): + uid = event.suggestion.utterance_id + else: + return False + return uid <= self._cleared_upto + + def on_unlock_language(self) -> None: + self.commands.set_language(None) + + def detach(self) -> None: + """Stop updating the view (shutdown). Later events and calls become no-ops.""" + self.view = NullView() + + def on_shield_status(self, status: ShieldStatus | None) -> None: + self.view.set_capture(self.capture_vm(status)) + + def on_user_language(self, code: str) -> None: + self.user_language = code + for u in self.rows.values(): + self.view.upsert_row(self.row_vm(u)) diff --git a/src/polyglot/ui/qt/__init__.py b/src/polyglot/ui/qt/__init__.py new file mode 100644 index 0000000..f29e7cd --- /dev/null +++ b/src/polyglot/ui/qt/__init__.py @@ -0,0 +1 @@ +"""PyQt6 views and the thread bridge. Imported only by ``polyglot.app``.""" diff --git a/src/polyglot/ui/qt/bridge.py b/src/polyglot/ui/qt/bridge.py new file mode 100644 index 0000000..8567c55 --- /dev/null +++ b/src/polyglot/ui/qt/bridge.py @@ -0,0 +1,34 @@ +"""The one thread bridge: core events (any thread) -> presenter (GUI thread).""" + +from __future__ import annotations + +from collections.abc import Callable + +from PyQt6.QtCore import QObject, pyqtSignal, pyqtSlot + +from polyglot.core.events import Event, EventBus + + +class EventBridge(QObject): + """Subscribes to the bus and re-emits each event as a queued Qt signal. + + Create it on the GUI thread: the connection then delivers to ``handler`` on + the GUI thread no matter which pipeline thread published the event. + """ + + _event = pyqtSignal(object) + + def __init__(self, bus: EventBus, handler: Callable[[Event], None]) -> None: + super().__init__() + self._handler = handler + # AutoConnection: queued when emitted from a pipeline thread (the receiver lives + # on the GUI thread), direct when emitted on the GUI thread itself. + self._event.connect(self._deliver) + self._unsubscribe = bus.subscribe(self._event.emit) + + @pyqtSlot(object) + def _deliver(self, event: Event) -> None: + self._handler(event) + + def close(self) -> None: + self._unsubscribe() diff --git a/src/polyglot/ui/qt/hotkeys.py b/src/polyglot/ui/qt/hotkeys.py new file mode 100644 index 0000000..9002179 --- /dev/null +++ b/src/polyglot/ui/qt/hotkeys.py @@ -0,0 +1,51 @@ +"""System-wide hotkeys (work while another app, e.g. the call, has focus). + +Uses pynput. If it cannot start (no permission on macOS, no display), the app keeps +working with the in-window buttons and logs why. +""" + +from __future__ import annotations + +import logging +from typing import Any + +from PyQt6.QtCore import QObject, pyqtSignal + +log = logging.getLogger(__name__) + + +class GlobalHotkeys(QObject): + suggest = pyqtSignal() + toggle_window = pyqtSignal() + + def __init__(self) -> None: + super().__init__() + self._listener: Any = None + + def bind(self, suggest_combo: str, toggle_combo: str) -> bool: + self.stop() + if not suggest_combo and not toggle_combo: + return False + try: + from pynput import keyboard + except Exception as exc: # ImportError, or a backend error on import + log.warning("global hotkeys unavailable: %s", exc) + return False + mapping = {} + if suggest_combo: + mapping[suggest_combo] = self.suggest.emit # emitted from pynput's thread: queued + if toggle_combo: + mapping[toggle_combo] = self.toggle_window.emit + try: + self._listener = keyboard.GlobalHotKeys(mapping) + self._listener.start() + except Exception as exc: + log.warning("could not register global hotkeys %s: %s", list(mapping), exc) + self._listener = None + return False + return True + + def stop(self) -> None: + if self._listener is not None: + self._listener.stop() + self._listener = None diff --git a/src/polyglot/ui/qt/overlay.py b/src/polyglot/ui/qt/overlay.py new file mode 100644 index 0000000..ff5de65 --- /dev/null +++ b/src/polyglot/ui/qt/overlay.py @@ -0,0 +1,328 @@ +"""The overlay window: a passive view. It draws what the presenter gives it and emits +intent signals for clicks. No logic, no services, no threads.""" + +from __future__ import annotations + +import bisect +from importlib import resources + +from PyQt6.QtCore import QPoint, Qt, QTimer, pyqtSignal +from PyQt6.QtGui import QGuiApplication, QKeySequence, QMouseEvent, QShortcut +from PyQt6.QtWidgets import ( + QFrame, + QHBoxLayout, + QLabel, + QPushButton, + QScrollArea, + QSizeGrip, + QSizePolicy, + QVBoxLayout, + QWidget, +) + +from polyglot.config import UiConfig +from polyglot.ui.presenter import CaptureVM, OptionVM, RowVM, StatusVM, SuggestionVM + + +def load_stylesheet() -> str: + return resources.files("polyglot.ui.qt").joinpath("theme.qss").read_text(encoding="utf-8") + + +def _label(text: str = "", name: str = "", *, wrap: bool = True, selectable: bool = True) -> QLabel: + lbl = QLabel(text) + if name: + lbl.setObjectName(name) + lbl.setWordWrap(wrap) + if selectable: + lbl.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse) + lbl.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Minimum) + return lbl + + +def _repolish(widget: QWidget) -> None: + style = widget.style() + if style is not None: + style.unpolish(widget) + style.polish(widget) + + +class RowWidget(QFrame): + """One utterance: original, translation underneath, and a note.""" + + def __init__(self) -> None: + super().__init__() + self.setObjectName("Row") + layout = QVBoxLayout(self) + layout.setContentsMargins(10, 6, 10, 6) + layout.setSpacing(2) + self.original = _label(name="Original") + self.translation = _label(name="Translation") + self.note = _label(name="Note", selectable=False) + for w in (self.original, self.translation, self.note): + layout.addWidget(w) + + def apply(self, vm: RowVM) -> None: + self.original.setText(vm.original or "…") + self.translation.setText(vm.translation or "") + self.translation.setVisible(bool(vm.translation)) + self.note.setText(vm.note or "") + self.note.setVisible(bool(vm.note)) + self.setProperty("partial", vm.partial) + self.setProperty("failed", vm.failed) + _repolish(self) + + +class OptionWidget(QFrame): + """One suggested reply. Click to copy what to say.""" + + def __init__(self, vm: OptionVM) -> None: + super().__init__() + self.setObjectName("Option") + self.setCursor(Qt.CursorShape.PointingHandCursor) + self.setToolTip("Click to copy") + self._say = vm.say + layout = QVBoxLayout(self) + layout.setContentsMargins(10, 6, 10, 6) + layout.setSpacing(2) + layout.addWidget(_label(vm.say, "Say", selectable=False)) + layout.addWidget(_label(vm.means, "Means", selectable=False)) + + def mousePressEvent(self, a0: QMouseEvent | None) -> None: + clipboard = QGuiApplication.clipboard() + if clipboard is not None: + clipboard.setText(self._say) + self.setProperty("copied", True) + _repolish(self) + QTimer.singleShot(600, self._uncopy) + + def _uncopy(self) -> None: + self.setProperty("copied", False) + _repolish(self) + + +class TitleBar(QWidget): + """Drag handle for the frameless window.""" + + def __init__(self, parent: QWidget) -> None: + super().__init__(parent) + self.setObjectName("TitleBar") + self._drag_from: QPoint | None = None + + def mousePressEvent(self, a0: QMouseEvent | None) -> None: + win = self.window() + if a0 is not None and win is not None and a0.button() == Qt.MouseButton.LeftButton: + self._drag_from = a0.globalPosition().toPoint() - win.frameGeometry().topLeft() + + def mouseMoveEvent(self, a0: QMouseEvent | None) -> None: + win = self.window() + if a0 is not None and win is not None and self._drag_from is not None: + win.move(a0.globalPosition().toPoint() - self._drag_from) + + def mouseReleaseEvent(self, a0: QMouseEvent | None) -> None: + self._drag_from = None + + +def _button(text: str, name: str, tip: str) -> QPushButton: + b = QPushButton(text) + b.setObjectName(name) + b.setToolTip(tip) + b.setCursor(Qt.CursorShape.PointingHandCursor) + b.setFocusPolicy(Qt.FocusPolicy.NoFocus) + return b + + +class OverlayWindow(QWidget): + start_stop_clicked = pyqtSignal() + suggest_clicked = pyqtSignal() + settings_clicked = pyqtSignal() + clear_clicked = pyqtSignal() + quit_clicked = pyqtSignal() + language_clicked = pyqtSignal() + + def __init__(self, ui: UiConfig) -> None: + super().__init__() + self.setObjectName("Overlay") + self.setWindowTitle("Polyglot") + self.setWindowFlags( + Qt.WindowType.FramelessWindowHint + | Qt.WindowType.WindowStaysOnTopHint + | Qt.WindowType.Tool + ) + self.setStyleSheet(load_stylesheet()) + self._rows: dict[int, RowWidget] = {} + self._order: list[int] = [] + self._build() + self.apply_ui(ui) + QShortcut(QKeySequence("Ctrl+Return"), self).activated.connect(self.suggest_clicked.emit) + QShortcut(QKeySequence("Escape"), self).activated.connect(self.hide) + + # ------------------------------------------------------------ layout + def _build(self) -> None: + root = QVBoxLayout(self) + root.setContentsMargins(0, 0, 0, 0) + root.setSpacing(0) + + title = TitleBar(self) + tl = QHBoxLayout(title) + tl.setContentsMargins(10, 4, 6, 4) + name = _label("Polyglot", "AppName", wrap=False, selectable=False) + self.language = _button("Language: auto", "LanguageButton", "Click to unlock and re-detect") + self.language.clicked.connect(self.language_clicked.emit) + tl.addWidget(name) + tl.addWidget(self.language) + tl.addStretch(1) + for text, obj, tip, signal in ( + ("⟲", "IconButton", "Clear conversation", self.clear_clicked), + ("⚙", "IconButton", "Settings", self.settings_clicked), + ): + b = _button(text, obj, tip) + b.clicked.connect(signal.emit) + tl.addWidget(b) + hide = _button("–", "IconButton", "Hide (tray icon or hotkey brings it back)") + hide.clicked.connect(self.hide) + tl.addWidget(hide) + close = _button("×", "CloseButton", "Quit Polyglot") + close.clicked.connect(self.quit_clicked.emit) + tl.addWidget(close) + root.addWidget(title) + + controls = QWidget() + controls.setObjectName("Controls") + cl = QHBoxLayout(controls) + cl.setContentsMargins(10, 6, 10, 6) + self.start = _button("Start", "StartButton", "Start or stop listening") + self.start.clicked.connect(self.start_stop_clicked.emit) + self.suggest = _button("Suggest", "SuggestButton", "Suggest replies to the last sentence") + self.suggest.clicked.connect(self.suggest_clicked.emit) + self.status = _label("Stopped", "Status", wrap=False, selectable=False) + self.status.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred) + cl.addWidget(self.start) + cl.addWidget(self.suggest) + cl.addWidget(self.status, 1) + root.addWidget(controls) + + self.transcript = QScrollArea() + self.transcript.setObjectName("Transcript") + self.transcript.setWidgetResizable(True) + self.transcript.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) + holder = QWidget() + holder.setObjectName("TranscriptBody") + self.rows_layout = QVBoxLayout(holder) + self.rows_layout.setContentsMargins(6, 6, 6, 6) + self.rows_layout.setSpacing(6) + self.rows_layout.addStretch(1) + self.transcript.setWidget(holder) + root.addWidget(self.transcript, 3) + + self.suggestions = QFrame() + self.suggestions.setObjectName("Suggestions") + sl = QVBoxLayout(self.suggestions) + sl.setContentsMargins(10, 8, 10, 8) + sl.setSpacing(6) + self.reply_to = _label("", "ReplyTo") + self.suggest_message = _label("", "SuggestMessage", selectable=False) + self.stale = _label( + "Newer sentences since. Press Suggest to refresh.", "Stale", selectable=False + ) + self.options_layout = QVBoxLayout() + self.options_layout.setSpacing(6) + sl.addWidget(self.reply_to) + sl.addLayout(self.options_layout) + sl.addWidget(self.suggest_message) + sl.addWidget(self.stale) + self.suggestions.hide() + root.addWidget(self.suggestions, 2) + + footer = QWidget() + footer.setObjectName("Footer") + fl = QHBoxLayout(footer) + fl.setContentsMargins(10, 2, 2, 2) + self.capture = _label("", "Capture", wrap=False, selectable=False) + fl.addWidget(self.capture, 1) + fl.addWidget(QSizeGrip(self), 0, Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignRight) + root.addWidget(footer) + + def apply_ui(self, ui: UiConfig) -> None: + self.setWindowOpacity(ui.opacity) + self.setGeometry(ui.x, ui.y, ui.width, ui.height) + + def toggle_visible(self) -> None: + if self.isVisible(): + self.hide() + else: + self.show() + self.raise_() + + # ------------------------------------------------------------ ViewPort + def _at_bottom(self) -> bool: + bar = self.transcript.verticalScrollBar() + return bar is None or bar.value() >= bar.maximum() - 4 + + def _scroll_to_bottom(self) -> None: + bar = self.transcript.verticalScrollBar() + if bar is not None: + bar.setValue(bar.maximum()) + + def upsert_row(self, row: RowVM) -> None: + follow = self._at_bottom() + widget = self._rows.get(row.id) + if widget is None: + widget = RowWidget() + idx = bisect.bisect(self._order, row.id) # placed by ID: spoken order + self._order.insert(idx, row.id) + self.rows_layout.insertWidget(idx, widget) + self._rows[row.id] = widget + widget.apply(row) + if follow: + QTimer.singleShot(0, self._scroll_to_bottom) + + def remove_row(self, utterance_id: int) -> None: + widget = self._rows.pop(utterance_id, None) + if widget is not None: + self._order.remove(utterance_id) + widget.setParent(None) + widget.deleteLater() + + def clear_rows(self) -> None: + for uid in list(self._rows): + self.remove_row(uid) + + def show_suggestions(self, vm: SuggestionVM) -> None: + while self.options_layout.count(): + item = self.options_layout.takeAt(0) + w = item.widget() if item is not None else None + if w is not None: + w.setParent(None) + w.deleteLater() + if not vm.visible: + self.suggestions.hide() + return + self.reply_to.setText(f"Replying to: “{vm.reply_to}”" if vm.reply_to else "") + self.reply_to.setVisible(bool(vm.reply_to)) + for opt in vm.options: + self.options_layout.addWidget(OptionWidget(opt)) + message = "Thinking…" if vm.loading else (vm.message or "") + self.suggest_message.setText(message) + self.suggest_message.setVisible(bool(message)) + self.stale.setVisible(vm.stale and not vm.loading) + self.suggestions.show() + + def set_status(self, vm: StatusVM) -> None: + self.status.setText(vm.text) + self.status.setToolTip(vm.text) + self.status.setProperty("level", vm.level) + _repolish(self.status) + + def set_listening(self, listening: bool, busy: bool) -> None: + self.start.setText("Stop" if listening else "Start") + self.start.setProperty("listening", listening) + self.start.setEnabled(not busy) + _repolish(self.start) + + def set_language(self, text: str) -> None: + self.language.setText(text) + + def set_capture(self, vm: CaptureVM) -> None: + self.capture.setText(("● " if not vm.hidden else "") + vm.text) + self.capture.setProperty("hidden", vm.hidden) + _repolish(self.capture) diff --git a/src/polyglot/ui/qt/settings_dialog.py b/src/polyglot/ui/qt/settings_dialog.py new file mode 100644 index 0000000..4431740 --- /dev/null +++ b/src/polyglot/ui/qt/settings_dialog.py @@ -0,0 +1,429 @@ +"""Settings dialog built from ``AppConfig``. Returns a new, validated config; API keys go +straight to the secret store and are never part of the config.""" + +from __future__ import annotations + +import logging +import threading +from collections.abc import Callable, Sequence +from typing import Any, ClassVar, Protocol + +from pydantic import ValidationError +from PyQt6.QtCore import QObject, Qt, pyqtSignal +from PyQt6.QtWidgets import ( + QCheckBox, + QComboBox, + QDialog, + QDialogButtonBox, + QDoubleSpinBox, + QFileDialog, + QFormLayout, + QHBoxLayout, + QLabel, + QLineEdit, + QMessageBox, + QPushButton, + QSpinBox, + QTabWidget, + QVBoxLayout, + QWidget, +) + +from polyglot.config import AppConfig, Secrets, SuggestionsConfig, TranslationConfig +from polyglot.core import languages + +log = logging.getLogger(__name__) + +WHISPER_MODELS = ("tiny", "base", "small", "medium", "large-v3", "large-v3-turbo") + + +def _combo(items: list[tuple[str, Any]], current: Any) -> QComboBox: + box = QComboBox() + for label, value in items: + box.addItem(label, value) + idx = box.findData(current) + if idx < 0 and current is not None: + # A value the list does not know (custom model, regional language, device by + # name) is kept as-is rather than silently replaced by the first entry. + box.addItem(str(current), current) + idx = box.count() - 1 + box.setCurrentIndex(max(idx, 0)) + return box + + +class ModelLike(Protocol): + @property + def id(self) -> str: ... + @property + def note(self) -> str: ... + + +class ModelCatalog(Protocol): + """Where model names come from (built by the composition root, so this module never + imports an adapter).""" + + def known(self) -> Sequence[ModelLike]: ... + def cached(self, api_key: str) -> Sequence[ModelLike] | None: ... + def fetch(self, api_key: str) -> Sequence[ModelLike]: ... + + +def _fill_models(box: QComboBox, models: Sequence[ModelLike], current: str, note: str) -> None: + """Editable list of model IDs (tooltips carry the notes); keeps ``current`` even if + the list does not contain it, so a custom or newer model is never lost.""" + box.blockSignals(True) + box.clear() + for m in models: + box.addItem(m.id) + box.setItemData(box.count() - 1, m.note or m.id, Qt.ItemDataRole.ToolTipRole) + if current and box.findText(current) < 0: + box.addItem(current) + box.setItemData(box.count() - 1, note, Qt.ItemDataRole.ToolTipRole) + box.setCurrentText(current) + box.blockSignals(False) + + +def _model_combo(models: Sequence[ModelLike], current: str) -> QComboBox: + box = QComboBox() + box.setEditable(True) # any model ID can be typed + box.setInsertPolicy(QComboBox.InsertPolicy.NoInsert) + box.setMinimumContentsLength(18) + _fill_models(box, models, current, "Custom model") + return box + + +class _ModelLoader(QObject): + """Fetches the live model list on a worker thread; results arrive as queued signals. + Parentless and kept alive until it reports, so closing the dialog early is safe (Qt + drops signals to a deleted receiver).""" + + loaded = pyqtSignal(object) + failed = pyqtSignal(str) + _alive: ClassVar[set[_ModelLoader]] = set() + + def __init__(self, catalog: ModelCatalog, api_key: str) -> None: + super().__init__() + self._catalog, self._key = catalog, api_key + + def start(self) -> None: + _ModelLoader._alive.add(self) + threading.Thread(target=self._run, name="polyglot-models", daemon=True).start() + + def _run(self) -> None: + try: + models = list(self._catalog.fetch(self._key)) + except Exception as exc: + log.info("could not list OpenAI models: %s", exc) + self.failed.emit(str(exc)) + else: + self.loaded.emit(models) + finally: + _ModelLoader._alive.discard(self) + + +def _language_items(with_auto: bool) -> list[tuple[str, Any]]: + items: list[tuple[str, Any]] = [("Auto-detect", None)] if with_auto else [] + items += sorted(((languages.name(c), c) for c in languages.known_codes()), key=lambda x: x[0]) + return items + + +def _spin(lo: int, hi: int, value: int, suffix: str = "") -> QSpinBox: + s = QSpinBox() + s.setRange(lo, hi) + s.setValue(value) + if suffix: + s.setSuffix(suffix) + return s + + +def _dspin(lo: float, hi: float, value: float, step: float, suffix: str = "") -> QDoubleSpinBox: + s = QDoubleSpinBox() + s.setRange(lo, hi) + s.setSingleStep(step) + s.setDecimals(2) + s.setValue(value) + if suffix: + s.setSuffix(suffix) + return s + + +class SettingsDialog(QDialog): + def __init__( + self, + config: AppConfig, + secrets: Secrets, + list_devices: Callable[[], list[dict[str, Any]]], + parent: QWidget | None = None, + *, + models: ModelCatalog | None = None, + ) -> None: + super().__init__(parent) + self.setWindowTitle("Polyglot settings") + self.setObjectName("SettingsDialog") + self._config, self._secrets = config, secrets + self._catalog = models + self._known_models: Sequence[ModelLike] = models.known() if models else () + self.result_config: AppConfig | None = None + self.keys_changed = False + tabs = QTabWidget() + tabs.addTab(self._audio_tab(list_devices), "Audio") + tabs.addTab(self._speech_tab(), "Speech") + tabs.addTab(self._translation_tab(), "Translation") + tabs.addTab(self._suggestions_tab(), "Suggestions") + tabs.addTab(self._window_tab(), "Window") + buttons = QDialogButtonBox( + QDialogButtonBox.StandardButton.Save | QDialogButtonBox.StandardButton.Cancel + ) + buttons.accepted.connect(self._save) + buttons.rejected.connect(self.reject) + layout = QVBoxLayout(self) + layout.addWidget(tabs) + layout.addWidget(buttons) + self._show_account_models(fetch=True) + + # ------------------------------------------------------------ tabs + def _audio_tab(self, list_devices: Callable[[], list[dict[str, Any]]]) -> QWidget: + a = self._config.audio + w, form = QWidget(), QFormLayout() + w.setLayout(form) + self.source = _combo( + [("Automatic (system audio on Windows)", "auto"), ("System audio (Windows loopback)", "loopback"), + ("Input device", "device"), ("WAV file (testing)", "file")], + a.source, + ) # fmt: skip + try: + devices = list_devices() + error = "" + except Exception as exc: + devices, error = [], str(exc) + items: list[tuple[str, Any]] = [("Default input", None)] + items += [ + (f"{d['name']}{' (virtual)' if d.get('virtual') else ''}", str(d["id"])) + for d in devices + ] + self.device = _combo(items, a.device) + self.file = QLineEdit(a.file or "") + browse = QPushButton("Browse…") + browse.clicked.connect(self._browse) + row = QHBoxLayout() + row.addWidget(self.file) + row.addWidget(browse) + form.addRow("Listen to", self.source) + form.addRow("Input device", self.device) + form.addRow("WAV file", row) + if error: + form.addRow(QLabel(f"Could not list devices: {error}")) + return w + + def _browse(self) -> None: + path, _ = QFileDialog.getOpenFileName(self, "Choose a WAV file", "", "WAV files (*.wav)") + if path: + self.file.setText(path) + + def _speech_tab(self) -> QWidget: + s, v = self._config.asr, self._config.vad + w, form = QWidget(), QFormLayout() + w.setLayout(form) + self.model = _combo([(m, m) for m in WHISPER_MODELS], s.model) + self.asr_device = _combo( + [("Automatic", "auto"), ("CPU", "cpu"), ("NVIDIA GPU (CUDA)", "cuda")], s.device + ) + self.compute_type = _combo( + [ + ("Automatic (fastest supported)", "auto"), + ("int8 (fast on CPU)", "int8"), + ("float16 (GPU)", "float16"), + ("float32 (most precise, slowest)", "float32"), + ], + s.compute_type, + ) + self.source_lang = _combo(_language_items(with_auto=True), s.language) + self.vad_engine = _combo( + [("Silero (recommended)", "silero"), ("Energy (simple)", "energy")], v.engine + ) + self.end_silence = _spin(100, 5000, v.end_silence_ms, " ms") + self.partials = QCheckBox("Show text while the speaker is still talking") + self.partials.setChecked(v.partial_interval_ms > 0) + form.addRow("Whisper model", self.model) + form.addRow("Run on", self.asr_device) + form.addRow("Precision", self.compute_type) + form.addRow("Their language", self.source_lang) + form.addRow("Speech detector", self.vad_engine) + form.addRow("End of sentence after", self.end_silence) + form.addRow("", self.partials) + return w + + def _translation_tab(self) -> QWidget: + t = self._config.translation + w, form = QWidget(), QFormLayout() + w.setLayout(form) + self.translate_on = QCheckBox("Translate (sends transcribed text to the provider)") + self.translate_on.setChecked(t.enabled) + self.provider = _combo( + [("OpenAI", "openai"), ("Google Cloud Translation", "google")], t.provider + ) + self.target = _combo(_language_items(with_auto=False), t.target_language) + self.translate_model = _model_combo(self._known_models, t.model) + self.translate_model.setToolTip("OpenAI model for translation. Type any model ID.") + self.provider.currentIndexChanged.connect(self._provider_changed) + self.openai_key = self._key_field(Secrets.OPENAI) + self.google_key = self._key_field(Secrets.GOOGLE) + form.addRow("", self.translate_on) + form.addRow("Provider", self.provider) + form.addRow("Your language", self.target) + form.addRow("OpenAI model", self._with_refresh(self.translate_model)) + self.models_status = QLabel("") + self.models_status.setWordWrap(True) + form.addRow("", self.models_status) + form.addRow("OpenAI API key", self.openai_key) + form.addRow("Google API key", self.google_key) + form.addRow(QLabel("Keys are stored in the system keychain, not in the config file.")) + self._provider_changed() + return w + + def _with_refresh(self, box: QComboBox) -> QWidget: + row, lay = QWidget(), QHBoxLayout() + lay.setContentsMargins(0, 0, 0, 0) + row.setLayout(lay) + refresh = QPushButton("Refresh") + refresh.setToolTip("Load the models your OpenAI API key can use") + refresh.clicked.connect(lambda: self._show_account_models(fetch=True, force=True)) + refresh.setEnabled(self._catalog is not None) + lay.addWidget(box, 1) + lay.addWidget(refresh) + return row + + def _provider_changed(self) -> None: + self.translate_model.setEnabled(self.provider.currentData() == "openai") + + # ------------------------------------------------------------ model list + def _openai_key(self) -> str | None: + typed = self.openai_key.text().strip() + return typed or self._secrets.get(Secrets.OPENAI) + + def _show_account_models(self, *, fetch: bool, force: bool = False) -> None: + """Show the models the OpenAI key can use: from the session cache at once, or + fetched in the background (on open, or when Refresh is pressed).""" + if self._catalog is None: + return + key = self._openai_key() + if not key: + self.models_status.setText("Add an OpenAI API key to list the models it can use.") + return + cached = None if force else self._catalog.cached(key) + if cached is not None: + self._models_loaded(list(cached)) + return + if not fetch: + return + self.models_status.setText("Loading the models your key can use…") + loader = _ModelLoader(self._catalog, key) + loader.loaded.connect(self._models_loaded) + loader.failed.connect(self._models_failed) + loader.start() + + def _models_loaded(self, models: list[ModelLike]) -> None: + if not models: + self.models_status.setText("Your key lists no chat models; showing the built-in list.") + return + note = "Not in your account's model list" + for box in (self.translate_model, self.suggest_model): + _fill_models(box, models, box.currentText().strip(), note) + self.models_status.setText(f"{len(models)} models available to your key.") + + def _models_failed(self, error: str) -> None: + self.models_status.setText( + f"Could not load your models ({error}); showing the built-in list." + ) + + def _key_field(self, name: str) -> QLineEdit: + field = QLineEdit() + field.setEchoMode(QLineEdit.EchoMode.Password) + source = self._secrets.source(name) + if source is None: + field.setPlaceholderText("not set") + elif source == "keychain": + field.setPlaceholderText("stored in the keychain") + else: + field.setPlaceholderText(f"from {source} (overrides the keychain)") + return field + + def _suggestions_tab(self) -> QWidget: + s = self._config.suggestions + w, form = QWidget(), QFormLayout() + w.setLayout(form) + self.suggest_on = QCheckBox("Suggest replies when I press the hotkey (uses OpenAI)") + self.suggest_on.setChecked(s.enabled) + self.suggest_model = _model_combo(self._known_models, s.model) + self.suggest_model.setToolTip("OpenAI model for reply suggestions. Type any model ID.") + self.conversation = _combo( + [("Meeting", "meeting"), ("Interview", "interview"), ("Casual", "casual")], + s.conversation_type, + ) + self.option_count = _spin(1, 3, s.options) + form.addRow("", self.suggest_on) + form.addRow("Model", self._with_refresh(self.suggest_model)) + form.addRow("Conversation", self.conversation) + form.addRow("Replies to offer", self.option_count) + return w + + def _window_tab(self) -> QWidget: + u, p = self._config.ui, self._config.privacy + w, form = QWidget(), QFormLayout() + w.setLayout(form) + self.opacity = _dspin(0.2, 1.0, u.opacity, 0.05) + self.hide_capture = QCheckBox("Hide this window from screen sharing (Windows 10 2004+)") + self.hide_capture.setChecked(u.hide_from_capture) + self.hotkey_suggest = QLineEdit(u.hotkey_suggest) + self.hotkey_toggle = QLineEdit(u.hotkey_toggle) + self.dump_audio = QCheckBox("Save each sentence's audio for debugging") + self.dump_audio.setChecked(p.dump_audio) + form.addRow("Opacity", self.opacity) + form.addRow("", self.hide_capture) + form.addRow("Suggest hotkey", self.hotkey_suggest) + form.addRow("Show/hide hotkey", self.hotkey_toggle) + form.addRow("", self.dump_audio) + return w + + # ------------------------------------------------------------ save + def _save(self) -> None: + c = self._config.model_dump() + c["audio"].update(source=self.source.currentData(), device=self.device.currentData(), + file=self.file.text().strip() or None) # fmt: skip + c["asr"].update(model=self.model.currentData(), device=self.asr_device.currentData(), + compute_type=self.compute_type.currentData(), + language=self.source_lang.currentData()) # fmt: skip + c["vad"].update( + engine=self.vad_engine.currentData(), + end_silence_ms=self.end_silence.value(), + partial_interval_ms=(c["vad"]["partial_interval_ms"] or 1000) + if self.partials.isChecked() + else 0, + ) + c["translation"].update(enabled=self.translate_on.isChecked(), provider=self.provider.currentData(), + target_language=self.target.currentData(), + model=self.translate_model.currentText().strip() + or TranslationConfig.model_fields["model"].default) # fmt: skip + c["suggestions"].update(enabled=self.suggest_on.isChecked(), + model=self.suggest_model.currentText().strip() + or SuggestionsConfig.model_fields["model"].default, + conversation_type=self.conversation.currentData(), + options=self.option_count.value()) # fmt: skip + c["ui"].update(opacity=self.opacity.value(), hide_from_capture=self.hide_capture.isChecked(), + hotkey_suggest=self.hotkey_suggest.text().strip(), + hotkey_toggle=self.hotkey_toggle.text().strip()) # fmt: skip + c["privacy"].update(dump_audio=self.dump_audio.isChecked()) + try: + new = AppConfig.model_validate(c) + except ValidationError as exc: + QMessageBox.warning(self, "Invalid settings", str(exc)) + return + for field, name in ((self.openai_key, Secrets.OPENAI), (self.google_key, Secrets.GOOGLE)): + if field.text().strip(): + try: + self._secrets.set(name, field.text().strip()) + except Exception as exc: + QMessageBox.warning(self, "Could not store key", f"{name}: {exc}") + return + self.keys_changed = True + self.result_config = new + self.accept() diff --git a/src/polyglot/ui/qt/shield_filter.py b/src/polyglot/ui/qt/shield_filter.py new file mode 100644 index 0000000..df74875 --- /dev/null +++ b/src/polyglot/ui/qt/shield_filter.py @@ -0,0 +1,160 @@ +"""Apply the capture shield to every top-level window the app shows. + +In Qt, dialogs, menus, combo-box popups and tooltips are separate top-level windows, +each with its own native handle. Shielding only the main window would expose a settings +dialog opened during a screen share. This event filter is installed on the +QApplication and shields each window when it is shown, and again whenever Qt replaces +its native handle (``WinIdChange``). + +Three rules keep it safe: + +* ``winId()`` is only called once the native window exists. Called earlier it *creates* + one, and on a window that is half created or being torn down PyQt returns ``None``. +* ``WinIdChange`` is also sent while a window is being destroyed, when the object must + not be touched. So it is never handled on the spot: it schedules a re-scan of the + application's live top-level windows on the next event-loop turn. +* No widget references are kept. Tooltips and menus are created and deleted by Qt in + C++, where PyQt cannot always tell that a wrapper has gone stale; only the ``destroyed`` + signal (which carries no object) is used to forget a window. +""" + +from __future__ import annotations + +import contextlib +import logging +from collections.abc import Callable + +from PyQt6 import sip +from PyQt6.QtCore import QEvent, QObject, Qt, QTimer, pyqtSignal +from PyQt6.QtWidgets import QApplication, QWidget + +from polyglot.core.ports import ShieldStatus, WindowShield + +log = logging.getLogger(__name__) + +_ORDER = {ShieldStatus.HIDDEN: 0, ShieldStatus.UNSUPPORTED: 1, ShieldStatus.FAILED: 2} + + +def native_handle(widget: QWidget) -> int | None: + """The widget's existing native window handle, or None. Never creates one. + + ``winId()`` only returns the existing handle once Qt has created the native window + (``WA_WState_Created`` and a ``windowHandle()``); before that it would create one. + """ + if sip.isdeleted(widget): + return None + if not widget.testAttribute(Qt.WidgetAttribute.WA_WState_Created): + return None + if widget.windowHandle() is None: # no native window (yet, or any more) + return None + handle = widget.winId() + if handle is None: # PyQt returns None for a null handle + return None + value = int(handle) + return value or None + + +class CaptureShieldFilter(QObject): + #: The worst status across all shown windows (FAILED > UNSUPPORTED > HIDDEN). + status_changed = pyqtSignal(object) + + def __init__(self, shield: WindowShield) -> None: + super().__init__() + self._shield = shield + self._applied: dict[int, tuple[int, ShieldStatus]] = {} # id(widget) -> (hwnd, status) + self._failed_once: set[int] = set() + self._rescan_pending = False + self._closed = False + self.status: ShieldStatus | None = None + + # ------------------------------------------------------------ shielding + def shield_widget(self, widget: QWidget) -> ShieldStatus | None: + """Shield one live top-level window. Returns None if it has no native handle yet.""" + if self._closed: + return None + win_id = native_handle(widget) + if win_id is None: + log.debug("no native handle yet for %s; waiting for WinIdChange", _describe(widget)) + return None + key = id(widget) + known = self._applied.get(key) + if known is not None and known[0] == win_id: + return known[1] + status = self._shield.exclude_from_capture(win_id) + if known is None: + widget.destroyed.connect(self._forgetter(key)) + self._applied[key] = (win_id, status) + if status is not ShieldStatus.HIDDEN: + log.info("window %s not hidden from capture: %s", _describe(widget), status.value) + self._update() + return status + + def rescan(self) -> None: + """Shield every visible top-level window, using fresh objects from Qt.""" + self._rescan_pending = False + if self._closed: + return + for widget in QApplication.topLevelWidgets(): + if widget.isVisible(): + self._shield_safely(widget) + + def _shield_safely(self, widget: QWidget) -> None: + try: + self.shield_widget(widget) + except Exception as exc: + key = id(widget) + if key not in self._failed_once: # one line per window, not one per event + self._failed_once.add(key) + log.warning("capture shield failed for %s: %r", _describe(widget), exc) + + def _schedule_rescan(self) -> None: + if not self._rescan_pending and not self._closed: + self._rescan_pending = True + QTimer.singleShot(0, self.rescan) + + # ------------------------------------------------------------ bookkeeping + def _forgetter(self, key: int) -> Callable[..., None]: + def forget(*_: object) -> None: + if self._closed: + return + self._failed_once.discard(key) + if self._applied.pop(key, None) is not None: + self._update() + + return forget + + def _update(self) -> None: + statuses = [s for _, s in self._applied.values()] + worst = max(statuses, key=_ORDER.__getitem__, default=None) + if worst != self.status: + self.status = worst + self.status_changed.emit(worst) + + def close(self) -> None: + """Stop for good: no more shielding and no more ``status_changed``. Call before + the windows are deleted, so their destruction cannot reach a deleted view.""" + if self._closed: + return + self._closed = True # pending forgetters and re-scans become no-ops + self._applied.clear() + with contextlib.suppress(TypeError): # nothing connected + self.status_changed.disconnect() + + # ------------------------------------------------------------ event filter + def eventFilter(self, obj: QObject | None, event: QEvent | None) -> bool: + if self._closed or event is None: + return False + kind = event.type() + if kind == QEvent.Type.WinIdChange: + # May arrive from a window's destructor: never touch ``obj`` here. + self._schedule_rescan() + elif kind == QEvent.Type.Show and isinstance(obj, QWidget) and obj.isWindow(): + self._shield_safely(obj) # a window being shown is alive + return False + + +def _describe(widget: QWidget) -> str: + if sip.isdeleted(widget): + return "" + name = widget.objectName() + return f"{type(widget).__name__}({name!r})" if name else type(widget).__name__ diff --git a/src/polyglot/ui/qt/theme.qss b/src/polyglot/ui/qt/theme.qss new file mode 100644 index 0000000..c968572 --- /dev/null +++ b/src/polyglot/ui/qt/theme.qss @@ -0,0 +1,56 @@ +/* Polyglot overlay theme. One file; no inline stylesheets. */ + +#Overlay { background: #16181d; color: #e8e8ea; font-size: 10pt; } + +#TitleBar { background: #1f2229; } +#AppName { color: #e8e8ea; font-weight: 600; } +#LanguageButton { background: transparent; border: none; color: #9aa0aa; padding: 2px 6px; } +#LanguageButton:hover { color: #e8e8ea; } +#IconButton, #CloseButton { + background: transparent; border: none; color: #c9ccd2; + min-width: 22px; max-width: 22px; min-height: 22px; max-height: 22px; border-radius: 4px; +} +#IconButton:hover { background: #2c3039; } +#CloseButton:hover { background: #c0392b; color: white; } + +#Controls { background: #1a1d23; } +#StartButton, #SuggestButton { + border: none; border-radius: 4px; padding: 5px 12px; font-weight: 600; color: white; +} +#StartButton { background: #2f7de1; } +#StartButton:hover { background: #4a90e8; } +#StartButton[listening="true"] { background: #c0392b; } +#StartButton[listening="true"]:hover { background: #d0493b; } +#StartButton:disabled { background: #3a3e47; color: #9aa0aa; } +#SuggestButton { background: #3a3e47; } +#SuggestButton:hover { background: #4a4f5a; } +#Status { color: #9aa0aa; padding-left: 6px; } +#Status[level="warn"] { color: #e3b341; } +#Status[level="error"] { color: #f0705f; } + +#Transcript, #TranscriptBody { background: #16181d; border: none; } +#Row { background: #1f2229; border-radius: 6px; } +#Row[partial="true"] #Original { color: #9aa0aa; font-style: italic; } +#Row[failed="true"] { border: 1px solid #6b2e28; } +#Original { color: #e8e8ea; } +#Translation { color: #8fc1ff; } +#Note { color: #7d838d; font-size: 8.5pt; } + +#Suggestions { background: #1b1e24; border-top: 1px solid #2c3039; } +#ReplyTo { color: #9aa0aa; font-size: 9pt; } +#Option { background: #232733; border-radius: 6px; } +#Option:hover { background: #2a2f3d; } +#Option[copied="true"] { background: #24452f; } +#Say { color: #e8e8ea; font-weight: 600; } +#Means { color: #9aa0aa; font-style: italic; } +#SuggestMessage { color: #9aa0aa; } +#Stale { color: #e3b341; font-size: 8.5pt; } + +#Footer { background: #1a1d23; } +#Capture { color: #e3b341; font-size: 8.5pt; } +#Capture[hidden="true"] { color: #6fbf73; } + +QScrollBar:vertical { background: transparent; width: 8px; } +QScrollBar::handle:vertical { background: #3a3e47; border-radius: 4px; min-height: 24px; } +QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { height: 0; } +QToolTip { background: #2c3039; color: #e8e8ea; border: 1px solid #3a3e47; } diff --git a/src/polyglot/wiring.py b/src/polyglot/wiring.py new file mode 100644 index 0000000..b16c333 --- /dev/null +++ b/src/polyglot/wiring.py @@ -0,0 +1,248 @@ +"""Composition: config -> concrete adapters -> Pipeline. No Qt here. + +This and ``polyglot.app`` are the only modules that know every concrete class. +""" + +from __future__ import annotations + +import logging +from dataclasses import dataclass, field + +from polyglot.config import AppConfig, Secrets, data_dir +from polyglot.core.errors import ConfigError, PolyglotError +from polyglot.core.events import EventBus +from polyglot.core.models import ConversationType, IdSource +from polyglot.core.pipeline import Pipeline, PipelineConfig +from polyglot.core.ports import AudioSource, Suggester, Transcriber, Translator, VoiceActivityModel +from polyglot.core.segmenter import SegmenterConfig +from polyglot.core.session import LanguagePolicy, Session + +log = logging.getLogger(__name__) + +DEMO_LINES = ( + "Buenos días, gracias por venir hoy.", + "¿Puede contarme un poco sobre su experiencia?", + "Interesante. ¿Por qué quiere trabajar con nosotros?", + "¿Tiene alguna pregunta para nosotros?", +) + + +@dataclass +class Built: + pipeline: Pipeline + warnings: list[str] = field(default_factory=list) + translation_enabled: bool = False + suggestions_enabled: bool = False + source_name: str = "" + + +def pipeline_config(cfg: AppConfig) -> PipelineConfig: + v = cfg.vad + return PipelineConfig( + segmenter=SegmenterConfig( + start_threshold=v.start_threshold, + end_threshold=v.end_threshold, + start_frames=v.start_frames, + end_silence_ms=v.end_silence_ms, + pre_roll_ms=v.pre_roll_ms, + max_utterance_s=v.max_utterance_s, + min_utterance_ms=v.min_utterance_ms, + partial_interval_ms=v.partial_interval_ms, + ), + target_language=cfg.translation.target_language, + language_policy=LanguagePolicy( + agree=cfg.asr.lock_after, + min_probability=cfg.asr.lock_min_probability, + forced=cfg.asr.language, + ), + translate_timeout_s=cfg.translation.timeout_s, + suggest_timeout_s=cfg.suggestions.timeout_s, + suggestion_history=cfg.suggestions.history, + suggestion_options=cfg.suggestions.options, + conversation_type=ConversationType(cfg.suggestions.conversation_type), + ring_seconds=cfg.audio.ring_seconds, + finals_queue_size=cfg.asr.queue_size, + gap_fill=cfg.audio.gap_fill, + ) + + +def build_source(cfg: AppConfig, warnings: list[str]) -> tuple[AudioSource, str]: + from polyglot import platform + + a = cfg.audio + kind = a.source + if kind == "auto": + kind = "loopback" if platform.current().has_loopback else "device" + if kind == "device": + warnings.append( + "System audio needs a virtual device on this OS (e.g. BlackHole on macOS); " + "using the default input device." + ) + if kind == "file": + if not a.file: + raise ConfigError("audio.source is 'file' but audio.file is not set") + from polyglot.adapters.audio.playback import WavFileSource + + return WavFileSource(a.file, realtime=True), f"file {a.file}" + if kind == "loopback": + if not platform.current().has_loopback: + raise ConfigError("loopback capture is only available on Windows") + from polyglot.adapters.audio.wasapi_loopback import WasapiLoopbackSource + + src = WasapiLoopbackSource() + return src, f"loopback: {src.device_name}" + from polyglot.adapters.audio.sounddevice_source import SoundDeviceSource + + device: int | str | None = a.device + if isinstance(device, str) and device.isdigit(): + device = int(device) + sd_src = SoundDeviceSource(device) + return sd_src, sd_src.device_name + + +def build_vad(cfg: AppConfig, warnings: list[str]) -> VoiceActivityModel: + from polyglot.adapters.vad.energy import EnergyVad + + if cfg.vad.engine == "energy": + return EnergyVad() + try: + from polyglot.adapters.vad.silero import SileroVad + + return SileroVad(cfg.vad.model_path) + except (PolyglotError, ImportError, OSError) as exc: + warnings.append(f"Silero VAD unavailable ({exc}); using the simpler energy detector.") + return EnergyVad() + + +def build_transcriber(cfg: AppConfig) -> Transcriber: + from polyglot.adapters.asr.faster_whisper import FasterWhisperTranscriber + + return FasterWhisperTranscriber( + cfg.asr.model, + device=cfg.asr.device, + compute_type=cfg.asr.compute_type, + beam_size=cfg.asr.beam_size, + ) + + +def build_translator(cfg: AppConfig, secrets: Secrets, warnings: list[str]) -> Translator | None: + t = cfg.translation + if not t.enabled: + return None + if t.provider == "google": + key = secrets.get(Secrets.GOOGLE) + if not key: + warnings.append("Translation is on but no Google API key is set.") + return None + from polyglot.adapters.translate.google import GoogleTranslator + + return GoogleTranslator(key) + key = secrets.get(Secrets.OPENAI) + if not key: + warnings.append("Translation is on but no OpenAI API key is set.") + return None + from polyglot.adapters.translate.openai import OpenAITranslator + + return OpenAITranslator(key, model=t.model) + + +def build_suggester(cfg: AppConfig, secrets: Secrets, warnings: list[str]) -> Suggester | None: + if not cfg.suggestions.enabled: + return None + key = secrets.get(Secrets.OPENAI) + if not key: + warnings.append("Suggestions are on but no OpenAI API key is set.") + return None + from polyglot.adapters.suggest.openai import OpenAISuggester + + return OpenAISuggester(key, model=cfg.suggestions.model) + + +def build( + cfg: AppConfig, + secrets: Secrets, + bus: EventBus, + *, + session: Session | None = None, + ids: IdSource | None = None, + source: AudioSource | None = None, +) -> Built: + """Build the real pipeline from config. Raises ConfigError for unusable settings. + + ``source`` overrides the configured audio source (the CLI uses it for fast replay). + """ + from polyglot.adapters.audio.resample import make_resampler + + warnings: list[str] = [] + if source is None: + source, source_name = build_source(cfg, warnings) + else: + source_name = type(source).__name__ + translator = build_translator(cfg, secrets, warnings) + suggester = build_suggester(cfg, secrets, warnings) + tap = None + if cfg.privacy.dump_audio: + from polyglot.adapters.dump import SegmentDumper + + tap = SegmentDumper(data_dir() / "dumps") + pipeline = Pipeline( + source=source, + resampler_factory=make_resampler, + vad=build_vad(cfg, warnings), + transcriber=build_transcriber(cfg), + translator=translator, + suggester=suggester, + bus=bus, + config=pipeline_config(cfg), + segment_tap=tap, + session=session, + ids=ids, + ) + return Built(pipeline, warnings, translator is not None, suggester is not None, source_name) + + +def build_demo( + cfg: AppConfig, + bus: EventBus, + *, + session: Session | None = None, + ids: IdSource | None = None, +) -> Built: + """Everything fake: synthetic audio, scripted transcripts, echo translation, canned + suggestions. Runs with no models, keys, audio devices or network.""" + from polyglot.adapters.audio.playback import ArraySource + from polyglot.adapters.audio.resample import IdentityResampler + from polyglot.adapters.fakes import ( + AmplitudeVad, + CannedSuggester, + EchoTranslator, + ScriptedTranscriber, + speech_like, + ) + from polyglot.core.models import SAMPLE_RATE + + pattern: list[tuple[str, float]] = [] + for _ in DEMO_LINES: + pattern += [("silence", 1.0), ("tone", 1.6)] + pattern.append(("silence", 1.0)) + audio = speech_like(pattern) + pcfg = pipeline_config(cfg) + built = Built( + Pipeline( + source=ArraySource(audio, SAMPLE_RATE, realtime=True), + resampler_factory=lambda _rate: IdentityResampler(), + vad=AmplitudeVad(), + transcriber=ScriptedTranscriber(list(DEMO_LINES), language="es", delay_s=0.3), + translator=EchoTranslator(), + suggester=CannedSuggester(delay_s=0.5), + bus=bus, + config=pcfg, + session=session, + ids=ids, + ), + ["Demo mode: synthetic audio, scripted text, no network."], + translation_enabled=True, + suggestions_enabled=True, + source_name="demo", + ) + return built diff --git a/src/services/__init__.py b/src/services/__init__.py deleted file mode 100644 index 751df0f..0000000 --- a/src/services/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""External service integrations module""" - diff --git a/src/services/response.py b/src/services/response.py deleted file mode 100644 index ec072ff..0000000 --- a/src/services/response.py +++ /dev/null @@ -1,240 +0,0 @@ -"""AI response generation service using OpenAI GPT API""" - -from typing import Optional, List, Dict, Any -from openai import OpenAI -from collections import deque - - -class ResponseGenerationService: - """Generates contextually appropriate responses using OpenAI GPT""" - - def __init__(self, api_key: str, model: str = "gpt-4.1-mini", max_context: int = 10, - debug_logging: bool = False, mock_mode: bool = False): - """ - Initialize response generation service - - Args: - api_key: OpenAI API key - model: GPT model to use (default: gpt-4) - max_context: Maximum number of conversation turns to keep in context - debug_logging: If True, print debug logs to terminal - mock_mode: If True, return dummy text instead of making API calls - """ - if not api_key and not mock_mode: - raise ValueError("OpenAI API key is required") - - self.client = OpenAI(api_key=api_key) if api_key else None - self.model = model - self.max_context = max_context - self.debug_logging = debug_logging - self.mock_mode = mock_mode - self.conversation_history: deque = deque(maxlen=max_context * 2) # Store pairs of messages - - def add_to_history(self, original_text: str, translated_text: str, - source_language: str, target_language: str): - """ - Add a conversation turn to history - - Args: - original_text: Original language text - translated_text: Translated text - source_language: Source language code - target_language: Target language code - """ - self.conversation_history.append({ - 'original': original_text, - 'translated': translated_text, - 'source_lang': source_language, - 'target_lang': target_language - }) - - def clear_history(self): - """Clear conversation history""" - self.conversation_history.clear() - - def generate_response(self, original_text: str, translated_text: str, - source_language: str, target_language: str, - context: Optional[str] = None) -> Dict[str, str]: - """ - Generate appropriate responses in both languages - - Args: - original_text: Original language text from the conversation - translated_text: Translated text - source_language: Source language code - target_language: Target language code - context: Optional additional context - - Returns: - Dictionary with 'original_response' and 'translated_response' keys - """ - # Mock mode: return dummy text without making API calls - if self.mock_mode: - if self.debug_logging: - print(f"[RESPONSE DEBUG] Mock mode enabled - returning dummy text") - return { - 'original_response': 'dummy text', - 'translated_response': 'dummy text' - } - - try: - if self.debug_logging: - print(f"[RESPONSE DEBUG] generate_response() called:") - print(f" Model: {self.model}") - print(f" Original text: {original_text[:100]}{'...' if len(original_text) > 100 else ''}") - print(f" Translated text: {translated_text[:100]}{'...' if len(translated_text) > 100 else ''}") - print(f" Source lang: {source_language}, Target lang: {target_language}") - print(f" History size: {len(self.conversation_history)}") - - # Build conversation context - context_messages = [] - - # Add system message - system_prompt = f"""You are a helpful interview assistant. Based on the conversation context, generate a brief, natural, and appropriate response. - -The conversation is happening between languages: {source_language} (original) and {target_language} (user's language). - -Generate responses that are: -- Brief and concise (1-2 sentences) -- Professional and appropriate for an interview context -- Natural and conversational -- Contextually relevant to what was just said - -Provide the response in BOTH languages: -1. First in {source_language} (the original language) -2. Then in {target_language} (the user's language) - -Format your response as: -ORIGINAL: [response in {source_language}] -TRANSLATED: [response in {target_language}]""" - - context_messages.append({ - "role": "system", - "content": system_prompt - }) - - # Add conversation history - if self.conversation_history: - history_text = "Recent conversation:\n" - for turn in list(self.conversation_history)[-5:]: # Last 5 turns - history_text += f"- {turn['translated']}\n" - context_messages.append({ - "role": "user", - "content": f"Conversation context:\n{history_text}" - }) - - # Add current message - current_message = f"Just said (in {source_language}): {original_text}\nTranslated (to {target_language}): {translated_text}" - if context: - current_message += f"\nAdditional context: {context}" - - current_message += f"\n\nGenerate an appropriate brief response in both {source_language} and {target_language}." - - context_messages.append({ - "role": "user", - "content": current_message - }) - - if self.debug_logging: - print(f"[RESPONSE DEBUG] Sending request to OpenAI API...") - print(f" Messages count: {len(context_messages)}") - - # Call GPT API - response = self.client.chat.completions.create( - model=self.model, - messages=context_messages, - temperature=0.7, - max_tokens=300 - ) - - response_text = response.choices[0].message.content.strip() - - if self.debug_logging: - print(f"[RESPONSE DEBUG] Received response from API:") - print(f" Raw response: {response_text[:200]}{'...' if len(response_text) > 200 else ''}") - - # Parse response - original_response = "" - translated_response = "" - - # Try to extract responses from formatted output - if "ORIGINAL:" in response_text and "TRANSLATED:" in response_text: - parts = response_text.split("TRANSLATED:") - if len(parts) == 2: - original_part = parts[0].replace("ORIGINAL:", "").strip() - translated_part = parts[1].strip() - original_response = original_part - translated_response = translated_part - if self.debug_logging: - print(f"[RESPONSE DEBUG] Parsed ORIGINAL/TRANSLATED format") - else: - # Fallback: try to split by newlines or use the whole response - lines = response_text.split('\n') - if len(lines) >= 2: - original_response = lines[0].strip() - translated_response = lines[1].strip() - if self.debug_logging: - print(f"[RESPONSE DEBUG] Parsed newline-separated format") - else: - # If we can't parse, use the response for both (not ideal but better than nothing) - original_response = response_text - translated_response = response_text - if self.debug_logging: - print(f"[RESPONSE DEBUG] Warning: Could not parse format, using full response for both") - - # If parsing failed, try a simpler approach: use GPT to generate separately - if not original_response or not translated_response: - if self.debug_logging: - print(f"[RESPONSE DEBUG] Parsing failed, generating separate responses...") - # Generate original language response - original_response = self._generate_single_response( - original_text, source_language, source_language - ) - # Generate translated response - translated_response = self._generate_single_response( - translated_text, target_language, target_language - ) - - if self.debug_logging: - print(f"[RESPONSE DEBUG] Final parsed responses:") - print(f" Original response: {original_response[:100]}{'...' if len(original_response) > 100 else ''}") - print(f" Translated response: {translated_response[:100]}{'...' if len(translated_response) > 100 else ''}") - - return { - 'original_response': original_response, - 'translated_response': translated_response - } - - except Exception as e: - if self.debug_logging: - print(f"[RESPONSE DEBUG] Error in generate_response(): {e}") - import traceback - traceback.print_exc() - print(f"Response generation error: {e}") - # Return fallback responses - return { - 'original_response': "I understand.", - 'translated_response': "I understand." - } - - def _generate_single_response(self, text: str, language: str, response_language: str) -> str: - """Generate a single response in one language""" - try: - prompt = f"Based on this statement: '{text}', generate a brief, natural response in {response_language} (1-2 sentences)." - - response = self.client.chat.completions.create( - model=self.model, - messages=[ - {"role": "system", "content": f"You are a helpful assistant. Generate brief, natural responses in {response_language}."}, - {"role": "user", "content": prompt} - ], - temperature=0.7, - max_tokens=150 - ) - - return response.choices[0].message.content.strip() - - except Exception as e: - print(f"Single response generation error: {e}") - return "I understand." - diff --git a/src/services/transcription.py b/src/services/transcription.py deleted file mode 100644 index f6c2798..0000000 --- a/src/services/transcription.py +++ /dev/null @@ -1,149 +0,0 @@ -"""Local transcription service using faster-whisper""" - -import numpy as np -from typing import Optional, Dict, Any -from faster_whisper import WhisperModel -import warnings - -# Suppress warnings from faster-whisper -warnings.filterwarnings("ignore", category=UserWarning) - - -class TranscriptionService: - """Handles audio transcription using local faster-whisper model""" - - def __init__(self, model_size: str = "base", device: str = "auto", compute_type: str = "auto"): - """ - Initialize transcription service with local Whisper model - - Args: - model_size: Model size - "tiny", "base", "small", "medium", "large-v2", "large-v3" - Smaller = faster but less accurate, Larger = slower but more accurate - device: "cpu", "cuda", or "auto" (auto-detects) - compute_type: "int8", "int8_float16", "int16", "float16", "float32", or "auto" - """ - self.model_size = model_size - self.device = device - self.compute_type = compute_type - self.model: Optional[WhisperModel] = None - self.current_transcription: Optional[str] = None - self.detected_language: Optional[str] = None - - # Initialize model (will be loaded on first use) - print(f"Transcription service initialized (model: {model_size}, device: {device})") - print("Note: Model will be downloaded on first use (~150MB-3GB depending on size)") - - def _ensure_model_loaded(self): - """Load the Whisper model if not already loaded""" - if self.model is None: - try: - print(f"Loading Whisper model '{self.model_size}'...") - self.model = WhisperModel( - self.model_size, - device=self.device, - compute_type=self.compute_type - ) - print("Model loaded successfully!") - except Exception as e: - print(f"Error loading Whisper model: {e}") - raise - - def transcribe(self, audio_data: np.ndarray, sample_rate: int = 16000, - language: Optional[str] = None) -> Dict[str, Any]: - """ - Transcribe audio data using local Whisper model - - Args: - audio_data: Audio samples as numpy array (float32, -1.0 to 1.0) - sample_rate: Sample rate in Hz - language: Optional language code (e.g., 'en', 'es', 'fr') for faster processing - - Returns: - Dictionary with 'text' and 'language' keys - """ - try: - # Ensure model is loaded - self._ensure_model_loaded() - - # Ensure audio is in the correct format - if audio_data.dtype != np.float32: - audio_data = audio_data.astype(np.float32) - - # Normalize to prevent clipping - max_val = np.abs(audio_data).max() - if max_val > 1.0: - audio_data = audio_data / max_val - - # faster-whisper expects audio in float32 format with values between -1.0 and 1.0 - # and sample rate of 16000 Hz (which we already have) - - # Transcribe using faster-whisper - segments, info = self.model.transcribe( - audio_data, - language=language, - beam_size=5, - vad_filter=True, # Voice Activity Detection - filters out silence - vad_parameters=dict(min_silence_duration_ms=500) - ) - - # Get detected language - detected_lang = info.language if hasattr(info, 'language') else None - - # Collect all segments into text - text_segments = [] - for segment in segments: - text_segments.append(segment.text.strip()) - - # Join segments - text = " ".join(text_segments).strip() - - self.current_transcription = text - self.detected_language = detected_lang - - return { - 'text': text, - 'language': detected_lang - } - - except Exception as e: - error_msg = str(e) - print(f"Transcription error: {error_msg}") - - return { - 'text': '', - 'language': None, - 'error': error_msg - } - - async def transcribe_async(self, audio_data: np.ndarray, sample_rate: int = 16000, - language: Optional[str] = None) -> Dict[str, Any]: - """ - Asynchronously transcribe audio data - - Args: - audio_data: Audio samples as numpy array - sample_rate: Sample rate in Hz - language: Optional language code - - Returns: - Dictionary with 'text' and 'language' keys - """ - # For local model, we can just call transcribe directly - # It's already fast enough, but we keep async interface for compatibility - import asyncio - loop = asyncio.get_event_loop() - return await loop.run_in_executor(None, self.transcribe, audio_data, sample_rate, language) - - def get_last_transcription(self) -> Optional[str]: - """Get the last transcription result""" - return self.current_transcription - - def get_detected_language(self) -> Optional[str]: - """Get the last detected language""" - return self.detected_language - - def change_model(self, model_size: str): - """Change the Whisper model size (requires reload)""" - self.model_size = model_size - self.model = None # Force reload on next transcription - print(f"Model changed to '{model_size}'. Will reload on next transcription.") diff --git a/src/services/translation.py b/src/services/translation.py deleted file mode 100644 index b2dba5e..0000000 --- a/src/services/translation.py +++ /dev/null @@ -1,239 +0,0 @@ -"""Translation service using OpenAI or Google Translate API""" - -from typing import Optional, Dict, Any -from openai import OpenAI -import requests -from functools import lru_cache - - -class TranslationService: - """Handles text translation between languages""" - - def __init__(self, openai_api_key: Optional[str] = None, - google_api_key: Optional[str] = None, - prefer_google: bool = False, - model: str = "gpt-4o-mini", - debug_logging: bool = False, - mock_mode: bool = False): - """ - Initialize translation service - - Args: - openai_api_key: OpenAI API key (for OpenAI translation) - google_api_key: Google Translate API key (for Google translation) - prefer_google: If True, prefer Google Translate over OpenAI - model: GPT model to use for OpenAI translation (default: gpt-4o-mini) - debug_logging: If True, print debug logs to terminal - mock_mode: If True, return dummy text instead of making API calls - """ - self.openai_client = None - self.google_api_key = google_api_key - self.prefer_google = prefer_google - self.model = model - self.debug_logging = debug_logging - self.mock_mode = mock_mode - - if openai_api_key: - self.openai_client = OpenAI(api_key=openai_api_key) - - # Translation cache to reduce API calls - self._cache: Dict[str, str] = {} - - def _get_cache_key(self, text: str, source_lang: str, target_lang: str) -> str: - """Generate cache key for translation""" - return f"{source_lang}:{target_lang}:{text}" - - def translate_with_openai(self, text: str, target_language: str, - source_language: Optional[str] = None) -> str: - """ - Translate text using OpenAI API - - Args: - text: Text to translate - target_language: Target language code (e.g., 'en', 'es', 'fr') - source_language: Optional source language code - - Returns: - Translated text - """ - if not self.openai_client: - raise ValueError("OpenAI API key not provided") - - if not text or not text.strip(): - return "" - - try: - # Build prompt for translation - source_hint = f" from {source_language}" if source_language else "" - prompt = f"Translate the following text{source_hint} to {target_language}. Only return the translation, no explanations:\n\n{text}" - - if self.debug_logging: - print(f"[TRANSLATION DEBUG] OpenAI translation request:") - print(f" Model: {self.model}") - print(f" Source: {source_language or 'auto'} -> Target: {target_language}") - print(f" Text: {text[:100]}{'...' if len(text) > 100 else ''}") - - response = self.openai_client.chat.completions.create( - model=self.model, - messages=[ - {"role": "system", "content": "You are a professional translator. Translate the given text accurately and naturally."}, - {"role": "user", "content": prompt} - ], - temperature=0.3, - max_tokens=500 - ) - - translated = response.choices[0].message.content.strip() - - if self.debug_logging: - print(f"[TRANSLATION DEBUG] OpenAI translation response:") - print(f" Translated: {translated[:100]}{'...' if len(translated) > 100 else ''}") - - return translated - - except Exception as e: - print(f"OpenAI translation error: {e}") - raise - - def translate_with_google(self, text: str, target_language: str, - source_language: Optional[str] = None) -> str: - """ - Translate text using Google Translate API - - Args: - text: Text to translate - target_language: Target language code (e.g., 'en', 'es', 'fr') - source_language: Optional source language code - - Returns: - Translated text - """ - if not self.google_api_key: - raise ValueError("Google Translate API key not provided") - - if not text or not text.strip(): - return "" - - try: - if self.debug_logging: - print(f"[TRANSLATION DEBUG] Google translation request:") - print(f" Source: {source_language or 'auto'} -> Target: {target_language}") - print(f" Text: {text[:100]}{'...' if len(text) > 100 else ''}") - - # Google Translate API v2 - url = "https://translation.googleapis.com/language/translate/v2" - params = { - 'key': self.google_api_key, - 'q': text, - 'target': target_language - } - if source_language: - params['source'] = source_language - - response = requests.post(url, params=params, timeout=5) - response.raise_for_status() - - data = response.json() - if 'data' in data and 'translations' in data['data']: - translated = data['data']['translations'][0]['translatedText'] - - if self.debug_logging: - print(f"[TRANSLATION DEBUG] Google translation response:") - print(f" Translated: {translated[:100]}{'...' if len(translated) > 100 else ''}") - - return translated - else: - raise ValueError("Unexpected response format from Google Translate API") - - except Exception as e: - print(f"Google translation error: {e}") - raise - - def translate(self, text: str, target_language: str, - source_language: Optional[str] = None) -> str: - """ - Translate text using available service - - Args: - text: Text to translate - target_language: Target language code - source_language: Optional source language code - - Returns: - Translated text - """ - if not text or not text.strip(): - return "" - - # Mock mode: return dummy text without making API calls - if self.mock_mode: - if self.debug_logging: - print(f"[TRANSLATION DEBUG] Mock mode enabled - returning dummy text") - return "dummy text" - - # Check cache - cache_key = self._get_cache_key(text, source_language or 'auto', target_language) - if cache_key in self._cache: - return self._cache[cache_key] - - # Try to translate - translated = "" - error = None - - # Determine which service to use - use_google = self.prefer_google and self.google_api_key - use_openai = self.openai_client is not None - print("Use google:", use_google) - - if self.debug_logging: - print(f"[TRANSLATION DEBUG] translate() called:") - print(f" Text: {text[:100]}{'...' if len(text) > 100 else ''}") - print(f" Source: {source_language or 'auto'} -> Target: {target_language}") - print(f" Using: {'Google' if use_google else 'OpenAI' if use_openai else 'None'}") - - if use_google: - try: - translated = self.translate_with_google(text, target_language, source_language) - except Exception as e: - error = e - if self.debug_logging: - print(f"[TRANSLATION DEBUG] Google translation failed: {e}") - # Fallback to OpenAI if available - if use_openai: - try: - translated = self.translate_with_openai(text, target_language, source_language) - except Exception as e2: - error = e2 - if self.debug_logging: - print(f"[TRANSLATION DEBUG] OpenAI fallback also failed: {e2}") - - elif use_openai: - try: - translated = self.translate_with_openai(text, target_language, source_language) - except Exception as e: - error = e - if self.debug_logging: - print(f"[TRANSLATION DEBUG] OpenAI translation failed: {e}") - - else: - raise ValueError("No translation service available. Provide OpenAI or Google API key.") - - if error and not translated: - raise error - - # Cache the result - if translated: - self._cache[cache_key] = translated - # Limit cache size - if len(self._cache) > 1000: - # Remove oldest entries (simple approach: clear half) - keys_to_remove = list(self._cache.keys())[:500] - for key in keys_to_remove: - del self._cache[key] - - return translated - - def clear_cache(self): - """Clear translation cache""" - self._cache.clear() - diff --git a/src/ui/__init__.py b/src/ui/__init__.py deleted file mode 100644 index ee7136c..0000000 --- a/src/ui/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""User interface module""" - diff --git a/src/ui/components.py b/src/ui/components.py deleted file mode 100644 index 93be101..0000000 --- a/src/ui/components.py +++ /dev/null @@ -1,207 +0,0 @@ -"""UI components for the overlay window""" - -from PyQt6.QtWidgets import QLabel, QVBoxLayout, QWidget, QTextEdit, QHBoxLayout -from PyQt6.QtCore import Qt -from PyQt6.QtGui import QFont, QColor, QPalette, QTextOption - - -class TextDisplay(QLabel): - """Custom label for displaying text with styling""" - - def __init__(self, title: str = "", parent=None): - super().__init__(parent) - self.title = title - self._setup_ui() - - def _setup_ui(self): - """Set up the label styling""" - self.setWordWrap(True) - self.setAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignTop) - self.setStyleSheet(""" - QLabel { - background-color: rgba(30, 30, 30, 200); - color: white; - padding: 8px; - border-radius: 4px; - border: 1px solid rgba(255, 255, 255, 50); - } - """) - - # Set font - font = QFont("Arial", 10) - self.setFont(font) - - def set_title(self, title: str): - """Set the title/label for this display""" - self.title = title - - def set_text(self, text: str): - """Set the text content""" - if self.title: - display_text = f"{self.title}:
{text}" - else: - display_text = text - self.setText(display_text) - - def clear_text(self): - """Clear the text""" - if self.title: - self.setText(f"{self.title}:") - else: - self.setText("") - - -class ScrollingTextDisplay(QWidget): - """Scrolling text display that appends text instead of replacing it""" - - def __init__(self, title: str = "", parent=None): - super().__init__(parent) - self.title = title - self._setup_ui() - - def _setup_ui(self): - """Set up the scrolling text display""" - self.layout = QVBoxLayout() - self.layout.setContentsMargins(0, 0, 0, 0) - self.layout.setSpacing(4) - - # Title label (always create, show if title is set) - self.title_label = QLabel() - self.title_label.setStyleSheet(""" - QLabel { - color: white; - background-color: transparent; - padding: 0px; - } - """) - font = QFont("Arial", 10, QFont.Weight.Bold) - self.title_label.setFont(font) - if self.title: - self.title_label.setText(f"{self.title}:") - self.title_label.show() - else: - self.title_label.hide() - self.layout.addWidget(self.title_label) - - # Scrolling text edit - self.text_edit = QTextEdit() - self.text_edit.setReadOnly(True) - self.text_edit.setWordWrapMode(QTextOption.WrapMode.WordWrap) - self.text_edit.setStyleSheet(""" - QTextEdit { - background-color: rgba(30, 30, 30, 200); - color: white; - padding: 8px; - border-radius: 4px; - border: 1px solid rgba(255, 255, 255, 50); - } - """) - - # Set font - font = QFont("Arial", 10) - self.text_edit.setFont(font) - - # Set minimum height for better visibility - self.text_edit.setMinimumHeight(100) - self.text_edit.setMaximumHeight(300) - - self.layout.addWidget(self.text_edit) - self.setLayout(self.layout) - - def set_title(self, title: str): - """Set the title/label for this display""" - self.title = title - if self.title: - self.title_label.setText(f"{self.title}:") - self.title_label.show() - else: - self.title_label.hide() - - def append_text(self, text: str): - """Append text to the display (scrolls to bottom automatically)""" - if text: - # Get current text to check if we need to append to it - current_text = self.text_edit.toPlainText() - - if current_text: - # Always add a new paragrpah - self.text_edit.append(text) - else: - # First text - just set it - self.text_edit.setPlainText(text) - - # Scroll to bottom - scrollbar = self.text_edit.verticalScrollBar() - scrollbar.setValue(scrollbar.maximum()) - - def set_text(self, text: str): - """Set the text content (replaces existing text)""" - self.text_edit.setPlainText(text) - # Scroll to bottom - scrollbar = self.text_edit.verticalScrollBar() - scrollbar.setValue(scrollbar.maximum()) - - def clear_text(self): - """Clear the text""" - self.text_edit.clear() - - -class OverlayPanel(QWidget): - """Panel containing multiple text displays""" - - def __init__(self, parent=None): - super().__init__(parent) - self._setup_ui() - - def _setup_ui(self): - """Set up the panel layout""" - layout = QVBoxLayout() - layout.setSpacing(8) - layout.setContentsMargins(10, 10, 10, 10) - - # Create text displays - use ScrollingTextDisplay for original transcript and translated text - self.original_display = ScrollingTextDisplay("Original", self) - self.translated_display = ScrollingTextDisplay("Translated", self) - self.response_original_display = TextDisplay("Suggested Response (Original)", self) - self.response_translated_display = TextDisplay("Suggested Response (Your Language)", self) - - # Add to layout - layout.addWidget(self.original_display) - layout.addWidget(self.translated_display) - layout.addWidget(self.response_original_display) - layout.addWidget(self.response_translated_display) - - # Add stretch at the end - layout.addStretch() - - self.setLayout(layout) - - def update_original(self, text: str, language: str = ""): - """Update original text display - appends new transcriptions""" - print(f"Updating original text display: {text}") - if language: - self.original_display.set_title(f"Original ({language})") - self.original_display.append_text(text) - - def update_translated(self, text: str): - """Update translated text display - appends new translations""" - print(f"Updating translated text display: {text}") - self.translated_display.append_text(text) - - def update_response_original(self, text: str): - print(f"Updating original language response display: {text}") - """Update original language response display""" - self.response_original_display.set_text(text) - - def update_response_translated(self, text: str): - """Update translated response display""" - print(f"Updating translated response display: {text}") - self.response_translated_display.set_text(text) - - def clear_all(self): - """Clear all displays""" - self.original_display.clear_text() - self.translated_display.clear_text() - self.response_original_display.clear_text() - self.response_translated_display.clear_text() - diff --git a/src/ui/overlay_window.py b/src/ui/overlay_window.py deleted file mode 100644 index 354e1e4..0000000 --- a/src/ui/overlay_window.py +++ /dev/null @@ -1,378 +0,0 @@ -"""Transparent overlay window for displaying translations and responses""" - -from PyQt6.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout, QPushButton, QLabel -from PyQt6.QtCore import Qt, QPoint, QTimer, pyqtSignal -from PyQt6.QtGui import QFont, QMouseEvent, QKeySequence, QShortcut -from .components import OverlayPanel -import platform - - -class OverlayWindow(QWidget): - """Transparent overlay window that stays on top""" - - # Signal emitted when window should be hidden/shown - visibility_changed = pyqtSignal(bool) - # Signal emitted when quit is requested - quit_requested = pyqtSignal() - # Signal emitted when start/stop button is clicked - start_stop_requested = pyqtSignal() - # Thread-safe signal for delivering translation results to the main thread - translation_result_ready = pyqtSignal(str, str, str) - - def __init__(self, opacity: float = 0.9, parent=None): - super().__init__(parent) - self.opacity = opacity - self.drag_position = QPoint() - self.is_dragging = False - self._setup_ui() - self.translation_result_ready.connect(self._apply_translation_result) - - def _setup_ui(self): - """Set up the overlay window""" - # Set window flags for transparency and always on top - self.setWindowFlags( - Qt.WindowType.FramelessWindowHint | - Qt.WindowType.WindowStaysOnTopHint | - Qt.WindowType.Tool - ) - - # Enable transparency - self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True) - self.setWindowOpacity(self.opacity) - - # Make window invisible to screen capture (Windows only) - self._set_screen_capture_exclusion() - - # Set window size - self.setMinimumSize(400, 550) - self.resize(400, 650) - - # Main layout - main_layout = QVBoxLayout() - main_layout.setContentsMargins(0, 0, 0, 0) - main_layout.setSpacing(0) - - # Title bar (for dragging) - title_bar = self._create_title_bar() - main_layout.addWidget(title_bar) - - # Control panel with Start/Stop button - control_panel = self._create_control_panel() - main_layout.addWidget(control_panel) - - # Content panel - self.panel = OverlayPanel(self) - main_layout.addWidget(self.panel) - - self.setLayout(main_layout) - - # Style the window - self.setStyleSheet(""" - QWidget { - background-color: rgba(20, 20, 20, 230); - border-radius: 8px; - } - """) - - # Add keyboard shortcuts - self._setup_shortcuts() - - def _create_title_bar(self) -> QWidget: - """Create a draggable title bar""" - title_widget = QWidget() - title_widget.setFixedHeight(30) - title_widget.setStyleSheet(""" - QWidget { - background-color: rgba(40, 40, 40, 255); - border-top-left-radius: 8px; - border-top-right-radius: 8px; - } - """) - - layout = QHBoxLayout() - layout.setContentsMargins(10, 5, 10, 5) - - # Title label - title_label = QLabel("Polyglot") - title_label.setStyleSheet("color: white; font-weight: bold;") - title_label.setFont(QFont("Arial", 10)) - layout.addWidget(title_label) - - layout.addStretch() - - # Settings button - self.settings_btn = QPushButton("⚙") - self.settings_btn.setFixedSize(20, 20) - self.settings_btn.setToolTip("Settings") - self.settings_btn.setStyleSheet(""" - QPushButton { - background-color: rgba(60, 60, 60, 255); - color: white; - border: none; - border-radius: 3px; - } - QPushButton:hover { - background-color: rgba(80, 80, 80, 255); - } - """) - layout.addWidget(self.settings_btn) - - # Minimize button - self.minimize_btn = QPushButton("−") - self.minimize_btn.setFixedSize(20, 20) - self.minimize_btn.setToolTip("Minimize") - self.minimize_btn.setStyleSheet(""" - QPushButton { - background-color: rgba(60, 60, 60, 255); - color: white; - border: none; - border-radius: 3px; - } - QPushButton:hover { - background-color: rgba(80, 80, 80, 255); - } - """) - self.minimize_btn.clicked.connect(self.hide) - layout.addWidget(self.minimize_btn) - - # Close/Quit button - self.close_btn = QPushButton("×") - self.close_btn.setFixedSize(20, 20) - self.close_btn.setToolTip("Quit Application") - self.close_btn.setStyleSheet(""" - QPushButton { - background-color: rgba(200, 60, 60, 255); - color: white; - border: none; - border-radius: 3px; - } - QPushButton:hover { - background-color: rgba(220, 80, 80, 255); - } - """) - layout.addWidget(self.close_btn) - - title_widget.setLayout(layout) - return title_widget - - def _create_control_panel(self) -> QWidget: - """Create control panel with Start/Stop button""" - control_widget = QWidget() - control_widget.setFixedHeight(50) - control_widget.setStyleSheet(""" - QWidget { - background-color: rgba(30, 30, 30, 255); - } - """) - - layout = QHBoxLayout() - layout.setContentsMargins(10, 5, 10, 5) - layout.setSpacing(10) - - # Status label - self.status_label = QLabel("Ready - Configure settings and press Start") - self.status_label.setStyleSheet("color: #aaa; font-size: 9pt;") - self.status_label.setFont(QFont("Arial", 9)) - layout.addWidget(self.status_label) - - layout.addStretch() - - # Start/Stop button - self.start_stop_btn = QPushButton("Start") - self.start_stop_btn.setFixedSize(80, 30) - self.start_stop_btn.setStyleSheet(""" - QPushButton { - background-color: #4a9eff; - color: white; - border: none; - border-radius: 4px; - font-weight: bold; - } - QPushButton:hover { - background-color: #5aaeff; - } - QPushButton:pressed { - background-color: #3a8eef; - } - """) - self.start_stop_btn.clicked.connect(self.start_stop_requested.emit) - layout.addWidget(self.start_stop_btn) - - control_widget.setLayout(layout) - return control_widget - - def mousePressEvent(self, event: QMouseEvent): - """Handle mouse press for window dragging""" - if event.button() == Qt.MouseButton.LeftButton: - self.drag_position = event.globalPosition().toPoint() - self.frameGeometry().topLeft() - self.is_dragging = True - event.accept() - - def mouseMoveEvent(self, event: QMouseEvent): - """Handle mouse move for window dragging""" - if self.is_dragging and event.buttons() == Qt.MouseButton.LeftButton: - self.move(event.globalPosition().toPoint() - self.drag_position) - event.accept() - - def mouseReleaseEvent(self, event: QMouseEvent): - """Handle mouse release""" - self.is_dragging = False - event.accept() - - def update_original_text(self, text: str, language: str = ""): - """Update original language text""" - self.panel.update_original(text, language) - - def update_translated_text(self, text: str): - """Update translated text""" - self.panel.update_translated(text) - - def update_response_original(self, text: str): - """Update original language response""" - self.panel.update_response_original(text) - - def update_response_translated(self, text: str): - """Update translated response""" - self.panel.update_response_translated(text) - - def _apply_translation_result(self, translated_text: str, response_original: str, response_translated: str): - """Apply translation results to UI (invoked on main thread via queued signal connection)""" - if translated_text: - self.panel.update_translated(translated_text) - if response_original: - self.panel.update_response_original(response_original) - if response_translated: - self.panel.update_response_translated(response_translated) - - def clear_all(self): - """Clear all text displays""" - self.panel.clear_all() - - def set_opacity(self, opacity: float): - """Set window opacity (0.0 to 1.0)""" - self.opacity = max(0.0, min(1.0, opacity)) - self.setWindowOpacity(self.opacity) - - def set_position(self, x: int, y: int): - """Set window position""" - self.move(x, y) - - def get_position(self) -> tuple[int, int]: - """Get current window position""" - pos = self.pos() - return (pos.x(), pos.y()) - - def set_capture_status(self, is_capturing: bool, status_message: str = ""): - """ - Update the capture status and button - - Args: - is_capturing: True if capturing, False if stopped - status_message: Optional status message to display - """ - if is_capturing: - self.start_stop_btn.setText("Stop") - self.start_stop_btn.setStyleSheet(""" - QPushButton { - background-color: #e74c3c; - color: white; - border: none; - border-radius: 4px; - font-weight: bold; - } - QPushButton:hover { - background-color: #c0392b; - } - QPushButton:pressed { - background-color: #a93226; - } - """) - if status_message: - self.status_label.setText(f"● Recording - {status_message}") - else: - self.status_label.setText("● Recording...") - self.status_label.setStyleSheet("color: #4a9eff; font-size: 9pt; font-weight: bold;") - else: - self.start_stop_btn.setText("Start") - self.start_stop_btn.setStyleSheet(""" - QPushButton { - background-color: #4a9eff; - color: white; - border: none; - border-radius: 4px; - font-weight: bold; - } - QPushButton:hover { - background-color: #5aaeff; - } - QPushButton:pressed { - background-color: #3a8eef; - } - """) - if status_message: - self.status_label.setText(f"Stopped - {status_message}") - else: - self.status_label.setText("Ready - Press Start to begin") - self.status_label.setStyleSheet("color: #aaa; font-size: 9pt;") - - def showEvent(self, event): - """Handle show event""" - super().showEvent(event) - # Re-apply screen capture exclusion after showing - self._set_screen_capture_exclusion() - self.visibility_changed.emit(True) - - def hideEvent(self, event): - """Handle hide event""" - super().hideEvent(event) - self.visibility_changed.emit(False) - - def _setup_shortcuts(self): - """Set up keyboard shortcuts""" - # Ctrl+Q to quit - quit_shortcut = QShortcut(QKeySequence("Ctrl+Q"), self) - quit_shortcut.activated.connect(self.quit_requested.emit) - - # Escape to hide - hide_shortcut = QShortcut(QKeySequence("Escape"), self) - hide_shortcut.activated.connect(self.hide) - - def _set_screen_capture_exclusion(self): - """Make window invisible to screen capture while visible to user""" - if platform.system() == "Windows": - try: - import ctypes - - # Get window handle (need to get the actual HWND) - hwnd = int(self.winId()) - - # SetWindowDisplayAffinity is available on Windows 10 version 2004+ - # WDA_EXCLUDEFROMCAPTURE = 0x00000011 - WDA_EXCLUDEFROMCAPTURE = 0x11 - - # Try to set display affinity to exclude from capture - result = ctypes.windll.user32.SetWindowDisplayAffinity(hwnd, WDA_EXCLUDEFROMCAPTURE) - if result: - print("Window set to be excluded from screen capture") - else: - # Get last error - error = ctypes.get_last_error() - if error != 0: - print(f"Could not set screen capture exclusion (error {error})") - else: - print("SetWindowDisplayAffinity not available on this Windows version") - - except (AttributeError, OSError) as e: - # Function not available or other error - print(f"Could not set screen capture exclusion: {e}") - print("Note: This feature requires Windows 10 version 2004 or later") - elif platform.system() == "Darwin": # macOS - try: - # On macOS, screen capture exclusion is handled differently - # We can use NSWindow's sharingType property via PyObjC if available - # For now, the transparent window should be less visible in captures - pass - except Exception as e: - print(f"Could not set screen capture exclusion: {e}") - - diff --git a/src/ui/settings_dialog.py b/src/ui/settings_dialog.py deleted file mode 100644 index 5d4daf3..0000000 --- a/src/ui/settings_dialog.py +++ /dev/null @@ -1,432 +0,0 @@ -"""Settings dialog for audio device and language selection""" - -from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, - QComboBox, QPushButton, QGroupBox, QCheckBox, - QSpinBox, QDoubleSpinBox, QSlider) -from PyQt6.QtCore import Qt, pyqtSignal -from PyQt6.QtGui import QFont -from typing import List, Dict, Optional - - -class SettingsDialog(QDialog): - """Settings dialog for configuring audio device and languages""" - - settings_changed = pyqtSignal(int, str, bool, int, float, str, str, float, bool, bool, bool, bool) - # device_id, target_language, auto_detect, sample_rate, chunk_duration, - # whisper_model_size, whisper_device, window_opacity, dump_audio, transcript_only, debug_logging, mock_mode - - def __init__(self, audio_devices: List[Dict], current_device_id: Optional[int], - current_target_language: str, current_auto_detect: bool = True, - current_sample_rate: int = 16000, current_chunk_duration: float = 5.0, - current_whisper_model_size: str = "base", current_whisper_device: str = "auto", - current_window_opacity: float = 0.9, current_dump_audio: bool = False, - current_transcript_only: bool = False, current_debug_logging: bool = False, - current_mock_mode: bool = False, parent=None): - super().__init__(parent) - self.audio_devices = audio_devices - self.current_device_id = current_device_id - self.current_target_language = current_target_language - self.current_auto_detect = current_auto_detect - self.current_sample_rate = current_sample_rate - self.current_chunk_duration = current_chunk_duration - self.current_whisper_model_size = current_whisper_model_size - self.current_whisper_device = current_whisper_device - self.current_window_opacity = current_window_opacity - self.current_dump_audio = current_dump_audio - self.current_transcript_only = current_transcript_only - self.current_debug_logging = current_debug_logging - self.current_mock_mode = current_mock_mode - self._setup_ui() - - def _setup_ui(self): - """Set up the settings dialog UI""" - self.setWindowTitle("Polyglot Settings") - self.setMinimumSize(450, 700) - self.setModal(True) - - # Style - self.setStyleSheet(""" - QDialog { - background-color: #2b2b2b; - } - QLabel { - color: white; - } - QComboBox { - background-color: #3c3c3c; - color: white; - padding: 5px; - border: 1px solid #555; - border-radius: 4px; - } - QComboBox:hover { - border: 1px solid #777; - } - QComboBox::drop-down { - border: none; - } - QComboBox QAbstractItemView { - background-color: #3c3c3c; - color: white; - selection-background-color: #555; - } - QPushButton { - background-color: #4a9eff; - color: white; - padding: 8px 20px; - border: none; - border-radius: 4px; - font-weight: bold; - } - QPushButton:hover { - background-color: #5aaeff; - } - QPushButton:pressed { - background-color: #3a8eef; - } - QGroupBox { - color: white; - border: 1px solid #555; - border-radius: 4px; - margin-top: 10px; - padding-top: 10px; - } - QGroupBox::title { - subcontrol-origin: margin; - left: 10px; - padding: 0 5px; - } - QCheckBox { - color: white; - spacing: 8px; - } - QCheckBox::indicator { - width: 18px; - height: 18px; - border: 2px solid #555; - border-radius: 3px; - background-color: #3c3c3c; - } - QCheckBox::indicator:hover { - border: 2px solid #777; - } - QCheckBox::indicator:checked { - background-color: #4a9eff; - border: 2px solid #4a9eff; - } - QCheckBox::indicator:checked:hover { - background-color: #5aaeff; - border: 2px solid #5aaeff; - } - QSpinBox, QDoubleSpinBox { - background-color: #3c3c3c; - color: white; - padding: 5px; - border: 1px solid #555; - border-radius: 4px; - } - QSpinBox:hover, QDoubleSpinBox:hover { - border: 1px solid #777; - } - QSlider::groove:horizontal { - background: #3c3c3c; - height: 8px; - border-radius: 4px; - } - QSlider::handle:horizontal { - background: #4a9eff; - width: 18px; - height: 18px; - margin: -5px 0; - border-radius: 9px; - } - QSlider::handle:horizontal:hover { - background: #5aaeff; - } - """) - - layout = QVBoxLayout() - layout.setSpacing(15) - layout.setContentsMargins(20, 20, 20, 20) - - # Audio Device Selection - audio_group = QGroupBox("Audio Device") - audio_layout = QVBoxLayout() - audio_layout.setSpacing(10) - - audio_label = QLabel("Select audio input device:") - audio_label.setFont(QFont("Arial", 10)) - audio_layout.addWidget(audio_label) - - self.audio_combo = QComboBox() - self.audio_combo.setFont(QFont("Arial", 9)) - - # Add "Default" option first - self.audio_combo.addItem("Default (Auto-detect)", None) - - # Add devices to combo box - # Filter to show only input-capable devices or loopback devices - for device in self.audio_devices: - device_name = device['name'] - device_id = device['id'] - is_input = device.get('is_input', False) - is_loopback = 'loopback' in device_name.lower() - is_virtual = any(kw in device_name.lower() for kw in ['vb-audio', 'virtual', 'blackhole', 'soundflower', 'obs', 'voicemeeter']) - - # Show input devices, loopback devices, or virtual devices - if is_input or is_loopback or is_virtual: - display_name = device_name - if is_loopback or is_virtual: - display_name += " (Recommended for system audio)" - - self.audio_combo.addItem(display_name, device_id) - - # Set current selection - if self.current_device_id is not None: - index = self.audio_combo.findData(self.current_device_id) - if index >= 0: - self.audio_combo.setCurrentIndex(index) - - audio_layout.addWidget(self.audio_combo) - audio_group.setLayout(audio_layout) - layout.addWidget(audio_group) - - # Language Selection - language_group = QGroupBox("Language") - language_layout = QVBoxLayout() - language_layout.setSpacing(10) - - language_label = QLabel("Target language (your language):") - language_label.setFont(QFont("Arial", 10)) - language_layout.addWidget(language_label) - - self.language_combo = QComboBox() - self.language_combo.setFont(QFont("Arial", 9)) - - # Common languages - languages = [ - ("English", "en"), - ("Spanish", "es"), - ("French", "fr"), - ("German", "de"), - ("Italian", "it"), - ("Portuguese", "pt"), - ("Chinese (Simplified)", "zh"), - ("Chinese (Traditional)", "zh-TW"), - ("Japanese", "ja"), - ("Korean", "ko"), - ("Russian", "ru"), - ("Arabic", "ar"), - ("Hindi", "hi"), - ("Dutch", "nl"), - ("Polish", "pl"), - ("Turkish", "tr"), - ("Vietnamese", "vi"), - ("Thai", "th"), - ] - - for lang_name, lang_code in languages: - self.language_combo.addItem(lang_name, lang_code) - - # Set current selection - index = self.language_combo.findData(self.current_target_language) - if index >= 0: - self.language_combo.setCurrentIndex(index) - else: - # Default to English - self.language_combo.setCurrentIndex(0) - - language_layout.addWidget(self.language_combo) - - # Auto-detect source language checkbox - self.auto_detect_checkbox = QCheckBox("Auto-detect source language") - self.auto_detect_checkbox.setFont(QFont("Arial", 9)) - self.auto_detect_checkbox.setToolTip("Automatically detect the language being spoken") - self.auto_detect_checkbox.setChecked(self.current_auto_detect) - language_layout.addWidget(self.auto_detect_checkbox) - - language_group.setLayout(language_layout) - layout.addWidget(language_group) - - # Audio Settings - audio_settings_group = QGroupBox("Audio Settings") - audio_settings_layout = QVBoxLayout() - audio_settings_layout.setSpacing(10) - - # Sample Rate - sample_rate_layout = QHBoxLayout() - sample_rate_label = QLabel("Sample Rate (Hz):") - sample_rate_label.setFont(QFont("Arial", 10)) - sample_rate_label.setMinimumWidth(150) - sample_rate_layout.addWidget(sample_rate_label) - - self.sample_rate_combo = QComboBox() - self.sample_rate_combo.setFont(QFont("Arial", 9)) - self.sample_rate_combo.addItems(["8000", "16000", "22050", "44100", "48000"]) - # Set current value - current_sr = str(self.current_sample_rate) - index = self.sample_rate_combo.findText(current_sr) - if index >= 0: - self.sample_rate_combo.setCurrentIndex(index) - else: - self.sample_rate_combo.setCurrentText(current_sr) - sample_rate_layout.addWidget(self.sample_rate_combo) - audio_settings_layout.addLayout(sample_rate_layout) - - # Chunk Duration - chunk_duration_layout = QHBoxLayout() - chunk_duration_label = QLabel("Chunk Duration (sec):") - chunk_duration_label.setFont(QFont("Arial", 10)) - chunk_duration_label.setMinimumWidth(150) - chunk_duration_layout.addWidget(chunk_duration_label) - - self.chunk_duration_spin = QDoubleSpinBox() - self.chunk_duration_spin.setFont(QFont("Arial", 9)) - self.chunk_duration_spin.setRange(1.0, 15.0) - self.chunk_duration_spin.setSingleStep(0.5) - self.chunk_duration_spin.setValue(self.current_chunk_duration) - self.chunk_duration_spin.setDecimals(1) - chunk_duration_layout.addWidget(self.chunk_duration_spin) - audio_settings_layout.addLayout(chunk_duration_layout) - - audio_settings_group.setLayout(audio_settings_layout) - layout.addWidget(audio_settings_group) - - # Whisper Model Settings - whisper_group = QGroupBox("Whisper Model") - whisper_layout = QVBoxLayout() - whisper_layout.setSpacing(10) - - # Model Size - model_size_layout = QHBoxLayout() - model_size_label = QLabel("Model Size:") - model_size_label.setFont(QFont("Arial", 10)) - model_size_label.setMinimumWidth(150) - model_size_layout.addWidget(model_size_label) - - self.whisper_model_combo = QComboBox() - self.whisper_model_combo.setFont(QFont("Arial", 9)) - self.whisper_model_combo.addItems(["tiny", "base", "small", "medium", "large-v2", "large-v3"]) - index = self.whisper_model_combo.findText(self.current_whisper_model_size) - if index >= 0: - self.whisper_model_combo.setCurrentIndex(index) - model_size_layout.addWidget(self.whisper_model_combo) - whisper_layout.addLayout(model_size_layout) - - # Device - device_layout = QHBoxLayout() - device_label = QLabel("Device:") - device_label.setFont(QFont("Arial", 10)) - device_label.setMinimumWidth(150) - device_layout.addWidget(device_label) - - self.whisper_device_combo = QComboBox() - self.whisper_device_combo.setFont(QFont("Arial", 9)) - self.whisper_device_combo.addItems(["auto", "cpu", "cuda"]) - index = self.whisper_device_combo.findText(self.current_whisper_device) - if index >= 0: - self.whisper_device_combo.setCurrentIndex(index) - device_layout.addWidget(self.whisper_device_combo) - whisper_layout.addLayout(device_layout) - - whisper_group.setLayout(whisper_layout) - layout.addWidget(whisper_group) - - # Window Settings - window_group = QGroupBox("Window Settings") - window_layout = QVBoxLayout() - window_layout.setSpacing(10) - - # Opacity - opacity_layout = QHBoxLayout() - opacity_label = QLabel("Opacity:") - opacity_label.setFont(QFont("Arial", 10)) - opacity_label.setMinimumWidth(150) - opacity_layout.addWidget(opacity_label) - - self.opacity_slider = QSlider(Qt.Orientation.Horizontal) - self.opacity_slider.setRange(0, 100) - self.opacity_slider.setValue(int(self.current_window_opacity * 100)) - self.opacity_slider.setToolTip(f"{int(self.current_window_opacity * 100)}%") - self.opacity_slider.valueChanged.connect(lambda v: self.opacity_slider.setToolTip(f"{v}%")) - opacity_layout.addWidget(self.opacity_slider) - - self.opacity_label = QLabel(f"{int(self.current_window_opacity * 100)}%") - self.opacity_label.setFont(QFont("Arial", 9)) - self.opacity_label.setMinimumWidth(40) - self.opacity_slider.valueChanged.connect(lambda v: self.opacity_label.setText(f"{v}%")) - opacity_layout.addWidget(self.opacity_label) - - window_layout.addLayout(opacity_layout) - window_group.setLayout(window_layout) - layout.addWidget(window_group) - - # Debug Settings - debug_group = QGroupBox("Debug Settings") - debug_layout = QVBoxLayout() - debug_layout.setSpacing(10) - - self.dump_audio_checkbox = QCheckBox("Dump audio chunks to file") - self.dump_audio_checkbox.setFont(QFont("Arial", 9)) - self.dump_audio_checkbox.setToolTip("Saves audio chunks to 'dumps' folder with timestamps") - self.dump_audio_checkbox.setChecked(self.current_dump_audio) - debug_layout.addWidget(self.dump_audio_checkbox) - - self.transcript_only_checkbox = QCheckBox("Transcript-only mode") - self.transcript_only_checkbox.setFont(QFont("Arial", 9)) - self.transcript_only_checkbox.setToolTip("Disable translation and GPT responses - show only transcription") - self.transcript_only_checkbox.setChecked(self.current_transcript_only) - debug_layout.addWidget(self.transcript_only_checkbox) - - self.debug_logging_checkbox = QCheckBox("Enable debug logging") - self.debug_logging_checkbox.setFont(QFont("Arial", 9)) - self.debug_logging_checkbox.setToolTip("Print detailed logging for translation and response generation to terminal") - self.debug_logging_checkbox.setChecked(self.current_debug_logging) - debug_layout.addWidget(self.debug_logging_checkbox) - - self.mock_mode_checkbox = QCheckBox("Mock mode (return dummy text)") - self.mock_mode_checkbox.setFont(QFont("Arial", 9)) - self.mock_mode_checkbox.setToolTip("Return 'dummy text' instead of making API calls for translation and responses") - self.mock_mode_checkbox.setChecked(self.current_mock_mode) - debug_layout.addWidget(self.mock_mode_checkbox) - - debug_group.setLayout(debug_layout) - layout.addWidget(debug_group) - - # Buttons - button_layout = QHBoxLayout() - button_layout.addStretch() - - cancel_btn = QPushButton("Cancel") - cancel_btn.clicked.connect(self.reject) - button_layout.addWidget(cancel_btn) - - apply_btn = QPushButton("Apply") - apply_btn.clicked.connect(self._apply_settings) - button_layout.addWidget(apply_btn) - - layout.addLayout(button_layout) - - self.setLayout(layout) - - def _apply_settings(self): - """Apply the selected settings""" - device_id = self.audio_combo.currentData() # Can be None for default - target_language = self.language_combo.currentData() - auto_detect = self.auto_detect_checkbox.isChecked() - sample_rate = int(self.sample_rate_combo.currentText()) - chunk_duration = self.chunk_duration_spin.value() - whisper_model_size = self.whisper_model_combo.currentText() - whisper_device = self.whisper_device_combo.currentText() - window_opacity = self.opacity_slider.value() / 100.0 - dump_audio = self.dump_audio_checkbox.isChecked() - transcript_only = self.transcript_only_checkbox.isChecked() - debug_logging = self.debug_logging_checkbox.isChecked() - mock_mode = self.mock_mode_checkbox.isChecked() - - self.settings_changed.emit( - device_id, target_language, auto_detect, sample_rate, chunk_duration, - whisper_model_size, whisper_device, window_opacity, dump_audio, transcript_only, debug_logging, mock_mode - ) - self.accept() - diff --git a/src/utils/__init__.py b/src/utils/__init__.py deleted file mode 100644 index f4b3564..0000000 --- a/src/utils/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -"""Utility modules""" - diff --git a/src/utils/audio_dump.py b/src/utils/audio_dump.py deleted file mode 100644 index d221e6b..0000000 --- a/src/utils/audio_dump.py +++ /dev/null @@ -1,90 +0,0 @@ -"""Utility for dumping audio chunks to files for debugging""" - -import os -import wave -import numpy as np -from datetime import datetime -from pathlib import Path -from typing import Optional - - -class AudioDumper: - """Handles dumping audio chunks to WAV files for debugging""" - - def __init__(self, dump_folder: str = "dumps", enabled: bool = False): - """ - Initialize audio dumper - - Args: - dump_folder: Folder to save audio chunks - enabled: Whether dumping is enabled - """ - self.dump_folder = Path(dump_folder) - self.enabled = enabled - self.chunk_counter = 0 - - # Create dump folder if it doesn't exist - if self.enabled: - self.dump_folder.mkdir(exist_ok=True) - - def set_enabled(self, enabled: bool): - """Enable or disable audio dumping""" - self.enabled = enabled - if self.enabled: - self.dump_folder.mkdir(exist_ok=True) - - def dump_audio_chunk(self, audio_data: np.ndarray, sample_rate: int = 16000) -> Optional[str]: - """ - Dump audio chunk to WAV file - - Args: - audio_data: Audio samples as numpy array (float32, -1.0 to 1.0) - sample_rate: Sample rate in Hz - - Returns: - Path to saved file if successful, None otherwise - """ - if not self.enabled: - return None - - try: - # Ensure audio is in the correct format - if audio_data.dtype != np.float32: - audio_data = audio_data.astype(np.float32) - - # Normalize to prevent clipping - max_val = np.abs(audio_data).max() - if max_val > 1.0: - audio_data = audio_data / max_val - - # Convert to int16 - audio_int16 = (audio_data * 32767).astype(np.int16) - - # Generate filename with timestamp - timestamp = datetime.now().strftime("%Y%m%d_%H%M%S") - self.chunk_counter += 1 - filename = f"audio_{timestamp}_{self.chunk_counter:04d}.wav" - filepath = self.dump_folder / filename - - # Write WAV file - with wave.open(str(filepath), 'wb') as wav_file: - wav_file.setnchannels(1) # Mono - wav_file.setsampwidth(2) # 16-bit - wav_file.setframerate(sample_rate) - wav_file.writeframes(audio_int16.tobytes()) - - return str(filepath) - - except Exception as e: - print(f"Error dumping audio chunk: {e}") - return None - - def clear_dumps(self): - """Clear all dumped audio files""" - if self.dump_folder.exists(): - for file in self.dump_folder.glob("*.wav"): - try: - file.unlink() - except Exception as e: - print(f"Error deleting {file}: {e}") - diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/adapters/__init__.py b/tests/adapters/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/adapters/test_audio_and_platform.py b/tests/adapters/test_audio_and_platform.py new file mode 100644 index 0000000..5fa1382 --- /dev/null +++ b/tests/adapters/test_audio_and_platform.py @@ -0,0 +1,335 @@ +"""Audio adapters, VAD, platform shield, secrets and dumps.""" + +from __future__ import annotations + +import logging +import sys +import threading +import types +import wave +from pathlib import Path +from typing import Any + +import numpy as np +import pytest + +from polyglot.adapters.audio.playback import ArraySource, WavFileSource, read_wav, write_wav +from polyglot.adapters.audio.resample import IdentityResampler, make_resampler +from polyglot.adapters.dump import SegmentDumper +from polyglot.adapters.fakes import NoopShield, ScriptedVad, silence, speech_like, tone +from polyglot.adapters.secrets import KeyringSecretStore, MemorySecretStore +from polyglot.adapters.vad.energy import EnergyVad +from polyglot.core.errors import AudioSourceError +from polyglot.core.models import FRAME_SAMPLES, SAMPLE_RATE, SpeechSegment +from polyglot.core.ports import ShieldStatus +from polyglot.platform import UnsupportedShield, current, window_shield +from polyglot.platform.windows import MIN_BUILD, WDA_EXCLUDEFROMCAPTURE, WindowsShield + + +class Sink: + def __init__(self) -> None: + self.blocks: list[np.ndarray] = [] + self.ended = threading.Event() + self.errors: list[Exception] = [] + + def on_audio(self, block: np.ndarray) -> None: + self.blocks.append(np.array(block)) + + def on_end(self) -> None: + self.ended.set() + + def on_error(self, error: Exception) -> None: + self.errors.append(error) + + +# ------------------------------------------------------------------ WAV / playback +def test_wav_round_trip_16bit(tmp_path: Path) -> None: + path = tmp_path / "a.wav" + data = tone(0.5, amp=0.5) + write_wav(path, data, SAMPLE_RATE) + back, rate = read_wav(path) + assert rate == SAMPLE_RATE and back.dtype == np.float32 + np.testing.assert_allclose(back, data, atol=1 / 32767 + 1e-6) + + +@pytest.mark.parametrize( + ("width", "dtype", "scale", "offset"), [(1, np.uint8, 127, 128), (4, " None: + path = tmp_path / "s.wav" + frames = np.array([[0.5, -0.5], [0.25, 0.0]], dtype=np.float64) + ints = (frames * scale + offset).astype(dtype) + with wave.open(str(path), "wb") as wf: + wf.setnchannels(2) + wf.setsampwidth(width) + wf.setframerate(8000) + wf.writeframes(ints.tobytes()) + data, rate = read_wav(path) + assert rate == 8000 and data.shape == (2, 2) + np.testing.assert_allclose(data, frames, atol=0.02) + + +def test_wav_24bit(tmp_path: Path) -> None: + path = tmp_path / "24.wav" + vals = np.array([0.5, -0.5, 0.0], dtype=np.float64) + ints = (vals * (2**23 - 1)).astype(np.int32) + raw = b"".join(int(v).to_bytes(4, "little", signed=True)[:3] for v in ints) + with wave.open(str(path), "wb") as wf: + wf.setnchannels(1) + wf.setsampwidth(3) + wf.setframerate(16000) + wf.writeframes(raw) + data, _ = read_wav(path) + np.testing.assert_allclose(data, vals, atol=1e-4) + + +def test_unreadable_wav_is_audio_error(tmp_path: Path) -> None: + bad = tmp_path / "bad.wav" + bad.write_bytes(b"not a wav") + with pytest.raises(AudioSourceError): + read_wav(bad) + with pytest.raises(AudioSourceError): + WavFileSource(tmp_path / "missing.wav") + + +def test_array_source_delivers_everything_then_ends() -> None: + data = np.arange(16000, dtype=np.float32) + src = ArraySource(data, 16000, block_ms=100) + sink = Sink() + src.start(sink) + assert sink.ended.wait(2) + np.testing.assert_array_equal(np.concatenate(sink.blocks), data) + assert all(len(b) == 1600 for b in sink.blocks) + assert src.duration_s == 1.0 + + +def test_array_source_realtime_pacing_and_stop() -> None: + src = ArraySource(np.zeros(16000 * 5, dtype=np.float32), 16000, realtime=True, block_ms=100) + sink = Sink() + src.start(sink) + threading.Event().wait(0.25) + src.stop() + assert 1 <= len(sink.blocks) <= 6 # ~3 blocks in 250 ms, not all 50 + assert not sink.ended.is_set() + + +def test_wav_file_source(tmp_path: Path) -> None: + path = tmp_path / "f.wav" + write_wav(path, tone(0.2), 16000) + src = WavFileSource(path) + assert src.sample_rate == 16000 and src.path == path + + +def test_array_source_rejects_3d() -> None: + with pytest.raises(ValueError): + ArraySource(np.zeros((2, 2, 2), dtype=np.float32), 16000) + + +# ------------------------------------------------------------------ resampling +def test_identity_resampler_flattens() -> None: + r = IdentityResampler() + np.testing.assert_array_equal(r.process(np.ones((3, 1), dtype=np.float32)), np.ones(3)) + assert r.flush().size == 0 + assert isinstance(make_resampler(16000), IdentityResampler) + + +def test_soxr_resampler_streams_48k_to_16k() -> None: + pytest.importorskip("soxr") + r = make_resampler(48000) + sig = tone(1.0, freq=440, rate=48000) + out = np.concatenate( + [r.process(sig[i : i + 960]) for i in range(0, sig.size, 960)] + [r.flush()] + ) + assert abs(out.size - 16000) <= 16 + crossings = np.count_nonzero(np.diff(np.signbit(out[100:-100]))) + assert crossings == pytest.approx(2 * 440 * (out.size - 200) / 16000, rel=0.02) + + +# ------------------------------------------------------------------ VAD +def frames(audio: np.ndarray) -> list[np.ndarray]: + return [ + audio[i : i + FRAME_SAMPLES] + for i in range(0, audio.size - FRAME_SAMPLES + 1, FRAME_SAMPLES) + ] + + +def test_energy_vad_separates_tone_from_silence_and_adapts() -> None: + vad = EnergyVad() + noise = (np.random.default_rng(0).standard_normal(16000) * 0.003).astype(np.float32) + quiet = [vad.speech_prob(f) for f in frames(noise)] + loud = [vad.speech_prob(f) for f in frames(tone(0.5, amp=0.2))] + assert max(quiet) < 0.5 < min(loud) + vad.reset() + assert vad.floor_db == vad.initial_floor_db + assert vad.speech_prob(np.zeros(0, dtype=np.float32)) < 0.01 + + +def test_scripted_vad() -> None: + v = ScriptedVad([0.9, 0.1], default=0.5) + f = silence(0.032) + assert [v.speech_prob(f) for _ in range(3)] == [0.9, 0.1, 0.5] + + +def test_silero_vad_on_silence_and_tone() -> None: + pytest.importorskip("onnxruntime") + pytest.importorskip("faster_whisper") + from polyglot.adapters.vad.silero import SileroVad + + vad = SileroVad() + probs = [vad.speech_prob(f) for f in frames(silence(1.0))] + assert max(probs) < 0.3 + vad.reset() + with pytest.raises(ValueError): + vad.speech_prob(np.zeros(100, dtype=np.float32)) + + +def test_silero_reports_missing_model(tmp_path: Path) -> None: + pytest.importorskip("onnxruntime") + from polyglot.adapters.vad.silero import SileroVad + from polyglot.core.errors import ConfigError + + with pytest.raises(ConfigError): + SileroVad(tmp_path / "nope.onnx") + + +# ------------------------------------------------------------------ Windows shield (fake user32) +class FakeUser32: + def __init__(self, set_ok: bool = True, readback: int = WDA_EXCLUDEFROMCAPTURE) -> None: + self.set_ok, self.readback = set_ok, readback + self.set_calls: list[tuple[int, int]] = [] + + def SetWindowDisplayAffinity(self, hwnd: int, affinity: int) -> int: + self.set_calls.append((hwnd, affinity)) + return int(self.set_ok) + + def GetWindowDisplayAffinity(self, hwnd: int, ref: Any) -> int: + ref._obj.value = self.readback + return 1 + + +def test_shield_hides_on_supported_build() -> None: + api = FakeUser32() + shield = WindowsShield(user32=api, build=MIN_BUILD, last_error=lambda: 0) + assert shield.exclude_from_capture(0x1234) is ShieldStatus.HIDDEN + assert shield.detail == "" + assert api.set_calls == [(0x1234, WDA_EXCLUDEFROMCAPTURE)] + + +def test_shield_skips_old_builds_to_avoid_black_box() -> None: + api = FakeUser32() + assert ( + WindowsShield(user32=api, build=MIN_BUILD - 1).exclude_from_capture(1) + is ShieldStatus.UNSUPPORTED + ) + assert api.set_calls == [] # never called: WDA_MONITOR fallback would show a black box + + +def test_shield_reports_failure_and_bad_readback() -> None: + assert ( + WindowsShield( + user32=FakeUser32(set_ok=False), build=MIN_BUILD, last_error=lambda: 5 + ).exclude_from_capture(1) + is ShieldStatus.FAILED + ) + assert ( + WindowsShield( + user32=FakeUser32(readback=1), build=MIN_BUILD, last_error=lambda: 0 + ).exclude_from_capture(1) + is ShieldStatus.FAILED + ) + + +def test_platform_selection() -> None: + info = current() + shield = window_shield() + if sys.platform == "win32": + assert info.has_loopback and isinstance(shield, WindowsShield) + else: + assert not info.has_loopback + assert isinstance(shield, UnsupportedShield) + assert shield.exclude_from_capture(1) is ShieldStatus.UNSUPPORTED + assert NoopShield(ShieldStatus.HIDDEN).exclude_from_capture(5) is ShieldStatus.HIDDEN + + +# ------------------------------------------------------------------ secrets +def test_memory_secret_store() -> None: + s = MemorySecretStore({"a": "1"}) + assert s.get("a") == "1" and s.get("b") is None + s.set("a", None) + assert s.get("a") is None + + +def test_keyring_store_with_fake_backend(monkeypatch: pytest.MonkeyPatch) -> None: + stored: dict[tuple[str, str], str] = {} + + class KeyringError(Exception): + pass + + class PasswordDeleteError(KeyringError): + pass + + fake = types.ModuleType("keyring") + fake.get_password = lambda svc, name: stored.get((svc, name)) # type: ignore[attr-defined] + fake.set_password = lambda svc, name, v: stored.__setitem__((svc, name), v) # type: ignore[attr-defined] + + def delete(svc: str, name: str) -> None: + if (svc, name) not in stored: + raise PasswordDeleteError + del stored[(svc, name)] + + fake.delete_password = delete # type: ignore[attr-defined] + errors = types.ModuleType("keyring.errors") + errors.KeyringError = KeyringError # type: ignore[attr-defined] + errors.PasswordDeleteError = PasswordDeleteError # type: ignore[attr-defined] + monkeypatch.setitem(sys.modules, "keyring", fake) + monkeypatch.setitem(sys.modules, "keyring.errors", errors) + + store = KeyringSecretStore("polyglot-test") + assert store.get("k") is None + store.set("k", "secret") + assert store.get("k") == "secret" and stored == {("polyglot-test", "k"): "secret"} + store.set("k", None) + store.set("k", None) # deleting twice is fine + assert store.get("k") is None + + +# ------------------------------------------------------------------ dumps / fakes +def test_segment_dumper_writes_wav(tmp_path: Path) -> None: + dumper = SegmentDumper(tmp_path) + dumper(SpeechSegment(7, tone(0.1), 0.0, 0.1, True)) + (path,) = list(dumper.folder.glob("*.wav")) + assert path.name == "utt-00007.wav" + data, rate = read_wav(path) + assert rate == SAMPLE_RATE and data.size == 1600 + + +def test_speech_like_pads_to_whole_frames() -> None: + audio = speech_like([("tone", 0.1), ("silence", 0.05)]) + assert audio.size % FRAME_SAMPLES == 0 + assert audio.size >= int(0.15 * SAMPLE_RATE) + + +def test_whisper_adapter_uses_auto_compute_type_and_reports_the_choice( + monkeypatch: pytest.MonkeyPatch, caplog: pytest.LogCaptureFixture +) -> None: + """Runs without faster-whisper: a stand-in module records how the model is built.""" + from polyglot.adapters.asr.faster_whisper import FasterWhisperTranscriber + + built: dict[str, Any] = {} + + class FakeWhisperModel: + def __init__(self, name: str, **kwargs: Any) -> None: + built.update(kwargs, name=name) + self.model = types.SimpleNamespace(device="cpu", compute_type="int8") + + monkeypatch.setitem( + sys.modules, "faster_whisper", types.SimpleNamespace(WhisperModel=FakeWhisperModel) + ) + t = FasterWhisperTranscriber("base") + with caplog.at_level(logging.INFO, logger="polyglot.adapters.asr.faster_whisper"): + t.load() + assert built["compute_type"] == "auto" and built["name"] == "base" + assert (t.effective_device, t.effective_compute_type) == ("cpu", "int8") + assert "loaded on cpu as int8" in caplog.text diff --git a/tests/adapters/test_openai_models.py b/tests/adapters/test_openai_models.py new file mode 100644 index 0000000..22de780 --- /dev/null +++ b/tests/adapters/test_openai_models.py @@ -0,0 +1,212 @@ +"""Model list, per-model request options and the unsupported-parameter fallback.""" + +from __future__ import annotations + +import json +import urllib.request +from collections.abc import Iterator +from typing import Any + +import pytest + +from polyglot.adapters.http import HttpResponse, UrllibHttpClient +from polyglot.adapters.openai_models import ( + KNOWN_MODELS, + MEMORY, + OpenAIModelCatalog, + chat_options, + is_text_chat_model, + list_chat_models, + uses_temperature, +) +from polyglot.adapters.suggest.openai import OpenAISuggester +from polyglot.adapters.translate.openai import OpenAITranslator +from polyglot.core.errors import AuthError, BadResponse, ProviderError +from polyglot.core.models import ConversationType, SuggestionContext, Utterance, UtteranceStatus + + +class FakeHttp: + def __init__(self, *responses: HttpResponse) -> None: + self.responses = list(responses) + self.posts: list[dict[str, Any]] = [] + self.gets: list[dict[str, Any]] = [] + + def post_json(self, url: str, payload: dict[str, Any], *, headers: dict[str, str] | None = None, + params: dict[str, str] | None = None, timeout: float) -> HttpResponse: # fmt: skip + self.posts.append({"url": url, "payload": dict(payload)}) + return self.responses.pop(0) + + def get_json( + self, url: str, *, headers: dict[str, str] | None = None, timeout: float + ) -> HttpResponse: + self.gets.append({"url": url, "headers": headers, "timeout": timeout}) + return self.responses.pop(0) + + +def ok(content: str = "Hello") -> HttpResponse: + return HttpResponse(200, json.dumps({"choices": [{"message": {"content": content}}]})) + + +def rejected(param: str, code: str = "unsupported_value") -> HttpResponse: + body = {"error": {"message": f"bad {param}", "param": param, "code": code}} + return HttpResponse(400, json.dumps(body)) + + +@pytest.fixture(autouse=True) +def _fresh_memory() -> Iterator[None]: + MEMORY.clear() + yield + MEMORY.clear() + + +# ------------------------------------------------------------------ request options +@pytest.mark.parametrize( + ("model", "legacy"), + [("gpt-4o-mini", True), ("gpt-4.1-mini", True), ("gpt-4o", True), ("gpt-6-luna", False), + ("gpt-5-mini", False), ("o4-mini", False), ("some-future-model", False)], +) # fmt: skip +def test_options_follow_the_model_family(model: str, legacy: bool) -> None: + assert uses_temperature(model) is legacy + opts = chat_options(model, temperature=0.2, effort="none") + assert opts == ({"temperature": 0.2} if legacy else {"reasoning_effort": "none"}) + + +def test_translator_sends_temperature_only_to_older_models() -> None: + http = FakeHttp(ok(), ok()) + OpenAITranslator("k", model="gpt-4o-mini", http=http).translate("hola", "es", "en", timeout=3) + OpenAITranslator("k", model="gpt-6-luna", http=http).translate("hola", "es", "en", timeout=3) + old, new = (r["payload"] for r in http.posts) + assert old["temperature"] == 0.2 and "reasoning_effort" not in old + assert new["reasoning_effort"] == "none" and "temperature" not in new + + +def test_suggester_uses_low_effort_on_reasoning_models() -> None: + content = json.dumps({"options": [{"source_text": "Sí", "user_text": "Yes"}]}) + http = FakeHttp(ok(content)) + target = Utterance(1, 0, 1, UtteranceStatus.TRANSLATED, "¿Listo?", "es", "Ready?") + ctx = SuggestionContext( + target=target, history=(), source_language="Spanish", user_language="English", + conversation_type=ConversationType.MEETING, max_options=1, + ) # fmt: skip + OpenAISuggester("k", model="gpt-6-luna", http=http).suggest(ctx, timeout=6) + payload = http.posts[0]["payload"] + assert payload["reasoning_effort"] == "low" and "temperature" not in payload + + +def test_rejected_effort_steps_down_then_is_remembered() -> None: + http = FakeHttp(rejected("reasoning_effort"), ok("one"), ok("two")) + t = OpenAITranslator("k", model="gpt-5-mini", http=http) + assert t.translate("uno", "es", "en", timeout=3) == "one" + assert [r["payload"]["reasoning_effort"] for r in http.posts] == ["none", "minimal"] + assert t.translate("dos", "es", "en", timeout=3) == "two" + assert http.posts[2]["payload"]["reasoning_effort"] == "minimal" # no second rejection + + +def test_effort_is_dropped_after_the_last_fallback() -> None: + http = FakeHttp(*(rejected("reasoning_effort") for _ in range(3)), ok()) + OpenAITranslator("k", model="odd-model", http=http).translate("x", None, "en", timeout=3) + efforts = [r["payload"].get("reasoning_effort") for r in http.posts] + assert efforts == ["none", "minimal", "low", None] + + +def test_rejected_temperature_is_dropped_and_remembered() -> None: + http = FakeHttp(rejected("temperature", "unsupported_parameter"), ok(), ok()) + t = OpenAITranslator("k", model="gpt-4o-mini", http=http) + t.translate("a", None, "en", timeout=3) + t.translate("b", None, "en", timeout=3) + assert "temperature" in http.posts[0]["payload"] + assert "temperature" not in http.posts[1]["payload"] + assert "temperature" not in http.posts[2]["payload"] + + +def test_other_bad_requests_are_not_retried() -> None: + http = FakeHttp(rejected("messages", "invalid_type")) + with pytest.raises(ProviderError): + OpenAITranslator("k", model="gpt-6-luna", http=http).translate("x", None, "en", timeout=3) + assert len(http.posts) == 1 + + +# ------------------------------------------------------------------ model list +def test_model_list_keeps_general_text_models_known_first() -> None: + ids = [ + "gpt-7-nova", "gpt-6-luna", "gpt-4o-mini", "o4-mini", "gpt-4o-mini-2024-07-18", + "gpt-realtime-2", "gpt-4o-mini-tts", "gpt-transcribe", "text-embedding-3-small", + "gpt-image-2.5-flare", "dall-e-3", "gpt-5.3-codex", "whisper-1", "gpt-6.1-sol", + "omni-moderation-latest", "gpt-live-1", + ] # fmt: skip + http = FakeHttp(HttpResponse(200, json.dumps({"data": [{"id": i} for i in ids]}))) + models = list_chat_models("sk", http=http, timeout=4) + assert [m.id for m in models] == [ + "gpt-6-luna", + "gpt-6.1-sol", + "gpt-4o-mini", + "gpt-7-nova", + "o4-mini", + ] + assert http.gets[0]["url"] == "https://api.openai.com/v1/models" + assert http.gets[0]["headers"] == {"Authorization": "Bearer sk"} + assert "Retires 2027-01-14" in next(m.note for m in models if m.id == "gpt-4o-mini") + + +@pytest.mark.parametrize( + "model_id", ["gpt-4o-audio-preview", "gpt-4o-search-preview", "babbage-002"] +) +def test_specialist_models_are_filtered(model_id: str) -> None: + assert not is_text_chat_model(model_id) + + +def test_model_list_errors_are_typed() -> None: + with pytest.raises(AuthError): + list_chat_models("bad", http=FakeHttp(HttpResponse(401, "{}"))) + with pytest.raises(BadResponse): + list_chat_models("k", http=FakeHttp(HttpResponse(200, '{"object": "list"}'))) + + +def test_catalog_caches_per_key() -> None: + body = json.dumps({"data": [{"id": "gpt-6-luna"}]}) + http = FakeHttp(HttpResponse(200, body)) + catalog = OpenAIModelCatalog(http=http) + assert catalog.known() == list(KNOWN_MODELS) + assert catalog.cached("k") is None + assert [m.id for m in catalog.fetch("k")] == ["gpt-6-luna"] + assert [m.id for m in catalog.cached("k") or []] == ["gpt-6-luna"] + assert catalog.cached("other") is None + + +def test_default_models_are_in_the_built_in_list() -> None: + from polyglot.config import SuggestionsConfig, TranslationConfig + + ids = {m.id for m in KNOWN_MODELS} + assert TranslationConfig().model in ids and SuggestionsConfig().model in ids + + +# ------------------------------------------------------------------ GET transport +def test_get_json_refuses_plain_http() -> None: + with pytest.raises(ProviderError): + UrllibHttpClient().get_json("http://api.openai.com/v1/models", timeout=1) + + +def test_get_json_sends_a_get_without_body(monkeypatch: pytest.MonkeyPatch) -> None: + seen: dict[str, Any] = {} + + class Resp: + status = 200 + + def read(self) -> bytes: + return b'{"data": []}' + + def __enter__(self) -> Resp: + return self + + def __exit__(self, *a: object) -> None: + return None + + def fake_urlopen(req: urllib.request.Request, timeout: float) -> Resp: + seen.update(method=req.get_method(), data=req.data, auth=req.get_header("Authorization")) + return Resp() + + monkeypatch.setattr(urllib.request, "urlopen", fake_urlopen) + resp = UrllibHttpClient().get_json( + "https://api.openai.com/v1/models", headers={"Authorization": "Bearer k"}, timeout=2 + ) + assert resp.status == 200 and seen == {"method": "GET", "data": None, "auth": "Bearer k"} diff --git a/tests/adapters/test_providers.py b/tests/adapters/test_providers.py new file mode 100644 index 0000000..10c7360 --- /dev/null +++ b/tests/adapters/test_providers.py @@ -0,0 +1,313 @@ +"""Translation/suggestion providers and the HTTP layer, against a fake transport.""" + +from __future__ import annotations + +import json +import urllib.error +from typing import Any + +import pytest + +from polyglot.adapters.http import HttpResponse, UrllibHttpClient, raise_for_status +from polyglot.adapters.suggest.openai import SCHEMA, OpenAISuggester, build_messages, parse_options +from polyglot.adapters.translate.google import GoogleTranslator +from polyglot.adapters.translate.openai import OpenAITranslator +from polyglot.core.errors import ( + AuthError, + BadResponse, + ProviderError, + ProviderTimeout, + ProviderUnavailable, + QuotaExceeded, +) +from polyglot.core.models import ( + ConversationType, + SuggestionContext, + Utterance, + UtteranceStatus, +) + + +class FakeHttp: + def __init__(self, *responses: HttpResponse) -> None: + self.responses = list(responses) + self.requests: list[dict[str, Any]] = [] + + def post_json(self, url: str, payload: dict[str, Any], *, headers: dict[str, str] | None = None, + params: dict[str, str] | None = None, timeout: float) -> HttpResponse: # fmt: skip + self.requests.append( + { + "url": url, + "payload": payload, + "headers": headers, + "params": params, + "timeout": timeout, + } + ) + return self.responses.pop(0) + + +def chat(content: Any, **message: Any) -> HttpResponse: + return HttpResponse( + 200, json.dumps({"choices": [{"message": {"content": content, **message}}]}) + ) + + +# ------------------------------------------------------------------ status mapping +@pytest.mark.parametrize( + ("status", "body", "exc", "retryable"), + [ + (401, "", AuthError, False), + (403, "", AuthError, False), + (403, '{"error":{"errors":[{"reason":"dailyLimitExceeded"}]}}', QuotaExceeded, False), + ( + 403, + '{"error":{"errors":[{"reason":"userRateLimitExceeded"}]}}', + ProviderUnavailable, + True, + ), + (429, '{"error":{"code":"insufficient_quota"}}', QuotaExceeded, False), + (429, "slow down", ProviderUnavailable, True), + (500, "", ProviderUnavailable, True), + (503, "", ProviderUnavailable, True), + (400, "bad request", ProviderError, False), + ], +) +def test_status_mapping(status: int, body: str, exc: type, retryable: bool) -> None: + with pytest.raises(exc) as info: + raise_for_status(HttpResponse(status, body), "X") + assert info.value.retryable is retryable + + +def test_2xx_passes() -> None: + raise_for_status(HttpResponse(200, "{}"), "X") + + +def test_non_json_body_is_bad_response() -> None: + with pytest.raises(BadResponse): + HttpResponse(200, "").json() + + +# ------------------------------------------------------------------ urllib transport +def test_refuses_plain_http() -> None: + with pytest.raises(ProviderError): + UrllibHttpClient().post_json("http://example.com", {}, timeout=1) + + +@pytest.mark.parametrize( + ("raised", "expected"), + [ + (TimeoutError("t"), ProviderTimeout), + (urllib.error.URLError(TimeoutError("t")), ProviderTimeout), + (urllib.error.URLError(ConnectionRefusedError("no")), ProviderUnavailable), + (OSError("reset"), ProviderUnavailable), + ], +) +def test_transport_errors_are_typed( + monkeypatch: pytest.MonkeyPatch, raised: Exception, expected: type +) -> None: + def boom(*_a: Any, **_k: Any) -> Any: + raise raised + + monkeypatch.setattr("urllib.request.urlopen", boom) + with pytest.raises(expected): + UrllibHttpClient().post_json("https://example.com", {}, timeout=1) + + +def test_http_error_status_is_returned_not_raised(monkeypatch: pytest.MonkeyPatch) -> None: + import io + + def fail(*_a: Any, **_k: Any) -> Any: + raise urllib.error.HTTPError("https://x", 401, "no", {}, io.BytesIO(b'{"error":"bad key"}')) # type: ignore[arg-type] + + monkeypatch.setattr("urllib.request.urlopen", fail) + resp = UrllibHttpClient().post_json( + "https://example.com", {"a": 1}, params={"k": "v"}, timeout=1 + ) + assert resp.status == 401 and "bad key" in resp.body + + +def test_success_path_sends_json(monkeypatch: pytest.MonkeyPatch) -> None: + seen: dict[str, Any] = {} + + class Resp: + status = 200 + + def read(self) -> bytes: + return b'{"ok": true}' + + def __enter__(self) -> Resp: + return self + + def __exit__(self, *a: Any) -> None: + return None + + def fake_urlopen(req: Any, timeout: float) -> Resp: + seen.update( + url=req.full_url, + data=json.loads(req.data), + headers=dict(req.header_items()), + timeout=timeout, + ) + return Resp() + + monkeypatch.setattr("urllib.request.urlopen", fake_urlopen) + resp = UrllibHttpClient().post_json( + "https://h/x", + {"a": 1}, + headers={"Authorization": "Bearer k"}, + params={"key": "q"}, + timeout=2.5, + ) + assert resp.json() == {"ok": True} + assert ( + seen["url"] == "https://h/x?key=q" and seen["data"] == {"a": 1} and seen["timeout"] == 2.5 + ) + assert seen["headers"]["Authorization"] == "Bearer k" + + +# ------------------------------------------------------------------ OpenAI translator +def test_openai_translate_request_and_result() -> None: + http = FakeHttp(chat(" Good morning ")) + out = OpenAITranslator("sk-test", model="m", http=http).translate( + "Buenos días", "es", "en", timeout=3 + ) + assert out == "Good morning" + req = http.requests[0] + assert req["url"] == "https://api.openai.com/v1/chat/completions" + assert req["headers"] == {"Authorization": "Bearer sk-test"} + assert req["timeout"] == 3 + assert req["payload"]["model"] == "m" + system = req["payload"]["messages"][0]["content"] + assert "from Spanish" in system and "into English" in system # names, not codes + assert req["payload"]["messages"][1] == {"role": "user", "content": "Buenos días"} + + +@pytest.mark.parametrize( + "resp", + [ + chat(""), + chat(None), + chat("x", refusal="no"), + HttpResponse(200, '{"choices": []}'), + HttpResponse(200, "{}"), + ], +) +def test_openai_bad_responses(resp: HttpResponse) -> None: + with pytest.raises(BadResponse): + OpenAITranslator("k", http=FakeHttp(resp)).translate("hola", None, "en", timeout=1) + + +def test_openai_auth_error() -> None: + with pytest.raises(AuthError): + OpenAITranslator("k", http=FakeHttp(HttpResponse(401, ""))).translate( + "hola", None, "en", timeout=1 + ) + + +def test_empty_text_makes_no_request() -> None: + http = FakeHttp() + assert OpenAITranslator("k", http=http).translate(" ", "es", "en", timeout=1) == "" + assert GoogleTranslator("k", http=http).translate("", "es", "en", timeout=1) == "" + assert http.requests == [] + + +# ------------------------------------------------------------------ Google +def test_google_request_uses_text_format_and_codes() -> None: + body = {"data": {"translations": [{"translatedText": "It's fine"}]}} + http = FakeHttp(HttpResponse(200, json.dumps(body))) + out = GoogleTranslator("gkey", http=http).translate("Está bien", "es-MX", "en-US", timeout=2) + assert out == "It's fine" + req = http.requests[0] + assert req["params"] == {"key": "gkey"} + assert req["payload"] == {"q": "Está bien", "target": "en", "source": "es", "format": "text"} + + +def test_google_without_source_and_bad_body() -> None: + http = FakeHttp( + HttpResponse(200, json.dumps({"data": {"translations": [{"translatedText": "x"}]}})) + ) + GoogleTranslator("k", http=http).translate("hola", None, "en", timeout=1) + assert "source" not in http.requests[0]["payload"] + with pytest.raises(BadResponse): + GoogleTranslator("k", http=FakeHttp(HttpResponse(200, "{}"))).translate( + "a", None, "en", timeout=1 + ) + + +# ------------------------------------------------------------------ Suggester +def ctx(**kw: Any) -> SuggestionContext: + def utt(i: int, t: str, tr: str | None = None) -> Utterance: + return Utterance(i, 0, 1, UtteranceStatus.TRANSLATED, t, "es", tr) + + return SuggestionContext( + target=utt(3, "¿Qué opina?", "What do you think?"), + history=(utt(1, "Hola", "Hello"), utt(2, "Bienvenido")), + source_language="Spanish", + user_language="English", + conversation_type=kw.get("conversation_type", ConversationType.INTERVIEW), + max_options=kw.get("max_options", 2), + ) + + +def test_suggester_uses_structured_output_and_context() -> None: + content = json.dumps({"options": [{"source_text": "Creo que sí", "user_text": "I think so"}, + {"source_text": "No estoy seguro", "user_text": "I'm not sure"}, + {"source_text": "Tal vez", "user_text": "Maybe"}]}) # fmt: skip + http = FakeHttp(chat(content)) + opts = OpenAISuggester("k", http=http).suggest(ctx(max_options=2), timeout=6) + assert [o.source_text for o in opts] == ["Creo que sí", "No estoy seguro"] # capped at max + payload = http.requests[0]["payload"] + assert payload["response_format"] == {"type": "json_schema", "json_schema": SCHEMA} + system, user = (m["content"] for m in payload["messages"]) + assert "job interview" in system and "in Spanish" in system and "English" in system + assert "Hola (Hello)" in user and "Bienvenido" in user and "¿Qué opina?" in user + + +@pytest.mark.parametrize( + "content", + [ + "not json", + "{}", + '{"options": [{"source_text": "x"}]}', + '{"options": []}', + '{"options": [{"source_text": "", "user_text": "y"}]}', + ], +) +def test_suggester_rejects_malformed_output(content: str) -> None: + with pytest.raises(BadResponse): + parse_options(content, 2) + + +def test_build_messages_without_history() -> None: + c = ctx() + c2 = SuggestionContext(c.target, (), "Spanish", "English", ConversationType.CASUAL, 1) + _, user = (m["content"] for m in build_messages(c2)) + assert user.startswith("They just said:") + assert "casual" in build_messages(c2)[0]["content"] + + +def test_truncated_response_is_unavailable(monkeypatch: pytest.MonkeyPatch) -> None: + import http.client + + def boom(*_a: Any, **_k: Any) -> Any: + raise http.client.IncompleteRead(b"partial") + + monkeypatch.setattr("urllib.request.urlopen", boom) + with pytest.raises(ProviderUnavailable): + UrllibHttpClient().post_json("https://example.com", {}, timeout=1) + + +def test_error_body_read_failure_keeps_status(monkeypatch: pytest.MonkeyPatch) -> None: + class Body: + def read(self, *_a: Any) -> bytes: + raise TimeoutError("slow body") + + def close(self) -> None: + pass + + def fail(*_a: Any, **_k: Any) -> Any: + raise urllib.error.HTTPError("https://x", 503, "busy", {}, Body()) # type: ignore[arg-type] + + monkeypatch.setattr("urllib.request.urlopen", fail) + assert UrllibHttpClient().post_json("https://example.com", {}, timeout=1).status == 503 diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..c73e526 --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,113 @@ +"""Shared test helpers. Everything here uses fakes: no models, devices or network.""" + +from __future__ import annotations + +import threading +import time +from collections.abc import Callable, Iterator +from typing import Any + +import pytest + +from polyglot.adapters.audio.playback import ArraySource +from polyglot.adapters.audio.resample import IdentityResampler +from polyglot.adapters.fakes import AmplitudeVad, ScriptedTranscriber, speech_like +from polyglot.core.events import Event, EventBus, UtteranceUpdated +from polyglot.core.models import SAMPLE_RATE, Utterance, UtteranceStatus +from polyglot.core.pipeline import Pipeline, PipelineConfig +from polyglot.core.ports import Suggester, Translator + + +class Recorder: + """Collects bus events from any thread.""" + + def __init__(self, bus: EventBus) -> None: + self._lock = threading.Lock() + self.events: list[Event] = [] + bus.subscribe(self._on) + + def _on(self, ev: Event) -> None: + with self._lock: + self.events.append(ev) + + def of(self, kind: type) -> list[Any]: + with self._lock: + return [e for e in self.events if isinstance(e, kind)] + + def utterances(self) -> dict[int, Utterance]: + """Latest state of each utterance.""" + out: dict[int, Utterance] = {} + for ev in self.of(UtteranceUpdated): + out[ev.utterance.id] = ev.utterance + return out + + def finals(self) -> list[Utterance]: + return [ + u + for _, u in sorted(self.utterances().items()) + if u.status in (UtteranceStatus.FINAL, UtteranceStatus.TRANSLATED) + ] + + +def wait_for(predicate: Callable[[], bool], timeout: float = 5.0, interval: float = 0.01) -> bool: + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + if predicate(): + return True + time.sleep(interval) + return predicate() + + +def utterances_audio(n: int, speech_s: float = 1.0, gap_s: float = 0.9) -> Any: + """n bursts of 'speech' (tone) separated by silences long enough to end each one.""" + pattern: list[tuple[str, float]] = [("silence", 0.3)] + for _ in range(n): + pattern += [("tone", speech_s), ("silence", gap_s)] + return speech_like(pattern) + + +@pytest.fixture +def bus() -> EventBus: + return EventBus() + + +@pytest.fixture +def recorder(bus: EventBus) -> Recorder: + return Recorder(bus) + + +@pytest.fixture +def make_pipeline(bus: EventBus) -> Iterator[Callable[..., Pipeline]]: + made: list[Pipeline] = [] + + def factory( + audio: Any = None, + *, + transcriber: ScriptedTranscriber | None = None, + translator: Translator | None = None, + suggester: Suggester | None = None, + config: PipelineConfig | None = None, + source: Any = None, + vad: Any = None, + **kw: Any, + ) -> Pipeline: + if source is None: + source = ArraySource(audio if audio is not None else utterances_audio(2), SAMPLE_RATE) + cfg = config or PipelineConfig(ring_seconds=600.0) + p = Pipeline( + source=source, + resampler_factory=lambda _rate: IdentityResampler(), + vad=vad or AmplitudeVad(), + transcriber=transcriber or ScriptedTranscriber(), + translator=translator, + suggester=suggester, + bus=bus, + config=cfg, + **kw, + ) + made.append(p) + return p + + yield factory + for p in made: + p.close() diff --git a/tests/integration/__init__.py b/tests/integration/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/integration/test_real_models.py b/tests/integration/test_real_models.py new file mode 100644 index 0000000..fed8f07 --- /dev/null +++ b/tests/integration/test_real_models.py @@ -0,0 +1,87 @@ +"""Real models on synthesized speech. Slow: run with ``pytest -m slow``. + +Needs faster-whisper (downloads the ``tiny`` model on first run, ~75 MB) and espeak-ng +(or espeak) to synthesize speech. CI runs these in the "models" job. +""" + +from __future__ import annotations + +import shutil +import subprocess +from pathlib import Path + +import numpy as np +import pytest + +from polyglot.adapters.audio.playback import WavFileSource, read_wav +from polyglot.adapters.audio.resample import make_resampler +from polyglot.core.events import EventBus +from polyglot.core.models import FRAME_SAMPLES +from polyglot.core.pipeline import Pipeline, PipelineConfig +from tests.conftest import Recorder, wait_for + +pytestmark = pytest.mark.slow + +SENTENCE = "Hello everyone. This is a test of the transcription system." + + +@pytest.fixture(scope="module") +def speech_wav(tmp_path_factory: pytest.TempPathFactory) -> Path: + exe = shutil.which("espeak-ng") or shutil.which("espeak") + if exe is None: + pytest.skip("espeak-ng is not installed") + out = tmp_path_factory.mktemp("speech") / "speech.wav" + subprocess.run([exe, "-w", str(out), SENTENCE], check=True, capture_output=True) + # Pad with silence so the utterance can end before the file does. + data, rate = read_wav(out) + from polyglot.adapters.audio.playback import write_wav + + padded = np.concatenate((np.zeros(rate // 2, np.float32), data, np.zeros(rate, np.float32))) + write_wav(out, padded, rate) + return out + + +def test_silero_detects_synthesized_speech(speech_wav: Path) -> None: + pytest.importorskip("faster_whisper") + pytest.importorskip("soxr") + from polyglot.adapters.vad.silero import SileroVad + + data, rate = read_wav(speech_wav) + r = make_resampler(rate) + audio = np.concatenate((r.process(data), r.flush())) + vad = SileroVad() + probs = [ + vad.speech_prob(audio[i : i + FRAME_SAMPLES]) + for i in range(0, audio.size - FRAME_SAMPLES, FRAME_SAMPLES) + ] + assert max(probs) > 0.5 + assert min(probs[:5]) < 0.2 # the leading silence + + +def test_whisper_tiny_end_to_end(speech_wav: Path) -> None: + pytest.importorskip("faster_whisper") + pytest.importorskip("soxr") + from polyglot.adapters.asr.faster_whisper import FasterWhisperTranscriber + from polyglot.adapters.vad.silero import SileroVad + + bus = EventBus() + rec = Recorder(bus) + p = Pipeline( + source=WavFileSource(speech_wav, realtime=False), + resampler_factory=make_resampler, + vad=SileroVad(), + transcriber=FasterWhisperTranscriber("tiny", device="cpu", compute_type="int8"), + translator=None, + suggester=None, + bus=bus, + config=PipelineConfig(ring_seconds=120), + ) + try: + p.start() + assert wait_for(lambda: p.source_ended, 120) + assert p.wait_idle(120) + text = " ".join(u.text for u in rec.finals()).lower() + assert "test" in text and "transcription" in text, text + assert all(u.source_lang == "en" for u in rec.finals()) + finally: + p.close() diff --git a/tests/pipeline/__init__.py b/tests/pipeline/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/pipeline/test_pipeline.py b/tests/pipeline/test_pipeline.py new file mode 100644 index 0000000..ffd1c2c --- /dev/null +++ b/tests/pipeline/test_pipeline.py @@ -0,0 +1,534 @@ +"""End-to-end pipeline behaviour with fakes: ordering, pairing, staleness, backpressure, +failures, suggestions and lifecycle. Deterministic; no models, devices or network.""" + +from __future__ import annotations + +import threading +import time +from typing import Any + +import numpy as np +import pytest + +from polyglot.adapters.audio.playback import ArraySource +from polyglot.adapters.fakes import ( + CannedSuggester, + EchoTranslator, + ScriptedTranscriber, + speech_like, + tone, +) +from polyglot.core.errors import AuthError, ProviderUnavailable, TranscriptionFailed +from polyglot.core.events import ( + LanguageChanged, + PipelineState, + PipelineStatus, + StageError, + SuggestionsReady, + SuggestionStarted, + UtteranceDiscarded, +) +from polyglot.core.models import SAMPLE_RATE, ErrorKind, UtteranceStatus +from polyglot.core.pipeline import PipelineConfig +from polyglot.core.ports import AudioSink +from polyglot.core.session import LanguagePolicy +from tests.conftest import Recorder, utterances_audio, wait_for + +TEXTS = ["uno", "dos", "tres", "cuatro"] + + +def run_to_end(pipeline: Any, timeout: float = 15.0) -> None: + pipeline.start() + assert wait_for(lambda: pipeline.source_ended, timeout), "source never ended" + assert pipeline.wait_idle(timeout), "pipeline never became idle" + + +def test_transcripts_and_translations_stay_paired_when_translations_finish_out_of_order( + make_pipeline: Any, recorder: Recorder +) -> None: + # The first sentence's translation is the slowest, so translations complete 4,3,2,1. + delays = {"uno": 0.4, "dos": 0.3, "tres": 0.2, "cuatro": 0.0} + tr = EchoTranslator(delays=delays) + p = make_pipeline(utterances_audio(4), transcriber=ScriptedTranscriber(TEXTS), translator=tr) + run_to_end(p) + finals = recorder.finals() + assert [u.id for u in finals] == [1, 2, 3, 4] + assert [u.text for u in finals] == TEXTS + for u in finals: + assert u.status is UtteranceStatus.TRANSLATED + assert u.translation == f"[es→en] {u.text}" # each translation on its own sentence + + +def test_exactly_one_asr_worker(make_pipeline: Any) -> None: + asr = ScriptedTranscriber(TEXTS, delay_s=0.05) + p = make_pipeline(utterances_audio(4), transcriber=asr) + run_to_end(p) + assert len(asr.calls) == 4 + assert asr.max_concurrency == 1 + + +def test_language_locks_and_is_passed_to_whisper(make_pipeline: Any, recorder: Recorder) -> None: + # All audio arrives at once here, so the worker may pick up sentence 3 a moment + # before the coordinator locks the language from sentence 2. What is guaranteed: + # no hint before two agreeing finals, the hint applies once locked, and never reverts. + asr = ScriptedTranscriber(TEXTS * 2, language="es", probability=0.95, delay_s=0.05) + cfg = PipelineConfig(ring_seconds=600, language_policy=LanguagePolicy(agree=2)) + p = make_pipeline(utterances_audio(6), transcriber=asr, config=cfg) + run_to_end(p) + hints = [hint for _, hint in asr.calls] + assert hints[:2] == [None, None] + first = hints.index("es") + assert all(h == "es" for h in hints[first:]) + assert hints[-1] == "es" + assert recorder.of(LanguageChanged) == [LanguageChanged("es", locked=True)] + + +def test_same_language_is_not_translated(make_pipeline: Any, recorder: Recorder) -> None: + tr = EchoTranslator() + p = make_pipeline( + utterances_audio(2), + transcriber=ScriptedTranscriber(["hi", "there"], language="en"), + translator=tr, + ) + run_to_end(p) + assert tr.calls == [] + assert all(u.status is UtteranceStatus.FINAL for u in recorder.finals()) + + +def test_retryable_translation_error_is_retried_once( + make_pipeline: Any, recorder: Recorder +) -> None: + class Flaky(EchoTranslator): + def __init__(self) -> None: + super().__init__() + self.failures = 1 + + def translate(self, text: str, source: str | None, target: str, *, timeout: float) -> str: + if self.failures: + self.failures -= 1 + self.calls.append((text, source, target)) + raise ProviderUnavailable("blip") + return super().translate(text, source, target, timeout=timeout) + + tr = Flaky() + p = make_pipeline(utterances_audio(1), transcriber=ScriptedTranscriber(["hola"]), translator=tr) + run_to_end(p) + (u,) = recorder.finals() + assert u.status is UtteranceStatus.TRANSLATED + assert len(tr.calls) == 2 + + +def test_non_retryable_translation_error_shows_on_the_row( + make_pipeline: Any, recorder: Recorder +) -> None: + tr = EchoTranslator(errors={"hola": AuthError("bad key")}) + p = make_pipeline(utterances_audio(1), transcriber=ScriptedTranscriber(["hola"]), translator=tr) + run_to_end(p) + (u,) = recorder.finals() + assert u.status is UtteranceStatus.FINAL + assert u.error is ErrorKind.AUTH + assert u.translation is None # never a made-up translation + assert len(tr.calls) == 1 + errs = recorder.of(StageError) + assert any(e.stage == "translate" and e.kind is ErrorKind.AUTH for e in errs) + + +def test_empty_transcript_is_discarded(make_pipeline: Any, recorder: Recorder) -> None: + p = make_pipeline(utterances_audio(2), transcriber=ScriptedTranscriber(["", "hola"])) + run_to_end(p) + assert [e.utterance_id for e in recorder.of(UtteranceDiscarded)] == [1] + assert [u.text for u in recorder.finals()] == ["hola"] + + +def test_transcription_failure_marks_row_failed(make_pipeline: Any, recorder: Recorder) -> None: + asr = ScriptedTranscriber(["a", "b"], fail_on=[0], error=TranscriptionFailed("decoder")) + p = make_pipeline(utterances_audio(2), transcriber=asr) + run_to_end(p) + us = recorder.utterances() + assert us[1].status is UtteranceStatus.FAILED and us[1].error is ErrorKind.TRANSCRIPTION + assert us[2].text == "b" + + +def test_falling_behind_drops_oldest_waiting_final_and_says_so( + make_pipeline: Any, recorder: Recorder +) -> None: + asr = ScriptedTranscriber(delay_s=0.3) + cfg = PipelineConfig(ring_seconds=600, finals_queue_size=1) + p = make_pipeline(utterances_audio(5, speech_s=0.5, gap_s=0.7), transcriber=asr, config=cfg) + run_to_end(p) + us = recorder.utterances() + overloaded = [u for u in us.values() if u.error is ErrorKind.OVERLOADED] + assert overloaded, "expected at least one dropped utterance" + assert all(u.status is UtteranceStatus.FAILED for u in overloaded) + assert any(s.state is PipelineState.FALLING_BEHIND for s in recorder.of(PipelineStatus)) + # Nothing is silently lost: every utterance ended up either transcribed or marked. + assert all(u.is_final for u in us.values()) + + +def test_suggestion_with_nothing_said(make_pipeline: Any, recorder: Recorder) -> None: + p = make_pipeline(utterances_audio(0), suggester=CannedSuggester()) + p.request_suggestion() + assert wait_for(lambda: recorder.of(StageError)) + assert recorder.of(StageError)[0].kind is ErrorKind.NOTHING_TO_ANSWER + + +def test_suggestion_not_configured(make_pipeline: Any, recorder: Recorder) -> None: + p = make_pipeline(utterances_audio(0)) + p.request_suggestion() + assert wait_for(lambda: recorder.of(StageError)) + assert recorder.of(StageError)[0].kind is ErrorKind.NOT_CONFIGURED + + +def test_suggestion_targets_latest_final_with_history( + make_pipeline: Any, recorder: Recorder +) -> None: + sug = CannedSuggester() + p = make_pipeline( + utterances_audio(3), transcriber=ScriptedTranscriber(TEXTS[:3]), suggester=sug + ) + run_to_end(p) + p.request_suggestion() + assert wait_for(lambda: recorder.of(SuggestionsReady)) + (ready,) = recorder.of(SuggestionsReady) + assert ready.suggestion.utterance_id == 3 + assert len(ready.suggestion.options) == 2 + ctx = sug.contexts[0] + assert ctx.target.text == "tres" + assert [u.text for u in ctx.history] == ["uno", "dos"] + assert ctx.source_language == "Spanish" and ctx.user_language == "English" + assert recorder.of(SuggestionStarted) == [SuggestionStarted(3)] + + +def test_pressing_suggest_again_supersedes_in_flight_request( + make_pipeline: Any, recorder: Recorder +) -> None: + p = make_pipeline(utterances_audio(1), suggester=CannedSuggester(delay_s=0.3)) + run_to_end(p) + p.request_suggestion() + time.sleep(0.05) + p.request_suggestion() + assert wait_for(lambda: len(recorder.of(SuggestionsReady)) >= 1, 3) + time.sleep(0.5) # let the first (superseded) request finish too + assert len(recorder.of(SuggestionsReady)) == 1 # only the newer request is shown + assert len(recorder.of(SuggestionStarted)) == 2 + + +def test_late_suggestion_is_still_shown_linked_to_its_sentence( + make_pipeline: Any, recorder: Recorder +) -> None: + """Asked about sentence 1; sentence 2 finishes before the reply arrives. The reply is + kept (not dropped) and stays linked to sentence 1.""" + audio = speech_like([("silence", 0.3), ("tone", 1.0), ("silence", 0.9)]) + later = speech_like([("tone", 1.0), ("silence", 0.9)]) + + class TwoPart: + sample_rate = SAMPLE_RATE + + def start(self, sink: AudioSink) -> None: + self._sink = sink + sink.on_audio(audio) + + def more(self) -> None: + self._sink.on_audio(later) + self._sink.on_end() + + def stop(self) -> None: + pass + + src = TwoPart() + sug = CannedSuggester(delay_s=0.6) + p = make_pipeline( + source=src, transcriber=ScriptedTranscriber(["primera", "segunda"]), suggester=sug + ) + p.start() + assert wait_for(lambda: len(recorder.finals()) == 1) + p.request_suggestion() + src.more() + assert wait_for(lambda: len(recorder.finals()) == 2, 5) + assert wait_for(lambda: recorder.of(SuggestionsReady), 5) + (ready,) = recorder.of(SuggestionsReady) + assert ready.suggestion.utterance_id == 1 + assert "primera" in ready.suggestion.options[0].source_text + + +def test_suggestion_failure_is_reported_not_replaced( + make_pipeline: Any, recorder: Recorder +) -> None: + p = make_pipeline(utterances_audio(1), suggester=CannedSuggester(error=AuthError("nope"))) + run_to_end(p) + p.request_suggestion() + assert wait_for(lambda: recorder.of(SuggestionsReady)) + s = recorder.of(SuggestionsReady)[0].suggestion + assert s.options == () and s.error is ErrorKind.AUTH + + +def test_clear_ignores_late_results(make_pipeline: Any, recorder: Recorder) -> None: + tr = EchoTranslator(delays={"uno": 0.4}) + p = make_pipeline(utterances_audio(1), transcriber=ScriptedTranscriber(["uno"]), translator=tr) + p.start() + assert wait_for(lambda: recorder.finals()) + p.clear() + time.sleep(0.6) + assert all(u.status is not UtteranceStatus.TRANSLATED for u in recorder.utterances().values()) + assert p.session.utterances == {} + from polyglot.core.events import ConversationCleared + + assert recorder.of(ConversationCleared) == [ConversationCleared(1)] + + +def test_stop_flushes_utterance_in_progress_and_restart_continues_ids( + make_pipeline: Any, recorder: Recorder +) -> None: + class Endless: + """Speech that never pauses; stops only when told to.""" + + sample_rate = SAMPLE_RATE + + def __init__(self) -> None: + self._stop = threading.Event() + + def start(self, sink: AudioSink) -> None: + self._stop.clear() + sink.on_audio(np.concatenate((np.zeros(4800, dtype=np.float32), tone(1.0)))) + + def stop(self) -> None: + self._stop.set() + + p = make_pipeline(source=Endless(), transcriber=ScriptedTranscriber(["a", "b"])) + p.start() + time.sleep(0.3) + p.stop() # mid-utterance: it must still be finished and transcribed + assert [u.text for u in recorder.finals()] == ["a"] + assert recorder.of(PipelineStatus)[-1].state is PipelineState.STOPPED or wait_for( + lambda: recorder.of(PipelineStatus)[-1].state is PipelineState.STOPPED + ) + p.start() + time.sleep(0.3) + p.stop() + assert [u.id for u in recorder.finals()] == [1, 2] + + +def test_gap_fill_ends_utterance_when_loopback_goes_silent( + make_pipeline: Any, recorder: Recorder +) -> None: + """WASAPI loopback stops delivering data when nothing plays. The utterance must still + end (by synthesized silence), without a stop or end-of-stream.""" + + class GoesQuiet: + sample_rate = SAMPLE_RATE + + def start(self, sink: AudioSink) -> None: + sink.on_audio(np.concatenate((np.zeros(4800, dtype=np.float32), tone(1.0)))) + # ...and then nothing at all, like a loopback device with no audio playing. + + def stop(self) -> None: + pass + + cfg = PipelineConfig(ring_seconds=60, gap_fill_after_s=0.1) + p = make_pipeline(source=GoesQuiet(), transcriber=ScriptedTranscriber(["hola"]), config=cfg) + p.start() + assert wait_for(lambda: [u.text for u in recorder.finals()] == ["hola"], 3) + + +def test_stereo_and_resampled_input(bus: Any, recorder: Recorder) -> None: + from polyglot.adapters.fakes import AmplitudeVad + from polyglot.core.pipeline import Pipeline + + mono = utterances_audio(1) + up = np.repeat(mono, 3) # 48 kHz version of the 16 kHz signal + stereo = np.stack((up, up), axis=1) + + class Decimate3: + def process(self, block: Any) -> Any: + return np.asarray(block, dtype=np.float32)[::3].copy() + + def flush(self) -> Any: + return np.zeros(0, dtype=np.float32) + + rates: list[int] = [] + + def factory(rate: int) -> Decimate3: + rates.append(rate) + return Decimate3() + + p = Pipeline( + source=ArraySource(stereo, 48_000, block_ms=30), + resampler_factory=factory, + vad=AmplitudeVad(), + transcriber=ScriptedTranscriber(["hola"]), + translator=None, + suggester=None, + bus=bus, + config=PipelineConfig(ring_seconds=60), + ) + try: + run_to_end(p) + assert rates == [48_000] + assert [u.text for u in recorder.finals()] == ["hola"] + finally: + p.close() + + +def test_source_start_failure_is_reported(make_pipeline: Any, recorder: Recorder) -> None: + class Broken: + sample_rate = SAMPLE_RATE + + def start(self, sink: AudioSink) -> None: + raise OSError("device busy") + + def stop(self) -> None: + pass + + p = make_pipeline(source=Broken()) + p.start() + assert not p.running + assert wait_for(lambda: any(e.kind is ErrorKind.AUDIO for e in recorder.of(StageError))) + assert wait_for(lambda: p.state is PipelineState.ERROR) + + +def test_source_error_mid_stream_is_reported(make_pipeline: Any, recorder: Recorder) -> None: + class Unplugged: + sample_rate = SAMPLE_RATE + + def start(self, sink: AudioSink) -> None: + threading.Timer(0.05, lambda: sink.on_error(OSError("unplugged"))).start() + + def stop(self) -> None: + pass + + p = make_pipeline(source=Unplugged()) + p.start() + assert wait_for(lambda: p.state is PipelineState.ERROR) + assert any("unplugged" in e.message for e in recorder.of(StageError)) + + +def test_model_load_failure_is_reported(make_pipeline: Any, recorder: Recorder) -> None: + asr = ScriptedTranscriber(load_error=TranscriptionFailed("model download failed")) + p = make_pipeline(utterances_audio(1), transcriber=asr) + p.start() + assert wait_for(lambda: p.state is PipelineState.ERROR) + assert any(e.stage == "asr" and "download" in e.message for e in recorder.of(StageError)) + + +def test_status_sequence(make_pipeline: Any, recorder: Recorder) -> None: + p = make_pipeline(utterances_audio(1)) + run_to_end(p) + p.stop() + assert wait_for(lambda: recorder.of(PipelineStatus)[-1].state is PipelineState.STOPPED) + states = [s.state for s in recorder.of(PipelineStatus)] + assert states[:2] == [PipelineState.LOADING, PipelineState.LISTENING] + + +@pytest.mark.parametrize("partial_ms", [320]) +def test_partials_flow_then_final_overrides( + make_pipeline: Any, recorder: Recorder, partial_ms: int +) -> None: + from polyglot.core.segmenter import SegmenterConfig + + cfg = PipelineConfig( + ring_seconds=600, segmenter=SegmenterConfig(partial_interval_ms=partial_ms) + ) + asr = ScriptedTranscriber(lambda audio: f"{len(audio)} samples") + # Real-time pacing: if all audio arrived at once, the final would (correctly) + # replace the queued partials before any were transcribed. + src = ArraySource(utterances_audio(1, speech_s=1.5), SAMPLE_RATE, realtime=True, block_ms=32) + p = make_pipeline(source=src, transcriber=asr, config=cfg) + run_to_end(p) + from polyglot.core.events import UtteranceUpdated + + statuses = [e.utterance.status for e in recorder.of(UtteranceUpdated)] + assert UtteranceStatus.PARTIAL in statuses + assert statuses[-1] is UtteranceStatus.FINAL + versions = [ + e.utterance.partial_version + for e in recorder.of(UtteranceUpdated) + if e.utterance.status is UtteranceStatus.PARTIAL + ] + assert versions == sorted(versions) + + +# ---------------------------------------------------------------- lifecycle regressions +# Found by an independent review probing start/stop/failure interleavings. + + +def test_model_load_failure_stops_capture_and_keeps_error( + make_pipeline: Any, recorder: Recorder +) -> None: + asr = ScriptedTranscriber(load_error=TranscriptionFailed("no model")) + src = ArraySource(utterances_audio(6), SAMPLE_RATE, realtime=True) + p = make_pipeline( + source=src, transcriber=asr, config=PipelineConfig(ring_seconds=60, finals_queue_size=1) + ) + p.start() + assert wait_for(lambda: not p.running, 5), "capture should stop when the model cannot load" + assert wait_for(lambda: recorder.of(PipelineStatus)[-1].state is PipelineState.STOPPED, 5) + states = [s.state for s in recorder.of(PipelineStatus)] + assert PipelineState.ERROR in states + assert PipelineState.FALLING_BEHIND not in states[states.index(PipelineState.ERROR) :] + # nothing left "listening" forever + assert all(u.status is not UtteranceStatus.LISTENING for u in recorder.utterances().values()) + + +def test_model_loaded_after_stop_does_not_claim_listening( + make_pipeline: Any, recorder: Recorder +) -> None: + class SlowLoad(ScriptedTranscriber): + def load(self) -> None: + time.sleep(0.5) + super().load() + + p = make_pipeline(utterances_audio(1), transcriber=SlowLoad()) + p.start() + p.stop(timeout=0.1) + time.sleep(0.8) + assert p.state is PipelineState.STOPPED + assert recorder.of(PipelineStatus)[-1].state is PipelineState.STOPPED + + +def test_restart_never_runs_two_asr_workers(make_pipeline: Any) -> None: + asr = ScriptedTranscriber(delay_s=0.5) + p = make_pipeline(utterances_audio(4), transcriber=asr) + p.start() + time.sleep(0.3) + p.stop(timeout=0.05) # the worker is mid-transcription and outlives stop() + p.start() + time.sleep(1.5) + p.stop() + assert asr.max_concurrency == 1 + + +def test_suggestion_skips_a_failed_latest_sentence(make_pipeline: Any, recorder: Recorder) -> None: + asr = ScriptedTranscriber(["uno", "dos"], fail_on=[1], error=TranscriptionFailed("x")) + sug = CannedSuggester() + p = make_pipeline(utterances_audio(2), transcriber=asr, suggester=sug) + run_to_end(p) + p.request_suggestion() + assert wait_for(lambda: recorder.of(SuggestionsReady)) + assert recorder.of(SuggestionsReady)[0].suggestion.utterance_id == 1 + + +def test_retranslate_pending_after_rebuild(bus: Any, recorder: Recorder) -> None: + from polyglot.adapters.audio.resample import IdentityResampler + from polyglot.adapters.fakes import AmplitudeVad + from polyglot.core.models import Utterance + from polyglot.core.pipeline import Pipeline + from polyglot.core.session import Session + + session = Session("en") + session.put(Utterance(1, 0.0, 1.0, UtteranceStatus.FINAL, "hola", "es")) + p = Pipeline( + source=ArraySource(utterances_audio(0), SAMPLE_RATE), + resampler_factory=lambda _r: IdentityResampler(), + vad=AmplitudeVad(), + transcriber=ScriptedTranscriber(), + translator=EchoTranslator(), + suggester=None, + bus=bus, + session=session, + ) + try: + p.retranslate_pending() + assert wait_for(lambda: session.get(1).status is UtteranceStatus.TRANSLATED) # type: ignore[union-attr] + assert session.get(1).translation == "[es→en] hola" # type: ignore[union-attr] + finally: + p.close() diff --git a/tests/ui/__init__.py b/tests/ui/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/ui/test_qt.py b/tests/ui/test_qt.py new file mode 100644 index 0000000..37818ea --- /dev/null +++ b/tests/ui/test_qt.py @@ -0,0 +1,452 @@ +"""Qt views, the thread bridge, the capture-shield filter and an app smoke test. + +Runs offscreen in CI (QT_QPA_PLATFORM=offscreen). Skipped where PyQt6/pytest-qt are +not installed. +""" + +from __future__ import annotations + +import sys +import threading +from pathlib import Path +from typing import Any + +import pytest + +pytest.importorskip("PyQt6") +pytest.importorskip("pytestqt") + +from PyQt6.QtCore import QEvent, QThread, QTimer +from PyQt6.QtWidgets import QApplication, QDialog, QWidget + +from polyglot.adapters.fakes import NoopShield +from polyglot.adapters.secrets import MemorySecretStore +from polyglot.config import AppConfig, Secrets, UiConfig, save_config +from polyglot.core.events import EventBus, PipelineState, PipelineStatus +from polyglot.core.ports import ShieldStatus +from polyglot.ui.presenter import CaptureVM, OptionVM, RowVM, StatusVM, SuggestionVM + +pytestmark = pytest.mark.ui + + +@pytest.fixture +def window(qtbot: Any) -> Any: + from polyglot.ui.qt.overlay import OverlayWindow + + w = OverlayWindow(UiConfig()) + qtbot.addWidget(w) + return w + + +def test_stylesheet_ships_with_package() -> None: + from polyglot.ui.qt.overlay import load_stylesheet + + assert "#Overlay" in load_stylesheet() + + +def test_rows_are_placed_in_spoken_order(window: Any) -> None: + for uid in (3, 1, 2): + window.upsert_row(RowVM(uid, f"text {uid}")) + assert window._order == [1, 2, 3] + widgets = [window.rows_layout.itemAt(i).widget() for i in range(3)] + assert [w.original.text() for w in widgets] == ["text 1", "text 2", "text 3"] + + +def test_row_update_in_place_and_remove(window: Any) -> None: + window.upsert_row(RowVM(1, "hola", note="translating…")) + row = window._rows[1] + assert not row.note.isHidden() and row.translation.isHidden() + window.upsert_row(RowVM(1, "hola", translation="hello")) + assert window._rows[1] is row # updated, not duplicated + assert row.translation.text() == "hello" and row.note.isHidden() + window.remove_row(1) + window.remove_row(1) # removing twice is harmless + assert window._rows == {} and window._order == [] + window.upsert_row(RowVM(2, "x")) + window.clear_rows() + assert window._rows == {} + + +def test_suggestions_panel(window: Any) -> None: + window.show_suggestions(SuggestionVM(reply_to="¿Qué?", loading=True)) + assert not window.suggestions.isHidden() + assert window.suggest_message.text() == "Thinking…" + window.show_suggestions( + SuggestionVM( + reply_to="¿Qué?", options=(OptionVM("Sí", "Yes"), OptionVM("No", "No")), stale=True + ) + ) + assert window.options_layout.count() == 2 + assert not window.stale.isHidden() + assert "¿Qué?" in window.reply_to.text() + window.show_suggestions(SuggestionVM(visible=False)) + assert window.suggestions.isHidden() and window.options_layout.count() == 0 + + +def test_option_click_copies_text(window: Any, qtbot: Any) -> None: + from PyQt6.QtCore import Qt + + window.show_suggestions(SuggestionVM(options=(OptionVM("Copiame", "Copy me"),))) + opt = window.options_layout.itemAt(0).widget() + qtbot.mouseClick(opt, Qt.MouseButton.LeftButton) + clipboard = QApplication.clipboard() + assert clipboard is not None and clipboard.text() == "Copiame" + + +def test_status_listening_language_capture(window: Any) -> None: + window.set_status(StatusVM("Falling behind", "warn")) + assert window.status.text() == "Falling behind" and window.status.property("level") == "warn" + window.set_listening(True, busy=True) + assert window.start.text() == "Stop" and not window.start.isEnabled() + window.set_listening(False, busy=False) + assert window.start.text() == "Start" and window.start.isEnabled() + window.set_language("Spanish (locked)") + assert window.language.text() == "Spanish (locked)" + window.set_capture(CaptureVM(False, "Visible in screen share")) + assert window.capture.text().endswith("Visible in screen share") + + +def test_buttons_emit_intents(window: Any, qtbot: Any) -> None: + with qtbot.waitSignal(window.start_stop_clicked): + window.start.click() + with qtbot.waitSignal(window.suggest_clicked): + window.suggest.click() + + +def test_bridge_delivers_on_gui_thread(qtbot: Any) -> None: + from polyglot.ui.qt.bridge import EventBridge + + bus = EventBus() + got: list[tuple[Any, bool]] = [] + app = QApplication.instance() + assert app is not None + gui_thread = app.thread() + bridge = EventBridge(bus, lambda ev: got.append((ev, QThread.currentThread() is gui_thread))) + ev = PipelineStatus(PipelineState.LISTENING) + t = threading.Thread(target=bus.publish, args=(ev,)) + t.start() + t.join() + qtbot.waitUntil(lambda: bool(got), timeout=2000) + assert got == [(ev, True)] + bridge.close() + bus.publish(ev) + qtbot.wait(50) + assert len(got) == 1 + + +def test_shield_filter_covers_every_top_level_window(qtbot: Any) -> None: + from polyglot.ui.qt.shield_filter import CaptureShieldFilter + + shield = NoopShield(ShieldStatus.HIDDEN) + filt = CaptureShieldFilter(shield) + app = QApplication.instance() + assert app is not None + app.installEventFilter(filt) + statuses: list[Any] = [] + filt.status_changed.connect(statuses.append) + try: + main = QWidget() + qtbot.addWidget(main) + main.show() + dialog = QDialog(main) + dialog.show() + qtbot.waitUntil(lambda: len(shield.calls) >= 2, timeout=2000) + assert int(main.winId()) in shield.calls and int(dialog.winId()) in shield.calls + main.hide() + main.show() # shown again: same handle, not re-applied + assert shield.calls.count(int(main.winId())) == 1 + assert statuses == [ShieldStatus.HIDDEN] + dialog.close() + finally: + app.removeEventFilter(filt) + + +def test_shield_filter_never_creates_a_native_handle(qtbot: Any) -> None: + """Regression: the filter called winId(), which creates a native window when there is + none and returned None for windows mid-creation/teardown (TypeError on every click).""" + from PyQt6.QtCore import Qt + + from polyglot.ui.qt.shield_filter import CaptureShieldFilter, native_handle + + shield = NoopShield(ShieldStatus.HIDDEN) + filt = CaptureShieldFilter(shield) + w = QWidget() # a top-level that was never shown has no native window + qtbot.addWidget(w) + assert native_handle(w) is None + assert filt.shield_widget(w) is None + assert shield.calls == [] + assert not w.testAttribute(Qt.WidgetAttribute.WA_WState_Created) # still not created + assert w.windowHandle() is None + w.show() + qtbot.waitExposed(w) + assert filt.shield_widget(w) is ShieldStatus.HIDDEN + assert shield.calls == [native_handle(w)] + + +def test_winid_change_is_deferred_to_a_rescan_of_live_windows(qtbot: Any) -> None: + """WinIdChange can arrive from a window's destructor, so the filter never touches the + object it came with; it re-scans the live top-level windows on the next loop turn.""" + from polyglot.ui.qt.shield_filter import CaptureShieldFilter, native_handle + + w = QWidget() + qtbot.addWidget(w) + w.show() + qtbot.waitExposed(w) + shield = NoopShield(ShieldStatus.HIDDEN) + filt = CaptureShieldFilter(shield) + app = QApplication.instance() + assert app is not None + app.installEventFilter(filt) + try: + QApplication.sendEvent(w, QEvent(QEvent.Type.WinIdChange)) + assert shield.calls == [] # not handled on the spot + qtbot.waitUntil(lambda: native_handle(w) in shield.calls, timeout=2000) + finally: + app.removeEventFilter(filt) + filt.close() + + +def test_clicking_overlay_buttons_raises_nothing_and_adds_no_native_children( + qtbot: Any, caplog: pytest.LogCaptureFixture +) -> None: + """Regression for the per-click shield error and the stray native 'TitleBarWindow' + (on Windows CI this runs with real native windows).""" + import logging + + from PyQt6.QtCore import QPoint, Qt + from PyQt6.QtWidgets import QPushButton, QToolTip + + from polyglot.ui.qt.overlay import OverlayWindow + from polyglot.ui.qt.shield_filter import CaptureShieldFilter + + shield = NoopShield(ShieldStatus.HIDDEN) + filt = CaptureShieldFilter(shield) + app = QApplication.instance() + assert app is not None + app.installEventFilter(filt) + try: + w = OverlayWindow(UiConfig()) + qtbot.addWidget(w) + w.show() + qtbot.waitExposed(w) + with caplog.at_level(logging.DEBUG, logger="polyglot.ui.qt.shield_filter"): + for button in w.findChildren(QPushButton): + if not w.isVisible(): + w.show() + qtbot.waitExposed(w) + if button.isVisible(): + QToolTip.showText(button.mapToGlobal(QPoint(2, 2)), button.toolTip(), button) + qtbot.mouseClick(button, Qt.MouseButton.LeftButton) + QToolTip.hideText() + qtbot.wait(100) + problems = [r for r in caplog.records if r.levelno >= logging.WARNING] + assert problems == [], [r.getMessage() for r in problems] + native = [ + c.objectName() or type(c).__name__ + for c in w.findChildren(QWidget) + if c.testAttribute(Qt.WidgetAttribute.WA_NativeWindow) + ] + assert native == [] + finally: + app.removeEventFilter(filt) + filt.close() + + +def test_closed_shield_filter_is_silent_while_windows_are_destroyed(qtbot: Any) -> None: + """Regression: on shutdown, destroying windows made the filter emit a new status into + a view whose labels were already deleted.""" + from PyQt6 import sip + + from polyglot.ui.qt.shield_filter import CaptureShieldFilter + + filt = CaptureShieldFilter(NoopShield(ShieldStatus.HIDDEN)) + w = QWidget() + w.show() + qtbot.waitExposed(w) + assert filt.shield_widget(w) is ShieldStatus.HIDDEN + got: list[Any] = [] + filt.status_changed.connect(got.append) + filt.close() + sip.delete(w) # destroyed now, synchronously + assert got == [] + other = QWidget() + qtbot.addWidget(other) + other.show() + qtbot.waitExposed(other) + assert filt.shield_widget(other) is None # closed for good + + +@pytest.mark.skipif(sys.platform != "win32", reason="real SetWindowDisplayAffinity is Windows-only") +def test_real_windows_shield_hides_a_window(qtbot: Any) -> None: + from polyglot.platform.windows import WindowsShield + + app = QApplication.instance() + if app is None or app.platformName() != "windows": # offscreen has no real HWNDs + pytest.skip("needs the native Windows Qt platform") + w = QWidget() + qtbot.addWidget(w) + w.show() + qtbot.waitExposed(w) + shield = WindowsShield() + status = shield.exclude_from_capture(int(w.winId())) + assert status in (ShieldStatus.HIDDEN, ShieldStatus.UNSUPPORTED), ( + f"{status.value}: {shield.detail} (build {shield.build})" + ) + + +def test_settings_dialog_builds_config_and_stores_keys(qtbot: Any) -> None: + from polyglot.ui.qt.settings_dialog import SettingsDialog + + secrets = Secrets(MemorySecretStore(), environ={}) + dlg = SettingsDialog( + AppConfig(), secrets, lambda: [{"id": 3, "name": "BlackHole 2ch", "virtual": True}] + ) + qtbot.addWidget(dlg) + dlg.translate_on.setChecked(True) + dlg.openai_key.setText("sk-test") + dlg.end_silence.setValue(800) + dlg.partials.setChecked(True) + dlg.device.setCurrentIndex(1) + dlg._save() + cfg = dlg.result_config + assert cfg is not None + assert ( + cfg.translation.enabled + and cfg.vad.end_silence_ms == 800 + and cfg.vad.partial_interval_ms == 1000 + ) + assert cfg.audio.device == "3" + assert secrets.get(Secrets.OPENAI) == "sk-test" and dlg.keys_changed + + +class FakeModelCatalog: + def __init__(self, live: list[str] | None = None, error: str | None = None) -> None: + from types import SimpleNamespace + + self._ns = SimpleNamespace + self.live, self.error = live or [], error + self.fetched: list[str] = [] + self._cache: dict[str, list[Any]] = {} + + def known(self) -> list[Any]: + return [ + self._ns(id=m, note=f"note {m}") for m in ("gpt-6-luna", "gpt-4o-mini", "gpt-4.1-mini") + ] + + def cached(self, key: str) -> list[Any] | None: + return self._cache.get(key) + + def fetch(self, key: str) -> list[Any]: + self.fetched.append(key) + if self.error: + raise RuntimeError(self.error) + models = [self._ns(id=m, note="") for m in self.live] + self._cache[key] = models + return models + + +def _items(box: Any) -> list[str]: + return [box.itemText(i) for i in range(box.count())] + + +def test_model_dropdowns_offer_the_list_and_accept_a_typed_model(qtbot: Any) -> None: + from polyglot.ui.qt.settings_dialog import SettingsDialog + + catalog = FakeModelCatalog() + dlg = SettingsDialog( + AppConfig(), Secrets(MemorySecretStore(), environ={}), list, models=catalog + ) + qtbot.addWidget(dlg) + assert _items(dlg.translate_model) == ["gpt-6-luna", "gpt-4o-mini", "gpt-4.1-mini"] + assert dlg.translate_model.currentText() == "gpt-4o-mini" # the default is kept + assert dlg.suggest_model.currentText() == "gpt-4.1-mini" + assert "API key" in dlg.models_status.text() and catalog.fetched == [] # no key: no call + dlg.suggest_model.setCurrentText("gpt-9-preview") # any model ID can be typed + dlg.translate_model.setCurrentIndex(0) + dlg._save() + assert dlg.result_config is not None + assert dlg.result_config.translation.model == "gpt-6-luna" + assert dlg.result_config.suggestions.model == "gpt-9-preview" + + +def test_model_dropdowns_load_the_accounts_models_in_the_background(qtbot: Any) -> None: + from PyQt6.QtCore import Qt + + from polyglot.ui.qt.settings_dialog import SettingsDialog + + secrets = Secrets(MemorySecretStore(), environ={}) + secrets.set(Secrets.OPENAI, "sk-test") + catalog = FakeModelCatalog(live=["gpt-6-luna", "gpt-6.1-sol"]) + dlg = SettingsDialog(AppConfig(), secrets, list, models=catalog) + qtbot.addWidget(dlg) + qtbot.waitUntil(lambda: "2 models" in dlg.models_status.text(), timeout=3000) + assert catalog.fetched == ["sk-test"] + # The current model is not in the account's list: kept, and marked as such. + assert _items(dlg.translate_model) == ["gpt-6-luna", "gpt-6.1-sol", "gpt-4o-mini"] + assert dlg.translate_model.currentText() == "gpt-4o-mini" + tip = dlg.translate_model.itemData(2, Qt.ItemDataRole.ToolTipRole) + assert "Not in your account" in tip + assert "gpt-6.1-sol" in _items(dlg.suggest_model) + # A second dialog uses the session cache: no second request. + dlg2 = SettingsDialog(AppConfig(), secrets, list, models=catalog) + qtbot.addWidget(dlg2) + assert "2 models" in dlg2.models_status.text() and catalog.fetched == ["sk-test"] + + +def test_model_list_failure_keeps_the_built_in_list(qtbot: Any) -> None: + from polyglot.ui.qt.settings_dialog import SettingsDialog + + secrets = Secrets(MemorySecretStore(), environ={}) + secrets.set(Secrets.OPENAI, "sk-bad") + dlg = SettingsDialog(AppConfig(), secrets, list, models=FakeModelCatalog(error="HTTP 401")) + qtbot.addWidget(dlg) + qtbot.waitUntil(lambda: "Could not load" in dlg.models_status.text(), timeout=3000) + assert _items(dlg.translate_model) == ["gpt-6-luna", "gpt-4o-mini", "gpt-4.1-mini"] + + +def test_translation_model_only_applies_to_openai(qtbot: Any) -> None: + from polyglot.ui.qt.settings_dialog import SettingsDialog + + dlg = SettingsDialog(AppConfig(), Secrets(MemorySecretStore(), environ={}), list) + qtbot.addWidget(dlg) + assert dlg.translate_model.isEnabled() + dlg.provider.setCurrentIndex(dlg.provider.findData("google")) + assert not dlg.translate_model.isEnabled() + + +def test_settings_dialog_survives_device_listing_error(qtbot: Any) -> None: + from polyglot.ui.qt.settings_dialog import SettingsDialog + + def broken() -> list[dict[str, Any]]: + raise OSError("PortAudio missing") + + dlg = SettingsDialog(AppConfig(), Secrets(MemorySecretStore(), environ={}), broken) + qtbot.addWidget(dlg) + dlg._save() + assert dlg.result_config == AppConfig() + + +def test_app_smoke_demo_mode(qtbot: Any, tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None: + """Start the real GUI in demo mode, let it run briefly, quit cleanly. + + Also the regression test for shutdown order: with the capture shield on (the + default), deleting the window used to push a status into its deleted labels.""" + import logging + + from polyglot.app import run_gui + + cfg = AppConfig() + cfg.ui.hotkey_suggest = "" + cfg.ui.hotkey_toggle = "" + path = tmp_path / "config.toml" + save_config(cfg, path) + app = QApplication.instance() + assert app is not None + QTimer.singleShot(2500, app.quit) + with caplog.at_level(logging.WARNING): + assert run_gui(path, demo=True) == 0 + # Run the deferred deletes queued by shutdown (event loop has already exited). + QApplication.sendPostedEvents(None, QEvent.Type.DeferredDelete.value) + QApplication.processEvents() + unhandled = [r.getMessage() for r in caplog.records if r.levelno >= logging.CRITICAL] + assert unhandled == [] diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/unit/test_architecture.py b/tests/unit/test_architecture.py new file mode 100644 index 0000000..145bd1f --- /dev/null +++ b/tests/unit/test_architecture.py @@ -0,0 +1,99 @@ +"""The dependency rule, enforced: imports point inward toward the core. + +Parses every module's imports with ``ast`` (no import-time side effects), so it runs +without Qt, models or devices installed. +""" + +from __future__ import annotations + +import ast +import sys +from pathlib import Path + +import pytest + +SRC = Path(__file__).resolve().parents[2] / "src" / "polyglot" +STDLIB = set(sys.stdlib_module_names) | {"__future__"} + + +def module_name(path: Path) -> str: + rel = path.relative_to(SRC.parent).with_suffix("") + parts = list(rel.parts) + if parts[-1] == "__init__": + parts.pop() + return ".".join(parts) + + +def imports_of(path: Path) -> set[str]: + tree = ast.parse(path.read_text(encoding="utf-8")) + pkg = module_name(path).rsplit(".", 1)[0] if path.name != "__init__.py" else module_name(path) + found: set[str] = set() + for node in ast.walk(tree): + if isinstance(node, ast.Import): + found.update(a.name for a in node.names) + elif isinstance(node, ast.ImportFrom): + if node.level: # relative import + base = pkg.split(".") + base = base[: len(base) - (node.level - 1)] + found.add(".".join([*base, node.module] if node.module else base)) + elif node.module: + found.add(node.module) + return found + + +def modules(subpackage: str) -> list[Path]: + root = SRC / subpackage if subpackage else SRC + return sorted(root.rglob("*.py")) if root.is_dir() else [root.with_suffix(".py")] + + +def top(name: str) -> str: + return name.split(".")[0] + + +@pytest.mark.parametrize("path", modules("core"), ids=lambda p: p.name) +def test_core_imports_only_stdlib_numpy_and_core(path: Path) -> None: + bad = { + m + for m in imports_of(path) + if not (top(m) in STDLIB or top(m) == "numpy" or m.startswith("polyglot.core")) + } + assert not bad, f"{path.name} imports outside the core: {sorted(bad)}" + + +@pytest.mark.parametrize("path", modules("adapters") + modules("platform"), ids=lambda p: p.name) +def test_adapters_and_platform_do_not_depend_on_ui(path: Path) -> None: + bad = { + m + for m in imports_of(path) + if top(m) == "PyQt6" or m.startswith(("polyglot.ui", "polyglot.app", "polyglot.controller")) + } + assert not bad, f"{path.name} depends on the UI layer: {sorted(bad)}" + + +def test_presenter_is_qt_free_and_adapter_free() -> None: + imports = imports_of(SRC / "ui" / "presenter.py") + assert not {m for m in imports if top(m) == "PyQt6" or m.startswith("polyglot.adapters")} + + +@pytest.mark.parametrize("path", modules("ui"), ids=lambda p: p.name) +def test_ui_does_not_reach_into_adapters(path: Path) -> None: + assert not { + m for m in imports_of(path) if m.startswith(("polyglot.adapters", "polyglot.wiring")) + } + + +def test_controller_and_wiring_are_qt_free() -> None: + for name in ("controller.py", "wiring.py", "config.py"): + assert not {m for m in imports_of(SRC / name) if top(m) == "PyQt6"}, name + + +def test_no_platform_checks_outside_platform_layer() -> None: + allowed = {"platform"} + offenders = [] + for path in SRC.rglob("*.py"): + if path.relative_to(SRC).parts[0] in allowed: + continue + text = path.read_text(encoding="utf-8") + if "platform.system()" in text or "sys.platform ==" in text: + offenders.append(str(path.relative_to(SRC))) + assert not offenders, f"OS checks belong in polyglot.platform: {offenders}" diff --git a/tests/unit/test_config.py b/tests/unit/test_config.py new file mode 100644 index 0000000..77c0fed --- /dev/null +++ b/tests/unit/test_config.py @@ -0,0 +1,197 @@ +from __future__ import annotations + +import sys +from pathlib import Path + +import pytest + +from polyglot.adapters.secrets import MemorySecretStore +from polyglot.config import ( + AppConfig, + Secrets, + changed_sections, + load_config, + save_config, + to_toml, +) +from polyglot.core.errors import ConfigError + +if sys.version_info >= (3, 11): + import tomllib +else: # pragma: no cover + import tomli as tomllib + + +def test_defaults_are_private_by_default(tmp_path: Path) -> None: + cfg = load_config(tmp_path / "missing.toml", environ={}) + assert cfg == AppConfig() + assert not cfg.translation.enabled and not cfg.suggestions.enabled # cloud is opt-in + assert not cfg.privacy.dump_audio and not cfg.privacy.log_content + + +def test_save_then_load_round_trips(tmp_path: Path) -> None: + path = tmp_path / "config.toml" + cfg = AppConfig() + cfg.asr.model = "small" + cfg.translation.target_language = "fr" + cfg.ui.hotkey_suggest = 'ctrl+"quoted"' + cfg.audio.file = "C:\\Users\\me\\a b.wav" + save_config(cfg, path) + assert load_config(path, environ={}) == cfg + assert [p.name for p in tmp_path.iterdir()] == ["config.toml"] # no temp files left + + +def test_toml_output_is_valid_and_skips_none() -> None: + text = to_toml(AppConfig()) + data = tomllib.loads(text) + assert set(data) == {"audio", "vad", "asr", "translation", "suggestions", "ui", "privacy"} + assert "language" not in data["asr"] # None -> omitted + assert "api_key" not in text + + +def test_precedence_env_over_file_over_default(tmp_path: Path) -> None: + path = tmp_path / "config.toml" + path.write_text( + '[asr]\nmodel = "small"\nbeam_size = 3\n[ui]\nopacity = 0.5\n', encoding="utf-8" + ) + env = { + "POLYGLOT_ASR__MODEL": "medium", + "POLYGLOT_TRANSLATION__ENABLED": "true", + "POLYGLOT_VAD__END_SILENCE_MS": "800", + "POLYGLOT_NOT_A_SECTION__X": "1", + "UNRELATED": "1", + } + cfg = load_config(path, environ=env) + assert cfg.asr.model == "medium" # env beats file + assert cfg.asr.beam_size == 3 # file beats default + assert cfg.ui.opacity == 0.5 + assert cfg.translation.enabled is True + assert cfg.vad.end_silence_ms == 800 + + +@pytest.mark.parametrize( + "content", + [ + "[asr]\nbeam_size = 99\n", + "[vad]\nstart_threshold = 0.3\nend_threshold = 0.6\n", + "[asr]\nunknown = 1\n", + "not toml [", + ], +) +def test_invalid_config_raises_config_error(tmp_path: Path, content: str) -> None: + path = tmp_path / "config.toml" + path.write_text(content, encoding="utf-8") + with pytest.raises(ConfigError): + load_config(path, environ={}) + + +def test_default_sections_are_independent_per_instance() -> None: + a, b = AppConfig(), AppConfig() + a.audio.ring_seconds = 99 + assert b.audio.ring_seconds == 30.0 + + +def test_changed_sections() -> None: + a = AppConfig() + b = a.model_copy(deep=True) + assert changed_sections(a, b) == set() + b.ui.opacity = 0.5 + b.asr.model = "tiny" + assert changed_sections(a, b) == {"ui", "asr"} + + +def test_secrets_env_overrides_store() -> None: + store = MemorySecretStore({Secrets.OPENAI: "from-store"}) + assert Secrets(store, environ={}).get(Secrets.OPENAI) == "from-store" + assert Secrets(store, environ={"OPENAI_API_KEY": "env"}).get(Secrets.OPENAI) == "env" + assert ( + Secrets(store, environ={"POLYGLOT_OPENAI_API_KEY": "p", "OPENAI_API_KEY": "env"}).get( + Secrets.OPENAI + ) + == "p" + ) + s = Secrets(store, environ={}) + s.set(Secrets.GOOGLE, "g") + assert s.get(Secrets.GOOGLE) == "g" + s.set(Secrets.GOOGLE, None) + assert s.get(Secrets.GOOGLE) is None + + +def test_store_keeps_env_overrides_out_of_the_file(tmp_path: Path) -> None: + from polyglot.config import ConfigStore + + path = tmp_path / "config.toml" + path.write_text('[asr]\nmodel = "small"\n', encoding="utf-8") + store = ConfigStore( + path, environ={"POLYGLOT_TRANSLATION__ENABLED": "true", "POLYGLOT_ASR__MODEL": "tiny"} + ) + cfg = store.load() + assert cfg.translation.enabled and cfg.asr.model == "tiny" + cfg.ui.opacity = 0.5 # a real change from the settings dialog + store.save(cfg) + saved = load_config(path, environ={}) + assert saved.ui.opacity == 0.5 + assert saved.translation.enabled is False # env value not persisted + assert saved.asr.model == "small" # file value kept under the env override + + +def test_store_saves_a_dialog_change_to_an_env_overridden_field(tmp_path: Path) -> None: + from polyglot.config import ConfigStore + + path = tmp_path / "config.toml" + store = ConfigStore(path, environ={"POLYGLOT_ASR__MODEL": "tiny"}) + cfg = store.load() + cfg.asr.model = "medium" + store.save(cfg) + assert load_config(path, environ={}).asr.model == "medium" + + +def test_store_refuses_to_overwrite_an_unloadable_file(tmp_path: Path) -> None: + from polyglot.config import ConfigStore + + path = tmp_path / "config.toml" + path.write_text("[asr]\nbeam_size = 99\n", encoding="utf-8") + store = ConfigStore(path, environ={}) + with pytest.raises(ConfigError): + store.load() + with pytest.raises(ConfigError): + store.save(AppConfig()) + assert "beam_size = 99" in path.read_text(encoding="utf-8") + + +def test_numeric_device_and_text_env_values(tmp_path: Path) -> None: + path = tmp_path / "config.toml" + path.write_text("[audio]\ndevice = 3\n", encoding="utf-8") + assert load_config(path, environ={}).audio.device == "3" + cfg = load_config( + tmp_path / "none.toml", + environ={"POLYGLOT_AUDIO__DEVICE": "3", "POLYGLOT_UI__OPACITY": "0.5"}, + ) + assert cfg.audio.device == "3" and cfg.ui.opacity == 0.5 + + +def test_toml_escapes_delete_character() -> None: + cfg = AppConfig() + cfg.ui.hotkey_suggest = "a\x7fb" + assert tomllib.loads(to_toml(cfg))["ui"]["hotkey_suggest"] == "a\x7fb" + + +def test_secret_source() -> None: + store = MemorySecretStore({Secrets.GOOGLE: "g"}) + s = Secrets(store, environ={"OPENAI_API_KEY": "e"}) + assert s.source(Secrets.OPENAI) == "OPENAI_API_KEY" + assert s.source(Secrets.GOOGLE) == "keychain" + assert Secrets(MemorySecretStore(), environ={}).source(Secrets.OPENAI) is None + + +def test_whisper_compute_type_defaults_to_auto(tmp_path: Path) -> None: + # "default" kept the model's saved float16, which CPUs convert to slow float32. + assert AppConfig().asr.compute_type == "auto" + path = tmp_path / "config.toml" + path.write_text('[asr]\ncompute_type = "default"\n', encoding="utf-8") + assert load_config(path, environ={}).asr.compute_type == "auto" # legacy value migrated + path.write_text('[asr]\ncompute_type = "int8"\n', encoding="utf-8") + assert load_config(path, environ={}).asr.compute_type == "int8" + path.write_text('[asr]\ncompute_type = "float64"\n', encoding="utf-8") + with pytest.raises(ConfigError): + load_config(path, environ={}) diff --git a/tests/unit/test_controller.py b/tests/unit/test_controller.py new file mode 100644 index 0000000..c84bd40 --- /dev/null +++ b/tests/unit/test_controller.py @@ -0,0 +1,183 @@ +from __future__ import annotations + +from typing import Any + +from polyglot.adapters.secrets import MemorySecretStore +from polyglot.config import AppConfig, Secrets +from polyglot.controller import AppController +from polyglot.core.errors import ConfigError +from polyglot.core.events import EventBus, StageError +from polyglot.core.models import IdSource +from polyglot.core.session import Session +from polyglot.wiring import Built + + +class FakePipeline: + def __init__(self, session: Session | None, ids: IdSource | None) -> None: + self.session = session or Session("en") + self.ids = ids or IdSource() + self.running = False + self.calls: list[str] = [] + + def start(self) -> None: + self.running = True + self.calls.append("start") + + def stop(self) -> None: + self.running = False + self.calls.append("stop") + + def close(self) -> None: + self.running = False + self.calls.append("close") + + def __getattr__(self, name: str) -> Any: + return lambda *a: self.calls.append(name) + + +class FakeBuilder: + def __init__(self, fail: bool = False) -> None: + self.fail: bool | Exception = fail + self.built: list[FakePipeline] = [] + + def __call__(self, cfg: AppConfig, secrets: Secrets, bus: EventBus, **kw: Any) -> Built: + if isinstance(self.fail, Exception): + raise self.fail + if self.fail: + raise ConfigError("no audio device") + p = FakePipeline(kw.get("session"), kw.get("ids")) + self.built.append(p) + return Built(p, ["a warning"], translation_enabled=True) # type: ignore[arg-type] + + +def make( + builder: FakeBuilder | None = None, +) -> tuple[AppController, FakeBuilder, list[AppConfig], list[Any]]: + builder = builder or FakeBuilder() + saved: list[AppConfig] = [] + bus = EventBus() + events: list[Any] = [] + bus.subscribe(events.append) + c = AppController( + AppConfig(), + Secrets(MemorySecretStore(), environ={}), + bus, + builder=builder, + save=saved.append, + ) + return c, builder, saved, events + + +def test_build_is_lazy_and_once() -> None: + c, b, _, events = make() + assert b.built == [] + c.start() + c.start() + assert len(b.built) == 1 and c.listening + assert any(isinstance(e, StageError) and e.message == "a warning" for e in events) + c.toggle() + assert not c.listening + + +def test_commands_forwarded() -> None: + c, b, _, _ = make() + c.request_suggestion() + c.set_language("es") + c.clear() + assert b.built[0].calls == ["request_suggestion", "set_language", "clear"] + + +def test_display_only_change_saves_without_rebuild() -> None: + c, b, saved, _ = make() + c.start() + new = c.config.model_copy(deep=True) + new.ui.opacity = 0.5 + assert c.apply_config(new) == {"ui"} + assert len(b.built) == 1 and saved == [new] + assert c.apply_config(new) == set() # no change, no save + assert len(saved) == 1 + + +def test_pipeline_change_rebuilds_keeping_conversation_and_listening() -> None: + c, b, _, _ = make() + c.start() + old = b.built[0] + new = c.config.model_copy(deep=True) + new.asr.model = "small" + assert c.apply_config(new) == {"asr"} + assert len(b.built) == 2 + fresh = b.built[1] + assert old.calls[-1] == "close" + assert fresh.session is old.session and fresh.ids is old.ids # conversation continues + assert fresh.running # was listening -> listening again + + +def test_rebuild_when_not_listening_stays_stopped() -> None: + c, b, _, _ = make() + c.ensure_built() + c.rebuild() + assert len(b.built) == 2 and not b.built[1].running + + +def test_build_failure_is_reported_not_raised() -> None: + c, _, _, events = make(FakeBuilder(fail=True)) + c.start() + assert not c.listening + assert any(isinstance(e, StageError) and "no audio device" in e.message for e in events) + + +def test_shutdown_closes() -> None: + c, b, _, _ = make() + c.start() + c.shutdown() + assert b.built[0].calls[-1] == "close" and c.built is None + + +def test_failed_rebuild_keeps_conversation_for_the_next_build() -> None: + c, b, _, events = make() + c.start() + first = b.built[0] + b.fail = ValueError("truncated WAV") # not a PolyglotError: must still be reported + new = c.config.model_copy(deep=True) + new.asr.model = "small" + c.apply_config(new) # must not raise + assert c.built is None + assert any(isinstance(e, StageError) and "truncated" in e.message for e in events) + b.fail = False + c.start() + assert b.built[-1].session is first.session and b.built[-1].ids is first.ids + assert "retranslate_pending" in b.built[-1].calls + + +def test_privacy_change_rebuilds_and_language_change_is_applied() -> None: + c, b, _, _ = make() + c.start() + new = c.config.model_copy(deep=True) + new.privacy.dump_audio = True + c.apply_config(new) + assert len(b.built) == 2 + newer = c.config.model_copy(deep=True) + newer.asr.language = "fr" + c.apply_config(newer) + assert "set_language" in b.built[-1].calls + + +def test_save_failure_is_reported_not_raised() -> None: + bus = EventBus() + events: list[Any] = [] + bus.subscribe(events.append) + + def broken_save(_cfg: AppConfig) -> None: + raise ConfigError("config file could not be loaded") + + c = AppController( + AppConfig(), + Secrets(MemorySecretStore(), environ={}), + bus, + builder=FakeBuilder(), + save=broken_save, + ) + new = c.config.model_copy(deep=True) + new.ui.opacity = 0.5 + assert c.apply_config(new) == {"ui"} + assert any(isinstance(e, StageError) and e.stage == "settings" for e in events) diff --git a/tests/unit/test_events_and_queue.py b/tests/unit/test_events_and_queue.py new file mode 100644 index 0000000..f142f32 --- /dev/null +++ b/tests/unit/test_events_and_queue.py @@ -0,0 +1,96 @@ +from __future__ import annotations + +import threading + +import numpy as np + +from polyglot.core.events import EventBus, PipelineState, PipelineStatus +from polyglot.core.models import SpeechSegment +from polyglot.core.pipeline import AsrQueue + + +def seg(uid: int, final: bool = True, version: int = 0) -> SpeechSegment: + return SpeechSegment(uid, np.zeros(4, dtype=np.float32), 0.0, 1.0, final, version) + + +# ------------------------------------------------------------------ EventBus +def test_bus_delivers_to_all_and_unsubscribes() -> None: + bus = EventBus() + a: list[object] = [] + b: list[object] = [] + unsub_a = bus.subscribe(a.append) + bus.subscribe(b.append) + ev = PipelineStatus(PipelineState.LISTENING) + bus.publish(ev) + unsub_a() + bus.publish(ev) + assert a == [ev] + assert b == [ev, ev] + + +def test_failing_subscriber_does_not_break_others() -> None: + bus = EventBus() + got: list[object] = [] + + def boom(_: object) -> None: + raise RuntimeError("subscriber bug") + + bus.subscribe(boom) + bus.subscribe(got.append) + bus.publish(PipelineStatus(PipelineState.STOPPED)) + assert len(got) == 1 + + +def test_bus_is_safe_under_concurrent_subscribe_and_publish() -> None: + bus = EventBus() + counts: list[int] = [] + stop = threading.Event() + + def publisher() -> None: + while not stop.is_set(): + bus.publish(PipelineStatus(PipelineState.LISTENING)) + + t = threading.Thread(target=publisher) + t.start() + for _ in range(200): + unsub = bus.subscribe(lambda _e: counts.append(1)) + unsub() + stop.set() + t.join() + + +# ------------------------------------------------------------------ AsrQueue +def test_finals_fifo_and_bounded_drop_oldest() -> None: + q = AsrQueue(max_finals=2) + assert q.put_final(seg(1)) is None + assert q.put_final(seg(2)) is None + dropped = q.put_final(seg(3)) + assert dropped is not None and dropped.utterance_id == 1 + assert [q.get(0).utterance_id, q.get(0).utterance_id] == [2, 3] # type: ignore[union-attr] + assert q.get(0) is None + + +def test_partial_slot_keeps_only_latest_per_utterance() -> None: + q = AsrQueue(4) + q.put_partial(seg(5, final=False, version=0)) + q.put_partial(seg(5, final=False, version=1)) + q.put_partial(seg(6, final=False, version=0)) + assert q.depth() == 2 + first = q.get(0) + assert first is not None and (first.utterance_id, first.version) == (5, 1) + + +def test_finals_are_served_before_partials_and_replace_them() -> None: + q = AsrQueue(4) + q.put_partial(seg(7, final=False)) + q.put_final(seg(6)) + q.put_final(seg(7)) # the final for 7 makes its partial pointless + got = [q.get(0) for _ in range(3)] + assert [(g.utterance_id, g.is_final) for g in got if g] == [(6, True), (7, True)] + + +def test_close_wakes_waiters() -> None: + q = AsrQueue(1) + threading.Timer(0.02, q.close).start() + assert q.get(2.0) is None + assert q.closed diff --git a/tests/unit/test_presenter.py b/tests/unit/test_presenter.py new file mode 100644 index 0000000..cf740fd --- /dev/null +++ b/tests/unit/test_presenter.py @@ -0,0 +1,182 @@ +from __future__ import annotations + +from typing import Any + +from polyglot.core.events import ( + ConversationCleared, + LanguageChanged, + PipelineState, + PipelineStatus, + StageError, + SuggestionsReady, + SuggestionStarted, + UtteranceDiscarded, + UtteranceUpdated, +) +from polyglot.core.models import ErrorKind, ReplyOption, Suggestion, Utterance, UtteranceStatus +from polyglot.core.ports import ShieldStatus +from polyglot.ui.presenter import Presenter, RowVM, StatusVM, SuggestionVM + + +class FakeView: + def __init__(self) -> None: + self.rows: dict[int, RowVM] = {} + self.calls: list[tuple[str, Any]] = [] + self.suggestion: SuggestionVM | None = None + self.status: StatusVM | None = None + + def upsert_row(self, row: RowVM) -> None: + self.rows[row.id] = row + + def remove_row(self, uid: int) -> None: + self.rows.pop(uid, None) + + def clear_rows(self) -> None: + self.rows.clear() + + def show_suggestions(self, vm: SuggestionVM) -> None: + self.suggestion = vm + + def set_status(self, vm: StatusVM) -> None: + self.status = vm + + def __getattr__(self, name: str) -> Any: + return lambda *a: self.calls.append((name, a)) + + +class FakeCommands: + def __init__(self) -> None: + self.calls: list[tuple[str, Any]] = [] + + def __getattr__(self, name: str) -> Any: + return lambda *a: self.calls.append((name, a)) + + +def u(uid: int, status: UtteranceStatus, text: str = "", **kw: Any) -> UtteranceUpdated: + t_end = None if status in (UtteranceStatus.LISTENING, UtteranceStatus.PARTIAL) else 1.0 + return UtteranceUpdated(Utterance(uid, 0.0, t_end, status, text, **kw)) + + +def make(translation: bool = True) -> tuple[Presenter, FakeView, FakeCommands]: + view, cmds = FakeView(), FakeCommands() + return Presenter(view, cmds, user_language="en", translation_enabled=translation), view, cmds + + +def test_row_lifecycle_notes() -> None: + p, view, _ = make() + p.handle(u(1, UtteranceStatus.LISTENING)) + assert view.rows[1].note == "listening…" + p.handle(u(1, UtteranceStatus.PARTIAL, "hola qu")) + assert view.rows[1].partial and view.rows[1].note is None + p.handle(u(1, UtteranceStatus.FINAL, "hola", source_lang="es")) + assert view.rows[1].note == "translating…" + p.handle(u(1, UtteranceStatus.TRANSLATED, "hola", source_lang="es", translation="hello")) + assert view.rows[1] == RowVM(1, "hola", "hello", None, False, False) + + +def test_no_translating_note_when_same_language_or_disabled() -> None: + p, view, _ = make() + p.handle(u(1, UtteranceStatus.FINAL, "hi", source_lang="en")) + assert view.rows[1].note is None + p2, view2, _ = make(translation=False) + p2.handle(u(1, UtteranceStatus.FINAL, "hola", source_lang="es")) + assert view2.rows[1].note is None + + +def test_failures_are_shown_not_hidden() -> None: + p, view, _ = make() + p.handle(u(1, UtteranceStatus.FINAL, "hola", source_lang="es", error=ErrorKind.TIMEOUT)) + assert view.rows[1].note == "translation failed: timed out" + p.handle(u(2, UtteranceStatus.FAILED, "", error=ErrorKind.OVERLOADED)) + assert view.rows[2].failed and "fell behind" in (view.rows[2].note or "") + + +def test_discard_removes_row() -> None: + p, view, _ = make() + p.handle(u(1, UtteranceStatus.LISTENING)) + p.handle(UtteranceDiscarded(1)) + assert 1 not in view.rows and 1 not in p.rows + + +def test_suggestions_labelled_with_sentence_and_marked_stale() -> None: + p, view, _ = make() + p.handle(u(1, UtteranceStatus.FINAL, "¿Qué opina?", source_lang="es")) + p.handle(SuggestionStarted(1)) + assert view.suggestion and view.suggestion.loading and view.suggestion.reply_to == "¿Qué opina?" + p.handle(SuggestionsReady(Suggestion(1, (ReplyOption("Creo que sí", "I think so"),)))) + assert view.suggestion.options[0].say == "Creo que sí" + assert not view.suggestion.stale + p.handle(u(2, UtteranceStatus.FINAL, "Otra cosa", source_lang="es")) + assert view.suggestion.stale # newer sentence said since: offer a refresh + assert view.suggestion.reply_to == "¿Qué opina?" # still linked to what it answers + + +def test_suggestion_error_and_hints() -> None: + p, view, _ = make() + p.handle(StageError("suggest", ErrorKind.NOTHING_TO_ANSWER, "x")) + assert view.suggestion and view.suggestion.message == "Nothing has been said yet." + p.handle(u(1, UtteranceStatus.FINAL, "hola")) + p.handle(SuggestionsReady(Suggestion(1, (), ErrorKind.QUOTA, "quota"))) + assert view.suggestion.message == "Suggestions failed: quota exhausted" + + +def test_status_and_listening_state() -> None: + p, view, _ = make() + p.handle(PipelineStatus(PipelineState.LOADING, "loading speech model")) + assert ("set_listening", (True, True)) in view.calls + p.handle(PipelineStatus(PipelineState.FALLING_BEHIND, "slow")) + assert view.status == StatusVM("Falling behind: slow", "warn") + p.handle(PipelineStatus(PipelineState.STOPPED)) + assert ("set_listening", (False, False)) in view.calls + p.handle(StageError("translate", ErrorKind.AUTH, "bad key")) + assert view.status is not None and view.status.level == "error" + assert "Translation: API key rejected" in view.status.text + p.handle(StageError("setup", ErrorKind.NOT_CONFIGURED, "No key")) + assert view.status == StatusVM("No key", "warn") + + +def test_language_and_capture_labels() -> None: + p, view, _ = make() + p.handle(LanguageChanged("es", locked=True)) + assert ("set_language", ("Spanish (locked)",)) in view.calls + assert p.capture_vm(ShieldStatus.HIDDEN).hidden + assert p.capture_vm(ShieldStatus.UNSUPPORTED).text == "Visible in screen share" + assert "failed" in p.capture_vm(ShieldStatus.FAILED).text + assert "off" in p.capture_vm(None).text + + +def test_user_actions_become_commands() -> None: + p, view, cmds = make() + p.handle(u(1, UtteranceStatus.FINAL, "hola")) + p.on_start_stop() + p.on_suggest() + p.on_unlock_language() + p.on_clear() + assert [c[0] for c in cmds.calls] == ["toggle", "request_suggestion", "set_language", "clear"] + assert cmds.calls[2] == ("set_language", (None,)) + assert 1 in view.rows # cleared only when the core confirms + + +def test_clear_waits_for_core_and_ignores_late_events_for_cleared_rows() -> None: + p, view, _ = make() + p.handle(u(1, UtteranceStatus.FINAL, "hola", source_lang="es")) + p.handle(u(2, UtteranceStatus.LISTENING)) + p.handle(ConversationCleared(upto=2)) + assert view.rows == {} and view.suggestion == SuggestionVM(visible=False) + # Results that were already queued when Clear was pressed must not resurrect rows. + p.handle(u(1, UtteranceStatus.TRANSLATED, "hola", source_lang="es", translation="hello")) + p.handle(SuggestionsReady(Suggestion(2, (ReplyOption("a", "b"),)))) + assert view.rows == {} and view.suggestion == SuggestionVM(visible=False) + p.handle(u(3, UtteranceStatus.LISTENING)) # new conversation + assert list(view.rows) == [3] + + +def test_detach_stops_all_view_updates() -> None: + """Shutdown detaches the presenter first, so a late signal (e.g. the shield status + recomputed while windows are destroyed) cannot reach deleted widgets.""" + p, view, _ = make() + p.detach() + p.on_shield_status(ShieldStatus.HIDDEN) + p.handle(u(1, UtteranceStatus.FINAL, "hola")) + p.handle(LanguageChanged("es", locked=True)) + assert view.calls == [] and view.rows == {} diff --git a/tests/unit/test_ringbuffer.py b/tests/unit/test_ringbuffer.py new file mode 100644 index 0000000..ec7a7fa --- /dev/null +++ b/tests/unit/test_ringbuffer.py @@ -0,0 +1,94 @@ +from __future__ import annotations + +import threading + +import numpy as np +import pytest + +from polyglot.core.ringbuffer import RingBuffer + + +def arange(a: int, b: int) -> np.ndarray: + return np.arange(a, b, dtype=np.float32) + + +def test_reads_back_in_order() -> None: + rb = RingBuffer(10) + rb.write(arange(0, 4)) + rb.write(arange(4, 7)) + assert rb.available() == 7 + np.testing.assert_array_equal(rb.read(), arange(0, 7)) + assert rb.available() == 0 + assert rb.read().size == 0 + + +def test_wraps_around_without_loss() -> None: + rb = RingBuffer(8) + rb.write(arange(0, 6)) + np.testing.assert_array_equal(rb.read(4), arange(0, 4)) + rb.write(arange(6, 12)) # crosses the end of the backing array + np.testing.assert_array_equal(rb.read(), arange(4, 12)) + assert rb.overrun_samples == 0 + + +def test_overrun_drops_oldest_and_counts() -> None: + rb = RingBuffer(5) + rb.write(arange(0, 4)) + rb.write(arange(4, 8)) # 3 samples too many + assert rb.overrun_samples == 3 + np.testing.assert_array_equal(rb.read(), arange(3, 8)) + + +def test_oversized_block_keeps_newest() -> None: + rb = RingBuffer(4) + rb.write(arange(0, 10)) + assert rb.overrun_samples == 6 + np.testing.assert_array_equal(rb.read(), arange(6, 10)) + + +def test_accepts_2d_column_and_empty() -> None: + rb = RingBuffer(4) + rb.write(np.zeros((0,), dtype=np.float32)) + rb.write(arange(0, 3).reshape(-1, 1)) + np.testing.assert_array_equal(rb.read(), arange(0, 3)) + + +def test_wait_wakes_on_write_and_clear() -> None: + rb = RingBuffer(16) + assert not rb.wait(0.01) + threading.Timer(0.02, lambda: rb.write(arange(0, 2))).start() + assert rb.wait(1.0) + rb.clear() + assert rb.available() == 0 + assert not rb.wait(0.01) + + +def test_rejects_bad_capacity() -> None: + with pytest.raises(ValueError): + RingBuffer(0) + + +def test_concurrent_producer_consumer_preserves_order() -> None: + rb = RingBuffer(4096) + total = 50_000 + got: list[np.ndarray] = [] + + def produce() -> None: + for start in range(0, total, 100): + rb.write(arange(start, start + 100)) + + t = threading.Thread(target=produce) + t.start() + n = 0 + while n < total and (t.is_alive() or rb.available()): + chunk = rb.read() + n += chunk.size + got.append(chunk) + rb.wait(0.001) + t.join() + got.append(rb.read()) + data = np.concatenate(got) + # Whatever survived must be strictly increasing (no reordering, no duplication), + # and everything lost must be accounted for as overrun. + assert np.all(np.diff(data) > 0) + assert data.size + rb.overrun_samples == total diff --git a/tests/unit/test_segmenter.py b/tests/unit/test_segmenter.py new file mode 100644 index 0000000..103b52c --- /dev/null +++ b/tests/unit/test_segmenter.py @@ -0,0 +1,168 @@ +from __future__ import annotations + +import numpy as np +import pytest + +from polyglot.core.models import FRAME_SAMPLES, FRAME_SECONDS, IdSource +from polyglot.core.segmenter import ( + Discarded, + Segmenter, + SegmenterConfig, + SegmentReady, + SpeechStarted, +) + +FRAME = np.zeros(FRAME_SAMPLES, dtype=np.float32) + + +def run(seg: Segmenter, probs: list[float], t0: float = 0.0) -> list[object]: + out: list[object] = [] + for i, p in enumerate(probs): + frame = np.full(FRAME_SAMPLES, i, dtype=np.float32) # frame index encoded in samples + out += seg.push(frame, p, t0 + i * FRAME_SECONDS) + return out + + +def finals(outputs: list[object]) -> list[SegmentReady]: + return [o for o in outputs if isinstance(o, SegmentReady) and o.segment.is_final] + + +def frames_of(ready: SegmentReady) -> list[int]: + audio = ready.segment.audio.reshape(-1, FRAME_SAMPLES) + return [int(f[0]) for f in audio] + + +def make(**kw: object) -> Segmenter: + return Segmenter(SegmenterConfig(**kw), IdSource()) # type: ignore[arg-type] + + +def test_start_needs_consecutive_frames() -> None: + seg = make(start_frames=3) + out = run(seg, [0.9, 0.9, 0.1, 0.9, 0.9]) + assert not any(isinstance(o, SpeechStarted) for o in out) + out = seg.push(FRAME, 0.9, 1.0) + assert out == [SpeechStarted(1, pytest.approx(out[0].t_start))] # type: ignore[union-attr] + assert seg.in_speech + + +def test_pre_roll_is_included_and_t_start_is_its_first_frame() -> None: + seg = make( + pre_roll_ms=96, + start_frames=3, + end_silence_ms=96, + min_utterance_ms=0, + trailing_silence_keep_ms=0, + ) + probs = [0.0] * 10 + [0.9] * 5 + [0.0] * 3 + out = run(seg, probs) + started = [o for o in out if isinstance(o, SpeechStarted)] + assert len(started) == 1 + (ready,) = finals(out) + # pre-roll = 3 frames (96 ms) + the 3 triggering frames -> utterance starts at frame 7 + assert frames_of(ready)[0] == 7 + assert started[0].t_start == pytest.approx(7 * FRAME_SECONDS) + assert ready.segment.t_start == pytest.approx(7 * FRAME_SECONDS) + + +def test_ends_after_silence_and_trims_trailing_silence() -> None: + seg = make( + pre_roll_ms=0, + start_frames=1, + end_silence_ms=320, + trailing_silence_keep_ms=64, + min_utterance_ms=0, + ) + probs = [0.9] * 20 + [0.0] * 10 # 10 frames = 320 ms of silence ends it + out = run(seg, probs) + (ready,) = finals(out) + kept = frames_of(ready) + assert kept == list(range(0, 22)) # 20 speech frames + 2 kept silence frames (64 ms) + assert not seg.in_speech + assert ready.segment.duration == pytest.approx(22 * FRAME_SECONDS) + + +def test_hysteresis_mid_probability_does_not_end_speech() -> None: + seg = make(start_frames=1, end_silence_ms=160, start_threshold=0.5, end_threshold=0.35) + out = run(seg, [0.9] * 5 + [0.4] * 30) # below start, above end threshold + assert finals(out) == [] + assert seg.in_speech + + +def test_short_noise_is_discarded() -> None: + seg = make(start_frames=3, pre_roll_ms=300, min_utterance_ms=300, end_silence_ms=200) + out = run(seg, [0.0] * 5 + [0.9] * 4 + [0.0] * 8) # 4 speech frames = 128 ms + assert [o for o in out if isinstance(o, Discarded)] == [Discarded(1)] + assert finals(out) == [] + + +def test_force_cut_at_quietest_frame_and_continue_as_new_utterance() -> None: + seg = make( + start_frames=1, + pre_roll_ms=0, + max_utterance_s=3.2, + force_cut_window_s=0.64, + min_utterance_ms=0, + ) + n_max = 100 # 3.2 s / 32 ms + probs = [0.9] * n_max + probs[95] = 0.36 # quietest frame inside the last 20 frames (0.64 s) + out = run(seg, probs) + (ready,) = finals(out) + assert ready.segment.utterance_id == 1 + assert frames_of(ready) == list(range(0, 96)) # cut after the quietest frame + started = [o for o in out if isinstance(o, SpeechStarted)] + assert [s.utterance_id for s in started] == [1, 2] + assert started[1].t_start == pytest.approx(96 * FRAME_SECONDS) + assert seg.in_speech # still talking: utterance 2 is open + out = seg.flush() + (rest,) = finals(out) + assert rest.segment.utterance_id == 2 + assert frames_of(rest) == list(range(96, 100)) + + +def test_partials_have_increasing_versions_then_final() -> None: + seg = make( + start_frames=1, + pre_roll_ms=0, + partial_interval_ms=320, + end_silence_ms=320, + min_utterance_ms=0, + ) + out = run(seg, [0.9] * 35 + [0.0] * 10) + partials = [o.segment for o in out if isinstance(o, SegmentReady) and not o.segment.is_final] + assert [p.version for p in partials] == [0, 1, 2] + assert all(p.utterance_id == 1 for p in partials) + assert [len(p.audio) for p in partials] == sorted(len(p.audio) for p in partials) + assert len(finals(out)) == 1 + + +def test_flush_finishes_open_utterance_and_is_idempotent() -> None: + seg = make(start_frames=1, pre_roll_ms=0, min_utterance_ms=0) + run(seg, [0.9] * 10) + out = seg.flush() + assert len(finals(out)) == 1 + assert seg.flush() == [] + + +def test_ids_increase_across_utterances() -> None: + seg = make(start_frames=1, pre_roll_ms=0, end_silence_ms=96, min_utterance_ms=0) + out = run(seg, ([0.9] * 5 + [0.0] * 4) * 3) + assert [f.segment.utterance_id for f in finals(out)] == [1, 2, 3] + + +@pytest.mark.parametrize( + "kw", + [ + {"start_threshold": 0.3, "end_threshold": 0.5}, + {"start_frames": 0}, + {"max_utterance_s": 1.0, "force_cut_window_s": 2.0}, + ], +) +def test_invalid_config_rejected(kw: dict[str, object]) -> None: + with pytest.raises(ValueError): + SegmenterConfig(**kw) # type: ignore[arg-type] + + +def test_rejects_wrong_frame_size() -> None: + with pytest.raises(ValueError): + make().push(np.zeros(100, dtype=np.float32), 0.9, 0.0) diff --git a/tests/unit/test_session_and_models.py b/tests/unit/test_session_and_models.py new file mode 100644 index 0000000..21e24af --- /dev/null +++ b/tests/unit/test_session_and_models.py @@ -0,0 +1,100 @@ +from __future__ import annotations + +import pytest + +from polyglot.core import languages +from polyglot.core.models import IdSource, Utterance, UtteranceStatus +from polyglot.core.session import LanguagePolicy, Session + + +def final(uid: int, text: str = "x") -> Utterance: + return Utterance(id=uid, t_start=0.0, t_end=1.0, status=UtteranceStatus.FINAL, text=text) + + +def test_latest_final_tracks_highest_final_id() -> None: + s = Session("en") + s.put(Utterance(id=1, t_start=0)) + assert s.latest_final_id is None + s.put(final(2)) + s.put(final(1)) # an earlier utterance finishing late does not move "latest" back + assert s.latest_final_id == 2 + s.remove(2) + assert s.latest_final_id == 1 + s.remove(1) + assert s.latest_final_id is None + + +def test_history_before_excludes_failed_partial_and_later() -> None: + s = Session("en") + for uid in range(1, 6): + s.put(final(uid, f"t{uid}")) + s.put(Utterance(id=6, t_start=0, status=UtteranceStatus.PARTIAL, text="p")) + s.put(final(3).evolve(status=UtteranceStatus.FAILED)) + hist = s.history_before(5, limit=3) + assert [u.id for u in hist] == [1, 2, 4][-3:] + assert s.history_before(5, limit=0) == () + assert [u.id for u in s.ordered()] == [1, 2, 3, 4, 5, 6] + + +def test_language_locks_after_agreeing_confident_finals() -> None: + s = Session("en", LanguagePolicy(agree=2, min_probability=0.8)) + assert not s.observe_language("es", 0.95) + assert not s.observe_language("fr", 0.95) # disagreement restarts the streak + assert not s.observe_language("es", 0.95) + assert s.observe_language("es", 0.9) + assert s.locked_language == "es" + assert not s.observe_language("fr", 0.99) # locked: ignored + assert s.locked_language == "es" + + +def test_low_confidence_breaks_the_streak() -> None: + s = Session("en", LanguagePolicy(agree=2, min_probability=0.8)) + s.observe_language("es", 0.95) + s.observe_language("es", 0.5) + assert not s.observe_language("es", 0.95) + assert s.observe_language("es", 0.95) + + +def test_manual_and_forced_language() -> None: + s = Session("en", LanguagePolicy(forced="de")) + assert s.locked_language == "de" and s.language_is_manual + s.set_language(None) + assert s.locked_language is None and not s.language_is_manual + s.set_language("it") + assert s.locked_language == "it" + + +def test_clear() -> None: + s = Session("en") + s.put(final(1)) + s.clear() + assert s.utterances == {} and s.latest_final_id is None + + +def test_id_source_is_monotonic() -> None: + ids = IdSource() + assert [ids(), ids(), ids()] == [1, 2, 3] + assert IdSource(10)() == 10 + + +def test_utterance_is_final_property() -> None: + assert not Utterance(1, 0).is_final + assert final(1).is_final + assert final(1).evolve(status=UtteranceStatus.TRANSLATED).is_final + assert Utterance(1, 0, t_end=1, status=UtteranceStatus.FAILED).is_final + assert not Utterance(1, 0, status=UtteranceStatus.FAILED).is_final + + +@pytest.mark.parametrize( + ("code", "name"), [("es", "Spanish"), ("pt-BR", "Portuguese"), ("zz", "zz"), (None, "Unknown")] +) +def test_language_names(code: str | None, name: str) -> None: + assert languages.name(code) == name + + +def test_same_language() -> None: + assert languages.same_language("en", "en-US") + assert languages.same_language("pt_BR", "pt") + assert not languages.same_language("en", "es") + assert not languages.same_language(None, None) + assert "es" in languages.known_codes() diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..27c5725 --- /dev/null +++ b/uv.lock @@ -0,0 +1,2582 @@ +version = 1 +revision = 5 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] + +[[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.15.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.15'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/d2/f4d173e22df740bc37b1db102b386ba719b66e95b0f0d751f556b387e6d2/anyio-4.15.1.tar.gz", hash = "sha256:9f28306018cbd6d329e64a36d58256edff76dd996fe423bc957326e578b82a94", size = 276966, upload-time = "2026-09-05T10:42:39.44Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl", hash = "sha256:6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101", size = 132079, upload-time = "2026-09-05T10:42:37.923Z" }, +] + +[[package]] +name = "ast-serialize" +version = "0.13.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/21/d5/5dc1ee8a80c3b20a0b63c61b43ba6bc53517faecd1def47bcd752d22268e/ast_serialize-0.13.1.tar.gz", hash = "sha256:401cc84e8888d4d76f2c8d296fa006ed1a5ff993b6aff90dd777c03973efd025", size = 955137, upload-time = "2026-10-17T00:04:17.183Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f3/a8/fbd136b9f70c59e75f59a8e974c84102976f1201828b4f886480ba956936/ast_serialize-0.13.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:3e129d44b0cffbea24a7f40117ce49e30993c3d119e584d4817ebd6f87246456", size = 897306, upload-time = "2026-10-17T00:02:52.479Z" }, + { url = "https://files.pythonhosted.org/packages/50/3f/2ad51e9823a790e7a70fd781e9595ab3abeace27f3aefcaa1939457efd72/ast_serialize-0.13.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:523d45bab16ddaf1399c04c4fe81bbf180f81e33c2f7bcbe76be56b0f7311ab4", size = 1236082, upload-time = "2026-10-17T00:02:54.82Z" }, + { url = "https://files.pythonhosted.org/packages/c0/5c/8e959db5cc2237f9d4c560a8e2253c98f9746883fb4774651e4cda458901/ast_serialize-0.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:638333fb8ae72c62753f9e794fda20290883ddc65b0d85e26e08f8bb227567ad", size = 1221242, upload-time = "2026-10-17T00:02:56.395Z" }, + { url = "https://files.pythonhosted.org/packages/d6/05/ab1c56c3b7adcac88764bba609502d6b4989e449b2dd60eb478e1d20e369/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc34c670747d85d4232834665e247009413eaebe47c69eaf60a5c439aaecaed9", size = 1282105, upload-time = "2026-10-17T00:02:58.275Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f4/41981fcd2ddffe0760e5326be9dcbd2eda9478a8430a637e5123bd8fcb26/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8c8ebd419811c435812d242fb2a173e57dfede198c9ac9a0a584666ebc9b9331", size = 1287905, upload-time = "2026-10-17T00:03:00.068Z" }, + { url = "https://files.pythonhosted.org/packages/6a/43/b783addc5681153707121991b7b47892f7e9c8ba58a0d03b71a3b023ba47/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8899c038b1c15ae8b98e379057fb3ef398ceb0b21d1737a8156dd5a0923b7e51", size = 1541806, upload-time = "2026-10-17T00:03:01.503Z" }, + { url = "https://files.pythonhosted.org/packages/47/10/969db095038ee15270f65ad20d1129c5e4da605bf7e93b70ae640f1c8a9f/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e14c4de98f965647a74e6eaf37e20207124e45451ccd36e84a6f6ebab45e0372", size = 1309946, upload-time = "2026-10-17T00:03:02.971Z" }, + { url = "https://files.pythonhosted.org/packages/06/dd/7c623d2fb0b868948952d1787e629a43b866f7d4caefd5445e20aefacec4/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f3e8a3eff69af640db985360fef35073fb46956dfc3e5c614cf00920d2746dd", size = 1302773, upload-time = "2026-10-17T00:03:04.378Z" }, + { url = "https://files.pythonhosted.org/packages/d4/c2/4d49469110a19a44fc6269f4fd59679bcf84df068f185f89b73bee4da19b/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:75d7750fe98f6f35a96c43aba8d98a2e623e22c778a0c17ab9ede92eb10f5d82", size = 1299579, upload-time = "2026-10-17T00:03:05.88Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9a/2d381f1f262dda15affc8ad643fba1619eb07e7d9f8bd904deffef183006/ast_serialize-0.13.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43e8ddd63e80fc280c2f790157386f27f9b9f6ccb9c4f8e803b863cbfb085769", size = 1355969, upload-time = "2026-10-17T00:03:07.321Z" }, + { url = "https://files.pythonhosted.org/packages/9d/9c/2266794e6c25fa9ce51ce04a9bf4b7e330e3ac9351ba3fa14e487678acdb/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9221e09496fb942901993c1812ee87950cc0ecbb514c7c0f1f5fa6d78f701ed8", size = 1460227, upload-time = "2026-10-17T00:03:08.733Z" }, + { url = "https://files.pythonhosted.org/packages/2b/d6/14deb28e5d8f328f626a0778ea2cf98fe908f2bbcccd804cb6f449ee1782/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:7a5c38bdb93669c596f94fb7204dd6ebe4fadb19058ac9a2faf2948c2a175f96", size = 1562691, upload-time = "2026-10-17T00:03:10.25Z" }, + { url = "https://files.pythonhosted.org/packages/f5/19/7a28c0e5ba54f0d3e054f847a2a549b748cb179ab433321a8dc1b39e398d/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:acf4e9f055d75058ab01536da330648746f2f82b7697a85230547f2d5ebe895c", size = 1558669, upload-time = "2026-10-17T00:03:11.799Z" }, + { url = "https://files.pythonhosted.org/packages/18/9a/f9e2690eab58217f1d395a964a78efa7eaf813a1e38be8dfd9a8d45d0840/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:87427913c325adc811e81e7c9a757b061f47ef1e29114ac479aa0953a2687a98", size = 1665071, upload-time = "2026-10-17T00:03:13.284Z" }, + { url = "https://files.pythonhosted.org/packages/8e/f3/ef5b159a0d7161b404f05e7ec21cf7735ee7edc10c000cd2cbbc7bb6b69a/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:ad88921f95b92bc144d9ad059a0e16f8c1ae69f5239f2d3c6536fd2774f73dfe", size = 1473364, upload-time = "2026-10-17T00:03:14.563Z" }, + { url = "https://files.pythonhosted.org/packages/1d/87/6e8ac4a865124a12cc4f915bf1bcfac3bba426cd5f58d3712a873ee61012/ast_serialize-0.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f8b17e2921e56621bcb46792bd3e0b82ca3b85de78d5936e7b8174ba1758b0aa", size = 1500566, upload-time = "2026-10-17T00:03:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/f5/1e/29155f1621433008013ad5c940a03d41a676be0680c41527040472d37583/ast_serialize-0.13.1-cp314-cp314t-win32.whl", hash = "sha256:2f9a9ce8b0994f757b941f7f7fe384a6666b4162b941ebc5c248081baea18e47", size = 1128674, upload-time = "2026-10-17T00:03:17.481Z" }, + { url = "https://files.pythonhosted.org/packages/bb/64/2506da65143ea138de5822e9173e0b72320a2f70e23bd723f044033175f1/ast_serialize-0.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5d99910e6b9a9b9360bcca2ae99aee36cc912ce058df2a57d1c33099b6cb2593", size = 1163306, upload-time = "2026-10-17T00:03:19.046Z" }, + { url = "https://files.pythonhosted.org/packages/6d/8f/c7cb22638899b0cf15908809c270560e46395e65604bc59e4b623ab9f405/ast_serialize-0.13.1-cp314-cp314t-win_arm64.whl", hash = "sha256:a789cbe14d0a0e9ec9b32a456e5abc81ad8799479c3cfd88a29e3442262aebe6", size = 1133775, upload-time = "2026-10-17T00:03:20.377Z" }, + { url = "https://files.pythonhosted.org/packages/2b/e2/b0c140fe50fa39dd249e382f7733af6f816c90021fe7959a0b026f86237f/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:23d768369b89d551077dc173da6892fad00443338417523b6732f4e8ba4a7ed5", size = 1236160, upload-time = "2026-10-17T00:03:21.945Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/a8a2ca21e3943555b48221f8fba546877a7ad39efaf6505506524967d7c4/ast_serialize-0.13.1-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:68f8829d114dab6c9db4a8bbb8d0e342958faee1b5e15a29022678df639960f8", size = 1222214, upload-time = "2026-10-17T00:03:23.462Z" }, + { url = "https://files.pythonhosted.org/packages/15/19/2f58f2ba64e4799b39de85c140aef09a03aa6ea53be75dd292a9d9b9d8ae/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e385b17d5bde892a6184003a9aff3518387908b73f8f5ea539313c07c8c0ede", size = 1282979, upload-time = "2026-10-17T00:03:24.695Z" }, + { url = "https://files.pythonhosted.org/packages/b1/af/ca6087fe84210c1ccd43e3182917bb70649fa1e69745a90c1d59ba08fea8/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:02686b281ec9b8e9614f6f0db27e12e4cac515f336c5d05b678bc9eb73ff2af5", size = 1288596, upload-time = "2026-10-17T00:03:26.04Z" }, + { url = "https://files.pythonhosted.org/packages/b0/2c/4ef964c763329a0347125e745ec0451ba4fbaceec9efe2ac729b7cd55f17/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a8ab2c2585b2e22e48cd4aff2136fce4eab4ced569b85f150ef9a5a5d6f34d49", size = 1545540, upload-time = "2026-10-17T00:03:27.52Z" }, + { url = "https://files.pythonhosted.org/packages/bb/85/aa961dbb75813cfa94de0ce9a16a9510c226b95f604c405421e727f44bb0/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c652d9f5d52d8b81eff3ff2c95c9dd0f281de45f6ad5d3fa95527550c396454a", size = 1309374, upload-time = "2026-10-17T00:03:29.091Z" }, + { url = "https://files.pythonhosted.org/packages/b4/e6/f2b67c327d9f9533e41791804403ccc2dc457821195a2e51f0b587a90b90/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:121e1d08d58b75c15491cc3003609cbad71ac2b0016043c36d30a6b2032b6605", size = 1303466, upload-time = "2026-10-17T00:03:30.451Z" }, + { url = "https://files.pythonhosted.org/packages/73/1d/33f18b81d1bb1f5d682943ea92fda8130a6593627f12f6201668d40824fd/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:30cf89b6a6844542d116c758725d13de5b97b9410a51ee577715f761270d0c1c", size = 1300576, upload-time = "2026-10-17T00:03:32.102Z" }, + { url = "https://files.pythonhosted.org/packages/25/cb/64914144925f1a4abdd9217e717b122255c38fc5ebe4342f92052f3bacbc/ast_serialize-0.13.1-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:732aaae9e498c973fc63fd7f308009b57c4afa6ff59d0b674d894e57d0bca01a", size = 1355960, upload-time = "2026-10-17T00:03:33.676Z" }, + { url = "https://files.pythonhosted.org/packages/ee/80/bd29379fab2bce19adc0bf9177002b11b23dfe8d8fecf409998b458b4624/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:d9c1a920b2aa0c1e016bed7721689717034ca0dba64ac3a3ff243b003d4e8dd8", size = 1459779, upload-time = "2026-10-17T00:03:35.09Z" }, + { url = "https://files.pythonhosted.org/packages/83/89/012dbe733de05ffdf8e40ca0f9fa5d417cb16ec93a74463c57c001914198/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:847cad4c22953823f5e76d0b126c6f9da670cfa45b1df41b9324e22189d77611", size = 1563399, upload-time = "2026-10-17T00:03:37.285Z" }, + { url = "https://files.pythonhosted.org/packages/69/37/ee4bcb0358bee38744eb0f18560446572d095fe3bf6b63d6f739d08a839c/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_i686.whl", hash = "sha256:aca07de3ca8e3d9f2b716c3c31f4f384fe4bd2d03e09912417cff7a3e08036f7", size = 1558808, upload-time = "2026-10-17T00:03:38.711Z" }, + { url = "https://files.pythonhosted.org/packages/54/1c/ff44c5355251d61ef22934c4430bb31a61de4781d25a992154aac9b8c82a/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:5db12d843d931b9d1f1519ce66b9cbfe72d8563b75c1204d255322254d1964dd", size = 1666324, upload-time = "2026-10-17T00:03:40.376Z" }, + { url = "https://files.pythonhosted.org/packages/c8/bb/6da4bfc8aa3403e6447607131bf3463acaf954d990c6c8b6787c1902ddfe/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:fb8021f4dc3296de18737e3b8b34994411da725374d74a0b9eb32a738f2a23d0", size = 1474089, upload-time = "2026-10-17T00:03:41.715Z" }, + { url = "https://files.pythonhosted.org/packages/21/97/897e33bef2eefd880e6350e375cc66bc5bcd00a139be480fd655f5b3f095/ast_serialize-0.13.1-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:0d764913374ba21df8cd618045b371ed104ce55c6276de7c59e554a4f5ba26fd", size = 1501542, upload-time = "2026-10-17T00:03:43.08Z" }, + { url = "https://files.pythonhosted.org/packages/8d/4c/821211ac83870c27e4412381b7c7838336456b40575bf840e4680b2018d9/ast_serialize-0.13.1-cp315-abi3.abi3t-win32.whl", hash = "sha256:2bad302ae2427454ef9dab71bd5c3ad67188860c39d36daee38f72031edb39c4", size = 1126118, upload-time = "2026-10-17T00:03:44.616Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/2b2d5e6c4fa352874a80618e742ffd32d249dee6c119f4233b51afc6b8f4/ast_serialize-0.13.1-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:032b09d86c785c3984e975378b7861f2a68ac44e22ba7b07b93a536b2524eeb8", size = 1163766, upload-time = "2026-10-17T00:03:45.986Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/d610cfcdabaa44fd62a54ca1fc57a7dba120643798b089a14914973562de/ast_serialize-0.13.1-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:929eda0c419e622ab49df3a4c45f81c57dcc10874bbad55d0470a4a03324dac3", size = 1134043, upload-time = "2026-10-17T00:03:48.453Z" }, + { url = "https://files.pythonhosted.org/packages/f0/89/0e30f9eddf7d44ccf9d25979030754fd0457af61fa4279acb8c293a04f97/ast_serialize-0.13.1-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:bf53a3ba1cbe45399fc1e4ccd684b8f2a11cca450f89706b79122f478534c6f5", size = 897546, upload-time = "2026-10-17T00:03:50.093Z" }, + { url = "https://files.pythonhosted.org/packages/81/92/d705be88ff452b9ba0088b554a0cbd308fd01879da092b33fd2ad7d1aa60/ast_serialize-0.13.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:4bcf1d5f4eefecaa325a34ecf079b2741189e7d0821523f92cb343a389a67489", size = 1242416, upload-time = "2026-10-17T00:03:51.521Z" }, + { url = "https://files.pythonhosted.org/packages/60/c2/98370845a7f35cb8a25782e78284b48e01bf3128339881d48d613f304f8f/ast_serialize-0.13.1-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1b158f1c9e3a0d386913924c57995d6df78224868a4d0f215bdd41587c97b34a", size = 1229729, upload-time = "2026-10-17T00:03:52.825Z" }, + { url = "https://files.pythonhosted.org/packages/d8/8b/2d7ffed76addd9d3fcf37fb171400942735c8912264c763561a85407f6a8/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:77a6201b69ce42e919f2fd9a559138d5410b5d8afff7c3a6b1f500b0481ff7d8", size = 1292255, upload-time = "2026-10-17T00:03:54.148Z" }, + { url = "https://files.pythonhosted.org/packages/6b/2a/bb9e0e719d89cc950fadfcfcc9cb4bc7640419c4228c852f031ab8abf440/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6eb0be64c9b8f1ed26637eef345abe75ea90351c92c85a8aec7838b3af971011", size = 1298501, upload-time = "2026-10-17T00:03:55.559Z" }, + { url = "https://files.pythonhosted.org/packages/7a/32/13ce07dce48226f5bd9cfd8f708ec101a8be05aa430cda4918ce31ce8c82/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7f2427bddfca208e84de700044fadf9aef2769a70bae740a1bdabb89ee9e1117", size = 1553758, upload-time = "2026-10-17T00:03:56.952Z" }, + { url = "https://files.pythonhosted.org/packages/e2/fb/9b51d186db0c20ca28cbaaefd50f03b573c89327b9a2627820cbce22196b/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:88df960e67184a71874e5b2ee014f87d1254a0dbc1f903c7bd7b1ab7733ecaef", size = 1318258, upload-time = "2026-10-17T00:03:58.418Z" }, + { url = "https://files.pythonhosted.org/packages/c5/fa/da311559dd3dae9af5825cf21660775a929b970f72e3786af3f2cd667944/ast_serialize-0.13.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9f99786e0d62082a5b121b3437f3167562133711df22128de1e9886f57f0b226", size = 1313260, upload-time = "2026-10-17T00:04:00.194Z" }, + { url = "https://files.pythonhosted.org/packages/2b/11/97a4b9e5b4776d72f47fcd9a09a497bbf68ec8c1ae074307a2c51e410d85/ast_serialize-0.13.1-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:a01b515b25a03184eff4acef25b981ae007916379682e908fc8785b342a0bf3e", size = 1309992, upload-time = "2026-10-17T00:04:01.575Z" }, + { url = "https://files.pythonhosted.org/packages/2e/c4/62f85121a80cd451ef04f550cf0f7ea0ad9ff46cc4e9a5b9ae439b6527b1/ast_serialize-0.13.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:29422d7bcd9e7f39411571c36cec45ce8a7a9b3ad4b2e7aa64497c15a9e397f6", size = 1362715, upload-time = "2026-10-17T00:04:02.881Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fa/c5f4a545f72a7681e3295bab6e3600ee0862ec4391bed961fe9f735b67e0/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:6ffb0f548a7dc126067fdfb7b2325ab5dfcdeecc29faf5e0f0461c96d6ebfa3d", size = 1469931, upload-time = "2026-10-17T00:04:04.181Z" }, + { url = "https://files.pythonhosted.org/packages/38/a9/65aed4f8fa7a001a7cfdc03e68e844517ab041ba6fb614b7d78a1d6ac056/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:2876444a5f87a7c76f371af3c07c2fda563a08bc8af52568df812e8aba4bf568", size = 1570945, upload-time = "2026-10-17T00:04:05.778Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8c/44b2da991cede79bfbf52089f33a5f0168945466b3d9cd38b5dcf08e7130/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:885a62ec6481ce58ab24c6357360d7a82023b62dd7e5e7ceccf59e9662a3272b", size = 1569978, upload-time = "2026-10-17T00:04:07.347Z" }, + { url = "https://files.pythonhosted.org/packages/46/e4/109b2a5beca700237767d5add920c2f8e1ba9bd5799b0faf143d0e9cf4ef/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:2015fd0165e463aac3b1aadc6a1fa1e5820c14ca950821f4fe02f8a3f6a388d6", size = 1676082, upload-time = "2026-10-17T00:04:08.7Z" }, + { url = "https://files.pythonhosted.org/packages/73/e0/7df70f6dbb11b5762da5416318f08316a1c51348e0d69ec79ca5f98f836a/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:eb41e1906502ac80d24ff343f45008552a3f5b5158607959fe6a07dbfc6eb037", size = 1483207, upload-time = "2026-10-17T00:04:10.162Z" }, + { url = "https://files.pythonhosted.org/packages/1f/bc/523aa1c08bd69b5654621beb3dc1a9035715a4a63762fb8d219d6fb3eb81/ast_serialize-0.13.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ca9acc67f796aa2554fa3037dccc022a4b08b38b2ad153edfac9c9bb7cb1f3c6", size = 1512140, upload-time = "2026-10-17T00:04:11.589Z" }, + { url = "https://files.pythonhosted.org/packages/66/83/6607060659998f00afdea0d8375c1e6e2b7d515ab905090d9a5a02f48851/ast_serialize-0.13.1-cp39-abi3-win32.whl", hash = "sha256:4f98da562e5901d69c7dd30885594c5438f859edf354e9ac7517d188fb026c3a", size = 1131889, upload-time = "2026-10-17T00:04:12.953Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6f/bafd6490fe7b355627fabe95f4417e3d02da93102c8552550eb9a0774e1e/ast_serialize-0.13.1-cp39-abi3-win_amd64.whl", hash = "sha256:ddf7cbc9c8abf70102c4a088efe154bb86bfb825b0a10e556d2b15972cf99bd7", size = 1171153, upload-time = "2026-10-17T00:04:14.362Z" }, + { url = "https://files.pythonhosted.org/packages/11/25/4235f4b375a67a37ac595bf478a5407a744eaf7b64113c1c3a5432b8d954/ast_serialize-0.13.1-cp39-abi3-win_arm64.whl", hash = "sha256:48f11d96c9ec71119612f8e79a8c55c12f2b136716d68347433c561d27a25f43", size = 1139035, upload-time = "2026-10-17T00:04:15.767Z" }, +] + +[[package]] +name = "av" +version = "17.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/5e/e3/477fa20578c284abeda08d91b63ee9abaebc93445d8feeb989d3d444bae1/av-17.1.0.tar.gz", hash = "sha256:7f1e71ff621b66253333926f948e00faae11d855b2442133c65128bca64cdeb3", size = 4288546, upload-time = "2026-06-07T05:52:55.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ca/92/c9d0cea4f6f8f93f5b15a39f99d2d593f922484f22a2d98a8d482283e15b/av-17.1.0-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:19c84fd72af5ef81a20f18fbc6f9aedff9e1455e53a7062c1d4c95926d73da4e", size = 22622703, upload-time = "2026-06-07T05:51:40.405Z" }, + { url = "https://files.pythonhosted.org/packages/dc/57/74399770aa103ee4b5ff6da1781440c91a41901d89abb2433fe88773246e/av-17.1.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:19264c9bb4bee404accc7ce9ec461f2044b7f577a70234d29aafde31ed17de46", size = 18273538, upload-time = "2026-06-07T05:51:43.078Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/27c85b12e9ffa8f3f6854358b3eabcd91f3c29c7dac36843fa1376e833f4/av-17.1.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:22dff0ae582d10ef08c75c2150a4fd27cfc26653b54930c7c27b9f7b3aa20723", size = 34519101, upload-time = "2026-06-07T05:51:45.305Z" }, + { url = "https://files.pythonhosted.org/packages/04/a4/542d4bfd9f4aec5f3265985b9dbc6b259d45c2e668f9714e5f4e05b71e64/av-17.1.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:90c49bc9608377d01e82e747377505419a229464873341db18202d5dddecce5a", size = 36647600, upload-time = "2026-06-07T05:51:48.57Z" }, + { url = "https://files.pythonhosted.org/packages/63/1e/63bd5c59580f38109fa4c452b29b715a20c9a5eb3a078b3c447484593c40/av-17.1.0-cp310-cp310-manylinux_2_31_armv7l.whl", hash = "sha256:cc5a5247622cb77e24c342364eb68f88c1442ddfaab60c1f1f483359d3cc7879", size = 25786289, upload-time = "2026-06-07T05:51:51.674Z" }, + { url = "https://files.pythonhosted.org/packages/70/30/78155cef0c9f8bc13f044130192c58bf962f2c9066982ff3593afe8d27f1/av-17.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ff457ed419348e5b8e8c811d341389b052c5e4d5839da3794d019b125b9fe830", size = 35599848, upload-time = "2026-06-07T05:51:54.207Z" }, + { url = "https://files.pythonhosted.org/packages/76/cb/ae1d7a735a5ad9dc502dba864c51d605cbe932a769218352fd570254c38e/av-17.1.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:1370b11a697eb3f2555906f8ab3519b0cfe48425d7830a3996ad42e6bffafda5", size = 26776479, upload-time = "2026-06-07T05:51:56.788Z" }, + { url = "https://files.pythonhosted.org/packages/fb/40/128429b9eb0c4a2beb122ed8d04b189515df68967987c2654a2e262a5c43/av-17.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3dcd41e53f53f9a3260751d9c3c11d34e93d70d61e506c81f13dbc1e3606e07b", size = 37763744, upload-time = "2026-06-07T05:51:59.222Z" }, + { url = "https://files.pythonhosted.org/packages/01/6a/5980e7bbeeadfd7a9db8e38e9f1140a3e0c392fccc31bd7b1e4a75cf5a96/av-17.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:3453b06075c7bb973fdb6de52563f7692ff05cbc64c0bb45f4fd6e8709131f2f", size = 28126516, upload-time = "2026-06-07T05:52:01.658Z" }, + { url = "https://files.pythonhosted.org/packages/ec/87/8036b5c781bc3639ea04ef42d4e26da253bd4bd4311d8705b6a1c8824047/av-17.1.0-cp311-abi3-macosx_11_0_x86_64.whl", hash = "sha256:ad7b4aa011093324b7118245f50ac6db244cfe9900d4072508a5245a2b0d3f41", size = 22460847, upload-time = "2026-06-07T05:52:04.261Z" }, + { url = "https://files.pythonhosted.org/packages/6d/af/dfdf6fc7b17814b50d0aa9e7a7e37b87be91be3890f44b0d525433cd1fd1/av-17.1.0-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:43ebbe977f19a7f2d2bd1a4e119675a0b15e05852cf7309846b6ab922ba7ffe9", size = 18159115, upload-time = "2026-06-07T05:52:06.64Z" }, + { url = "https://files.pythonhosted.org/packages/ad/13/64f6c466471cea225b8b2f4cdc51a571f8a286984b55a08d169b932fda5d/av-17.1.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6a20658ec7d96a70e14b1196eff00b7cdd8831ac3b99868e16b8ba8b24090847", size = 33224427, upload-time = "2026-06-07T05:52:09.165Z" }, + { url = "https://files.pythonhosted.org/packages/77/43/96b35170bf2e64e00a41748c6400ff73232dc0fc62ded283679fb07c7fe0/av-17.1.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f9a65d1f48b818323fb411e80358f89d77dec340b01d27c6b2dfbb9cbf4b779f", size = 35370183, upload-time = "2026-06-07T05:52:11.959Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b3/8e8b4b6498731bfbd88e8399a756543f8088f1bd33d08eab678b5aebe728/av-17.1.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:58f7593726437cda5bd19793027e027768450b5c4a594777bf487798a33db702", size = 24459265, upload-time = "2026-06-07T05:52:14.66Z" }, + { url = "https://files.pythonhosted.org/packages/14/ac/ceb84b7553db21f1143d817245c560d9267168e1e58b1a8eeae2b62c4d04/av-17.1.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:bbab058bd965309f39962e53caac8126987c68c0be094fc4f9427e5615b0218f", size = 34283709, upload-time = "2026-06-07T05:52:17.389Z" }, + { url = "https://files.pythonhosted.org/packages/59/f9/4115fd84148c9a1cf365096694be6ac882fd3cd3cdb7a2f35e71fecf1631/av-17.1.0-cp311-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:9514cfda85180554c430695282faf4be3ffdf95775d8519733821244eecb58e0", size = 25397573, upload-time = "2026-06-07T05:52:20.012Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ac/92e52d5ed0e0b84d9d93e52b4338c2713d8a44082b8696e6516fdae7c4e4/av-17.1.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e1c90f85cd7431ede95b11e8e711571a896ebea433f298849c2c0f1594c8d86e", size = 36451495, upload-time = "2026-06-07T05:52:22.581Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f2/53a7cd34adb6a971d7e6d99663e74db286966c9db8afdca17472fdf0f98e/av-17.1.0-cp311-abi3-win_amd64.whl", hash = "sha256:5df5c1172ef1cf65a1529d612f7da7798ce2cf82c1ff7212466b538a6cc7214c", size = 28036393, upload-time = "2026-06-07T05:52:25.657Z" }, + { url = "https://files.pythonhosted.org/packages/66/47/cd9ae0edf2206351c1251bb94b5ec58728e42c5f6ee16c03c412f3a1bb3e/av-17.1.0-cp311-abi3-win_arm64.whl", hash = "sha256:ee98534242a74da847af78624779ac5a3177dc7c69f956a4da9e6f0fdb37d7f6", size = 21174601, upload-time = "2026-06-07T05:52:28.077Z" }, + { url = "https://files.pythonhosted.org/packages/36/90/b5668cddb3c401fcf22553bc495d5b0c6d8a01d118624b26f0db1d0b8653/av-17.1.0-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:5327807c1219293803ef0c5d1578ff3ae1cf638c09e5998962026e1a554ec240", size = 22699499, upload-time = "2026-06-07T05:52:30.335Z" }, + { url = "https://files.pythonhosted.org/packages/e0/7e/7be6bfddb823d045ff9fd5d4deb922ee3847605e162c3882e6c45b4c35ff/av-17.1.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:6c9b71fe5c0c5a8d303b1588d4d8ce9397d6b023f467cfef95000ba1f75507fa", size = 18366696, upload-time = "2026-06-07T05:52:32.645Z" }, + { url = "https://files.pythonhosted.org/packages/a2/23/391dcfa75c1ae1977efca44b753a11b929399b558826670c16a8808dd0e3/av-17.1.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:f997e3351bdf51127c07a74e21741a2996e9230cbeb2d81c14acde761b116c9c", size = 36582649, upload-time = "2026-06-07T05:52:35.218Z" }, + { url = "https://files.pythonhosted.org/packages/fb/32/7312854868b318b9d1b1dcbd1bddb460aaaeac7d57f816e11efec3bef5b1/av-17.1.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:efe9b1397300b67b644ad220c89df4892a76f2debe70f16bae1749fa20526e63", size = 38479390, upload-time = "2026-06-07T05:52:37.968Z" }, + { url = "https://files.pythonhosted.org/packages/2a/72/af47f59b4458e81ca7d89f477698dbfb3d5a0cd8ae6c1e4441d01074af8a/av-17.1.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:fa64e1f1500d01c4a98e7a41dc1a9a35fb4dfe71f5de0389264ec1192200c76a", size = 27127432, upload-time = "2026-06-07T05:52:40.371Z" }, + { url = "https://files.pythonhosted.org/packages/88/85/c2e6861baf0f8c7d21c4ce811d4d424fedac915e3910d3570ce4377717dc/av-17.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ffbd78d73d2c9bf31e9a007c992faec3991428b2941a3b085b84fb82e8c32d19", size = 37406592, upload-time = "2026-06-07T05:52:43.215Z" }, + { url = "https://files.pythonhosted.org/packages/ba/40/3cc13125aea976101c0858af99ac47257c0654411aa199b5d8e81eea7002/av-17.1.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bff8896454b38fcb785a70e5ae0485d7021cb776303a5849393128a30b8f850b", size = 28336228, upload-time = "2026-06-07T05:52:46.134Z" }, + { url = "https://files.pythonhosted.org/packages/a2/38/c7d9c3e746209a1a695c13e3aa7d817229e84a85d0a84271f313d1befdd3/av-17.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:1284addf3c0dd939887a9722dc30df2241a97471ad52c3c507e31583ae22ff02", size = 39490680, upload-time = "2026-06-07T05:52:48.887Z" }, + { url = "https://files.pythonhosted.org/packages/a1/25/9d42da561b7b8f7dabdfaebba07b52977bee58c5c7e4285ac991abcfaa72/av-17.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:ec630be6321b04e317862f6082e84812bbd801e55a3c2298312e3fc8a0a4af4f", size = 28355673, upload-time = "2026-06-07T05:52:51.614Z" }, + { url = "https://files.pythonhosted.org/packages/a8/41/562a61d5a61fba3ffb273a115e249f1d8471b9515c59fcc38b4b9deda238/av-17.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b41647e42884bf543b8e8d0a1dabd4d1b006c99183eb1a2d7afc5b01f73eeff4", size = 21324700, upload-time = "2026-06-07T05:52:53.972Z" }, +] + +[[package]] +name = "av" +version = "18.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/8d/f4/f22114d30d3435e38c6af2b4870f37b864403dca6ae7af747a289ce0a18e/av-18.1.0.tar.gz", hash = "sha256:47bfc286e1bc9de7ab4681fc2b575cd2460a66919d31ffe1bd5aa54fae531a28", size = 4451061, upload-time = "2026-08-12T22:28:18.761Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/d4/d7cdc8bff143c17a6d35924375ae28dd692cacde38700a7d419fde54f44a/av-18.1.0-cp311-abi3-macosx_11_0_x86_64.whl", hash = "sha256:ae75d8bb6467895ed1f8572ededf7ffa49eac07f6e483222f5d7d62a41d12f04", size = 22546147, upload-time = "2026-08-12T22:27:11.851Z" }, + { url = "https://files.pythonhosted.org/packages/3f/c9/37a619297492256b77d5ed906e7d8166c10a26ed251dccf1ae03ab19bff6/av-18.1.0-cp311-abi3-macosx_14_0_arm64.whl", hash = "sha256:b30a4e8d934558e19602b68998a4d9ac9f250fa0dacef216f7e8e40153b13316", size = 18217603, upload-time = "2026-08-12T22:27:14.713Z" }, + { url = "https://files.pythonhosted.org/packages/d9/84/2464ffb64c08c5ce8b522c8e74594714414e3b0575267652c5c51c0574b9/av-18.1.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:6fc837cc51adf80331ac850779cd53b5d4c4460b0ebe9057a02a921c6736f19d", size = 33640142, upload-time = "2026-08-12T22:27:17.835Z" }, + { url = "https://files.pythonhosted.org/packages/27/3a/204dbfc3e08eb4cdc6e6ff57be02150bc44523ebdb50182d10025792ebd9/av-18.1.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:8a032e8d8ebc73dec079364b9b4a6837638a2d106e8472314e685ffbf163e700", size = 35786210, upload-time = "2026-08-12T22:27:20.984Z" }, + { url = "https://files.pythonhosted.org/packages/e1/99/b0d04ec553ff9a7e00455458dfa3a39c8a8f627b273056b4e5fe57d590de/av-18.1.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:3c8b1f8b46f99d52e2d8b0ed5d0cdadf172d24794d46e2077b16e44ed08e26ff", size = 39379798, upload-time = "2026-08-12T22:27:24.432Z" }, + { url = "https://files.pythonhosted.org/packages/56/b1/e00d4feae59160149df6126585e726fdc6300798fd40c5dd324879e81f68/av-18.1.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:ab5ac081bc9eaf54109120d4e56284674fecfbe520d9aa1707c7fa911ec5f4d2", size = 34690321, upload-time = "2026-08-12T22:27:27.769Z" }, + { url = "https://files.pythonhosted.org/packages/dc/94/836fa987e3084d11a21489f11357fb24843ef3aa8faf74ddddfc603d5062/av-18.1.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:191224788d87af06c31784a395bb73f14b72f33d7f4871ace0157de2abdc6276", size = 36859932, upload-time = "2026-08-12T22:27:31.403Z" }, + { url = "https://files.pythonhosted.org/packages/33/b4/76ba21e46704f632004276b85289a1582e95f5eff760436d6149875a1881/av-18.1.0-cp311-abi3-win_amd64.whl", hash = "sha256:ea1480b7a8d5405cb5f382b344731bf125fd2c1c6fae3964f6c48595628387ff", size = 27595679, upload-time = "2026-08-12T22:27:35.177Z" }, + { url = "https://files.pythonhosted.org/packages/4f/ad/a3135884c5753b09773176b97201ae602f67ad14206c395ff838d66bf9b0/av-18.1.0-cp311-abi3-win_arm64.whl", hash = "sha256:5509ec12aaa19fd6601de13cfa6f4cdad450da07982118510592875d970454d6", size = 20257584, upload-time = "2026-08-12T22:27:38.472Z" }, + { url = "https://files.pythonhosted.org/packages/4f/5b/4a756265d7fb164336c8d377bca21c39cfa2c178be23cedee840a69b59c5/av-18.1.0-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:b36b0bae9e4c62f9487c99481ec15e4e3870fcc868522cd6d18fc2d6bfa04f01", size = 22795654, upload-time = "2026-08-12T22:27:42.016Z" }, + { url = "https://files.pythonhosted.org/packages/d5/cc/1bc841462114a1adf4f7d87456ab78a6972e23271e71865fcd2bbd0e7360/av-18.1.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:025f84494cb23278498f03b0d8117d3e47a1cbc9c44b97eb31875cf02251e46b", size = 18435735, upload-time = "2026-08-12T22:27:45.787Z" }, + { url = "https://files.pythonhosted.org/packages/b8/20/005500ed17a2e62a5e4bb94aa3786942560ec2f55ec1895ebf174c87abef/av-18.1.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:08a9ae288299cfcbf739dba4ad0c53b9b71f45184303dd45947920d022fed695", size = 37090807, upload-time = "2026-08-12T22:27:50.14Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f7/11e7f6d848d3690c31ca4f8578167393e619177f1493ccc93b9400852d4e/av-18.1.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:cf8a17466bef07765dbdecc9e66ed9b25d20b4e14f654fbf35345a58ac45fa0c", size = 38976836, upload-time = "2026-08-12T22:27:54.565Z" }, + { url = "https://files.pythonhosted.org/packages/c3/63/b271473b24e806062d31191e40c6d65545e9cf59f80f044eba56dcbba0f4/av-18.1.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d49a5c542dfdc00f43c6cdb6cc41dac1781ee206fe180b56aa7433dfa816dfae", size = 40896630, upload-time = "2026-08-12T22:27:59.118Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9f/2ab7fa292a947ad3466ed8e655eefa3b82f535d7ea598c297b4471a937c4/av-18.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5548b79e2bf1f59b3e9aedc918a72d9dc45b9adaac10ff9470d5dbdda0002e47", size = 37895673, upload-time = "2026-08-12T22:28:03.98Z" }, + { url = "https://files.pythonhosted.org/packages/e9/d8/04507c57249b399c3e4f23f01d221532f357338b5316fd2858fbd343127d/av-18.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7ea063f6690193ea335a1d592d6e0274350d45e2ed6af83ee107cb90cbfd84f", size = 39992431, upload-time = "2026-08-12T22:28:08.736Z" }, + { url = "https://files.pythonhosted.org/packages/d6/d6/bc4b95bea9c2353a7e4d62a3fcfad9adcf0f881741c6ce01ee179d539ce3/av-18.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e4d48b9f12cad009cc72fe4f4099107de5e819c95f82767f4fd01a01481c0661", size = 28497798, upload-time = "2026-08-12T22:28:13.003Z" }, + { url = "https://files.pythonhosted.org/packages/c1/d2/0c277a46f12647c1833f40496e132fb6001e0d19e6144b5ea30896461feb/av-18.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:5cd9085028902c9880622bd37a12fd4b33060f06a52311f6f4867ca9f29a2c3b", size = 21421979, upload-time = "2026-08-12T22:28:16.48Z" }, +] + +[[package]] +name = "av" +version = "19.0.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", +] +sdist = { url = "https://files.pythonhosted.org/packages/23/01/76b6bf563fe907597cf58f10d10168e93fe588b6db9f2658db87e87efa7e/av-19.0.2.tar.gz", hash = "sha256:bebbc52598886480f4d861c575dc2b020785d6c04e1308680ddcc545e1b94c66", size = 4277157, upload-time = "2026-10-21T03:45:30.799Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4a/2f/f51f37820741134516e841053d5ecebf6350fbd451adcbff9ead96aa1244/av-19.0.2-cp312-abi3-macosx_11_0_x86_64.whl", hash = "sha256:f5f7bcf987567cd3f9b01f1c375c59bf59d8a5b98c9c5c154aeda7a11e0c5dce", size = 22627374, upload-time = "2026-10-21T03:44:28.296Z" }, + { url = "https://files.pythonhosted.org/packages/7c/42/067d0bcd2c07103f18cc23b510a8289dd80330e984c49d51ce0bafcee017/av-19.0.2-cp312-abi3-macosx_14_0_arm64.whl", hash = "sha256:b0dff6dfcc6ff9944fbbff15bc4ee2d90a2c1695d493bdea96e86f48823e9feb", size = 18556422, upload-time = "2026-10-21T03:44:31.267Z" }, + { url = "https://files.pythonhosted.org/packages/de/0c/448f89f76cf5e4da35dd6294a1e8155b75daa8839f2f2fa353775855d152/av-19.0.2-cp312-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:04c8e412642c652cb2b1997a9cb2114546ee7d894600c631f4be8ceb26a0d0d2", size = 32683287, upload-time = "2026-10-21T03:44:34.588Z" }, + { url = "https://files.pythonhosted.org/packages/e1/7f/9f1237feb894afa472ef834aa1fbfe4d6398f28dc7e86a1b418650204c36/av-19.0.2-cp312-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9c1da7aad0fa6c13b4a5c1e7985be0d13f8526a96284573acaf3d55ead6d3fe8", size = 34990159, upload-time = "2026-10-21T03:44:37.637Z" }, + { url = "https://files.pythonhosted.org/packages/f1/b5/1bde0e54e525d88ad8f5becae657f8142543fd3be9d10b72141f041ca868/av-19.0.2-cp312-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:9d4f9f78c0ce1f20deb72626fdb3c723757f61a8cd6fbb7dd44d9401884a91fd", size = 44422922, upload-time = "2026-10-21T03:44:41.847Z" }, + { url = "https://files.pythonhosted.org/packages/08/21/65997929fa4dd7c20f64e742aa87205a8d65485718a2ab51633756078e83/av-19.0.2-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:dfe7af5aa8243afd5d4778f85ad1a7c948e37fad272869da1f8f93f8d57fa7ad", size = 33754699, upload-time = "2026-10-21T03:44:45.772Z" }, + { url = "https://files.pythonhosted.org/packages/30/44/4de8c0ff5a5e25ceb0841efc0a4a7530a22d61800bc0cc19a1d03aa04358/av-19.0.2-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:44d3faae747cf04a33f39db8ae983ff3d93adc864ee663bc186b25b686803c3e", size = 36014845, upload-time = "2026-10-21T03:44:49.64Z" }, + { url = "https://files.pythonhosted.org/packages/32/5a/743a83666ded197df8b9957e2800bef9a39d52b23be2ca211bbd14b5fb22/av-19.0.2-cp312-abi3-win_amd64.whl", hash = "sha256:3ce5a1d7b916d13c16ac58f1756f0fee4af2d53f02bc1403e18550b50d375a22", size = 28150949, upload-time = "2026-10-21T03:44:53.434Z" }, + { url = "https://files.pythonhosted.org/packages/42/fe/e79d786628d9c0428f72214dbe4b90ee0c625e04d552a604d5235ff35515/av-19.0.2-cp312-abi3-win_arm64.whl", hash = "sha256:79a277b077e3768a0ea9f881ca0b3bc96d4135a8d3a7a579938adb58718d0dfd", size = 20708023, upload-time = "2026-10-21T03:44:56.435Z" }, + { url = "https://files.pythonhosted.org/packages/08/f5/e7988f64d3debf50748f1c4372a3dac70cfe53720563056cb57bd77771a6/av-19.0.2-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:b632e026f4375037438a6b2b5d6a489e55bc9504fad22078991ef96211bec2a9", size = 22911715, upload-time = "2026-10-21T03:44:59.378Z" }, + { url = "https://files.pythonhosted.org/packages/76/86/dbe91321e6b233970c7fdfdb82cb1750a745e5779ab9ee69a6ce2589b1cb/av-19.0.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:32a8d37bde9e24ad0cc855140cbeecde17a363d7dc7928dcfc71a34b5f3ed387", size = 18864540, upload-time = "2026-10-21T03:45:02.227Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c7/afca86772d825f5eb5fd8d1a193b206ed9a4a0d74ffbe5bbe0a19521ed7d/av-19.0.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:1e7cb7b66a832bce8996af5b94f1cf4014a05ff51e0005feac4cb2566d711020", size = 36479296, upload-time = "2026-10-21T03:45:05.955Z" }, + { url = "https://files.pythonhosted.org/packages/b3/71/6c6fc7e80dd5aa71109cb9324638620c40b7de8f677a6446d2f744295587/av-19.0.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:b559ff381bd800c46fee6a17d7e22a3443708cdd58d0901ae91d27cf5dd0578c", size = 38467551, upload-time = "2026-10-21T03:45:09.493Z" }, + { url = "https://files.pythonhosted.org/packages/3f/93/fa67f5d4180e57e7f740053fd855a6d312f4848f1e5582b8d3ab131184dd/av-19.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:91924f5c836b1cbf89fe1522c642f98e89a733124908561fd49dc7a70e9b6d10", size = 46223361, upload-time = "2026-10-21T03:45:13.396Z" }, + { url = "https://files.pythonhosted.org/packages/25/f9/f98627770ccb4761e8cb87edd8b4bcf91549288bca95130c1a91ea7cdcb8/av-19.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ae4618eab172f8135596972252f39c7399291c921e661c1771ba26b9254b800f", size = 37349208, upload-time = "2026-10-21T03:45:17.213Z" }, + { url = "https://files.pythonhosted.org/packages/7e/3a/183b4f96a604a8544180e256d16f9a6c0534d6b7db22dc22fb0842aa96fc/av-19.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8596fad2017d380708de35ddf9d34f808b8488c912cdc3f361691d866d9dc32d", size = 39475989, upload-time = "2026-10-21T03:45:20.658Z" }, + { url = "https://files.pythonhosted.org/packages/22/6e/84b65c58171a6d75a5d129a9cf856ca730843f8c476f08033e7f9d4a1af6/av-19.0.2-cp314-cp314t-win_amd64.whl", hash = "sha256:9db27c2248112a8eed3edd3ca83cf4405f52a402cda2eb1956035e646e6b99c6", size = 29064804, upload-time = "2026-10-21T03:45:24.24Z" }, + { url = "https://files.pythonhosted.org/packages/60/4e/d96cc9fff457069c52754f63151a0340cb4886330d58e09061f203696b60/av-19.0.2-cp314-cp314t-win_arm64.whl", hash = "sha256:0e425d631510ca21e47c58f3837a9dceae0453c24e926408c8a12b95239cbbd6", size = 21916888, upload-time = "2026-10-21T03:45:27.298Z" }, +] + +[[package]] +name = "backports-tarfile" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/86/72/cd9b395f25e290e633655a100af28cb253e4393396264a98bd5f5951d50f/backports_tarfile-1.2.0.tar.gz", hash = "sha256:d75e02c268746e1b8144c278978b6e98e85de6ad16f8e4b0844a154557eca991", size = 86406, upload-time = "2024-05-28T17:01:54.731Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/fa/123043af240e49752f1c4bd24da5053b6bd00cad78c2be53c0d1e8b975bc/backports.tarfile-1.2.0-py3-none-any.whl", hash = "sha256:77e284d754527b01fb1e6fa8a1afe577858ebe4e9dad8919e34c862cb399bc34", size = 30181, upload-time = "2024-05-28T17:01:53.112Z" }, +] + +[[package]] +name = "cffi" +version = "2.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", version = "3.11", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and implementation_name != 'PyPy'" }, + { name = "pycparser", version = "3.12", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9e/ef/008a1939e372c06329a3fce4279c02f328488f3526744906eeec3da7ad5f/cffi-2.1.1.tar.gz", hash = "sha256:dd31f52ea1086513bb9df30f8fcee9b8918323ae067a3d5b78bc826a000712be", size = 530807, upload-time = "2026-08-03T21:21:18.939Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/d2/2cde336b375f55c76ca670f0be3978cc048e31e24f3b4d7ce8473150a388/cffi-2.1.1-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:baed1e86cc735622097354b9d1281406caf42ff42a886d29faa8e8d1630333be", size = 183779, upload-time = "2026-08-03T21:19:15.602Z" }, + { url = "https://files.pythonhosted.org/packages/94/1a/4b2f7c92293ba05cbd4a9a1b28faaf0326272d9488e6354657571c48a7aa/cffi-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ca82be1a1d406ecfe1d25dc16cb33488e5a16bf4438c9fb590484ea29d92478b", size = 184178, upload-time = "2026-08-03T21:19:16.67Z" }, + { url = "https://files.pythonhosted.org/packages/17/0b/ba385d8ccedf926c3cd06e8e2f327027da5afe5f0eb30f1f7bc43ac55125/cffi-2.1.1-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:42e2f76b9455f5a9a844f770bf3e200ed3da0e15f5df3db9c31fe80b04b3d004", size = 211037, upload-time = "2026-08-03T21:19:17.705Z" }, + { url = "https://files.pythonhosted.org/packages/a3/b9/0f2e58b2cefa33255bff36935d42b13180fe559bba82596540eb404bde7d/cffi-2.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5a59cc1c4442bc3d5c703bf720b51138d0bfc173618807c9ee2490a7541dd3d9", size = 218652, upload-time = "2026-08-03T21:19:18.735Z" }, + { url = "https://files.pythonhosted.org/packages/37/15/180e0dab27b9312c7479003d14c9e547634b7dcb934e2cc4650e1b131a7a/cffi-2.1.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:9f8d177621de5cb38ee3e731eda45d421db093ec0739f46a5594babda7987a98", size = 205422, upload-time = "2026-08-03T21:19:19.96Z" }, + { url = "https://files.pythonhosted.org/packages/18/d4/03026f0c850cbbaa9030750490225b4a7f4d524ea4df72c3cc740a90f4ef/cffi-2.1.1-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:75f80557d1389eddbd0de2681f6a390a0c5338c31ddaa821381c203fc3fd50d9", size = 205444, upload-time = "2026-08-03T21:19:21.246Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/60bebf6f818bec84210ac5b6979ce4eeadce6fbbaabc9c7ab23e506d1ce5/cffi-2.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:194cffa889098ced9976c3fc6340305e43f6303657d298da55366907c05c22d6", size = 218742, upload-time = "2026-08-03T21:19:22.523Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ae/679bf47e73fd77b352171727f07de559a003f14de5d02b904a6ec1fa73ca/cffi-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5bb4e7ea95dcd6a014a6fef62e62467d67d8e582326443f3d68e71d6320a9fcf", size = 221054, upload-time = "2026-08-03T21:19:23.694Z" }, + { url = "https://files.pythonhosted.org/packages/09/b8/eefc0e06913b70aa153bf74c946094a18f58fd4aff11b7f372bfdfdca050/cffi-2.1.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3d22a20b1fb1632cc72c22f95f7b0d2961c3e1c235f245ba4c606c4771035659", size = 213489, upload-time = "2026-08-03T21:19:24.922Z" }, + { url = "https://files.pythonhosted.org/packages/6f/13/4e56852824a03cdf68523a35686f1c28eacd4bd30a7b0a78e682e6e6e1d3/cffi-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:1dea0e4d7d4f11f619fe8c1d76caf49e24405b4b5743c0e3be16a500ecd930c9", size = 220241, upload-time = "2026-08-03T21:19:26.214Z" }, + { url = "https://files.pythonhosted.org/packages/99/7f/040f9e163e4acac3ee3d85b02d00b2576e7ca980d8785f0a3a5f1a9bf7f5/cffi-2.1.1-cp310-cp310-win32.whl", hash = "sha256:7ce713ace7c0e4520535b42b77eaa742c16dab813978064913e5a3cf82973b41", size = 174578, upload-time = "2026-08-03T21:19:27.338Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0b/644a2ec1a4eaba49c2939410bb1eb1d25b09d6d0582f5d2f95c537043725/cffi-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:a48d62ab9d6f4f98c983223a547af44be6ca3691074c31cecced6facd3ba2dc1", size = 185082, upload-time = "2026-08-03T21:19:28.409Z" }, + { url = "https://files.pythonhosted.org/packages/70/d2/16d99a0c4948febc0ebd133a13b2f688ff7f8cb04da971e1128872ce0c03/cffi-2.1.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:c8d2c9fd1f2d16f780d15127abb050d13d1a76c03a4bd87d7e4980e45e511e12", size = 183838, upload-time = "2026-08-03T21:19:29.637Z" }, + { url = "https://files.pythonhosted.org/packages/cd/95/31b535a9f0220ae9f357de4a08d57ce89cb417653c2fd9f075f50822a388/cffi-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:398aff33cee2767e3e781d2554c54bd0dff386bb437581e0d8011fde1a942ec1", size = 184168, upload-time = "2026-08-03T21:19:30.764Z" }, + { url = "https://files.pythonhosted.org/packages/ad/5a/4707a0dc1f203f5dde5a907b0d4e3c25d71120241048bd5bc6f1bb9d4e71/cffi-2.1.1-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:154852545011f779917b11c78db2358d095da62a9a172b78ad0a583ee5adc0d0", size = 211805, upload-time = "2026-08-03T21:19:31.867Z" }, + { url = "https://files.pythonhosted.org/packages/ad/66/c19feabb28485b6e0bbaaafa90837a1ef5d302e90f2178bd33f17a49879b/cffi-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3311ed60d36f83378794e1009ac6258bafbf81f7888b4caa7b35a521e3f95813", size = 218716, upload-time = "2026-08-03T21:19:32.896Z" }, + { url = "https://files.pythonhosted.org/packages/a7/92/500760486c8baab49a7a8a58ba7fc3355ec3974b454b8a09e528efde9e1d/cffi-2.1.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6e192623c49c94421616a5778fba35cf0d5a8d000650c1967ef4448ee5cdd990", size = 205569, upload-time = "2026-08-03T21:19:34.142Z" }, + { url = "https://files.pythonhosted.org/packages/a5/a7/a67c733254d6e7373f7822f8082d8d6beade791e0cf12a7611f376fa61c7/cffi-2.1.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a6e721d4b0e45d5b65e87534470e67b18dcd092c83f68fba09f152b9cbc061af", size = 204907, upload-time = "2026-08-03T21:19:35.174Z" }, + { url = "https://files.pythonhosted.org/packages/f7/a4/4399daaf8f7dfee9d7c3327fdb0426ee041cc63edc358b93911ceb2bfc7a/cffi-2.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:34e261f78cb6ceaaa36f42f2613f4380d94d9c759a9c73c769ee6e0247364632", size = 217807, upload-time = "2026-08-03T21:19:36.286Z" }, + { url = "https://files.pythonhosted.org/packages/28/f7/dabe6da2466ecbd82dc62e7342dc6b1065dad990c06f00f0ede9ebf2a0ed/cffi-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7225e4514edb64eb6740324353e0da0711954fd8d7da4576755b1c6e09b697cd", size = 221252, upload-time = "2026-08-03T21:19:37.416Z" }, + { url = "https://files.pythonhosted.org/packages/ce/87/616202d8e51342c07d2534c510111c4cc37201775ce8f60802c9335d1edd/cffi-2.1.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:df913725b79db7bcf03448f36b7bf8815363417d5b58deecf9305e3e30f0f21a", size = 214214, upload-time = "2026-08-03T21:19:38.507Z" }, + { url = "https://files.pythonhosted.org/packages/b4/c6/ab025d75d2c26c19b087c0124e75ee31cb65032f4fe345d356d8c507ab97/cffi-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f5cfbc5fe74540d335175b656c725d74d90e3730c626d92575eea35029d9afaa", size = 219408, upload-time = "2026-08-03T21:19:39.809Z" }, + { url = "https://files.pythonhosted.org/packages/db/e2/7e8109f65445bdc673a7b54f02c677de462db75674220fd1335efc8eb598/cffi-2.1.1-cp311-cp311-win32.whl", hash = "sha256:f8ec5e643a9a937f64e1999eb9f75d072263751912dc5cd06d3c85f8f44be7c3", size = 174470, upload-time = "2026-08-03T21:19:41.246Z" }, + { url = "https://files.pythonhosted.org/packages/73/c0/77ba02423c2f7d7091143c45cd49e0e6575c4c1967394bb542bd923a9b74/cffi-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:42f6930c31dc7f50732c9ae793c2786c7b6b044195967bbdde40bb9be81c4cc0", size = 185096, upload-time = "2026-08-03T21:19:42.615Z" }, + { url = "https://files.pythonhosted.org/packages/7c/47/9f1f85f9672ceda4984dc6c4f8824e8558992a2972c3d3c81fb8eb28d4ba/cffi-2.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:c7659f22557c5a0bc4855cd635f55edec690cc008a40768527762cb9fb263455", size = 179941, upload-time = "2026-08-03T21:19:43.747Z" }, + { url = "https://files.pythonhosted.org/packages/10/69/43965eccfdead3b9220015fd1320e117be8c6ed01a62ffab76eeb752f5d5/cffi-2.1.1-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:c8c69575568085ba0b1b10c0249d779a214aea6f6522e949a0fc9fb0fcb449d0", size = 184821, upload-time = "2026-08-03T21:19:44.887Z" }, + { url = "https://files.pythonhosted.org/packages/54/7d/16e5a096677b5e313ca80cd5e5170efa3ea44624a82bb111925522da64b1/cffi-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f81b3b8f3d4e343550fa4baa0e479bba9f2d29ce9c2e9b51d1ce1718d7442fcf", size = 184719, upload-time = "2026-08-03T21:19:46.129Z" }, + { url = "https://files.pythonhosted.org/packages/56/e6/8941622732edec876dd17d0453dce07317ae96db34f2ec1436c9d3785986/cffi-2.1.1-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:811bd1e21d32de12efca32393a0ab3f5133b54fce9bd44b8bd77ab07da14bf6a", size = 214799, upload-time = "2026-08-03T21:19:47.218Z" }, + { url = "https://files.pythonhosted.org/packages/44/de/f98430906df1545ffde0d543dd124a7a439bc2cd32b36b9c53f805df7333/cffi-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:68e62fe11f30d5ca8289242866f0a5291402d8529ca2178ab8afc5c9694ae890", size = 222389, upload-time = "2026-08-03T21:19:48.331Z" }, + { url = "https://files.pythonhosted.org/packages/6a/5b/717f1526b9957b34456313c31645c5b82b8fb5c3fe9e4752999be7128bfc/cffi-2.1.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4a7c934f7360e8cd64fe9efadcbd10c7c6364f531e432b9a4bf5ccbc9e0e8b50", size = 210249, upload-time = "2026-08-03T21:19:49.543Z" }, + { url = "https://files.pythonhosted.org/packages/64/b3/f8aa4f3e34986c7e4ec45072d1b1b9dd295b6b18007b45518d79726dd725/cffi-2.1.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:3143d81e29e1e20a9ce10901ec369012947876596f75a222235965f2b7ae832e", size = 208775, upload-time = "2026-08-03T21:19:50.918Z" }, + { url = "https://files.pythonhosted.org/packages/b1/db/dceb9dd5b231e1da801793f8acc9f3c52a7e1afe40bb1aae37e02b0faad5/cffi-2.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c1453022f490d2459a11819d83ad1d586e9ff65a12ac3e705ffebd46d3685dcf", size = 221822, upload-time = "2026-08-03T21:19:52.054Z" }, + { url = "https://files.pythonhosted.org/packages/a0/d2/6cd24ae3be000a634109c247d1475d62e5616d0dc78c82770942ec384248/cffi-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:208f941bb9d18e768138677f0a6d2ce01f590df56043dda1df1535ac57c88517", size = 225232, upload-time = "2026-08-03T21:19:53.109Z" }, + { url = "https://files.pythonhosted.org/packages/cb/52/3fa190537004dd7f0ab860a6dc7c0175b8667f68d1e618a46f5498d30250/cffi-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:210019b6c7cf07f081b4c54635c8cf744377001350e29cc0f81c4377b4797735", size = 223597, upload-time = "2026-08-03T21:19:54.515Z" }, + { url = "https://files.pythonhosted.org/packages/80/fb/0bb75b7039588c074b37ae99f40d9bfddf990ecb2fbc346ebccd2e56b9be/cffi-2.1.1-cp312-cp312-win32.whl", hash = "sha256:046bfc24911b37851ee1b51aab8bffe713d89c68c6a057b09484ce9fd5f69b4e", size = 175292, upload-time = "2026-08-03T21:19:55.566Z" }, + { url = "https://files.pythonhosted.org/packages/d9/79/615cc094e2fb508cade7de88d3b4f6c4ec2bab695c97bce9153dc65aadf5/cffi-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:f53e442b08449d42821fa4a4fba000095af9f62742a500f978a9f557ec44339a", size = 185919, upload-time = "2026-08-03T21:19:56.89Z" }, + { url = "https://files.pythonhosted.org/packages/70/c6/d0ea84713fe46b243a436a18fcd47d639732747e21635c8a27191b06dc30/cffi-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:7bde5e4cc5c10140859842b9d383af292b22639a4dffb725314baf45968cef80", size = 180093, upload-time = "2026-08-03T21:19:58.155Z" }, + { url = "https://files.pythonhosted.org/packages/9d/f4/035513d4117049066b4779dc3b7c0c0fdad175fa13731c9f4003f1cd1478/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:b5bdfd1c873d4e093aabc0ca84c4ca6dbc4f752afb5c86f146d9742580c9da2e", size = 194248, upload-time = "2026-08-03T21:19:59.399Z" }, + { url = "https://files.pythonhosted.org/packages/76/af/2aeb4dbb5fc41a04161ae9ff1518de7cec08e164f44a8ce6a4cf7fd2cd1d/cffi-2.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:31348097ff5bbe827ccc41795d4dd099d9f0625e7def00ee653c137a490c2a6c", size = 196908, upload-time = "2026-08-03T21:20:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/a7/46/2e5fdde8555706dd98139a910ca11be02809f3f605ce956f655d0214e100/cffi-2.1.1-cp313-cp313-macosx_10_15_x86_64.whl", hash = "sha256:9d2055050ea716bd38b7f7f1579c275386646b4894c155a3e2f3cd62ed41b7c6", size = 184805, upload-time = "2026-08-03T21:20:02.02Z" }, + { url = "https://files.pythonhosted.org/packages/55/41/4c7042f317b9217502988f0873af87e16ad606dc20f84e546e3e6ce9764c/cffi-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:19ee6127ee34de7d83ce3d371ebc5ed91addbdcc39f9ab15ce4eb35a4e534971", size = 184764, upload-time = "2026-08-03T21:20:03.141Z" }, + { url = "https://files.pythonhosted.org/packages/43/1f/1c3d90d91811c8f86ced9ed637956c54bfe5b79ca98fe976d7f8c8979f6b/cffi-2.1.1-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:6a8dddef476fab96d066d578fc88526767b836ab5ab21754e1d5bf3879c31c7c", size = 214722, upload-time = "2026-08-03T21:20:04.377Z" }, + { url = "https://files.pythonhosted.org/packages/37/6f/3b5ce4c3b2192d250f04908f2bfd91ef34552ec8f7716a5d4abdb8d67bb2/cffi-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f16c709686a78c727bbbf059f92b0bf41c6fc60deec706d2dc19f529175a6125", size = 222369, upload-time = "2026-08-03T21:20:05.544Z" }, + { url = "https://files.pythonhosted.org/packages/02/10/4b3c75dde3d9663c9e02ba05c2668b954f671d4bbe346413ca8c696b295a/cffi-2.1.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:fcd22650c908d7b7da162bbfaab594a1227a15d1643a98c68b122ac642fa2264", size = 210175, upload-time = "2026-08-03T21:20:06.75Z" }, + { url = "https://files.pythonhosted.org/packages/df/62/14f74b9543e605d17701dc797b815958b8bb70b7624ce1b832ddad48ed6c/cffi-2.1.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:aa9511c62d14da7aacc9b4bf51f3f697a621e83b2d6919008243c3aad168eea3", size = 208670, upload-time = "2026-08-03T21:20:08.04Z" }, + { url = "https://files.pythonhosted.org/packages/95/95/86342356ff5953b3fb06f7ef7c5bee212d45e770abc7218d451b9148313c/cffi-2.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a931079504ecc49efed7744c476a5c343a92fabf66dec2db95edb1b2fdc770e2", size = 221824, upload-time = "2026-08-03T21:20:09.274Z" }, + { url = "https://files.pythonhosted.org/packages/eb/ff/7b3429ff53aafe931ed8a5fc69f481bbef7ba6de87ddcbb63d08f483f613/cffi-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a2d7755bef5a12ed488f4ef1f1b69ee9191d7396083b755a5d2295f6edb4768b", size = 225148, upload-time = "2026-08-03T21:20:10.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/34/a95870b9221e09cf4f2ce3178b1a210abdfe63a1bd357da940418d7b8d15/cffi-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e0bcb7e0f677f543555d2adff3bf19c05f66cdb4796e5ff602442ab2fe3c4ef7", size = 223564, upload-time = "2026-08-03T21:20:12.165Z" }, + { url = "https://files.pythonhosted.org/packages/70/ea/839b50531021a647fb5e929f72cf97bc1ff702b5472166164b5b6e76b851/cffi-2.1.1-cp313-cp313-win32.whl", hash = "sha256:334644fbac4eff73d985a17a91226df55d0f394160c4cfb880e084c8f7161cac", size = 175263, upload-time = "2026-08-03T21:20:13.559Z" }, + { url = "https://files.pythonhosted.org/packages/60/a6/8b149b2c3f2e11aaa1618ef64500b45f50f22c57a977a4dff1aff1f91042/cffi-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:1aa5645c30469b09530c4ebca77ebf8f17618293c58f8549cb1a543a50236e7d", size = 185688, upload-time = "2026-08-03T21:20:14.69Z" }, + { url = "https://files.pythonhosted.org/packages/01/9a/11f687cb39d6a3504060d5242f04f48c735afb4d3d533958a20594890cb2/cffi-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:63bbfd5ded17c4840ac07cd8f1c21ba9d9708141f840b324f422f41b207e3973", size = 180078, upload-time = "2026-08-03T21:20:15.917Z" }, + { url = "https://files.pythonhosted.org/packages/d3/7b/d6bbf82b8b96e7391438898c42f5bd96dd02030fd5b64937d248220003e2/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7dbb61fe3a7699468030f71bbe5f8a0e326a151daa91beb11a6fc1f980c55e1c", size = 194064, upload-time = "2026-08-03T21:20:17.148Z" }, + { url = "https://files.pythonhosted.org/packages/94/e6/bcc91b283be94735e268487a054004f0aa19947b6348fa367db53230abc8/cffi-2.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f24fb43132a4c6b4cb4eb029492919b2db645be6808d738f244fd146c03c32cb", size = 196720, upload-time = "2026-08-03T21:20:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/d9/99/c4b0c17cacdc9c3b8f280026286a9826d6a208c0f047591a3c3ce99b91fd/cffi-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d28630f5854ab07ab1fd4aba756de52326c82e6be15d414b12793f1975048b54", size = 184964, upload-time = "2026-08-03T21:20:19.708Z" }, + { url = "https://files.pythonhosted.org/packages/b3/a9/9db617d05d7367c1ad0ab00b3aa6e6f9281edd689b4ee9ea0e5a84e89c97/cffi-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:661c298b4821edebead0c91edd2b00374d67ad7c5a1f7a91d4442633b79d6a72", size = 184962, upload-time = "2026-08-03T21:20:20.833Z" }, + { url = "https://files.pythonhosted.org/packages/67/b8/b42132ca113dc567d37684437b46ca1dafc885902b02a110a02d5b511857/cffi-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58acb8ab8e295e6c5ea12f888cbb13cf21511ef2a3303a23f4325c29d17fe5c1", size = 222328, upload-time = "2026-08-03T21:20:22.118Z" }, + { url = "https://files.pythonhosted.org/packages/80/10/c5c0cbf0a657aecf59ef511409734230bf556f05a0d6c9eed7aa5c0a0166/cffi-2.1.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:456a61fa52d579ebf9df2e9552ead5129855dbaff6c1e5a9b1bc408809bdc062", size = 209985, upload-time = "2026-08-03T21:20:23.401Z" }, + { url = "https://files.pythonhosted.org/packages/d5/6c/bfa0b87b03b9238148beca990292843c9396ba069b54496596594173de7b/cffi-2.1.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a4f00aa42f75d6e4595e8866e748cc1705adc0cddfeb2ca86d0d03993d63ba03", size = 208530, upload-time = "2026-08-03T21:20:24.628Z" }, + { url = "https://files.pythonhosted.org/packages/e9/02/4e7d553a7ac4b4238b38b3c1b80d486e9d4436f8d2acbf87a0997fe3f402/cffi-2.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b0431303acaea1089ad4b3e9ce4e6518193def1118d4073ca848635ee4ea2e96", size = 221525, upload-time = "2026-08-03T21:20:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/82/1d/a4aaf9babd75acb4d5f223bff71533bee748dd770a382619a798960ee9ba/cffi-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:64faea20f4e2613363a1a9b9c7dd73058f3ecd00133a511e72ad7c511658f527", size = 225053, upload-time = "2026-08-03T21:20:26.985Z" }, + { url = "https://files.pythonhosted.org/packages/81/10/5dc0e7bdd18e22107054288283380fc97a06ae3f1656a106908d666a3c88/cffi-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5c58fe613dc5e5336357eff555824a314d8e43282600435c8d1cb6a7a2fedd13", size = 223213, upload-time = "2026-08-03T21:20:28.277Z" }, + { url = "https://files.pythonhosted.org/packages/0b/e9/d0061c364cde06ee43168a0d076ac1da512cbc380d44767b844ba34fe2b6/cffi-2.1.1-cp314-cp314-win32.whl", hash = "sha256:1a18a57b58cfb21fc28d72e876acf10eaed67a1ed96226f92af4df681d571c4c", size = 177682, upload-time = "2026-08-03T21:20:44.288Z" }, + { url = "https://files.pythonhosted.org/packages/a7/06/1c3e01e3ba14c39f6d10bfbac52753b7e22259e38088e5cfe1d704918690/cffi-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:3222ba5d678f80a030e6afbcc33dc1ae5cb45facabb61cee2c7016b8432fde48", size = 187949, upload-time = "2026-08-03T21:20:45.623Z" }, + { url = "https://files.pythonhosted.org/packages/87/5b/da4e39efe18eeb89cf580ea9cfc66b6a7c3eadb808fc0cc1d3a295cb5a5d/cffi-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:ab36d55f9ed2d067327667c2fea18dda018eb628dd6347aa01dda6cf1f5d3836", size = 182947, upload-time = "2026-08-03T21:20:46.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/59/40338bf421c5accea1d45158170c87006ef1cd371b05c077e76476949728/cffi-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7750c6449dff7864bb9bb27ddfb0267756189201a3afc911d82b3caacd70dfc3", size = 188504, upload-time = "2026-08-03T21:20:29.495Z" }, + { url = "https://files.pythonhosted.org/packages/7d/47/5ecf1023850036e674c77ec4de86182d309ae344e39e7cba984b7df5d647/cffi-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0beceaabe56af686895136a2de78db54ecd8e4046b236b8fd6d6cb61389e9bf2", size = 188259, upload-time = "2026-08-03T21:20:31.291Z" }, + { url = "https://files.pythonhosted.org/packages/2a/9c/92934c3bea9f785b23eba304538c0b4d37a2a96d2431eb3a1bc87a11aa19/cffi-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:49cbc70e6542d4ccccb936558d1064a8012541e78f821f955cff24e357776c94", size = 223864, upload-time = "2026-08-03T21:20:32.571Z" }, + { url = "https://files.pythonhosted.org/packages/4d/45/ba4c93527bc38616a8bd36488acb69a2212d60486794f0c1f318949bbb76/cffi-2.1.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:e2d65b31f36619cda3999b78b2aa9632e76b78448e7a56fc4240824200e7c4fc", size = 211538, upload-time = "2026-08-03T21:20:33.808Z" }, + { url = "https://files.pythonhosted.org/packages/80/e9/b6ef565e452acb932fb0cb5443f44a78efbd1233e566f02b5a83855e9115/cffi-2.1.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:28907ab9bfb6aa13184cfc17c6b8e1023c5ab6fd7076d8c20a35e59fe04f8f29", size = 210688, upload-time = "2026-08-03T21:20:34.974Z" }, + { url = "https://files.pythonhosted.org/packages/9a/95/eff5f0cee78d2eabc7eebffec40d3fc1876b5f3c95582e018bb4b99601f2/cffi-2.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51b31d1c98274844cfd7838ce00bfc27c7423a4dc00fc0772fc3331c2cc90676", size = 223803, upload-time = "2026-08-03T21:20:36.564Z" }, + { url = "https://files.pythonhosted.org/packages/fa/01/579d39fb8bef00a335a23d83757b44feb24cd6345a2c451b64cb67b9c362/cffi-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5e7cecbaadb83884793e05828cee59b210b24583b9c7425d0ba6a754fe22eb4e", size = 226763, upload-time = "2026-08-03T21:20:37.816Z" }, + { url = "https://files.pythonhosted.org/packages/8d/b0/0b44f47c60b01b57b6e2bbd92343f13a85a1d93bc46ccf6e47e244acd99c/cffi-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:25792eac27877609e7bb06d42ff88278a6624fff2ba9bbb523c09616b117e80f", size = 225688, upload-time = "2026-08-03T21:20:38.959Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d2/3b7176cb570a1d3e27faf67b72f591af508036e0d8b2be2ef9af9e8c84bb/cffi-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:8ef53b2de9bcb9197d31854256575d59dbac0cba72ac627bb291ef5eceb74be4", size = 182868, upload-time = "2026-08-03T21:20:40.388Z" }, + { url = "https://files.pythonhosted.org/packages/56/78/31f00c1bcd97c9bbf55f1bfdf5bc809a5de8887473e90bb9960dca825e80/cffi-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:616f097f2fe415bc92a247f02e11f634e1f9e9a83d327e3c915c15089c87869e", size = 194104, upload-time = "2026-08-03T21:20:41.725Z" }, + { url = "https://files.pythonhosted.org/packages/7b/1b/58496f2ed0a35de575250c02a43ab3cc2c04d494a88fed31c1cabc0fd176/cffi-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ad2c86c495b899d862ea0f4b42891b8713a3bd45dd4105c7fd51c2a72f39f3a5", size = 186402, upload-time = "2026-08-03T21:20:43.042Z" }, + { url = "https://files.pythonhosted.org/packages/c1/8f/9ebe220eab48a093d1a5a5e339ab0dc7316eef3bb04d63c42f0251b61f50/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:dddad92b554513a31f272570678ba307fb9f618f05e3d4a5eacafff9eae03e1d", size = 194043, upload-time = "2026-08-03T21:20:48.179Z" }, + { url = "https://files.pythonhosted.org/packages/ff/69/844bad3ece306c4782c2ecb93597035b6690d48704b803914c199da1e8b3/cffi-2.1.1-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:da0e573f9f97159390c89d9f1a9e41908b66d408cc5b58d08cf3847d844c531b", size = 196737, upload-time = "2026-08-03T21:20:49.457Z" }, + { url = "https://files.pythonhosted.org/packages/1b/8a/af668013284634733f02d683458a0728739c7d6ddb5e14cb0c20832266fe/cffi-2.1.1-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:fb92203a88b3d3053034db775110081c49d28be6551923805e039924093761e4", size = 184933, upload-time = "2026-08-03T21:20:50.639Z" }, + { url = "https://files.pythonhosted.org/packages/0c/75/2f5207ff6d1a613133b23a5203cc0c2a628313b5eb3974d7956ae3c57950/cffi-2.1.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:2ae64be792b8966f2c69538199728b290e34726562896df1e5dc8ffd8d8188e8", size = 185002, upload-time = "2026-08-03T21:20:52.173Z" }, + { url = "https://files.pythonhosted.org/packages/e2/31/9e1313b0a6e30e91b3b3d3fff51ae99c857c07738e3afcce1f7334e1b7ab/cffi-2.1.1-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:507a24c282e0f42f8ed737cf048572cbf580468da5555764a8331735e9c736b6", size = 222271, upload-time = "2026-08-03T21:20:53.462Z" }, + { url = "https://files.pythonhosted.org/packages/50/e3/f6234a833e6e08c7007003074723c406559eecf9b48dfc97471e5a8eb7a0/cffi-2.1.1-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:246fa40ce8645a614ff682e0b70f37134e460eaf93a775e0cbe3cca585a67a80", size = 209919, upload-time = "2026-08-03T21:20:54.783Z" }, + { url = "https://files.pythonhosted.org/packages/0d/fc/5f74e293fced6edb51af3a46c4ccf6c23c9943774ecb375ddbd522c76add/cffi-2.1.1-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:471cee653ae88de62096552e6d24ccb4a5adb8c8c9f10b5054d0122c15bf2779", size = 208529, upload-time = "2026-08-03T21:20:56.066Z" }, + { url = "https://files.pythonhosted.org/packages/44/16/29e6d01b388bef055ecd6ca8244b3f4d336bd09e92d5d892187b9601084e/cffi-2.1.1-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aeae0e330c9f6acd681f647d46cefd30c29f93e3392882e792e82080c9691399", size = 221630, upload-time = "2026-08-03T21:20:57.336Z" }, + { url = "https://files.pythonhosted.org/packages/a4/18/fa7f1f6857d5eb88a4ca99ffcbfb7c387a287ccc154c64a73e86314745d7/cffi-2.1.1-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:42a494cee34437f05546455144f2b5d9ac09b1face62bcfce597d2e521066688", size = 225134, upload-time = "2026-08-03T21:20:58.675Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9f/e8e3dfa04a1b4c241f8c91faacad872b4d4efd051d49764ad4e2fd4b9fea/cffi-2.1.1-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:cc572dace3f60ef98d7b12ff411d20f5362feb31a0439eab0085bbfd349982d7", size = 223197, upload-time = "2026-08-03T21:20:59.968Z" }, + { url = "https://files.pythonhosted.org/packages/f8/7e/8debeb04f1ab9fe2a6963964cd6f1aaf7192627b83926586a6a4e089c9fa/cffi-2.1.1-cp315-cp315-win32.whl", hash = "sha256:4f42141fc14250de6dde5ee7ea4432be017252d91f19c5ad043c084cea629cac", size = 177683, upload-time = "2026-08-03T21:21:14.901Z" }, + { url = "https://files.pythonhosted.org/packages/e0/31/5158704cc474ab65c1647932e88be78dc0873f47130e253be38bcaf13d01/cffi-2.1.1-cp315-cp315-win_amd64.whl", hash = "sha256:e6e8cff14d6fb0be70a09c0bdc58096f501952d04624ebf867e0e56da2df8960", size = 187897, upload-time = "2026-08-03T21:21:16.108Z" }, + { url = "https://files.pythonhosted.org/packages/cc/4b/b3a2da8570c704ffc0f9762cdc3ec0f02c8573798e0b5cf7f11c82bbb70f/cffi-2.1.1-cp315-cp315-win_arm64.whl", hash = "sha256:27350daa11d4f10c540e6e89dada4c54feb7256ad03e9a4dc075ebad7ba360d1", size = 182935, upload-time = "2026-08-03T21:21:17.271Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ef/5443574510a1207e6f6bc38ba6e1f1de36cb48fef07b2728bb896a21f430/cffi-2.1.1-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c26608d2222fb1e94487e4a387d85f13eb55d5ed725cb25a0c589ac4ee60e7bc", size = 188464, upload-time = "2026-08-03T21:21:01.163Z" }, + { url = "https://files.pythonhosted.org/packages/7e/ae/a56fa8c4686ad50e148fcbc8d3ae0d03915ff5c30d795058988c24118cef/cffi-2.1.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:4be96343e422f2dfcd12ab5c9f5aebe03f82f737c6bffeca6830b3875cb44aab", size = 188262, upload-time = "2026-08-03T21:21:02.382Z" }, + { url = "https://files.pythonhosted.org/packages/53/b2/6187f46f2912276a3ae284076109cc5c8680482f11f766ccf26db4a86427/cffi-2.1.1-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:937c0052c05a31ca1daf18de3158eed4dbfcb9cc107adbea227728d647be701e", size = 223779, upload-time = "2026-08-03T21:21:03.553Z" }, + { url = "https://files.pythonhosted.org/packages/8a/f6/c3ad28bd19f77047a03084424fbd4cbe997303267c14423737324be0385d/cffi-2.1.1-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:df423d40ee8654634421812bc3b196da3f9bd7d32929da813f8394c4348a5358", size = 211520, upload-time = "2026-08-03T21:21:04.863Z" }, + { url = "https://files.pythonhosted.org/packages/a0/cd/ccac9013a5bd9fd764de118674ab9c805b5ca10c19270d90ee273f8b2240/cffi-2.1.1-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:a730a083190634c65cca36ba5f489531576ebd79bcd5c8e172130f6453127231", size = 210673, upload-time = "2026-08-03T21:21:06.223Z" }, + { url = "https://files.pythonhosted.org/packages/52/86/2976131c639aead931c5bee5aba67e4b09fbeb8018b6f282f70803f923a7/cffi-2.1.1-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:363e05fa78e15116c3c32c210ee36884fd6b9afa6d440e47112c3bd511d64cb6", size = 223835, upload-time = "2026-08-03T21:21:07.539Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0c/33a7aeab2f9c76918c52e084beb39c570db3588133412929e8ec06fab90b/cffi-2.1.1-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:770de9db11e84213beec501cfcaa013b019820ca881e03344dea5844f7876d94", size = 226705, upload-time = "2026-08-03T21:21:08.774Z" }, + { url = "https://files.pythonhosted.org/packages/e3/26/2cde30fdde421130bfc18f70395731a6e6b2053c6a1978a5258ff04e72fa/cffi-2.1.1-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:7da0c5eff80f0197f3b3d1232ec5a682a9325f4ae9016a78f5f5ca35f9ced1f5", size = 225539, upload-time = "2026-08-03T21:21:09.911Z" }, + { url = "https://files.pythonhosted.org/packages/6d/cd/a361394c94b2129d604bb846f624a8e88255a3ee33129c434a00d715e64f/cffi-2.1.1-cp315-cp315t-win32.whl", hash = "sha256:06c72bb76605a4b0cd0aad6930b69d4baf7dd5d806cfc409b824191099700e66", size = 182707, upload-time = "2026-08-03T21:21:11.226Z" }, + { url = "https://files.pythonhosted.org/packages/9b/b5/ba2b299993c26577d529b6ae29841f9e15b9fcf004d65f423f4fcf94ade9/cffi-2.1.1-cp315-cp315t-win_amd64.whl", hash = "sha256:d9c275eaacd24aa73f94ffd6de08fc3f932424d8b6c376f4bed7cde376fe7bc3", size = 193772, upload-time = "2026-08-03T21:21:12.39Z" }, + { url = "https://files.pythonhosted.org/packages/aa/29/35e016098c814cd93de9cd320c66b5bfba14dc6ecedd3cb518fa7c408c69/cffi-2.1.1-cp315-cp315t-win_arm64.whl", hash = "sha256:d18e5ac0f2f03f4f518d3e23db0f0cad7faa1da8620e9c09461d443bbf6e6692", size = 186360, upload-time = "2026-08-03T21:21:13.636Z" }, +] + +[[package]] +name = "click" +version = "8.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/0e/7fa0ef50764b67090eca4114772a2abf8b6148198475e54c660b97caeee6/click-8.5.0.tar.gz", hash = "sha256:ba0d2089de75ea0310e2dde03160e6ca10009947fb95a182f9b54021bb272e34", size = 382235, upload-time = "2026-08-26T13:33:14.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/50/6c0d534c5f134586a8e1ba4e330569e32f057e33372ae556463212fb4cd3/click-8.5.0-py3-none-any.whl", hash = "sha256:255bc9599cf7748b4b1a446ccc735421bd08a2ae529a8b88597d3de5664ee360", size = 125251, upload-time = "2026-08-26T13:33:12.928Z" }, +] + +[[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 = "coloredlogs" +version = "15.0.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "humanfriendly" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cc/c7/eed8f27100517e8c0e6b923d5f0845d0cb99763da6fdee00478f91db7325/coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0", size = 278520, upload-time = "2021-06-11T10:22:45.202Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/06/3d6badcf13db419e25b07041d9c7b4a2c331d3f4e7134445ec5df57714cd/coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934", size = 46018, upload-time = "2021-06-11T10:22:42.561Z" }, +] + +[[package]] +name = "coverage" +version = "7.16.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/2f/55/d1eaf3e73781174340a00dc1ba2aee8a65f82fadb18e2797b192b6b3925b/coverage-7.16.2.tar.gz", hash = "sha256:ca64d9f1f384f151b9511bec01126072acd2f313439f8ed015a22d8790aab6fa", size = 971999, upload-time = "2026-09-27T12:29:01.118Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/72/db17bf5f87568ab524413693385be2eeb03e652ab56c54ea05fa85515675/coverage-7.16.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:23219888477edd736b6fcaec1272d47d93b926e999641ffea7e53a1738e70b2b", size = 223670, upload-time = "2026-09-27T12:25:34.675Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e1/285727a8a74d48de256e8605413ee4cf82301228253ea58e5ab4270138b0/coverage-7.16.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:40c0f00899fe6181ae7f434ceb200e51f5ee4b8ed10e3b5f0b605f0cae15da87", size = 224191, upload-time = "2026-09-27T12:25:36.476Z" }, + { url = "https://files.pythonhosted.org/packages/50/c7/c737b73bac9bf5034f5ff45a4237b7a189d417a4e36751faf5d10c082cbe/coverage-7.16.2-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:a4624f80732f6b427ac58f1f59c577a0994a12e8174b5af6a027b4b58795d4c3", size = 250921, upload-time = "2026-09-27T12:25:37.857Z" }, + { url = "https://files.pythonhosted.org/packages/29/4e/e1d38d27817d91776ca543d01276a67eace3df675a673cac32b12c167d58/coverage-7.16.2-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:191803c4996b499fcd78c2ad5e5f767dcc53cb4dc6de6d6a741b443a1821ef02", size = 252751, upload-time = "2026-09-27T12:25:39.291Z" }, + { url = "https://files.pythonhosted.org/packages/0e/19/14a8e44cbb2ad36ae62aaa03c5eec4a06a7f7df220ea3776af26927acbe2/coverage-7.16.2-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fd670ac43b709c575aefc25bf52d8a598a3bc5017bddfd0a179152ab06a2deb", size = 254616, upload-time = "2026-09-27T12:25:40.506Z" }, + { url = "https://files.pythonhosted.org/packages/f9/72/f5bcad0d9a9b450080032344fbff7ec60c1b0e3d38019f7735dee2b69645/coverage-7.16.2-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:705e5af11d34647efdc170c7840b6857c81cf74be96419a553f237e68e62cb72", size = 256541, upload-time = "2026-09-27T12:25:41.785Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9a/8c735234e8abb52bf5d063f98c780fa942e77c4c0225f9fcb9b33effc346/coverage-7.16.2-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8afd9bf35cc6a1f22eb3634808fa8e0b91902459c5721ef2e4461dfe771d7f08", size = 251589, upload-time = "2026-09-27T12:25:43.269Z" }, + { url = "https://files.pythonhosted.org/packages/35/6a/1bf6d32e55642d6972aa842640e0a8850e612d19ac7d05e2c32fa59dfd34/coverage-7.16.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:3f43bac1856ba269b905302778d4df433d6006489a192174ad77ac528e395032", size = 252660, upload-time = "2026-09-27T12:25:45.051Z" }, + { url = "https://files.pythonhosted.org/packages/53/5b/05b1c0d0e9495cb056155a16066259adc1e935e7411a82a62779bf729975/coverage-7.16.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:f8475460aa33ee28ac896ab1156d0bb3b6c639f7f8383c2677d3359eb35f8205", size = 250660, upload-time = "2026-09-27T12:25:46.51Z" }, + { url = "https://files.pythonhosted.org/packages/05/33/5bc3db57fc9c56b4ef055725c38c34faa818a27d17d65e251371f7f0e3a0/coverage-7.16.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d6276d78f6fca7d0ac066d5da4165c5acd07829e8305c2cb900b738fb3a75a72", size = 254479, upload-time = "2026-09-27T12:25:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/f6/0f/4a5de66daef26eb919213f63b84f45d5065ab2df94cd767fc7c1174ac5e2/coverage-7.16.2-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:736fde09ea39646d11f8e3b76bd3425c075aa4dd45f24891970bb77c14ff20f5", size = 250940, upload-time = "2026-09-27T12:25:49.227Z" }, + { url = "https://files.pythonhosted.org/packages/57/d3/84cd6a11e707e422194739e9734d947746efa5e5b3358ff2d601f823ee45/coverage-7.16.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c85d54e7e8a2ca932fe8399301af9b8d5907ea2a455ffaff6e7d1208db83b943", size = 251543, upload-time = "2026-09-27T12:25:50.554Z" }, + { url = "https://files.pythonhosted.org/packages/ab/bc/3d84c2e2a95f38e346ce3730d9f0e53114f4e8aace72e6e51e014afb9992/coverage-7.16.2-cp310-cp310-win32.whl", hash = "sha256:5139009b5efd2194fc168ee9362f0e191ba612ef5d29242f9269c22f9b8f80c7", size = 225732, upload-time = "2026-09-27T12:25:51.945Z" }, + { url = "https://files.pythonhosted.org/packages/07/86/31f1f3170571a345ab9d8361a7b2f8e0c5698173fbecd1f7149b6e2089ee/coverage-7.16.2-cp310-cp310-win_amd64.whl", hash = "sha256:c3305c38a2fa21a4254f2ace7dd9ef5fc569c9a558b66e7017650b3d637fb95e", size = 226357, upload-time = "2026-09-27T12:25:53.272Z" }, + { url = "https://files.pythonhosted.org/packages/58/fa/ce3baf63d85b730398d92a7162f486f3a5e4e2cc3382a02488b3943725ba/coverage-7.16.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:732d950e51f3ba4fb6209c73250f3e8924fefca42953ee04a9e65d8c02414d7d", size = 223797, upload-time = "2026-09-27T12:25:54.756Z" }, + { url = "https://files.pythonhosted.org/packages/7a/57/9ba29c2aac7f756d479f03d45762120060f0f988788001001bf36e0e6fca/coverage-7.16.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5dca0bb66b4c3d624ba047887bf70270030c150692d543cb501293dc38a9f4b5", size = 224303, upload-time = "2026-09-27T12:25:56.214Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/0d6d60906dca7d28cc1e3fce12a9861801c4fbb6cbf220ad78cd059c9467/coverage-7.16.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:af2a2a8c7c74de0559e0c368d94c8def9e16c58faaee33a0bf081057c4227e3b", size = 254715, upload-time = "2026-09-27T12:25:57.755Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b8/9198b865679379fb165c689c64f6e11105ef380f6bd1c7673e83f73d9f5c/coverage-7.16.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:db5f8394e17f877a625b257f2ba0ce8e728a499c2c1579ad66220272cd3df510", size = 256627, upload-time = "2026-09-27T12:25:59.131Z" }, + { url = "https://files.pythonhosted.org/packages/98/79/9521462cb6072fe394701bc8974b74afd576c9c9355156c7844e1a86a42b/coverage-7.16.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b3146d2317c75f70df2509066d979dadd941f7021cdf9b5db4bcd8568258e25", size = 258724, upload-time = "2026-09-27T12:26:00.691Z" }, + { url = "https://files.pythonhosted.org/packages/a6/76/8d7d5d633db9fe0f3182fedc731bf09f9bcf2366055735152504ad614677/coverage-7.16.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e1d0ced76318bab499693ff25f64faa343415187cb2e4d7befdfdd391a1cf6a", size = 260692, upload-time = "2026-09-27T12:26:02.083Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a7/76cb09c89ba46d74d37428bf93251fc14fb0bbe9e05cc2a5ef61773d318a/coverage-7.16.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:af98ad5ed9d6daaca956201e00bb429a7eb2b080426686f70a20353e0f9839f5", size = 254800, upload-time = "2026-09-27T12:26:03.369Z" }, + { url = "https://files.pythonhosted.org/packages/72/b6/2351c1979aaeb5b4a8091a75b90ca997ad60de36e181ddba267cf61dac97/coverage-7.16.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d56e4d21c56d2046447733f8b118409597db48c01efe898ee9ac24e858ec2d6", size = 256423, upload-time = "2026-09-27T12:26:04.751Z" }, + { url = "https://files.pythonhosted.org/packages/0f/f4/ad9a4f8b5cb2d494fa9452b546fe742ed2f9d3847cc14c05e36279a3e649/coverage-7.16.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1d5d0e3b660506fb84f995814e3118a21efdc0c8eb80127da1be627d90093c17", size = 254487, upload-time = "2026-09-27T12:26:06.082Z" }, + { url = "https://files.pythonhosted.org/packages/6c/1f/a520470472f3e8b01169bf42162b1470c9ba992230432f62ca36269bf3a0/coverage-7.16.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:17228fbca0f22976f797be94e975dcd237799c657d49551c7de1e0654d1202e9", size = 258259, upload-time = "2026-09-27T12:26:07.513Z" }, + { url = "https://files.pythonhosted.org/packages/09/d2/ff26d5938274745855fa61cfcba0245c88ccc10d98d2cbd96064f16cd5a7/coverage-7.16.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:bc0b0ac781d489304b741269857f1f8338b7a26b1b89c06c0344658001ec0035", size = 254216, upload-time = "2026-09-27T12:26:08.982Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1d/5d832d3b06785d9f53267e4f2724a9f60c312eee6ebed9063a461d0d3b45/coverage-7.16.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bf1bd822ec4e387ed245bed0d71151582cf7be9e5309bc4145eefe36083d5878", size = 255125, upload-time = "2026-09-27T12:26:10.35Z" }, + { url = "https://files.pythonhosted.org/packages/55/4d/1d33edbc2fcf7d99e384e393e712aa5a2ebbbd8409825357815982207976/coverage-7.16.2-cp311-cp311-win32.whl", hash = "sha256:7ed238d227e23cc300c3d464babdaf9f6ddc740aa1b15a77ae96136e6a7c4516", size = 225898, upload-time = "2026-09-27T12:26:11.7Z" }, + { url = "https://files.pythonhosted.org/packages/6f/7c/676df4882118756c4f8f560c954eddb93e166d84dda8c5f0b6a829689bde/coverage-7.16.2-cp311-cp311-win_amd64.whl", hash = "sha256:a90700f743e29aa3d75a6ff5f01953176a889c00e526194bc4d281731b88d99d", size = 226369, upload-time = "2026-09-27T12:26:13.375Z" }, + { url = "https://files.pythonhosted.org/packages/7a/0e/a457f4a461b3c5610d845137fdd45fa465e011a64c25af440518ab1f4e41/coverage-7.16.2-cp311-cp311-win_arm64.whl", hash = "sha256:a336eec40e3520d369b8a6cdabb4f596e69a8b42927ca074aa1452fed943238a", size = 226344, upload-time = "2026-09-27T12:26:15.127Z" }, + { url = "https://files.pythonhosted.org/packages/5e/2c/f8296c63c5d542f3d21aed685e56b7031a419037d155bb3382fc0940d249/coverage-7.16.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:218d742afca2b5ad5ca759e93eddedfbcc6eadf8322f080dcefc40b7bd4e2d48", size = 223969, upload-time = "2026-09-27T12:26:16.753Z" }, + { url = "https://files.pythonhosted.org/packages/90/23/6f3dcb1423a0d43216e402ea1746e4a7c7c44f38896b97dd573790f56a40/coverage-7.16.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9a638be322a8d76a41cdb17781c7f82aaee6a66493d8ffb7e2c09ee22423d99", size = 224328, upload-time = "2026-09-27T12:26:18.15Z" }, + { url = "https://files.pythonhosted.org/packages/ac/7d/8f3b6dc920e3fc6732f7678785a2091db439f186afbec30dbf2214d9b1f7/coverage-7.16.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:724bd0f1e81856b35e59fc98cf7b4e544a3cb662e4e0864dca73d4326ee9d808", size = 255832, upload-time = "2026-09-27T12:26:19.799Z" }, + { url = "https://files.pythonhosted.org/packages/d1/36/6c45f15be4eca4ac1062c6a55a323286494c99726a7e58951fe85967ac08/coverage-7.16.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5375ebd99038021b35e99dc88255022912c06565d316212f4a576e4b08d30f5d", size = 258571, upload-time = "2026-09-27T12:26:21.199Z" }, + { url = "https://files.pythonhosted.org/packages/34/fb/b54cbeba3ad89082c2e441278681859e538322cc34b84b2af7ebff00080f/coverage-7.16.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a076277ca9f5750cc230f0f578ebd2620cec60255b25707361699fef6fb465c", size = 259680, upload-time = "2026-09-27T12:26:22.822Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a2/0dc65ec3d61930e1e4c2e371763b15eb4290896eb343a12d5d3091308116/coverage-7.16.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:58d4a54c6ea672afef66d49be922a2c69826c5ae1a42a9cd94f0c9c2bacdf800", size = 261945, upload-time = "2026-09-27T12:26:24.336Z" }, + { url = "https://files.pythonhosted.org/packages/d6/93/5fad7a61f2c14e08e98946fc31c1c7ffc1195061bf3fdc351db3be77a863/coverage-7.16.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcbcfcc059117284c603ff8cb61a65872512882f84a8cf0339241f7f7c2f148", size = 256191, upload-time = "2026-09-27T12:26:25.89Z" }, + { url = "https://files.pythonhosted.org/packages/2d/47/74e5de9227b939ece9f64e729645ddc4296bea10dbfa98721c1333c8be2e/coverage-7.16.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afdf43b72ef3876c1fe66423b91466e37877c9e81e8cec70542b7e8525b9d1b7", size = 257610, upload-time = "2026-09-27T12:26:27.35Z" }, + { url = "https://files.pythonhosted.org/packages/13/fe/2cf28d40b43645d1b72388fe3ee7f7c747533a6a9557bb8c24a7ae74fe1a/coverage-7.16.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9acc7f7ec4a1b5f89bd929fde5b8a714f6fafdc6cc18725413d510aa082b47ad", size = 255757, upload-time = "2026-09-27T12:26:28.949Z" }, + { url = "https://files.pythonhosted.org/packages/d7/3d/7c149fd99fc8bbc39c80db5e688d1d39fd040be2ecb78b8335a51a55b9c0/coverage-7.16.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:80d3f7b48d43ee8fc5e8707a8adb43d743a5a1a85256c25a24f9d6d0e2238fa6", size = 259822, upload-time = "2026-09-27T12:26:30.515Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3f/b283fce09d5995e227bd8e513358dd7471bedc0f78abc85a925ebdb0a2f6/coverage-7.16.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:126d1af8804d7224421fe991ff65d3ce649081560df7a98b1a5ffff07f9923bd", size = 255325, upload-time = "2026-09-27T12:26:32.037Z" }, + { url = "https://files.pythonhosted.org/packages/bf/91/f3325edf0c4223fb1fe1532b8dbef2a1d2f729459a9a7d1a44d073bae534/coverage-7.16.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c19cd6d025c1673f22afcd22c7df8a662d779e05d8e3fa6820c22afb895b0206", size = 257191, upload-time = "2026-09-27T12:26:33.525Z" }, + { url = "https://files.pythonhosted.org/packages/c4/89/21eb5e83ecf2eed523c4eb3d65ae513cd082c8fd1b6deb34c4cb6c332f97/coverage-7.16.2-cp312-cp312-win32.whl", hash = "sha256:152877cdc8a07264882cfcd503ba56a3ef6cba56a70e8c70f6eb8ffd7384789a", size = 226034, upload-time = "2026-09-27T12:26:35.021Z" }, + { url = "https://files.pythonhosted.org/packages/db/de/e3ad6d864c0833624b4f1f9b53f9e58e116c945e5e965c3f1e172c5e84cd/coverage-7.16.2-cp312-cp312-win_amd64.whl", hash = "sha256:e6c52d3307824ff93b39efd99e4185d557db40bd841452abfb32e5d9151ca162", size = 226569, upload-time = "2026-09-27T12:26:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c1/bccc58ebe5489cc70628f635c1932fd371f5d7da850dbcf960f95f4c4afc/coverage-7.16.2-cp312-cp312-win_arm64.whl", hash = "sha256:a678c0b6b22086ec2427359d22e37445d4a792f5fdbbc744112c7dade65cad02", size = 226372, upload-time = "2026-09-27T12:26:38.406Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f6/8eb4f220ef24f84fb27d852d4f9bf83e0c73ec1a4a08dd9a87e3f4529739/coverage-7.16.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1a37c6e478cf687e1aa30a593d19c92c02fad9d122b51ab73f51b8dc7a0c0fc9", size = 223993, upload-time = "2026-09-27T12:26:40.164Z" }, + { url = "https://files.pythonhosted.org/packages/40/23/d4bbaf0c154e0b0c2b5264890dbf6ef098dcb50ec8f2469be9490d191660/coverage-7.16.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0993d0e90858c03943d3cb152e068a20dd4707924deec84dd2230261baae3b1b", size = 224368, upload-time = "2026-09-27T12:26:41.762Z" }, + { url = "https://files.pythonhosted.org/packages/7f/48/fc1e88fd571ec5cb38150b7f89f7696ca1bdf9920e01432febb69774cc85/coverage-7.16.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bb2fc905bbf4e6b7f40806ea79e31515abf6349594cdf0adf27c4215f0463204", size = 255358, upload-time = "2026-09-27T12:26:43.442Z" }, + { url = "https://files.pythonhosted.org/packages/1d/56/6785397d07c29c8e70fbb9a07e97d062b43c21ffc5f12385917847f09f63/coverage-7.16.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4358b9c8c0125b460407f3017c6cce8156e904b32772c5630d27112f52bdbfe5", size = 257955, upload-time = "2026-09-27T12:26:45.725Z" }, + { url = "https://files.pythonhosted.org/packages/27/3b/c8cdd07721e5f99abd81cea970d971997f99bf158c0b85f51bd284179c8b/coverage-7.16.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f15254427c9b33eedac4f198eaf9e356eb4f6214551afb43da6194a2c088ad7", size = 259183, upload-time = "2026-09-27T12:26:47.208Z" }, + { url = "https://files.pythonhosted.org/packages/9b/11/606b192fe43d32574ec6238549d48de588fdcc18485682a5ec0a8ac357f2/coverage-7.16.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9a75a4704ff640e46170042eec1f984385a121227c505d5a16ad8e495f452541", size = 261325, upload-time = "2026-09-27T12:26:49.084Z" }, + { url = "https://files.pythonhosted.org/packages/67/90/eea481f8b0305ceeb33f081a5f47e298391dbd1b589de0c4b3b3aa50d3f2/coverage-7.16.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:14253fc7bb15749b849795a06f5d3b6d8bc3fb8a4b5ddc341faf7a89dce205fc", size = 255531, upload-time = "2026-09-27T12:26:50.509Z" }, + { url = "https://files.pythonhosted.org/packages/6b/be/dedbf9aea1457b120c27ac10b8fc2a357f37fa2b54c3e7286d42980a0a2a/coverage-7.16.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:921415102a90637fcc2e3f169f61dad7699ecf690e8639fc21b813acbedc0967", size = 257329, upload-time = "2026-09-27T12:26:52.005Z" }, + { url = "https://files.pythonhosted.org/packages/fa/cb/b25c19d5bb2bd0f2e4e27fe8e2ffcae80c7a91ae181c0dc749ed60e9b1a4/coverage-7.16.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cce2bc991293f15cc4084ca116827b5900c5f34e1a54dfe83f10ab5c43162eb7", size = 255294, upload-time = "2026-09-27T12:26:53.634Z" }, + { url = "https://files.pythonhosted.org/packages/5f/a2/892c5c5f4ad44b7b2ca009aee705191f3f268f15052244f2f9e3539b2e35/coverage-7.16.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1fa594c887365b69745f25a416806e61085dd07b94c9eae68a6e20730629b23", size = 259444, upload-time = "2026-09-27T12:26:55.243Z" }, + { url = "https://files.pythonhosted.org/packages/ed/99/a562537deba0a3e370182ae71c149be796c39d8087365f17a09188f27145/coverage-7.16.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:11e597173af1dc33d5f8a7332ada544199269a223af1ee1770ddd5e245ad0fe8", size = 255111, upload-time = "2026-09-27T12:26:56.851Z" }, + { url = "https://files.pythonhosted.org/packages/2d/20/854ec68641a9b3362ff068a32dfa41637299761617ef253791dbade6fc76/coverage-7.16.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3e7f99698ba3a7d13988bdd984b7ebf13af4dbe2166dc8502eef90d77603b0a4", size = 256882, upload-time = "2026-09-27T12:26:58.41Z" }, + { url = "https://files.pythonhosted.org/packages/db/0d/748e4518b0ac0f9ff2687c248a6e5f8c0737306e709372632a2556f84443/coverage-7.16.2-cp313-cp313-win32.whl", hash = "sha256:f80bd9f9633eafc73d0a913ba2645c96ba58bba1befc30590f7c0fbfde59d865", size = 226045, upload-time = "2026-09-27T12:26:59.983Z" }, + { url = "https://files.pythonhosted.org/packages/31/fa/6e46edba66a183fe4d99d4bb52c173287e9b8dddabe0888d24cb8210e580/coverage-7.16.2-cp313-cp313-win_amd64.whl", hash = "sha256:8be099e979fc42559328a21828281b4578304191ae46ed4e80a407048a82eee6", size = 226581, upload-time = "2026-09-27T12:27:01.494Z" }, + { url = "https://files.pythonhosted.org/packages/1b/d9/9ef6845367600b336ff75d000444a0d32497d6972c833141bd39356abf68/coverage-7.16.2-cp313-cp313-win_arm64.whl", hash = "sha256:28ff850182a67d117990fa2ce5ea1032836d8c9630dae867e8bdd3bff4533b79", size = 226409, upload-time = "2026-09-27T12:27:03.116Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/577fc0803dab4155dcf808faffbdd7b159256781c0874a8586e17b81b149/coverage-7.16.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4ee546b9e4872ffa194bf07ac87bfa1202ebb824d0795dc1ef22f175545ca90a", size = 224138, upload-time = "2026-09-27T12:27:05.141Z" }, + { url = "https://files.pythonhosted.org/packages/75/9e/e3785ba3ecba2bd11efc74bfe2801ca4b78c4480b15a375648d809a59da3/coverage-7.16.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a2fac6895eb299a2e52d7bbb8fb3903502b9da8d3f5309ceb16ec40c646b58ee", size = 224445, upload-time = "2026-09-27T12:27:06.805Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d0/963ff22d3fd27117da3b8cc442f5bdc91196f783321e1a8ff0ec43476772/coverage-7.16.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:57ff3783f99d75a1e81dd56a9737eb5665e6736a5d93258ba596b6dcad8fd05b", size = 256112, upload-time = "2026-09-27T12:27:08.43Z" }, + { url = "https://files.pythonhosted.org/packages/a8/d4/a306940c81c6ae759e82fff27d20b7fdc6896e422b821f51313cce212b6c/coverage-7.16.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:35f37886699cb9abd29958247d718628d5bc6f39e623dff66a09e546c42a7e03", size = 258727, upload-time = "2026-09-27T12:27:09.927Z" }, + { url = "https://files.pythonhosted.org/packages/b9/a3/d3d99d93b02517087aa05bc0cf2d04d372956b849e5443e059079901429b/coverage-7.16.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fd7a86fdda7cb6d616d178654bd0ad6bc0f3f33c2e478aa598500a1a9e34eda", size = 259909, upload-time = "2026-09-27T12:27:11.55Z" }, + { url = "https://files.pythonhosted.org/packages/08/44/39dd599181726758dd185ae4dc0c0ab3aeabf7ca70e68e145060feeaaa16/coverage-7.16.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ac0f3b379c94acc2f7dce5f5f0b24d44fa1cc6a509717ef83dfee07450c2117c", size = 262481, upload-time = "2026-09-27T12:27:13.17Z" }, + { url = "https://files.pythonhosted.org/packages/99/e8/91ee43f6ded411460c359d7e1aebde4d6fd8f00a2e5394182d9d212eb23c/coverage-7.16.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7d0732c83746bc24123c581a85d9dd96b70ddb538c9076020aa1a041790361e9", size = 256012, upload-time = "2026-09-27T12:27:14.91Z" }, + { url = "https://files.pythonhosted.org/packages/11/8c/e9499ddc33197bd7eabcb1118ca81756fc874457b324e2b479a4804b2ad2/coverage-7.16.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b451c68218c150f616bc9649783ec8de76a59792c759b43aa0c9c0466a465e4", size = 257898, upload-time = "2026-09-27T12:27:16.588Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6e/c081cb5991a0afba99f9c4ad6c74a5fce9513a38ddc64e3e6680c6fed9af/coverage-7.16.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a56ac4fa5a75c7e182e8f62600cfb4aff43c5ed7356a034f3557659c3bec1d90", size = 255938, upload-time = "2026-09-27T12:27:18.19Z" }, + { url = "https://files.pythonhosted.org/packages/b2/42/1c3d819e8f9b6eb01c2fe90874d67a8882adb9507e0bbb09361ed131ea89/coverage-7.16.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4cc4f73aa3fabc36e32046d6cd2971405948d8a903636508a3d3b2f9128b3a95", size = 260368, upload-time = "2026-09-27T12:27:19.903Z" }, + { url = "https://files.pythonhosted.org/packages/19/4f/d70eac07901fd587b6ab05e659b52afe13959992aa5113bf6cce059cc572/coverage-7.16.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:723dcdab91357159b722935b500ee8abc0a66c8c432e1e9fabf4cc7598952de8", size = 255620, upload-time = "2026-09-27T12:27:21.621Z" }, + { url = "https://files.pythonhosted.org/packages/34/5e/6d87af88317d3d9a9b18a9ca1bc1673eb516917f296e579d0d4a55cb3490/coverage-7.16.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5397e21a90dde0e9c6896b77ded8f0be26b66f8b22b33aed41f6043ed95d55e6", size = 257521, upload-time = "2026-09-27T12:27:23.358Z" }, + { url = "https://files.pythonhosted.org/packages/79/bb/90c2641170d2fa1a6757b3f8450ba2740197317b0ddd749e9604b914e886/coverage-7.16.2-cp314-cp314-win32.whl", hash = "sha256:848893e1d361448c113dc2f0913503522a6f7be231d0e38333d2a22d9698a011", size = 226248, upload-time = "2026-09-27T12:27:25.153Z" }, + { url = "https://files.pythonhosted.org/packages/30/08/d8d0478bb02c8eb0ae20a496fc80c40fcf4d3450bd184300d682ba2d28a6/coverage-7.16.2-cp314-cp314-win_amd64.whl", hash = "sha256:5a27b731c171e43dc8b5f32b76a5051dde2ec9b9366c87028f08a7088ebc2c7b", size = 226732, upload-time = "2026-09-27T12:27:26.907Z" }, + { url = "https://files.pythonhosted.org/packages/32/3f/0001da22155b0a8ce063ec0f7e64ecbe17b373f306e7a74435f6d6accb72/coverage-7.16.2-cp314-cp314-win_arm64.whl", hash = "sha256:1c569a9fd25505f1cd6bea90588818f90373ce90e2632e2cacf19ddbd6e14fdb", size = 226645, upload-time = "2026-09-27T12:27:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/d7/85/6d8813aff9b8b8586691a9d33c43c5604f7227622574da7cdc3d91a86861/coverage-7.16.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d93db87adb6b1c1b408dce4763314b55d76a9f589e96783a84ac9e7689e48bdf", size = 224871, upload-time = "2026-09-27T12:27:30.32Z" }, + { url = "https://files.pythonhosted.org/packages/5c/70/444f3a4981ac2cda40fdcf4cc9b56a4e1a33c222abeb33e51ed3e3eb2a6b/coverage-7.16.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:aa62c85046473959c13ba9edca9dc90a77d5c1095b1ba313556314d77fe5b036", size = 225123, upload-time = "2026-09-27T12:27:32.33Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c1/980681cd7b33eb66ac835044116ef0a92e11fcc7bdd866cc89d10b1130b9/coverage-7.16.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:db76506aa5416081f3e8974ae0f7965c58ada0bb0ef7339ac86099588dbb20d3", size = 265049, upload-time = "2026-09-27T12:27:34.085Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e3/87679875c33bb2191f0f05544a1cc9adcc940fe0c35443a10f2df753dde5/coverage-7.16.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a0f2285329dac10ab08f79cb11f5692c497018e6c7c511f95e6fd63a70b8f831", size = 267717, upload-time = "2026-09-27T12:27:36.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/64/5d372776d6eb523d4e93bafba2253f96984e3b18261c4cc56a50863c6d0d/coverage-7.16.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:382d3346d56b0eec1b793d53a4c88799c8053f516aa3a8d7c44315696954bacf", size = 270047, upload-time = "2026-09-27T12:27:37.96Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/44082ff0cbf9f97d0043f57970a71204097ec7ba606361a9fd2065393669/coverage-7.16.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:648352b94507179d82637292e7ae8802508d95f78e2f00a705a50b6c48011681", size = 271360, upload-time = "2026-09-27T12:27:39.766Z" }, + { url = "https://files.pythonhosted.org/packages/b8/17/9a215efe25b5e0ecc87c89dbe525c4a87d14d87c8c0c7316ef140a5f6f3e/coverage-7.16.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fb2bde05838fffae1a1bf75e5d411a6cac3e4e9bb97e6640fed8cd47888b33f0", size = 264736, upload-time = "2026-09-27T12:27:42.072Z" }, + { url = "https://files.pythonhosted.org/packages/a2/da/7f0a31af8e448107d4d32844bd684757f51ea907bc0c68c8fd537b2123ff/coverage-7.16.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6a75180829efb8ae62b4aded25be6ddca1c888d138d2d82e21d93bfbd88f41cb", size = 267600, upload-time = "2026-09-27T12:27:43.85Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a4/3bfecbd3366b775bacdcb3330394d356cf384b5d8f5b2146ac4b14b252b5/coverage-7.16.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:99704f73721e23859112072d522076e11c31744fc96b5652e5dd2018aa4359f7", size = 264767, upload-time = "2026-09-27T12:27:45.768Z" }, + { url = "https://files.pythonhosted.org/packages/b8/3f/5d62163732d87e4a0c4710a0eab30f0fd6a2d480112abe2029f014fe8c9d/coverage-7.16.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:29309ccc86b7f33df7db12813c299f215bbbc470ed6292d0bedd63ffae1ebf64", size = 269026, upload-time = "2026-09-27T12:27:47.787Z" }, + { url = "https://files.pythonhosted.org/packages/49/4d/8e4579f225426535085a9be371cc75e3b026d058d679b80affbdfb4c3ef0/coverage-7.16.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:30c1b65d529e46569899fadca59e4a87c1faf2886923f1307ba61e654d4f3c20", size = 264147, upload-time = "2026-09-27T12:27:49.681Z" }, + { url = "https://files.pythonhosted.org/packages/d1/36/ef1f77e2c3f7bb03c2b13b9a2006f88700fdd75535ef158d70049f425c1c/coverage-7.16.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dcf4bc2aab4e16b1c4c0c2005918f23a7dd5d7821ddae82caed9e3342dc2fcce", size = 266376, upload-time = "2026-09-27T12:27:51.551Z" }, + { url = "https://files.pythonhosted.org/packages/be/79/0cb2bf4428830dec971c718c2c841a039c084415c99e67281f5a72841aab/coverage-7.16.2-cp314-cp314t-win32.whl", hash = "sha256:a9cd3de0a5bfe7b0e21ee10e1a14e3d61bf52efc88217ab1d95d6ace6970bd46", size = 226585, upload-time = "2026-09-27T12:27:53.945Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f9/da17121c16667fd84998e972200ae226a41540f6ea4795776c6d99e8976f/coverage-7.16.2-cp314-cp314t-win_amd64.whl", hash = "sha256:611a44e5229a59d7483ce830160e1a0e85f700562c7a5651c7c63fb8f4eb528c", size = 227378, upload-time = "2026-09-27T12:27:55.778Z" }, + { url = "https://files.pythonhosted.org/packages/74/89/01179c62d1b7e6e33bd5001566b02d7f778cf33d3ec1e81e94ca170c517f/coverage-7.16.2-cp314-cp314t-win_arm64.whl", hash = "sha256:22957cef43ce038641de78ba995de7568d2d6a37c6ddbf7fa0fd7d1ae2344d91", size = 227064, upload-time = "2026-09-27T12:27:57.496Z" }, + { url = "https://files.pythonhosted.org/packages/4c/57/52935003c3f627ba6e5203d7179aad32448c10899663a30336aba8e81a2c/coverage-7.16.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:414c26dfdb96aac2d570a54e03008f001e32eb2d413705365503648c6bd361d8", size = 224140, upload-time = "2026-09-27T12:27:59.343Z" }, + { url = "https://files.pythonhosted.org/packages/31/38/df472520f3e626524d7e2fc9d6da0afe7895a2f1489d36b48af8ca40bb41/coverage-7.16.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00d3eb96e9988c45f50cccd1f1496571ac5c1f91386ac02c4d55516eeda19a24", size = 224449, upload-time = "2026-09-27T12:28:01.299Z" }, + { url = "https://files.pythonhosted.org/packages/0c/aa/3be084d5b82e63ccdad4ed751e4acbae294673573e30481d29f8b7402eec/coverage-7.16.2-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4dbbd1155ca46e6e0b6b89d204428c56ef6a459af21333f365d135a2820e5a09", size = 256060, upload-time = "2026-09-27T12:28:03.185Z" }, + { url = "https://files.pythonhosted.org/packages/de/29/48fca82a7ebf7ff7b2e35019cc9537e7f65e4d2aa1215cc5a8792c989251/coverage-7.16.2-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8fc15cc8d0d06e873c00ef18e1372d605f9aaf3de27d8c24e50782e75bc8b843", size = 259106, upload-time = "2026-09-27T12:28:05.15Z" }, + { url = "https://files.pythonhosted.org/packages/06/3d/b2d5986f2dd53fe201aa1be2e4ab204fa1aed5101e67c0dbbb419b850aee/coverage-7.16.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c6afdd69218202bc1758c9a14b86b8cf1084f37ed2ca143e567a103772b16d1", size = 260674, upload-time = "2026-09-27T12:28:06.868Z" }, + { url = "https://files.pythonhosted.org/packages/ce/7e/b50160be3506ead12e6480d14279af7f0f17627694300a2d1fd2c42d2ff5/coverage-7.16.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aba5c63b7afdc749cc9eae943d5b868cba2b261a176378fa1c5a30bc8bc89982", size = 263139, upload-time = "2026-09-27T12:28:08.771Z" }, + { url = "https://files.pythonhosted.org/packages/14/5e/7c805ac9a32606de1399bd7e9bd375aa2f973dc61b12680d9e6403c2e891/coverage-7.16.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9174f0af24e5eff248b9dbfe76ec5275a3d19d37edbc2810543f12cf97347a34", size = 256591, upload-time = "2026-09-27T12:28:10.842Z" }, + { url = "https://files.pythonhosted.org/packages/ab/9e/76f1ed129a2daf658a3ea17122824cf2e3b91fea0460d8d3664fc5a61018/coverage-7.16.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:80e9fdb4c3d926b6ba721d4bf7435bdb869c3527ae7803290361d0ab73db13b6", size = 258708, upload-time = "2026-09-27T12:28:12.962Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b7/8d62e75f48b527619239a65294f842d4b7fd02a0839d43ae1de80184e2df/coverage-7.16.2-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:7b3bce4a0d05401d70b7d0d5ca783e686bc9d30e81dbd7d980d532609bf809e4", size = 256562, upload-time = "2026-09-27T12:28:14.934Z" }, + { url = "https://files.pythonhosted.org/packages/b8/8d/0a15f95c3afb78e947c52644786ba4bc9de259905687dd720d5e6fae2e76/coverage-7.16.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:44f21e407b278efdfc1ee5e481e00518bd1d500310a30a5fbf2bcbedfef4aaf0", size = 261077, upload-time = "2026-09-27T12:28:17.215Z" }, + { url = "https://files.pythonhosted.org/packages/25/00/88389987305a47d732866c07c8a500000ab574df9505e3114ac69c8d027f/coverage-7.16.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:59c3926585e1cd1f2190f4b2ac9014de1bbeaf0d5d0587b0dc6b0aa90d17896a", size = 256034, upload-time = "2026-09-27T12:28:19.08Z" }, + { url = "https://files.pythonhosted.org/packages/92/02/34d079d4952ad461bde037d353f9a6e037a7edc45fe0f9ee8781ff73f028/coverage-7.16.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:066429634299e14dd2d511e1e85f8f9cecc500781f6b41907c0dd6f1baea7e63", size = 258034, upload-time = "2026-09-27T12:28:21.242Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d8/3e59a62879285b464ec1b10fd824fbc1af9ce66e842cd39974f80a0becc4/coverage-7.16.2-cp315-cp315-win32.whl", hash = "sha256:893ea9cf86cb8d2546812ac93d973aaf2ee1fb45110a873b014214fd23e3725e", size = 226252, upload-time = "2026-09-27T12:28:23.102Z" }, + { url = "https://files.pythonhosted.org/packages/f4/e1/128026e1b2836e9ad6b219207ba9edf1c5e0088a7869e23088aee7fbbe7a/coverage-7.16.2-cp315-cp315-win_amd64.whl", hash = "sha256:01c6908bc613b420c26c818fe948e1b97dfd041a53c98b01c63bd8321f5c9aae", size = 226728, upload-time = "2026-09-27T12:28:25.21Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f4/c9fa8e7cf525ca7748ac52b0ee89331d13fe09808e45c679830708782e90/coverage-7.16.2-cp315-cp315-win_arm64.whl", hash = "sha256:967d72c835d7a8cf0af99ec813a2d06e3db6df706402f1fe85b31b437645f495", size = 226648, upload-time = "2026-09-27T12:28:27.136Z" }, + { url = "https://files.pythonhosted.org/packages/a2/13/e96b045447a856666f36f9c653e2a80bdaa732aaaf72412b19aa2c26a473/coverage-7.16.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:98d9c97f51b334b0adce7b964442a9af33c1a00c6ac856984cc5dc8d18f81c75", size = 224858, upload-time = "2026-09-27T12:28:29.169Z" }, + { url = "https://files.pythonhosted.org/packages/23/90/087f6ad1bd3df059632ca3407a4e6552ed1053ee35354de0a771acf35423/coverage-7.16.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3e861f1071dcc2fec1e88bef0920f6b1eaa66a143555b4f8ab79ba2b0f30ef55", size = 225139, upload-time = "2026-09-27T12:28:31.131Z" }, + { url = "https://files.pythonhosted.org/packages/7e/8e/285dcef0184358044e7cbcd810a1bdc9566bc620f54702d605477155df4a/coverage-7.16.2-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fb9d92ecfe2d5b494367c67f7446f8b75b68d8d0c8cf3bc3e6997478be25d9e2", size = 265090, upload-time = "2026-09-27T12:28:33.04Z" }, + { url = "https://files.pythonhosted.org/packages/06/b2/cc83f3a6e5789a4e89059c69555bc641c2efcde568405a1c06fc702951ab/coverage-7.16.2-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb57acff4a74246ae513c142d4b36e18c389c3aed8661914a53f7cd0071031b2", size = 268254, upload-time = "2026-09-27T12:28:35.135Z" }, + { url = "https://files.pythonhosted.org/packages/ac/41/f548c19530f5d66ac6e3c92bbcbc49da7261de3a458b9f3e54a3efb1a0b2/coverage-7.16.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:444889f7f66b74e4455c0a97e0e166dd41177f1dca8c0239a47cff25e05ba7e1", size = 270695, upload-time = "2026-09-27T12:28:36.959Z" }, + { url = "https://files.pythonhosted.org/packages/94/61/4dc27cf82ef96434d2874110ad0cc10ea4621025705dc5049862bd3bd181/coverage-7.16.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a740ea6f083c6db7b926534d159508f80ba275ab35e722522de0d18d0f56e55f", size = 271853, upload-time = "2026-09-27T12:28:38.821Z" }, + { url = "https://files.pythonhosted.org/packages/38/29/bf8072b1b8bd5f2de8b21460a404460b1a2b97e80a9464c78ec0271f6199/coverage-7.16.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8e209591f7c41ae4a9171335cf6156afda0b21de73b02f73f5aa95b2d5fbb08d", size = 265644, upload-time = "2026-09-27T12:28:40.815Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2f/0aecb8721be5cdeb8afd9d6d9f6b463f074e4d8d37f00f4c42442522709f/coverage-7.16.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:396bb16e04ce04efbb3df91456ae4e3da918e69ecdf67fb711b0a0fdf35ccce0", size = 268530, upload-time = "2026-09-27T12:28:42.725Z" }, + { url = "https://files.pythonhosted.org/packages/ab/0b/92b4b7628268ee711249958e68fc0328779bd3d9a7ab4715379465aedb84/coverage-7.16.2-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9cdf19874e0d247f32f03609200370343c3c7aa260b191d8c2bb251d36198283", size = 265154, upload-time = "2026-09-27T12:28:44.684Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d9/41c95c1ab29b3dcd357cd1227181d1c98185632aca41ce670ce671b23a43/coverage-7.16.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:fd3d72233eb8b48acc94fa57d44e2d32ce8e7abed02882ccb6d855ccc4ed33ec", size = 269799, upload-time = "2026-09-27T12:28:46.672Z" }, + { url = "https://files.pythonhosted.org/packages/80/07/ebeb259aa5362b033a137b86d7274ff4b109d59be8cc9913889b783bf75a/coverage-7.16.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:bb4ffe96aa663cee727659db5a2afeb38c95f8677b747d447b90d6d4874ea2c5", size = 265196, upload-time = "2026-09-27T12:28:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/b2/18/8437620f90d023680a072eee02f968055f3658bbfb7d386d0ea34cfb7f30/coverage-7.16.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dba2edfb054f6d4a08df9d1637c39a5aa3865bca6617c13c86be21e45658a59c", size = 267266, upload-time = "2026-09-27T12:28:51.361Z" }, + { url = "https://files.pythonhosted.org/packages/28/6c/f08e8ee4293e6434035424180bef4d45e028e8ecc006c61bf9453e74405e/coverage-7.16.2-cp315-cp315t-win32.whl", hash = "sha256:251aed777c47c77aba047096d4542889db089227655711dfc2b9c54ef0e15e35", size = 226583, upload-time = "2026-09-27T12:28:53.33Z" }, + { url = "https://files.pythonhosted.org/packages/f7/fd/3f939c2847f4a72c20cff8b1ac33da78ea91a2d38d9b43336e60db719103/coverage-7.16.2-cp315-cp315t-win_amd64.whl", hash = "sha256:2aca0bdfa9e91621d5b09d815357bf63def4fc0e9cb66da67bf2cf93f3b1a6f5", size = 227374, upload-time = "2026-09-27T12:28:55.158Z" }, + { url = "https://files.pythonhosted.org/packages/5a/35/b98cdc354c952402132e675a87f2cc3227fb68f959c84aaa491fbe15933d/coverage-7.16.2-cp315-cp315t-win_arm64.whl", hash = "sha256:b88841e654f09732804809e435b3e005a929ffd9998b872b7b213957b8759cb8", size = 227064, upload-time = "2026-09-27T12:28:57.075Z" }, + { url = "https://files.pythonhosted.org/packages/3f/0c/7a64e1ac90541a8edf50daef0914848011fb057a5bf55284a4811e21939a/coverage-7.16.2-py3-none-any.whl", hash = "sha256:11d28e9123a9156cb405d8d27b44256c9a58fb5decc2073a8f17862057e3aa0f", size = 215754, upload-time = "2026-09-27T12:28:59.075Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli" }, +] + +[[package]] +name = "coverage" +version = "7.17.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d2/79/e78bd8f75a9b8e32233ce92d4607f0a21ce88a9156cace2884e7175a82f5/coverage-7.17.0.tar.gz", hash = "sha256:cc010a0a7fbdd9bb8bdfd0d3f04a5151275860213cbd7e2b876b29778489c712", size = 991021, upload-time = "2026-10-22T16:06:50.009Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/25/79a66272edd250031aeee6db87d500a0bf76390d0d5f8c2f431fe354715f/coverage-7.17.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:99a7b390cbccc6bf029ca4da3f0f607c218bb4085e9cd6b58a90d14ca12993c3", size = 225837, upload-time = "2026-10-22T16:03:55.622Z" }, + { url = "https://files.pythonhosted.org/packages/52/a6/f5f6fefb2fc1305363927edad1d0a60ce6ef80d6c1a74a79e825f0f670eb/coverage-7.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f72640e02a470b57b15cd655820133f6892760209283a363a60e2df932d5f0fe", size = 226257, upload-time = "2026-10-22T16:03:57.164Z" }, + { url = "https://files.pythonhosted.org/packages/28/61/72889bac8eb44c51f8043edb227df551dfdca1fc4819a6c6d67b3f69427b/coverage-7.17.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2dc9233f39149b5a4f4aba17a4b6bc5cca22e52cfc4b06fdb07d014439b8b2ea", size = 258282, upload-time = "2026-10-22T16:03:58.521Z" }, + { url = "https://files.pythonhosted.org/packages/f4/e4/03e4a5644df9b73de0d44d1b82acd18b06c42b5abc3f1433be8363fa983d/coverage-7.17.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8e8113d3852e9377421a61de1917df27b3abb25404a4ecf69f9e64612c4345b5", size = 260506, upload-time = "2026-10-22T16:04:00.116Z" }, + { url = "https://files.pythonhosted.org/packages/6f/4e/949022286df7e59e8633a3a7e6635e0e6b53af7d57074cb0bf8f500373fb/coverage-7.17.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c86a39539d10d666bb819c16c94d7edfc1aa2e0531b937f7c549b83d15177c6e", size = 262600, upload-time = "2026-10-22T16:04:01.49Z" }, + { url = "https://files.pythonhosted.org/packages/27/cf/7d67f60df081006315699b7edb9402c1b47142caf1383f4e56ae8ff1a501/coverage-7.17.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:559f748446ee799803686b5784e3deb54c70d655ac386a860e06b11672504ba7", size = 264609, upload-time = "2026-10-22T16:04:03.286Z" }, + { url = "https://files.pythonhosted.org/packages/e1/e0/9293d94afbc099990a085e88229a51c79b00828aba0f2adda32dc4cc16d1/coverage-7.17.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:34d65c9e8e257f48a654908005046fbf1bc48d9540ae3776ad08c0acd010e10c", size = 258382, upload-time = "2026-10-22T16:04:04.804Z" }, + { url = "https://files.pythonhosted.org/packages/24/c8/bcd28efedf262c074dae76f61098739eb02b15f3f716f80cc86f9885b8a9/coverage-7.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:5b7fa0997b8eba7378ac66f31ec7f70164490353ab79b9667d37c0d365e50177", size = 260299, upload-time = "2026-10-22T16:04:06.291Z" }, + { url = "https://files.pythonhosted.org/packages/b8/dc/503f55e5e2200933403c90d619d9f779b5060ddd338b1bdc63cd235592cb/coverage-7.17.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:6ae0453a3390e67f7bfbe34417bbdf5b4ebfc21db23fb446a0a41115eeeca6ca", size = 258314, upload-time = "2026-10-22T16:04:07.729Z" }, + { url = "https://files.pythonhosted.org/packages/bb/b1/f1a57c36077cc516240636f7eff0d1427939ed795f096dd2c7769213a56c/coverage-7.17.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:96151262832f3c230ebae23b2d6911ad549e1738465946c97004913ff06112ba", size = 262239, upload-time = "2026-10-22T16:04:09.116Z" }, + { url = "https://files.pythonhosted.org/packages/a8/4f/c2e59d4a132936c7c207b9b69ab99c0f27b14c3c93266e9922aa3b562b37/coverage-7.17.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:cd7397de6cc782f00fe5ac1d75e9b306bcfa49c8b6b8dd6ed1f7709393ad40b3", size = 257841, upload-time = "2026-10-22T16:04:10.509Z" }, + { url = "https://files.pythonhosted.org/packages/05/04/50742c0ee8b6c85826ff11737c93ed957fea4c9acf4b4b99804bdac1dd84/coverage-7.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9d1fdf82c6fea57b5e9dada509f9ce9638c8334664e2c98c7f6f1ccf3d143ad2", size = 259039, upload-time = "2026-10-22T16:04:11.916Z" }, + { url = "https://files.pythonhosted.org/packages/8e/cd/83ad4bbbfcb6d045a33c14cdca313f6c9275737c67f3b7300222e3239a37/coverage-7.17.0-cp311-cp311-win32.whl", hash = "sha256:38c86e5d74bbfd88a393fa3f91257c1225c63aa6db6d5918de3e49ab04f91c6e", size = 227687, upload-time = "2026-10-22T16:04:13.537Z" }, + { url = "https://files.pythonhosted.org/packages/ca/c8/dcc5a7effa79707eb8a61e699b141cff7c9b46036771274cfb48ea7b765f/coverage-7.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:2ed3097c6817bc1a7fc8ae0a6131db74aa1150d863cccc308237ff362d3226b2", size = 228290, upload-time = "2026-10-22T16:04:14.899Z" }, + { url = "https://files.pythonhosted.org/packages/d1/58/a8553e0dcd38d8136df63964638d2b588e0a4a916bff1bca996244fda693/coverage-7.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:6052e878b628abcd38fa5f2b64abebc686eed4e2267da42434017a9c6d24f241", size = 228199, upload-time = "2026-10-22T16:04:16.351Z" }, + { url = "https://files.pythonhosted.org/packages/0a/25/989fd3b495c4274ac0cf54cb6664326415e60183a7f8a73dd9bbb0b11e34/coverage-7.17.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:0cfdc938ca3319d873d1f1252e60620a39aee4ebf9dbd7cc58238109ebda9c51", size = 225938, upload-time = "2026-10-22T16:04:18.113Z" }, + { url = "https://files.pythonhosted.org/packages/db/cb/14726426bf3241657facbf0f7df7babd8f7d3fcf8e4609b7929f9dceecbc/coverage-7.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d523da3c2e4bca49417768bcdb1a443c5b359dc44b8b93a3102e118fce912c40", size = 226166, upload-time = "2026-10-22T16:04:19.524Z" }, + { url = "https://files.pythonhosted.org/packages/8e/97/f95ed32cd3cfbe261a3598e694cb770cefc7b2d13ff013418d6f70a44dde/coverage-7.17.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:adbf3450c0f3f2b2854e282a8758f2b3eddf787eeff24ec9c9bc2cbc38328cc1", size = 258462, upload-time = "2026-10-22T16:04:21.079Z" }, + { url = "https://files.pythonhosted.org/packages/91/ac/eb4c31f741509a9ef48cf6f28385e98e9de0785599282252eee252ff8af7/coverage-7.17.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:85932227e9dd38e62cd29c17fefdfecfb919eead6af1e3259522d03cf85de983", size = 261789, upload-time = "2026-10-22T16:04:23.037Z" }, + { url = "https://files.pythonhosted.org/packages/e8/3e/d9cd006d1a3cc5deab07beb29b86cb4a10dd84d66b330820363fb8d310d6/coverage-7.17.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:30f5477aac9c9e4a0a641c55f8f8fddd7f3bd91176c912c50f40ffced96b4034", size = 262322, upload-time = "2026-10-22T16:04:24.94Z" }, + { url = "https://files.pythonhosted.org/packages/c0/3a/4c872c6ae0762b09cdb8e856891bb3f584848cb60b6dda2bacb85fe2f3f0/coverage-7.17.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0b8bb651a4406fb6a983a905309fec1783443c65e1771b41e92740a0f4a1176b", size = 264600, upload-time = "2026-10-22T16:04:26.444Z" }, + { url = "https://files.pythonhosted.org/packages/df/98/1d41a2373fa98b423bcd70adb91d75e38eafb417955426dbb920b10016f3/coverage-7.17.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0edeb6594f080c8de1263cccb239cb316ef77aeb959e2e0f38f2953fcc72a49e", size = 258678, upload-time = "2026-10-22T16:04:27.832Z" }, + { url = "https://files.pythonhosted.org/packages/92/6a/fe04b5e63e76506daa63d90bdfb00a53767fe5df18546b437d6226918d6b/coverage-7.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:da94ec0484e84fce5c7bf8d0f54b97767a90d992653a129b35634699d516e0a5", size = 260210, upload-time = "2026-10-22T16:04:29.275Z" }, + { url = "https://files.pythonhosted.org/packages/4f/c3/5c5a78dc19dd4799be9c6ec022316fb25ababaeacfaf0f52f24c56a57b43/coverage-7.17.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a25cc5e8c23a590815c6a7aa43624234d25cb23b21b484adb8a0daed59860db5", size = 258375, upload-time = "2026-10-22T16:04:30.647Z" }, + { url = "https://files.pythonhosted.org/packages/ed/e7/4c1d8eaff4d756fefd15d58c4953a78ab656782fd0e32c5a3465dba61aa0/coverage-7.17.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:db645c81cf4d6bcb392ea1894aad65d55d1588a8472c834b25ca575da3029a56", size = 262422, upload-time = "2026-10-22T16:04:32.053Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2a/0b17c3e2e7b6ff1a5d92eb58915c0d1026668928f961d14dac73cf1b6096/coverage-7.17.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:6a80a11b90c4a03df1502304cf24ff953255b6b5d076ef79066ecf88baaff31f", size = 257875, upload-time = "2026-10-22T16:04:33.824Z" }, + { url = "https://files.pythonhosted.org/packages/d3/2d/eb0cbde0535342df0d17a667163030a3afb67e5eb9e3ad94af9540041584/coverage-7.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e4eaf11d6b0f2147f46cfbf06fe7edcca6f095d0120da00ddc2458995ee869fc", size = 260361, upload-time = "2026-10-22T16:04:35.661Z" }, + { url = "https://files.pythonhosted.org/packages/2e/47/1be2a6db7eb655d0a1d899217c3f2469f9121cbbeddac35c1c8173b1482e/coverage-7.17.0-cp312-cp312-win32.whl", hash = "sha256:912a29f338798541d795e2e25903c6fe7a99dee70a40fe4706a9a124649b523e", size = 227747, upload-time = "2026-10-22T16:04:37.102Z" }, + { url = "https://files.pythonhosted.org/packages/11/c5/201c894c57de81875d8b8cc527ba222aa350e8cfb183eb3f6df45d06ad8e/coverage-7.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:88a1a9fb0075b83389dd9b403bb3fce976031b3c2aa0e05e3e57143cf639de69", size = 228325, upload-time = "2026-10-22T16:04:38.989Z" }, + { url = "https://files.pythonhosted.org/packages/0b/5d/196095339b19758cf83f507fb598bc42820ae124745feb3084662729e17a/coverage-7.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:2c680e838ff9e68d491158625ca2c1ddb17d78d791bba96a31f8b839b4990438", size = 228131, upload-time = "2026-10-22T16:04:40.654Z" }, + { url = "https://files.pythonhosted.org/packages/54/e6/1f01afbc9f4fa8ca5e1fa6fdf537a5c58b5765d1b4167ee284cddb9acc72/coverage-7.17.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:84538c040f4e6214f663459d89372ce4e6b2bbdd9d397ef0dca7b3ecd56b8eb2", size = 227080, upload-time = "2026-10-22T16:04:42.325Z" }, + { url = "https://files.pythonhosted.org/packages/92/7a/bdb7e6260c4a211389aeac9b89dc31662ebe122153ad0ecfd156897912df/coverage-7.17.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:6abfb6a4cf1cb1b67bc8fccdde177e2d2b781d0d34449e7078156547025140e5", size = 227152, upload-time = "2026-10-22T16:04:43.737Z" }, + { url = "https://files.pythonhosted.org/packages/37/4e/276e7d5b3cfb124871bdb544c27b004a8b4e270e6bf8e7414149c54b5e5b/coverage-7.17.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:ef65e96f0fc1a7c8b7644c7011d47a8228555e7888ac4d6246f715a7f3d7c398", size = 225397, upload-time = "2026-10-22T16:04:45.292Z" }, + { url = "https://files.pythonhosted.org/packages/b3/7d/dac073db12f3c131598a6693253aded581e4d7d622a89864f11bfb0ca2f5/coverage-7.17.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:55939ea4c097fda2edabf80fac5e49bef15597b950a9f29fc56292a895245feb", size = 225705, upload-time = "2026-10-22T16:04:46.603Z" }, + { url = "https://files.pythonhosted.org/packages/00/45/877b0a9248e921080ae91d115c13192d17e308f5aee86bcc7f7bc2a54ed1/coverage-7.17.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bfb6f868af552c0ceb2d19220b8cbcc2be096ca26163ac30e682a13041433429", size = 225828, upload-time = "2026-10-22T16:04:48.065Z" }, + { url = "https://files.pythonhosted.org/packages/4f/f5/2c48d47abec0e4590b302920334be5ee3854f96bbd22524feabb8d92b220/coverage-7.17.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8d823d66afd59566030539c49c7a6acaf3083996682be2dda760c63555842094", size = 226088, upload-time = "2026-10-22T16:04:49.513Z" }, + { url = "https://files.pythonhosted.org/packages/a8/a0/ec0442f3f372c7fd742f49b3022edd392f79e37a0048e1fa333f56d01ec3/coverage-7.17.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:50678474e714c684b82c108e63fbb8f1bcf1266d8293a49980f1d08526f093b5", size = 257257, upload-time = "2026-10-22T16:04:50.982Z" }, + { url = "https://files.pythonhosted.org/packages/92/e2/eb0927ba93809f76eee69fa1e47999825fc7dbbabc3e0e1a2744f2677acb/coverage-7.17.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:045c1eeb19fb4eae949850a761102fffb3a5f638b97f977912f95843e54f6669", size = 260165, upload-time = "2026-10-22T16:04:52.409Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a2/8d4c6055efb32099b15c9cc33d007b8aabebc4832f372a3274de5ba0afc5/coverage-7.17.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dfb12891a773cbc2132349c77c690a045a882fe3f98b4bda50dfabb01893f9bd", size = 261098, upload-time = "2026-10-22T16:04:53.763Z" }, + { url = "https://files.pythonhosted.org/packages/2c/1e/93412288688a7b03f152a734c8ef086e395108a0a6a746985d3967e220f2/coverage-7.17.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3067608b4429629f640c1b23d2f69b05d2fd45e00ebb6ee9e8fad220a6c11722", size = 263164, upload-time = "2026-10-22T16:04:55.386Z" }, + { url = "https://files.pythonhosted.org/packages/3c/20/7eb8d805c4f1a212245cef20181dfbf39535357985073d49730ee9cf08d4/coverage-7.17.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a1762e85cbbe3b5ff9c6dcbcc1b89d5c72320094292b7b9572bf882c85e428b7", size = 257287, upload-time = "2026-10-22T16:04:56.976Z" }, + { url = "https://files.pythonhosted.org/packages/1a/c1/1df29630b4ed17e135c76390afcc6bd273c3dc5ba2a21a76813a600fe98c/coverage-7.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62bb77987d3f72a0aaa77c567ee7f9806bc2e748c8f46fafbe1fdb90dd148398", size = 259256, upload-time = "2026-10-22T16:04:58.545Z" }, + { url = "https://files.pythonhosted.org/packages/a1/79/2365d1008d28aafe468a450a24c6c63363de794b5140223d67685cd0e205/coverage-7.17.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:6cc31f27240d4e080437e3b8229d92f1d809c9a4f233607385373b73974e183e", size = 257178, upload-time = "2026-10-22T16:05:00.103Z" }, + { url = "https://files.pythonhosted.org/packages/c0/9f/f002952d295d772688dffce0d991e3822795b1e3aad158073712a5a5e86e/coverage-7.17.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:61cde5222f1933d476647c5a25ed1a8678b7703098cb5a15f4a0aa39967d8c28", size = 261275, upload-time = "2026-10-22T16:05:01.462Z" }, + { url = "https://files.pythonhosted.org/packages/40/fe/f9e15fbb426be97cd679ee5d359151e046f103bcd76b5092c318c26ed596/coverage-7.17.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:11f5f7fb2d97a0fe865f5e7bad4eb0619b957637f676bc088d13844adf26ba95", size = 257029, upload-time = "2026-10-22T16:05:02.8Z" }, + { url = "https://files.pythonhosted.org/packages/c2/4a/3c398f38694387334ff4c9f71afc8e15b4fa7db7bc0bea4d5b6032eb0df0/coverage-7.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e09612b1b82c9df1d2b6c85dee88d5aad3e73d77a8ec0b16ac6a7322cbdf5d9", size = 259109, upload-time = "2026-10-22T16:05:04.241Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a9/908a3cf1a2335aec1c788682a06c2f742a62a4f987033f080de1c5fd1997/coverage-7.17.0-cp313-cp313-win32.whl", hash = "sha256:bd3e9eb493631ff1ca34bf5efac25b5c66724f837bf6182c4fc771c55946423d", size = 227691, upload-time = "2026-10-22T16:05:05.636Z" }, + { url = "https://files.pythonhosted.org/packages/13/f7/8cdd7bfd8a63b3e6b133fc395ecfc7b1cb6f561926e7e2ad050de85b83e7/coverage-7.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:f1fc9a7cea899c51d8a53e66c2f082a3d9e461ece32418d3ef0a0b90c32bfd3d", size = 228418, upload-time = "2026-10-22T16:05:07.057Z" }, + { url = "https://files.pythonhosted.org/packages/09/cf/0b3fc57f735cd3831ca13d0be5312a5477d5934066683c5d34018cab7541/coverage-7.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:e65a1e61a68493fbfbe44d8bec71b3231d81b9917f62d3dafe0e105072147e83", size = 228142, upload-time = "2026-10-22T16:05:08.435Z" }, + { url = "https://files.pythonhosted.org/packages/4d/e1/722462fe79912ebebc101497bd16c42413cde2dbae771017f1ec0acb84c2/coverage-7.17.0-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:dc5936491e306f2f6f095bd5fba593de11eb0375cee787ca1f245c3a333a523a", size = 227197, upload-time = "2026-10-22T16:05:09.846Z" }, + { url = "https://files.pythonhosted.org/packages/b7/74/826b9c09f2ebfea803bccb391d935688a25309bff8e819fc446bc629c108/coverage-7.17.0-cp314-cp314-android_24_x86_64.whl", hash = "sha256:968c5fb6e0c83cab752d79a70209648ce4d90cae815c60fa229b59e264601062", size = 227314, upload-time = "2026-10-22T16:05:11.422Z" }, + { url = "https://files.pythonhosted.org/packages/6d/19/c8514d7f5e0659a96ff2bc7377119dca6d420e2761c5fc69ae37618734f8/coverage-7.17.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:12cb8a20ad904a5811e6660d829a586b216e5254b9b34b76dde8a4d65d827dc6", size = 225477, upload-time = "2026-10-22T16:05:12.761Z" }, + { url = "https://files.pythonhosted.org/packages/81/74/ef9433ce599f07d8633b4ce6e6d6921505c4ef3f7f9006f8eb66e2c278cf/coverage-7.17.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:bb5ca66937c55bc85d1a5e9c5900a3e4693a8edf2280a9b3672b7b2661a84b95", size = 225787, upload-time = "2026-10-22T16:05:14.394Z" }, + { url = "https://files.pythonhosted.org/packages/d8/66/26e58981940e8b3944c6a9941bec5c7f50840e7009a046712e3f3bcd9e6a/coverage-7.17.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:5cc15faaf318ee5040d835a62c75bc6f122d837274f3b5efd47bf9fbd4ac5b85", size = 226019, upload-time = "2026-10-22T16:05:15.798Z" }, + { url = "https://files.pythonhosted.org/packages/e9/63/fe175310815cc8357b83b773c9b4c20943c269f217dd825a37c4b4bfe324/coverage-7.17.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7d6d9d396c8b7bcaf76d774a10140b218111484e54c73a5f2a1b75655381748e", size = 226169, upload-time = "2026-10-22T16:05:17.188Z" }, + { url = "https://files.pythonhosted.org/packages/2c/b0/ac84761f5b4bd226696b0ec4606903d2ef7208abda0aec06c14a4218def4/coverage-7.17.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:42e6f170d1ac04b7eb3363310a6c41cdfd82c1fe6bf9ffbc4a86f380bdf091c7", size = 258092, upload-time = "2026-10-22T16:05:18.691Z" }, + { url = "https://files.pythonhosted.org/packages/e9/58/d8bdd65a661913bc12eaaa3e59742b2cb8b94f2e7f78e62184f0a58ca493/coverage-7.17.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:acdb5f3c96046efff9dc6c572a6acb2b8d0da09372d7b9a9ed7249cf7d17434f", size = 261096, upload-time = "2026-10-22T16:05:20.089Z" }, + { url = "https://files.pythonhosted.org/packages/7b/15/5d82e2f0a75ea149e0a6412e137e1d610538772fdfd7199737db7fe234da/coverage-7.17.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3393209f6894713161ee82a9b0e673e58237e0f9733c6638e7a6c0c620ef0b33", size = 262080, upload-time = "2026-10-22T16:05:21.568Z" }, + { url = "https://files.pythonhosted.org/packages/0f/cc/e3ebfd295d1dd47c7bc84a17d73f150465a37ab388dd68fe82b495dc79a0/coverage-7.17.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e9494d9e99389d39e6a96227749af898d8924ff591cb63944f8a98e68582bf0e", size = 264558, upload-time = "2026-10-22T16:05:22.906Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9d/e2adff76d6544bbc6df7366d74967923c2de37ba889a006bfb875bf5857b/coverage-7.17.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:032d4c2db4c677eb71d43f2f8b80bf64e9346f7a3f7b6ebb13f1782f3cc6c274", size = 257855, upload-time = "2026-10-22T16:05:24.343Z" }, + { url = "https://files.pythonhosted.org/packages/d9/fd/ecd1e9cddf1c36b5d03c438568b1f53e63db84bb3656539d71b454484c7d/coverage-7.17.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:4343a9378b964eb3cb80fa90406385de91c7e982a769ca9314d848f93bc0d3f2", size = 259933, upload-time = "2026-10-22T16:05:25.79Z" }, + { url = "https://files.pythonhosted.org/packages/40/b6/e17a19dccdbcad494c64691f71c1dba3e55c30625bc29ffbb88ac5a0aa8b/coverage-7.17.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:b609df3d6d900464207532c5170a65c6ede8d2e0b91f151f90008a866395cd76", size = 257972, upload-time = "2026-10-22T16:05:27.185Z" }, + { url = "https://files.pythonhosted.org/packages/6a/0d/37dac534709a3fa43a937c8b0604839bb44b8670b83d143a4b78fec20d1e/coverage-7.17.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:a01ef92caeedfa4f2ad171a3a8e6fece4565de871d8bca428151bf9929f41048", size = 262271, upload-time = "2026-10-22T16:05:28.619Z" }, + { url = "https://files.pythonhosted.org/packages/cb/17/7c05186925b4d64a46c271dfd944e3f0c1ad89db9095c31a6df157a75df2/coverage-7.17.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:a3914e2c98c34b94c26d2add3d2a61ccfd3534fc4eaa879ee290bdbb5184ba6c", size = 257604, upload-time = "2026-10-22T16:05:30.07Z" }, + { url = "https://files.pythonhosted.org/packages/95/65/c241cdee66a0ff86c68f6d37328e735d10e3d30cd6ff66f356039eb688d2/coverage-7.17.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e8a72b26dc5c9a9422e45472b1d67ba5caf273c524c8668cc04b23062663755e", size = 259714, upload-time = "2026-10-22T16:05:31.402Z" }, + { url = "https://files.pythonhosted.org/packages/db/09/e93233fe2405574ce0a31ed201c0cba3a860e085db5d2828bf12b7dc0790/coverage-7.17.0-cp314-cp314-win32.whl", hash = "sha256:03baf0688e14a5a44ffd1eefa8928dfc92b14565e521174e072b31b971aa1657", size = 227914, upload-time = "2026-10-22T16:05:32.78Z" }, + { url = "https://files.pythonhosted.org/packages/d7/77/04979eb217edb94b94afabb4bcc179f60c746f68d3fd0b12688ba9195730/coverage-7.17.0-cp314-cp314-win_amd64.whl", hash = "sha256:3a4459b0f389dd1e51aac3dbfc4ca35b30cae7dc99caa3c0a086d1997a985709", size = 228543, upload-time = "2026-10-22T16:05:34.118Z" }, + { url = "https://files.pythonhosted.org/packages/a0/38/155f2f2c6769f8c43eca8a5e581443faa0908828650090b97103b4a41376/coverage-7.17.0-cp314-cp314-win_arm64.whl", hash = "sha256:a32ee5831b15ba239bef5d272ae586ca8acea4a661b5f2941f5a0d380e518b23", size = 228396, upload-time = "2026-10-22T16:05:35.951Z" }, + { url = "https://files.pythonhosted.org/packages/52/55/d6751572d9445485c4c5a51ec6ae11caa5c11b7ef2448cdccc884f7f54d9/coverage-7.17.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9c083e253e96fdeeaf48133fe836cac86ace2db215d235700e7f7532420a200c", size = 226486, upload-time = "2026-10-22T16:05:37.363Z" }, + { url = "https://files.pythonhosted.org/packages/2f/a8/82d37760e537bfdb9fdee285fa1e1b45bc153293d23e2331c7befedd1990/coverage-7.17.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b88fb4d4d7608cbcebdc7ff7dbffc2115e3b81d6c33a79147cd79d54fcb080f4", size = 226861, upload-time = "2026-10-22T16:05:38.777Z" }, + { url = "https://files.pythonhosted.org/packages/24/96/70ec00a9db6d7bdd3f914eba12057360769f5cb78a98456e71fe1937deb5/coverage-7.17.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:2bf3ee38a40c0570c316b9e7507c472469586906a20f289705898528c31aaea8", size = 266849, upload-time = "2026-10-22T16:05:40.285Z" }, + { url = "https://files.pythonhosted.org/packages/77/d8/d99be3bfbb208512f039c80b31e404138a86678fc929a17acd5b7135a6ae/coverage-7.17.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7c570293f001ea91598b90e90cb9b98fddee833e90bbede432cbd218331ccd8e", size = 269402, upload-time = "2026-10-22T16:05:41.585Z" }, + { url = "https://files.pythonhosted.org/packages/82/50/6cbe8b5a5060edbd21ce8109c4e900f8b7656e8b72ede6dc4d82dc0b8bfb/coverage-7.17.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:791f9ee09814dd30d9562b4f4eb037a371485ec1c830b53999d2320d20c4e764", size = 272025, upload-time = "2026-10-22T16:05:42.921Z" }, + { url = "https://files.pythonhosted.org/packages/bd/05/d3633add01e5518dfdacfdbd1be41cb5c581412dd8bccd663edf6ef7fec8/coverage-7.17.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c7c5672ecf1b497de7a0b37743bef40e3b58e3207e9fe2ed6682cb0420836a88", size = 273515, upload-time = "2026-10-22T16:05:44.324Z" }, + { url = "https://files.pythonhosted.org/packages/57/d9/b83387780271bf9ea9f96a3aeb01c1c302c4494a927923c4fa70cd170a3f/coverage-7.17.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:337f87e62e1c5f43c8198d879f677c342d152f84d3f157add12558853cbb8eaf", size = 266725, upload-time = "2026-10-22T16:05:45.713Z" }, + { url = "https://files.pythonhosted.org/packages/e4/be/8e80b29764ae3f4d70d44952eee3f3927eb36897490fe799e400adb7f5da/coverage-7.17.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c8a58baa8eb6154c6645eadcc19b6c089deab78c24a612a83206f2a8a5992a7c", size = 269312, upload-time = "2026-10-22T16:05:47.054Z" }, + { url = "https://files.pythonhosted.org/packages/b8/c9/e702f588fe8d83ca844f133270ad0a49bf650c8cf260551ff6f11a6b6bbf/coverage-7.17.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:fb5745048ee20f796b0e3ab61831049e749acff188563e2af32f58ede957ac1b", size = 266740, upload-time = "2026-10-22T16:05:48.343Z" }, + { url = "https://files.pythonhosted.org/packages/8a/11/ee13ad14b714d75ef07c490b6e43969574a8b8b8c6d67bc741fcbacbf9c3/coverage-7.17.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:7b5abcae74750302ac4bc77351eaee87c450e4abd3b6225eacde3858e260f8b2", size = 271036, upload-time = "2026-10-22T16:05:49.727Z" }, + { url = "https://files.pythonhosted.org/packages/e2/bc/854e8912c11c54aaf416e74602000589c6efbbe1f251dc90202fdabddcb6/coverage-7.17.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4e153f0bd6509dbf837fd585f489b3328bfd98f2a718a0b15ae63032148b285c", size = 266158, upload-time = "2026-10-22T16:05:51.141Z" }, + { url = "https://files.pythonhosted.org/packages/a8/dd/96432830ddf63bc42654de54eee77a0cd6949cc65769bda06f353323f23a/coverage-7.17.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e42a835271922fe7bf98c7a05c78d4032f4e52bf5b07fafa1eadfdfc2f0ad22f", size = 268088, upload-time = "2026-10-22T16:05:52.92Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ee/230c6ec065a6629d41cc89323ceb54d37e2650c104f70fc108f4ee7c5051/coverage-7.17.0-cp314-cp314t-win32.whl", hash = "sha256:5900055351ec89fdffb34b27898815106529ded29a9496464c1ebd6313fd40fa", size = 228229, upload-time = "2026-10-22T16:05:54.255Z" }, + { url = "https://files.pythonhosted.org/packages/f0/1d/23eb6aadcb3c00764ff2961c0ff55f5dfa2543856d932b949bbc04fa68e9/coverage-7.17.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5ee9c8bd13a59e301dc2aefe7aa8384633406808de051b1982775667094eb673", size = 229154, upload-time = "2026-10-22T16:05:55.682Z" }, + { url = "https://files.pythonhosted.org/packages/3e/f1/7df117e8e016b7a3ee459e833b3456f3610505afefd071f8727702d98439/coverage-7.17.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a9cb9a0fb58e6fff5442969af36094ecd6976f4907f179e33b27e15355d8f74", size = 228726, upload-time = "2026-10-22T16:05:57.179Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a1/f9c24911755f91e6f451ca2e2c1804fbcbe9fecbc3310e341bbbbfa1d85b/coverage-7.17.0-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:adabc1079ba844b096799ba8638d8df434aca1613f95bb7d5791af320cf05559", size = 227196, upload-time = "2026-10-22T16:05:58.543Z" }, + { url = "https://files.pythonhosted.org/packages/b0/a5/2b665b40c626e6bb40e5e8e23d91170b48b5f2f57186f46b07f2fac42386/coverage-7.17.0-cp315-cp315-android_24_x86_64.whl", hash = "sha256:6b4593d2871c4c801656dd5861e759f8f5156febd6b6061b02f6a72d64618b7b", size = 227315, upload-time = "2026-10-22T16:06:00.409Z" }, + { url = "https://files.pythonhosted.org/packages/3d/8c/22b518d61b930b8a4d62905d046c76a03675ef19b466462011dfb16439a3/coverage-7.17.0-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:c2c48a36bb970b7265b196032bfd4237c0b373f2b25ef7012d7e905b5b35c19c", size = 225490, upload-time = "2026-10-22T16:06:01.743Z" }, + { url = "https://files.pythonhosted.org/packages/08/5b/d3b141455944e030cd4987f055f8c84a44a1a0b28d81ae93389f44051691/coverage-7.17.0-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:f8bc2cd4c6aa58be1ca243fb8cddb6c3c42031fe4403991ad9cf2b3baed03d9f", size = 225797, upload-time = "2026-10-22T16:06:03.423Z" }, + { url = "https://files.pythonhosted.org/packages/03/24/aab2156983f7022361352640c583d08f0238e4cd7463eb921172001b4cfe/coverage-7.17.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:cbf0b83ce927de6053279ba61342d9f8892afde1385fcba9144cd05d4023d109", size = 226025, upload-time = "2026-10-22T16:06:04.76Z" }, + { url = "https://files.pythonhosted.org/packages/87/db/94697b9ccf4ec94cdad07bf94e2a21b9702247cb212d2d5f18d2b9c3d0de/coverage-7.17.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:66efc0fb99cee34626fc17d3adac9c3cd816bfdad563bb1e983c3ef432f566d4", size = 226193, upload-time = "2026-10-22T16:06:06.167Z" }, + { url = "https://files.pythonhosted.org/packages/a0/fd/db1c4ade4219831d590fff5aa5b7d9ceaf84586e8e60da6fff71b6182251/coverage-7.17.0-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:58a304efdf2253fb2ea03d45d0a04cc174a92a0cd5279c28c5bb893ce7410968", size = 258046, upload-time = "2026-10-22T16:06:07.51Z" }, + { url = "https://files.pythonhosted.org/packages/95/ee/84ed138990ed752abd73db4adffc1842d6152017d8e21809cc109a413fda/coverage-7.17.0-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:aed06129a9f530a948928260d7d2d81c47261355b0127e3c782251b38958463c", size = 261735, upload-time = "2026-10-22T16:06:08.861Z" }, + { url = "https://files.pythonhosted.org/packages/64/ad/c1e4367bbd1e7d562d6bc979c82b542f2040544e95a8cd995b694caf0e1a/coverage-7.17.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f6cdb47a9be2d3313829bed1d296086287682a3ee901ff987b3432b45705b771", size = 262819, upload-time = "2026-10-22T16:06:10.49Z" }, + { url = "https://files.pythonhosted.org/packages/b5/3a/e8e8509b0940403eab15d86f70022790a01fce3e971a161919c544953f7a/coverage-7.17.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:804fbaf81d09b34e2f8b1159d01e211a50713d743d32fd9b2ca6cf0ae507a66f", size = 265194, upload-time = "2026-10-22T16:06:11.847Z" }, + { url = "https://files.pythonhosted.org/packages/1f/77/d64bbdbb734b1059ebcde2b5df567f142a9948079e51af9b0abf8c9ec17b/coverage-7.17.0-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b2afebb96da9a1bbca142f8cc12320c14e5c215e0a49cded4f191f5a31506a28", size = 258410, upload-time = "2026-10-22T16:06:13.234Z" }, + { url = "https://files.pythonhosted.org/packages/e2/29/7cf81f08a254532c074eb52cfe6b12bb753d08f2997269c9fac8de359541/coverage-7.17.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:bd04fd23206be9ad3de13b0b39313094fafa66a1f6baf70f5471c004a9fac47d", size = 260697, upload-time = "2026-10-22T16:06:14.595Z" }, + { url = "https://files.pythonhosted.org/packages/7f/56/bacea6dee2d5ccb31ab0cfffcee87ca7efa80ff048840209c8013aeaf02e/coverage-7.17.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:5ebfbc87836529a31d25c2dec1262c38eea852ec1c46c0f690a515a7339d9c5b", size = 258649, upload-time = "2026-10-22T16:06:16.265Z" }, + { url = "https://files.pythonhosted.org/packages/a4/97/fd8a6a63740f9ee177c53b59e2f4d0752369bb0fd154086a1e69aa1fb255/coverage-7.17.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:a59c3b470ac3b2432af3598a996affbeb10236cd899a005c1c4e517fcff8b592", size = 262989, upload-time = "2026-10-22T16:06:17.85Z" }, + { url = "https://files.pythonhosted.org/packages/c1/37/7cd3d3520d45db3788456452b65446182c08f2a7c276f40c9dd11966be02/coverage-7.17.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:7fef12cec4b96f59e09761cbd4fc9bdf4788062d1ae435b920241fc16c8a9549", size = 257955, upload-time = "2026-10-22T16:06:19.563Z" }, + { url = "https://files.pythonhosted.org/packages/c1/b9/80343a55e07d854927a915cc21a52e350ae1db9ead33f0248507b960785f/coverage-7.17.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:a14e8d69464da9cbe1dc29e7116dbd37296d1d51a695327c478e250349085089", size = 260512, upload-time = "2026-10-22T16:06:21.055Z" }, + { url = "https://files.pythonhosted.org/packages/f3/32/e4c816f0cb3efdc6392bb276ff88359729f9dec605bdd3c1c7a44776f759/coverage-7.17.0-cp315-cp315-win32.whl", hash = "sha256:9a66074231799d8884d267234d49f60c90b43a945dfe069646b72f3058cd4e67", size = 227913, upload-time = "2026-10-22T16:06:22.407Z" }, + { url = "https://files.pythonhosted.org/packages/43/14/283120142ac281834808584249b89957de997c28573ddd65ae106b622121/coverage-7.17.0-cp315-cp315-win_amd64.whl", hash = "sha256:79cf71e5f9a48877ccfed5baa2c72f45af4feeaa596249e23eb15b473134830e", size = 228532, upload-time = "2026-10-22T16:06:23.756Z" }, + { url = "https://files.pythonhosted.org/packages/b9/bc/83dbc6c3bd58042afaefcb0cfd7d7a2e3076989a2f3d9bc6e6edac819784/coverage-7.17.0-cp315-cp315-win_arm64.whl", hash = "sha256:09e563b49c81cd0a33734e926d7a4a6ef1778d74304cde2dcc3aff8b30ea1036", size = 228393, upload-time = "2026-10-22T16:06:25.163Z" }, + { url = "https://files.pythonhosted.org/packages/00/ed/9463d1cb1766a2570343a372c2871c7fb4d561e5051f029399f4d57ce947/coverage-7.17.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:a5e2e0625dfc789af0b2e10acfc106b352f314fffbd19e6392a7961c8cbe5d9a", size = 226481, upload-time = "2026-10-22T16:06:26.563Z" }, + { url = "https://files.pythonhosted.org/packages/ae/59/6536c7fa87be13236b4184fc395f14d18f622a5b8ef7448a6bfdf5f24ec0/coverage-7.17.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:194562ab1eff0d85aee8a17ce4c5c0bc1ebf70a629a7145257123156ad100fd6", size = 226876, upload-time = "2026-10-22T16:06:27.921Z" }, + { url = "https://files.pythonhosted.org/packages/b0/bc/4ffae6038f78382c9ab6a4969cb5fc01d50b083d119851085807629abe88/coverage-7.17.0-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:85682ca89bc4601125dcdff23fa70e6274e13c9ad502fba845e6c274ab2c6569", size = 267241, upload-time = "2026-10-22T16:06:29.356Z" }, + { url = "https://files.pythonhosted.org/packages/c0/60/cae4b708b4217d33ebf66b9c57f8910a257346b3eaf054a78d73605ddc4c/coverage-7.17.0-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0d0fac604a962ff546beb038cba9a5a09d88e6e3f01612fb46f7bd4fe5dc8dca", size = 270079, upload-time = "2026-10-22T16:06:30.736Z" }, + { url = "https://files.pythonhosted.org/packages/a9/84/1225ab04e55a6a2e483e903a5eb0f8f081cb5325df833594534aa288d91c/coverage-7.17.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72edd4f9483ae30cd1ba4f230687840ef7b58a16afb1c9e81131fd6d64655f36", size = 272775, upload-time = "2026-10-22T16:06:32.247Z" }, + { url = "https://files.pythonhosted.org/packages/94/ad/567f8dd9246a553aa8753732c41f0e0654e98e9a617d6282e64eae0e6aa8/coverage-7.17.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:91e487ad07c511da77b574820141a7c2da09bc2a4b4090b5be2424295d100697", size = 274110, upload-time = "2026-10-22T16:06:33.859Z" }, + { url = "https://files.pythonhosted.org/packages/66/5f/e0ee76895df40601e4aedffb6b8e71ea48e276a629fb4488b92cffffca14/coverage-7.17.0-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1cabb31531002fef5197de5df3c84730aef01e750e25154b9813a2583435aba2", size = 267775, upload-time = "2026-10-22T16:06:35.193Z" }, + { url = "https://files.pythonhosted.org/packages/19/6d/d19c6e45e940e5b9ba697b7be9a8e63cef73d90bdea45b670a59df466717/coverage-7.17.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:c9ac886242bbd50fb35a2242ba79555a99891e657da33f98b7ca968e3488a350", size = 270268, upload-time = "2026-10-22T16:06:36.597Z" }, + { url = "https://files.pythonhosted.org/packages/27/a3/b2731bb7aef2db800b330603675c3fa58a6497a05d5b5f8625f3b6285f68/coverage-7.17.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:d45cdc495671fc99268ff3653e0da4244972e9fc0e1fc3ea9de18781ad28963a", size = 267298, upload-time = "2026-10-22T16:06:37.973Z" }, + { url = "https://files.pythonhosted.org/packages/50/75/d0c90a81b6b6607933109914dc8b0ef0a5f4cacf9482ca868ae773ee5d0b/coverage-7.17.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:12961f738d717a046d4bf3f8d1727eb3ebe2ed5478ff96cd6233d4dfc39323d3", size = 271899, upload-time = "2026-10-22T16:06:39.389Z" }, + { url = "https://files.pythonhosted.org/packages/64/1e/f038f3a2614e9ef839a40a184713aca40b8ed79e626ab5cdc388771045df/coverage-7.17.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1ee0a982b0e1230b3edf768a7dd022bd2377303763895327ac62deb5efacee03", size = 267380, upload-time = "2026-10-22T16:06:40.97Z" }, + { url = "https://files.pythonhosted.org/packages/c9/30/8d636e639b2d8b1934128573402a7caf66c8cfbc794fa02061d84f115c34/coverage-7.17.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:460679f53893081edb94eeed011d26be37228ba649b853fd2aed7e4394fb1f35", size = 268993, upload-time = "2026-10-22T16:06:42.361Z" }, + { url = "https://files.pythonhosted.org/packages/73/7a/219f6b391cb0636242d06c390a8add5af91afa3e92afd0380dbedd34f487/coverage-7.17.0-cp315-cp315t-win32.whl", hash = "sha256:600e121e412cd6bdb52ec105b95c6a04da0c9710d1534f6e64a42db667907802", size = 228216, upload-time = "2026-10-22T16:06:43.714Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3f/514d294319c5eac11494394545de209079f33993e14526c220eab29b2a96/coverage-7.17.0-cp315-cp315t-win_amd64.whl", hash = "sha256:c3e11b81faafb1f063248735c3e2c5c4183fc1db2c7f46782170dd7760dffcbc", size = 229146, upload-time = "2026-10-22T16:06:45.262Z" }, + { url = "https://files.pythonhosted.org/packages/f6/82/c0d8bb0a67df838fc7bc6f4060ffc404fd1154fd18e624d83e6abc41aeef/coverage-7.17.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d472ee1c64868a917a47f02ffb4ac8c22b477f7589d57a3eb0c58b1ad4f0137c", size = 228716, upload-time = "2026-10-22T16:06:47.097Z" }, + { url = "https://files.pythonhosted.org/packages/c9/17/48032919343afa2906112d458aceda2043afdb24a2ee8eb4c60904d8ddf1/coverage-7.17.0-py3-none-any.whl", hash = "sha256:bac487dce0d2aff28ddf1a533a916f771416eee0e493960f611e49037b878e9d", size = 217383, upload-time = "2026-10-22T16:06:48.471Z" }, +] + +[[package]] +name = "cryptography" +version = "50.0.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9d/af/182eb91b0df3fe75c4d9f26fe70684569566745f6ba7e5c9c73a862c5252/cryptography-50.0.2.tar.gz", hash = "sha256:7b46165bb56eb4704e2eaaf86f3c940d19154535d9b0ca7d6d590b04060e00d5", size = 880623, upload-time = "2026-09-30T15:30:04.884Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/69/c9bd862c3bf43d6399c433caf002df16e2dffd4be49bdf515cda38038711/cryptography-50.0.2-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:79def8d059362e7831389ed3be0ecdf58a89386e1271e35dd9f5af84e81bffd0", size = 4731146, upload-time = "2026-09-30T14:43:47.113Z" }, + { url = "https://files.pythonhosted.org/packages/21/69/64cef1f702bf6657e0cc186ed1a2891d50d29fb41586b254e1c07adea261/cryptography-50.0.2-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:630ebfea3bf689d075f82316324ff7433dc447fe6bc1bfc76524b74b4a9567d2", size = 4719841, upload-time = "2026-09-30T14:43:49.01Z" }, + { url = "https://files.pythonhosted.org/packages/38/6b/61a3f8d8c5e1e49a6cddccafc4015cc1c0021360ab0acb4080e7a423644a/cryptography-50.0.2-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:f9f6143a8c75945eb960d9eb98905a441394abfa24afaae239d514ffb2586480", size = 4738340, upload-time = "2026-09-30T14:43:50.932Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2e/7212ca32fd43dc91f2f41db20160b268098874b4c9a0e7be94d6835f5b2e/cryptography-50.0.2-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:a582ab2ae1d34f67112cadc86702774c9ea4374df6bca6afe672817203c99134", size = 5367029, upload-time = "2026-09-30T14:43:52.911Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f1/b474e930c4d910328780e3940da76f5aa5cbc48ce1fc14e44d239d9ea9db/cryptography-50.0.2-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:4061c0079120205fb760c58acab6443e217307dcf05e3702cf970e0689972856", size = 4753050, upload-time = "2026-09-30T14:43:55.272Z" }, + { url = "https://files.pythonhosted.org/packages/7c/52/9af10e80ac16b0fcc2123f9cbd5e7afbd0fd5075bb7a607c592258a39cda/cryptography-50.0.2-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:ac9ed99d81760c62fe89d5f0815cdfa1ba9a35141cf30f1c2d044f04b4803d2e", size = 4376724, upload-time = "2026-09-30T14:43:57.24Z" }, + { url = "https://files.pythonhosted.org/packages/71/37/6202e488cc1eb625ea110c292c6bda92823176e023f427d8d5660ce8d632/cryptography-50.0.2-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:87e9ce85beb6b328ba370cc6e6aea483c92617b4c95b1d33a49297eb662bfb04", size = 4737859, upload-time = "2026-09-30T14:43:59.541Z" }, + { url = "https://files.pythonhosted.org/packages/8f/30/e86d7d518489b0ae2497091a35287abcb1a2ce4037837a34afbe9b1d6964/cryptography-50.0.2-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:f265528741e048bce55c3463ed721fb0aa45a5888d8add8cfeccb3035451bbdc", size = 5324103, upload-time = "2026-09-30T14:44:01.901Z" }, + { url = "https://files.pythonhosted.org/packages/d3/69/2c833a049475e0a3444e94c7d0aca0aa51d166374a449b09e92ac98138de/cryptography-50.0.2-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:9dab55f57c74c3cad24c323bacbbd04be4705ba6eb0d92e920b1fc4837ed5079", size = 4752576, upload-time = "2026-09-30T14:44:04.545Z" }, + { url = "https://files.pythonhosted.org/packages/6c/5d/906970b83bbfc1f5bbfb677a143c181f2801f23b6a7204a3b47c42c97e65/cryptography-50.0.2-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25784ce8b9621c90c643efb9e1e2162ab3b0224cae446ad5e70e7fcb1ce18b51", size = 4870819, upload-time = "2026-09-30T14:44:06.884Z" }, + { url = "https://files.pythonhosted.org/packages/68/e3/f2298d3bb55e0c4a91841ec4d01b3f020ba8c5fbf15ccdcc6dcf03f97025/cryptography-50.0.2-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:85d0d9a31b9098e98534226d5686b47264b95e62ce459dc2e62fdfc809f9fe93", size = 5030152, upload-time = "2026-09-30T14:44:09.443Z" }, + { url = "https://files.pythonhosted.org/packages/19/8e/aa1fc533d4546b127b45de8aa024eb5933d23eff9debfe25931e56861095/cryptography-50.0.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:0ecbc5652bdb6fc9eaf89a7d196e20941adfe812f43bc4ca05d9150496821047", size = 4710431, upload-time = "2026-09-30T14:44:15.427Z" }, + { url = "https://files.pythonhosted.org/packages/6a/64/72bc3f75176e7e406b748a3e3830432b8c51297b38368713df04dc04898a/cryptography-50.0.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ab50ee449bf968271e820086f10a33d101dd060370abc10bcd22279be2656539", size = 4694824, upload-time = "2026-09-30T14:44:17.69Z" }, + { url = "https://files.pythonhosted.org/packages/4e/c6/62c77550edfa5ca3f14bf44a1e6739b9fa09d6e998a11d97ed8213bccc98/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a9f7355e6fab51f6c369b86fb7571cffa05edee2c2121e0380a37fb9ac1cd5c1", size = 4716967, upload-time = "2026-09-30T14:44:19.661Z" }, + { url = "https://files.pythonhosted.org/packages/f4/37/cce70f150c432914460157a6ecc161752e053aa5ec0ef3b3f7dc6e31039a/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:94e5e9f108ee10471288214d3d233fbfbb492840a8457eb85178d643ddeb32c7", size = 5328676, upload-time = "2026-09-30T14:44:21.744Z" }, + { url = "https://files.pythonhosted.org/packages/aa/9a/6f2f0304d634ceafdeaf23e84537336664ac419b5d07611675c2ad3f6b7a/cryptography-50.0.2-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:241449bf940a5d27309bd317e6f9a2af6932113818bb2b8f5c59ddc7ef16da18", size = 4727698, upload-time = "2026-09-30T14:44:24.178Z" }, + { url = "https://files.pythonhosted.org/packages/1d/de/66bcf9244d118663b2e1aaded8990f4640e3d7b7411870a5765f252074d2/cryptography-50.0.2-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:d8947001be83df1394050758ce0e745dd74fb134eef0a4b5124208dfc3a68c37", size = 4354821, upload-time = "2026-09-30T14:44:26.263Z" }, + { url = "https://files.pythonhosted.org/packages/bd/e6/db28a28c7b6c676addce89136de3d8db49ea825a8c863472e36e42ead4ad/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:4a20ce1e5cb4284a86692fdcba7cb8754185c6b2e5c56fcef3751cf451d3cdc2", size = 4716748, upload-time = "2026-09-30T14:44:28.447Z" }, + { url = "https://files.pythonhosted.org/packages/30/96/01546c7f69ea0e2ab790a2e4f0934a4052fb9b388147fbf83c2fd72f1e57/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:84f964e537f916e2cc85199e5a88742e964939b575ac8598b3f9d6cc416cdaf1", size = 5285085, upload-time = "2026-09-30T14:44:30.704Z" }, + { url = "https://files.pythonhosted.org/packages/6c/01/03263395f74d50b071e9e66daace3f8bef80493e5d410726f2ba8554736b/cryptography-50.0.2-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:828d49b0ff5a0e3975865571c5d91dbbdd0d38d8289b249a163e9425413a5e05", size = 4727268, upload-time = "2026-09-30T14:44:32.92Z" }, + { url = "https://files.pythonhosted.org/packages/eb/94/2bfe8f29ec0cc9c0d99359c4161adf32858e4934b72c6d100d2ac0bbe962/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:deb9fde5c60e437ee4821bc9bc39ff31b42135c27e1dc61ef0a629389c1de62e", size = 4849503, upload-time = "2026-09-30T14:44:34.969Z" }, + { url = "https://files.pythonhosted.org/packages/54/44/e80651ecbf0e42b62e2bb5f5768916e07eea72e1297338956a61df361f88/cryptography-50.0.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8c71ba2cd31fc93748c38e1b613200ff1c2665cbfd5341fe3a61cfde35a1430e", size = 5004057, upload-time = "2026-09-30T14:44:37.064Z" }, + { url = "https://files.pythonhosted.org/packages/8c/75/32ac2a56243d778805c16ca6a32b8f74fb757df7e28d7ecb560afafb59cf/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d370b8d1dfcdf7130178137f6fbee6140774a1acc6cacefc4b42643ec11d0a3a", size = 4956267, upload-time = "2026-09-30T14:44:43.693Z" }, + { url = "https://files.pythonhosted.org/packages/aa/a4/2c8d734e43d97f0842ee9f1b7b4bfb3d0cf5e19edebf43c2afe6675c2320/cryptography-50.0.2-cp315-abi3.abi3t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f2f9bd7f90c64fe89253f0a2c05e3c4856072660429ce8831b4235bf29403a67", size = 4966465, upload-time = "2026-09-30T14:44:45.769Z" }, + { url = "https://files.pythonhosted.org/packages/c2/58/ee288c829a6f41f6235ae9dd33d82fd19b45442b65b4c8a3da36963d9f7a/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_aarch64.whl", hash = "sha256:e275096ea1e60cc595cda2836fd4a6c725d1125108b868be17f53684d164e2cc", size = 4959356, upload-time = "2026-09-30T14:44:48.211Z" }, + { url = "https://files.pythonhosted.org/packages/92/20/9ded6d51ddd9897f6b6e81fb9ebea7951d7cc5d6c890b0ed8abf77a51a80/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_ppc64le.whl", hash = "sha256:b13478603dcd0a2479ff8e87e2c19a7d525734686fe3c49542472293a204212d", size = 5548822, upload-time = "2026-09-30T14:44:50.86Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/8df951850d6b31d2a00218f19e2b3f999523437ed7a819df7fa427942fca/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_28_x86_64.whl", hash = "sha256:58a0c478eeca76fe5e07993c5a0703def34a6dc6a0cda4f5564639b33112ffe7", size = 5001199, upload-time = "2026-09-30T14:44:53.379Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f9/36b3022218ce75b7cdf068fb95f809f9bd0d820e4955ef43b90c255cc7ac/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_31_armv7l.whl", hash = "sha256:d38cdff612d06fa6a32840d5e1b1f7a27cee4a349aa9085d94a67789d6bfd408", size = 4629333, upload-time = "2026-09-30T14:44:55.635Z" }, + { url = "https://files.pythonhosted.org/packages/8c/72/20f99a219f6af47cdd1cbd978c243b92d71496e168a746138af44ded4f29/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_aarch64.whl", hash = "sha256:fdd28f912fccfec1846a94e2e1e8f9b0012f557f0c46fe4f3eb0d7a87afcf90b", size = 4958822, upload-time = "2026-09-30T14:44:59.639Z" }, + { url = "https://files.pythonhosted.org/packages/f2/20/196f112617fb08eb4d608a2a6c422373d46f9cc2857f38fc0667033c0899/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_ppc64le.whl", hash = "sha256:cbc8738fd8526d80f35cb3a40d41f41a2e7030bb3b18b09a6778ef63d291c2fd", size = 5506351, upload-time = "2026-09-30T14:45:02.267Z" }, + { url = "https://files.pythonhosted.org/packages/24/95/83378121ef3eaaaf71d4b781577ff794acb39b9e1b87a3f156898c8497ed/cryptography-50.0.2-cp315-abi3.abi3t-manylinux_2_34_x86_64.whl", hash = "sha256:e105ab60406787da31fccc883fc0f733af1efd78f0136a4599692c4083a73d0c", size = 5000859, upload-time = "2026-09-30T14:45:05.009Z" }, + { url = "https://files.pythonhosted.org/packages/22/f7/70fd7ae4d1dbfa7ba29b02e1b9068771519a86027756510b700ce81086a8/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:6f8700550aa1474a91e5dc07049c46f98b423b5b1ddd0483e0b51362eeeaf5be", size = 5092151, upload-time = "2026-09-30T15:29:15.932Z" }, + { url = "https://files.pythonhosted.org/packages/d4/be/688367b74de86984bd58d8efacfc7c9e68b89a6a22ced0fb4f38db50254a/cryptography-50.0.2-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:c71be1cbfa5cd9a41ee452acf1eccd82b2c05950358b106ec8ceb83411d1a020", size = 5286120, upload-time = "2026-09-30T15:29:18.309Z" }, + { url = "https://files.pythonhosted.org/packages/d5/8d/6d585339bedf85d45044c85d8412dac53f2bb6f918e8b7777efba1787844/cryptography-50.0.2-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5e67125c7dca78d199ec4e116aa93dbb83494808ecbb8211a2cb09b1bf41dbd", size = 4756166, upload-time = "2026-09-30T15:29:24.58Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f1/1c1f6874e8550cfddd4b688ceb38cefb6ed15ceed224d56f133f3d88c214/cryptography-50.0.2-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ee247f5c245c9a2fe7c8e2214e295918838e44e00a45a6718451e4004219e767", size = 4749145, upload-time = "2026-09-30T15:29:26.807Z" }, + { url = "https://files.pythonhosted.org/packages/c1/63/61b15dc1a8de03fe0adbe3fd7608b3ad5c73bf50993bbcb1faaa930afe33/cryptography-50.0.2-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dfe9763530994147d9af1def057a5b9658b00e8f8fe8743d144d1e0911c2e454", size = 4763638, upload-time = "2026-09-30T15:29:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/fc/35/b345bdfa40c9126df1a9d33236aa98418367931b8725f84fc3ae2b98dc59/cryptography-50.0.2-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:58ddb5a8e3179d12f19e4ea34d2d32e9d63a4baa142c875c1eb59f41b7243acd", size = 5382217, upload-time = "2026-09-30T15:29:30.589Z" }, + { url = "https://files.pythonhosted.org/packages/4f/87/ef344a9e616871f2519c22d6afcda79ddd5d35e9592d95eb6e677608d055/cryptography-50.0.2-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:f21e8a22c8605750c7af886bab299a363721264061b4ac0a30efb73cfd58efc5", size = 4781387, upload-time = "2026-09-30T15:29:32.605Z" }, + { url = "https://files.pythonhosted.org/packages/90/5b/f2fdb13cd0b96f6f932c8627bb292a45f11c64d21620a8e120aee9a3b848/cryptography-50.0.2-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:9c8402a82ea0dc4ceeab793db05f0fafa8ca139ca34fcde5df0f596103c74107", size = 4403790, upload-time = "2026-09-30T15:29:34.374Z" }, + { url = "https://files.pythonhosted.org/packages/bc/ce/7e4f662b1e3c393513569e402cfc85ac7da0bd3d5435e122a3140219eb2d/cryptography-50.0.2-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:0ddc924c04591c2811ca024d62ecad4f7f6f08af8939c211438f48a16bd23602", size = 4764319, upload-time = "2026-09-30T15:29:36.149Z" }, + { url = "https://files.pythonhosted.org/packages/3c/3f/86ff33ce34cc0de6847fb96e035a1a760d81652e38643f617c02ad32ef7a/cryptography-50.0.2-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:a6557e5f38e065ca9fbdaf7cfc7435ecb1d113aa81a022d1b51921ee7432e227", size = 5338560, upload-time = "2026-09-30T15:29:39.053Z" }, + { url = "https://files.pythonhosted.org/packages/40/cf/6b5c8e2fd9202d98988ab7cb5cc5c991704c4ad55f492ff408e4969f83f1/cryptography-50.0.2-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:1981f1db4630889b9ef7803fadef12b056f428cb6b85c27ba57b774793b6093c", size = 4780973, upload-time = "2026-09-30T15:29:41.251Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/8d6ebc7dded797bd0f0160d52188021211f011a2b164ef0ae1dac4587465/cryptography-50.0.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:7a8701d6b584d76e909e3d305b7d126b41439876a5aaf76cddc67fc230eafa2e", size = 4897738, upload-time = "2026-09-30T15:29:43.106Z" }, + { url = "https://files.pythonhosted.org/packages/d4/aa/f3f6e0de7e6253b8baa8b2d8fb9d50924fa75cee3d4624bd4bc1208ee923/cryptography-50.0.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:ce47f66801c20ec6c6632453bb5960fe38939e9306970b48b3a5a26de7745d94", size = 5058280, upload-time = "2026-09-30T15:29:44.827Z" }, + { url = "https://files.pythonhosted.org/packages/1d/7a/f08d34ce09d60f89ebd391e2ebc6ba2b995e6dd7552f41820f8085f94e53/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:92e665960f25fcdc73725b9cec7a3824f279ba97a98653afe9ffac2e43668f67", size = 4716035, upload-time = "2026-09-30T15:29:48.681Z" }, + { url = "https://files.pythonhosted.org/packages/45/67/e18fb65592451a2acb76e9f2fbe14e0f47a8318b4c5430f1633851d03daa/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:eef4c2f3423810b3070ab391f85436d2f8bbfcb286ac15cbc73190b3563b1f1a", size = 4726917, upload-time = "2026-09-30T15:29:50.608Z" }, + { url = "https://files.pythonhosted.org/packages/83/28/38fdce17e60f6b825e69fc3b7f75e70a6612759980704697e1de4cbfaf6e/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:7c6d0330c472d96f6a6afe24d80dfdf15176c33096f0a4397ae4c60f3dd3be48", size = 4715341, upload-time = "2026-09-30T15:29:52.522Z" }, + { url = "https://files.pythonhosted.org/packages/b6/b1/d9121a717e0f893c64bd6ca7702614778d7df2a5c309128a002421788516/cryptography-50.0.2-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:1ba34f04897fcdaa73f74145c25f3ec146fbd56593853e88adc2e811303c5f42", size = 4726322, upload-time = "2026-09-30T15:29:54.263Z" }, +] + +[[package]] +name = "ctranslate2" +version = "4.8.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "pyyaml" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/3b/39a12024384645df7645738c9393e4010b6f6e65a3bb9421cef4243d1cb1/ctranslate2-4.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a812a2836a1cd873bc9553d68f6b8a1ed196a095be0a38edc8a34b7b51dafd89", size = 1488585, upload-time = "2026-10-25T19:03:48.732Z" }, + { url = "https://files.pythonhosted.org/packages/ef/44/ab48e19a24e66e383a7f686eb801c00c3a1d6e348d76e32246d597d51512/ctranslate2-4.8.4-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:737a5edcae69fb062218b0068b9788bdd9ff871e2cd196c273f5331c0f163e3c", size = 12166050, upload-time = "2026-10-25T19:03:51Z" }, + { url = "https://files.pythonhosted.org/packages/89/af/030d1d439ee31e06eea31b8c75adce7277287b9742ad3fa35d2f80a3e46e/ctranslate2-4.8.4-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c120b2207d97cb6bfedd694bc7e278c2f25f2fed83c9fa32071cf2e770a59902", size = 18592983, upload-time = "2026-10-25T19:03:53.385Z" }, + { url = "https://files.pythonhosted.org/packages/c7/18/2f682e72cbb2e6d1aefe213a774c10fdf614c71eb3146cdd151b3f2312be/ctranslate2-4.8.4-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:193edb3516df7fcd580ccd45e5f12d13fb7eb07f8ae2d27568461c2fedd14d95", size = 42302451, upload-time = "2026-10-25T19:03:56.912Z" }, + { url = "https://files.pythonhosted.org/packages/70/b8/f5b29606a97832770109c53d11f13eaa13ad9fc08f20d0dbfd8bd03325a7/ctranslate2-4.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:0a6e2260899b99f5feef648f92dd34840f16c7cc0dc113bde03c6e7798b65f37", size = 20368546, upload-time = "2026-10-25T19:03:59.999Z" }, + { url = "https://files.pythonhosted.org/packages/b3/01/4bdbbb7f564725629dfa638c4492997e12697822d5f5855a61705d116bb3/ctranslate2-4.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d7b6cd9e832e47c00d3da14976b1621b065d8680a7d27a95a009af4a41e169ac", size = 1489306, upload-time = "2026-10-25T19:04:02.114Z" }, + { url = "https://files.pythonhosted.org/packages/da/a7/c9cd5ab778b2f1eed8c4552e94c236e4e26a3742ffd54eb8ec54880fec8f/ctranslate2-4.8.4-cp311-cp311-macosx_11_0_x86_64.whl", hash = "sha256:2c366cb89ffcd99f76e44dfbb199979d450a9c698dae5eefd65e94a7ef25443c", size = 12167392, upload-time = "2026-10-25T19:04:03.775Z" }, + { url = "https://files.pythonhosted.org/packages/b8/f9/e0250f31eadfbb70e467b2c33867399665ab783ecc3fff18412595b1693f/ctranslate2-4.8.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd6ed9d10b46b9bc2ee801ea9624acf28bd53ffddfd5e92d23b2340dbc4d6474", size = 18793231, upload-time = "2026-10-25T19:04:06.692Z" }, + { url = "https://files.pythonhosted.org/packages/d5/fb/c20dd76f7636bdef710e2f6e8419db3a07687cec65e78228ff3624875afe/ctranslate2-4.8.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1037b3f51d18f1546120686670d71fcdaf85a0500fffccc56d8439ded5d284e5", size = 42428932, upload-time = "2026-10-25T19:04:10.532Z" }, + { url = "https://files.pythonhosted.org/packages/45/a0/7f9744949aac9a143a1245511fb0ce5f62434aed9b1ca026cb72d9ff6e5f/ctranslate2-4.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:01bfca5d6e1736e38602511066a437677470c690e1458fa7c72ff322a3cfc4f9", size = 20369372, upload-time = "2026-10-25T19:04:13.542Z" }, + { url = "https://files.pythonhosted.org/packages/45/18/68692f8cf2684690cc6f2b407fa6d5909895cac37aa9d1df1bc5849017f9/ctranslate2-4.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:36ebf8d2f5b7af176cef7869cd98a1c722ee01c177168fda5c9a045fc930be67", size = 1490254, upload-time = "2026-10-25T19:04:15.694Z" }, + { url = "https://files.pythonhosted.org/packages/8b/2f/7495643e0d5f530f927bbaf9daecb180606fe484d6afc056fcb773974344/ctranslate2-4.8.4-cp312-cp312-macosx_11_0_x86_64.whl", hash = "sha256:1094d0128657903677b3be3aab9186bf28ac8d89a4676fb590bcabf3c7605971", size = 12172517, upload-time = "2026-10-25T19:04:17.411Z" }, + { url = "https://files.pythonhosted.org/packages/5e/0f/f7aad2355dbb4a0115d9265f0ab04feddfd506388d19bfe7e0387fd7c5e1/ctranslate2-4.8.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a102683e7dc5d0cd0c31de5771ce4c27fffa837721470e7aae64ebffa64f3206", size = 18976989, upload-time = "2026-10-25T19:04:19.951Z" }, + { url = "https://files.pythonhosted.org/packages/39/42/ab136f76cf379ed97d3f95563ad227fdd5cdbbeb20eaa797b0962be62b1a/ctranslate2-4.8.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d1830d12c84b2240bf51893ee6bfe24a671dccfd232b05a74ef197d27fb164a", size = 42669573, upload-time = "2026-10-25T19:04:23.931Z" }, + { url = "https://files.pythonhosted.org/packages/af/25/cca7f6807d37cbfd9eebed8bbf136f5214c31d7d66de267ad05b676e9deb/ctranslate2-4.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:056db4b4c2a31b7811d453155a3d6ab316ddb1dc104f413beee7bce26bcbf92d", size = 20371102, upload-time = "2026-10-25T19:04:26.986Z" }, + { url = "https://files.pythonhosted.org/packages/56/83/f96841f2123ee983c41a69477ca00f171d75e6434a4c40c0e3decbe457bb/ctranslate2-4.8.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:183a21b4c0da1846f8c3faac0267c497d7bdc8dd43350e23fa4f584b4ba2d4ba", size = 1490195, upload-time = "2026-10-25T19:04:29.168Z" }, + { url = "https://files.pythonhosted.org/packages/40/ef/570715e8b607df28e129e913a496f41e6efa2665b85e3536f54e87b31d1e/ctranslate2-4.8.4-cp313-cp313-macosx_11_0_x86_64.whl", hash = "sha256:a547c5970c17c3259a59e731e5479579463b2d3a6235862a99a46654437faeb9", size = 12172432, upload-time = "2026-10-25T19:04:31.073Z" }, + { url = "https://files.pythonhosted.org/packages/db/5a/29467590dbc2fe339e159da946f9192f231cfd753d36dd30095de88d6578/ctranslate2-4.8.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f4ed771f82c4078113d811c5f9ad0a4597bb79f54784adb58fd50d69b04cb7a5", size = 18959426, upload-time = "2026-10-25T19:04:33.746Z" }, + { url = "https://files.pythonhosted.org/packages/17/0b/430c7f43bc06cbdb5f9f66dac1ce13c1d713e03e729b295856a51ac33043/ctranslate2-4.8.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:271e77faf49ff9fa117b490b9008ac0b294744c19dabc93087e202299c1a8e27", size = 42612303, upload-time = "2026-10-25T19:04:37.457Z" }, + { url = "https://files.pythonhosted.org/packages/37/ae/4fbe636b36fd4fd4266e309d050548c1ae0a23c88ef73ef89c6485db99d1/ctranslate2-4.8.4-cp313-cp313-win_amd64.whl", hash = "sha256:d9523961651ac0f51e4e62d03307609ff93d828b32ae92dc8b14a7e55243f6f2", size = 20371182, upload-time = "2026-10-25T19:04:40.548Z" }, + { url = "https://files.pythonhosted.org/packages/7a/3e/3f133db61ec4483b67ca264b63ae5fef9d60c0c5d6f253fad3f9bbf9e850/ctranslate2-4.8.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:87145e4ebdabd19c7bc8eb1f96a30b2df2b6923e6bdea8c97c637c872962f51a", size = 1490930, upload-time = "2026-10-25T19:04:43.285Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/b38afe110dc1af43a45434e4c37564371e10ce9e91a3b200dda4494cc851/ctranslate2-4.8.4-cp314-cp314-macosx_11_0_x86_64.whl", hash = "sha256:40d49ce50fc38432eae920c36a13fb943fc73363934ff699986eadaf1a9e178b", size = 12172898, upload-time = "2026-10-25T19:04:45.409Z" }, + { url = "https://files.pythonhosted.org/packages/d2/e1/2f4b85f47567b934fb3e38da9f76451fd243f5111daf3dcef7b9211dfb7d/ctranslate2-4.8.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec9639dd36511eecf23bbc99a61a8fe77f16e2169e8dd35be6502ae3b2147a20", size = 18934359, upload-time = "2026-10-25T19:04:48.674Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f4/d14d4ad8d1eac0e49aafcc11ff9ec83ac5758ae23acc526f15b73c980c19/ctranslate2-4.8.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e838fb78e8db9daee96187a08c3d0839bf45bd4853afda839f3b4b4979336ed6", size = 42590297, upload-time = "2026-10-25T19:04:52.638Z" }, + { url = "https://files.pythonhosted.org/packages/50/98/6bd005eb63150a8d029aa06076180bc3452243b56da592c770128ac6f47b/ctranslate2-4.8.4-cp314-cp314-win_amd64.whl", hash = "sha256:4b322215f3b8eaab1db45b9e6aebfb8ddfe1336651e15a569c90826bfdb4b136", size = 20638792, upload-time = "2026-10-25T19:04:55.966Z" }, + { url = "https://files.pythonhosted.org/packages/89/7b/51b68b23870e9e09c3dda27e629b78dbbc259750036474bea8e38171f721/ctranslate2-4.8.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9fc200ff85351d6e6f7403c43857086df8ebc754bf243a77079fee7c2156ada5", size = 1517691, upload-time = "2026-10-25T19:04:58.538Z" }, + { url = "https://files.pythonhosted.org/packages/45/9d/83f3f40d0e07878f62eb3b633ca186fe163b3c4fbdb960ab7bb66064a625/ctranslate2-4.8.4-cp314-cp314t-macosx_11_0_x86_64.whl", hash = "sha256:1cf96ce8f625166ef67358b42c798271b307bb0b4a1d39a9965ff848f17f9d74", size = 12199614, upload-time = "2026-10-25T19:05:00.307Z" }, + { url = "https://files.pythonhosted.org/packages/a2/e3/a1a4b5a2b66acda963f08a6e73a4866ad79fa7bd079569be881da8d08f25/ctranslate2-4.8.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:230b5216b71f5502d6ae0d9151c646aa69de7817b2e424ee67d6a87a9aeb19e1", size = 19315986, upload-time = "2026-10-25T19:05:03.08Z" }, + { url = "https://files.pythonhosted.org/packages/78/69/8750a4bd23c85a41d14686de0fadb101d5241a2a79e0c5a36d56d04c69ba/ctranslate2-4.8.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbf71062d93031ad709a20588a6d2cb624f66253c53e8509c8f9410078d53bd9", size = 42942312, upload-time = "2026-10-25T19:05:07.228Z" }, + { url = "https://files.pythonhosted.org/packages/22/3e/94c4fb70d2844b5b396fa29e04139013292b8129feab427c6241953a1a6f/ctranslate2-4.8.4-cp314-cp314t-win_amd64.whl", hash = "sha256:81397be8ef6c7966ebe5b549244114e543f19219976d7e1437fdebb624f296c0", size = 20665797, upload-time = "2026-10-25T19:05:10.444Z" }, + { url = "https://files.pythonhosted.org/packages/e8/de/7dd4ad23e7fa5c0ebb3be622d94283a73885847f886c7803e5e683617548/ctranslate2-4.8.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:ed6d6e53e9414f702868f8c9543da8b526b8d1703dd0c1136c99d01c8e6b0614", size = 1491298, upload-time = "2026-10-25T19:05:12.626Z" }, + { url = "https://files.pythonhosted.org/packages/5b/4a/a37f99662f23132282540b33c26080dc498d66a3dd63418026d6bf143639/ctranslate2-4.8.4-cp315-cp315-macosx_11_0_x86_64.whl", hash = "sha256:18286b049aa9afb1df301bf627eb8dcbe4e9069810e7e3e4ef069e55a68b5934", size = 12172901, upload-time = "2026-10-25T19:05:14.422Z" }, + { url = "https://files.pythonhosted.org/packages/a8/7d/56ef3c91f58c1ad99daaf1b4ff798109e6a73ae5784549e0bcc3efe37b6f/ctranslate2-4.8.4-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1ac23582ee919235fd6a73ab383eb7cb97b544dc7c70fcc445dc22de7d70dc90", size = 18944558, upload-time = "2026-10-25T19:05:17.362Z" }, + { url = "https://files.pythonhosted.org/packages/58/cc/07a6c500aa65910691eb345fb4fca463906168cd75c6dde8735f02f01746/ctranslate2-4.8.4-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6139f57b316420469d1400968d40185ff7b99123d45a88ab3112d364809fffb", size = 42613272, upload-time = "2026-10-25T19:05:21.321Z" }, + { url = "https://files.pythonhosted.org/packages/d4/93/c3f255c6a7e7aded6c3fcabbb383d5b9277f05ff62d960dd9a99dae698f1/ctranslate2-4.8.4-cp315-cp315-win_amd64.whl", hash = "sha256:a6c28ac653a3598d3a978e9c9c629c3a4f30072b0d0473be2880d3d82599e11a", size = 20638838, upload-time = "2026-10-25T19:05:24.766Z" }, + { url = "https://files.pythonhosted.org/packages/ba/9f/890c9c520135642c5c338c0687872f41e65e25dd1d58a217d514258c9211/ctranslate2-4.8.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:8eb7a167ff37ddc2c0237064fd25101fe00775a7deaf1f094be9c7f88694d54c", size = 1518152, upload-time = "2026-10-25T19:05:27.037Z" }, + { url = "https://files.pythonhosted.org/packages/ec/80/08a06ade4d67b63384189c280edfd00be9a5ec3b9f6c0d263d322b7c12e5/ctranslate2-4.8.4-cp315-cp315t-macosx_11_0_x86_64.whl", hash = "sha256:63a715c34b5e3c462e5680ea32ea12bad30ada8db1a6d99fc8e0e541d6117542", size = 12199353, upload-time = "2026-10-25T19:05:29.26Z" }, + { url = "https://files.pythonhosted.org/packages/a7/1d/b44cd0038a265768ba649bd45359e6029be670fd6f0135a5d07637d38182/ctranslate2-4.8.4-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82caf13dce0563d96a92e0bcfe541f3ff73875b4d3d9335e8dfc46a66d0e2a51", size = 19368566, upload-time = "2026-10-25T19:05:32.297Z" }, + { url = "https://files.pythonhosted.org/packages/01/76/81a2e86d63183c597ef977c03d19166bab0857c1a92bdcfe394770bbd274/ctranslate2-4.8.4-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8849e5dfd27f3e5ad781d327f477434badfcb3deead4c4758ceeb621aed930a7", size = 43008255, upload-time = "2026-10-25T19:05:36.566Z" }, + { url = "https://files.pythonhosted.org/packages/ae/f7/d3ca639be986018bc1ee06e8c07652c44fc7c65b70022f161a7adce2d014/ctranslate2-4.8.4-cp315-cp315t-win_amd64.whl", hash = "sha256:b8f5ea44f93342cb460642f966bb87bf79d3fdcded6db049001cca28e82c0be8", size = 20666116, upload-time = "2026-10-25T19:05:39.895Z" }, +] + +[[package]] +name = "evdev" +version = "1.9.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/a5/f5/397b61091120a9ca5001041dd7bf76c385b3bfd67a0e5bcb74b852bd22a4/evdev-1.9.3.tar.gz", hash = "sha256:2c140e01ac8437758fa23fe5c871397412461f42d421aa20241dc8fe8cfccbc9", size = 32723, upload-time = "2026-02-05T21:54:24.987Z" } + +[[package]] +name = "evdev" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/2e/07/eb30593524303d1367f0dc00c1c66582c994dba412a47751e34bad9fa29b/evdev-2.0.0.tar.gz", hash = "sha256:442fb3f4c8dfc9e61e901133c356220c02d663eca8f34722e0cecdd637eba504", size = 33766, upload-time = "2026-08-23T10:31:26.835Z" } + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "faster-whisper" +version = "1.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "av", version = "17.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "av", version = "18.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "av", version = "19.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "ctranslate2" }, + { name = "huggingface-hub" }, + { name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "onnxruntime", version = "1.31.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/99/49ee85903dee060d9f08297b4a342e5e0bcfca2f027a07b4ee0a38ab13f9/faster_whisper-1.2.1-py3-none-any.whl", hash = "sha256:79a66ad50688c0b794dd501dc340a736992a6342f7f95e5811be60b5224a26a7", size = 1118909, upload-time = "2025-10-31T11:35:47.794Z" }, +] + +[[package]] +name = "filelock" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/4c/58/6fd434bec86eff7c38a3168454cb132b762b2bea9b3ac094101a2f7bc32a/filelock-4.1.0.tar.gz", hash = "sha256:ad7f724afef953e731b1cc39bcd3a09166d72ed7fcdf29e6e88b1c3235c6715d", size = 561277, upload-time = "2026-10-09T19:57:20.34Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ee/86/032133892a5de43b5a98200b01aadcad68cc255e274a762f08b8a76d2912/filelock-4.1.0-py3-none-any.whl", hash = "sha256:2ce9818e3e2d8f284c1a964414447ef148d42a5fd5e2a477a7118e574b293ec1", size = 133003, upload-time = "2026-10-09T19:57:18.716Z" }, +] + +[[package]] +name = "filelock" +version = "4.2.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d8/28/3893324bcadf8f89b1616637468d766af3f625008c0735bf704fdfa86617/filelock-4.2.4.tar.gz", hash = "sha256:c6d8663535e1650ee430507b4ffbac7b464dd64b7647ea0112a9f406499d163d", size = 652444, upload-time = "2026-10-19T01:57:51.001Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/1b/5e74289a1878e666bb4b65fe5805a04cafcac2aa5f519ef1ead67ef91c56/filelock-4.2.4-py3-none-any.whl", hash = "sha256:301241438c57936ef93f4243a94f2559022268bfcf9b375a9a72eb0f8db8358e", size = 162475, upload-time = "2026-10-19T01:57:49.419Z" }, +] + +[[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 = "fsspec" +version = "2026.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/77/cd/9be253869fc42e764de7f3dedd6969af7d44ff9c3375214a3442a6f3fc08/fsspec-2026.9.0.tar.gz", hash = "sha256:0f08147951c8cb31d844c3547d631053b127863b60be04cf06e121333ee0e2fe", size = 333545, upload-time = "2026-09-18T17:50:42.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6c/c0/a98505f18594f1bce828bb159cec0fcf9860562f1a2c85913409fc8f3d9e/fsspec-2026.9.0-py3-none-any.whl", hash = "sha256:8dd6e646e99ea382bd85f97a45e6b526a442d79423a7dc673f1e2756d05fcb5f", size = 221738, upload-time = "2026-09-18T17:50:41.341Z" }, +] + +[[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.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9e/27/06d899ea7bd721d272f84aac98bdb238de98af4cc767a69056d967d68c71/hf_xet-1.7.0.tar.gz", hash = "sha256:d406ec79053c0871817f700c2ac8c36ba0d87f9c34b7458b0f0063bb218b0466", size = 985689, upload-time = "2026-10-06T20:18:43.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9f/7c/3e45174942e6793adde6cba4daa7fb037275cf02a944d9eadfcf9ff33b86/hf_xet-1.7.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:fa029678be1ba7f953c409b0b27bf15cc69cd1c9b3a674fbd78856ebefca1052", size = 3803919, upload-time = "2026-10-06T20:18:09.844Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3a/5e8b363391adcbb002e191dbf924dab31464ea9c45adfeb73502afc36d35/hf_xet-1.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:57bc157b8b7fe3bee9dcb9af7f3da8de41801c3b31a9ef68a77a33c6a6be382f", size = 3553588, upload-time = "2026-10-06T20:18:13.376Z" }, + { url = "https://files.pythonhosted.org/packages/e5/c2/0d1eaa5da13bbf9c896badc7f380601c7d973a87a6ffb4d100267c4536c1/hf_xet-1.7.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:87dab080f8f7d32781c2586904e3603f4e60d09bfc727706c3ae419e0829beeb", size = 4201962, upload-time = "2026-10-06T20:18:16.11Z" }, + { url = "https://files.pythonhosted.org/packages/23/2d/225d5b11a9ca7d31b9470a57f2b2be1a5cef8b84325a2146aeb4589e226c/hf_xet-1.7.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:b01fe18dbbd151a2403d2c64ed30dc6547b00d6babab9a617d77c7acdb81ee66", size = 3982978, upload-time = "2026-10-06T20:18:18.092Z" }, + { url = "https://files.pythonhosted.org/packages/93/34/9d681f0e3dac0b5dae0d7dea748429266f24e52415446523f464fbaa828e/hf_xet-1.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4ee5e05a627f5ab5bad7a86582277d645556ea1e199903aae19e033a392aa13a", size = 4181558, upload-time = "2026-10-06T20:18:20.082Z" }, + { url = "https://files.pythonhosted.org/packages/de/f0/277f039b7d72027bc2ed277f1b62a2f70f740a5aac2a3e7243e5b6854c5d/hf_xet-1.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:19c0e64f14175ccb6a1aff69e0d2ab9ec5269a560e6687abaf2b3fa4f73de7cd", size = 4411546, upload-time = "2026-10-06T20:18:21.999Z" }, + { url = "https://files.pythonhosted.org/packages/3d/7f/832d3ddb49326114175b7bcc50daea8565c09fd21ac03a02b211c09fefb7/hf_xet-1.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:757168feb5679647c0bb13ee5d0faebe799c4dff9051419885a566ebd79f949d", size = 3812809, upload-time = "2026-10-06T20:18:24.288Z" }, + { url = "https://files.pythonhosted.org/packages/3d/c4/310c3c29e5beae7c049e63947bd1923d597883b41c9ec4718589920812c4/hf_xet-1.7.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b91569d5f1b61c34b043687da02c05dd3604f3d329e7868510bf3f7971599006", size = 3646174, upload-time = "2026-10-06T20:18:26.279Z" }, + { url = "https://files.pythonhosted.org/packages/9c/0b/b03be21ffaada749ba0d3197d8aefbf1aa698bac149580421c15239b299e/hf_xet-1.7.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:e3e88a7a75d7d95cbee1f37dc31341d6201124cf21c6c4b1dfab8ccba9b09e0f", size = 3796096, upload-time = "2026-10-06T20:18:28.43Z" }, + { url = "https://files.pythonhosted.org/packages/c3/47/a26ebdce7056a61e931f228439bc0ab08cbec239d1690f965e5e637cba79/hf_xet-1.7.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:59fba37039233c7fcbe196817d6cdcf1b40dfb17b410f229d85b0cf0a1848da4", size = 3560352, upload-time = "2026-10-06T20:18:30.365Z" }, + { url = "https://files.pythonhosted.org/packages/a3/4c/2bf3b66c215d409655f28de1622393dde04c9461280d48c7924bb3b2decd/hf_xet-1.7.0-cp38-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2814a6e999d13464c4d679b788cc5d784eb5a4edfc638a31f10e9a11ab531ef8", size = 4212180, upload-time = "2026-10-06T20:18:32.292Z" }, + { url = "https://files.pythonhosted.org/packages/49/0c/a2f703a5a78267556e89e03316fa0805c86b72b50829bc67665746e8ebf0/hf_xet-1.7.0-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:fcfd6c22418e57dd5b3aea649e813b2e2cfb2aebf317b210d90f1fe4b3018b52", size = 3990011, upload-time = "2026-10-06T20:18:34.21Z" }, + { url = "https://files.pythonhosted.org/packages/a4/77/e52e4201b1cbf571530a61cc57f70182045a39a230089ee5f1df182a4de2/hf_xet-1.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:80f79dae613ce9e0ea1fd1ae15616ca9ac74aed4c770aabc199c4f03ebecc863", size = 4190628, upload-time = "2026-10-06T20:18:36.062Z" }, + { url = "https://files.pythonhosted.org/packages/6c/dc/03a21b89f118664a0926ff25b0f8e44a519bf22724a6a8fc7a9abbc188b6/hf_xet-1.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:0a9e802f33bf50c851abe45fc5380e61f959e2d369647d6742b79ad9d6c27cab", size = 4418814, upload-time = "2026-10-06T20:18:37.888Z" }, + { url = "https://files.pythonhosted.org/packages/4d/59/b35106dfa71b6eef605dc88bd038fe99c7f86fb132a15b60d0bf2f235b2c/hf_xet-1.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:2b7bb5727889b0f2436dbaaad8fc4c3e66b8240d992716989e0c086b4278b1bc", size = 3822644, upload-time = "2026-10-06T20:18:40.052Z" }, + { url = "https://files.pythonhosted.org/packages/48/cd/072313585f74fe9d441e2eb5e0a4703c30586cd709810ea369675f61b74e/hf_xet-1.7.0-cp38-abi3-win_arm64.whl", hash = "sha256:acc3851cf2576a8fb2ae926da863f4efabe21303cf292e9a44332802ab0dcc6a", size = 3662436, upload-time = "2026-10-06T20:18:42.205Z" }, +] + +[[package]] +name = "httpcore2" +version = "2.14.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "h11" }, + { name = "truststore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/30/ff/b53af1b49bb2cb5fa97c92215614b173ca5c1a99ded80e2d52f15a94fa6d/httpcore2-2.14.0.tar.gz", hash = "sha256:4f57a1a8249fe6af589d935cfd456f1d13bbdcb0f0fc72af9142368fc94811d7", size = 69096, upload-time = "2026-10-18T16:29:21.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/06/a8d6a8f90d11b76d9086242b6bb0ee4b503473bfc8be34c2d5b067275c22/httpcore2-2.14.0-py3-none-any.whl", hash = "sha256:4c4f64f4b544afeb778c42c0ffb5941b29e671157e90ed3f6dc787c4bca90cd1", size = 84291, upload-time = "2026-10-18T16:29:19.743Z" }, +] + +[[package]] +name = "httpcore2" +version = "2.16.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "h11" }, + { name = "truststore" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/61/afa9d6b7452f9eca73f73d45324eb0bb52f098fd5e6049bf6b8263be9b4e/httpcore2-2.16.0.tar.gz", hash = "sha256:c72cd0413563b17e1cd8354677dff887466f8ec2551679759e93126534428643", size = 69886, upload-time = "2026-10-21T07:09:45.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/c2/ce417c397afa5181f0e3c6ff01a4d01639414e1adef08730d97571297151/httpcore2-2.16.0-py3-none-any.whl", hash = "sha256:5c4358319f2602d984ad93182c9fee5160f22e9da7babdda870a5e7c4e2dc34f", size = 85070, upload-time = "2026-10-21T07:09:42.802Z" }, +] + +[[package]] +name = "httpx2" +version = "2.14.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "anyio", marker = "sys_platform != 'emscripten'" }, + { name = "httpcore2", version = "2.14.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'emscripten'" }, + { name = "idna" }, + { name = "truststore", marker = "sys_platform != 'emscripten'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e8/67/58353f1848b4ba568e1ec22ea1e0d8e039f0bca5fde7e2d1f07739fd83e7/httpx2-2.14.0.tar.gz", hash = "sha256:47ad61a3c40282cd8d0dc96311531f00f5bfc71a066c6fe3b36d8f63fb9e4f6e", size = 102036, upload-time = "2026-10-18T16:29:22.627Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/69/5a/469616aa8c2cbb0bb9dd67a3c18d07c01ab604cc0b236ee1c47d260c7f6e/httpx2-2.14.0-py3-none-any.whl", hash = "sha256:9d20c13a10bae1773a0be3b0f1e5beeb4bdd549bc3a2ba18efa32897c65403e4", size = 96901, upload-time = "2026-10-18T16:29:20.819Z" }, +] + +[[package]] +name = "httpx2" +version = "2.16.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "anyio", marker = "sys_platform != 'emscripten'" }, + { name = "httpcore2", version = "2.16.0", source = { registry = "https://pypi.org/simple" }, marker = "sys_platform != 'emscripten'" }, + { name = "httpx2-jsfetch", marker = "python_full_version >= '3.12' and sys_platform == 'emscripten'" }, + { name = "idna" }, + { name = "truststore", marker = "sys_platform != 'emscripten'" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/73/5ca2cedf5e4e50423d1c258877865a6b62793633b561c58499f8aeb33b7e/httpx2-2.16.0.tar.gz", hash = "sha256:0d54c98128e8f2ff7fbbde0fca8c359e5f032edeaaaac443cdb7f31f685bcd7f", size = 103116, upload-time = "2026-10-21T07:09:46.348Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7b/3d/2e4bc4fd1ef9770871669adb348d612a6e4786b303a23f9935b81c48dd60/httpx2-2.16.0-py3-none-any.whl", hash = "sha256:fd2c5d7909e8d86fe92d53020c310ca0e4e431b838c207c5754b9bbf0308d49a", size = 97880, upload-time = "2026-10-21T07:09:44.01Z" }, +] + +[[package]] +name = "httpx2-jsfetch" +version = "1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/0e5636363151a2a1795e0a77617168b9ca438e1748ec05fc9b5687f93d64/httpx2_jsfetch-1.0.tar.gz", hash = "sha256:70a0e3eabfef7cce5ad9c629f7d01ca05e418f586646f4ddf14782e4c1454c60", size = 6872, upload-time = "2026-08-07T00:13:07.492Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9b/43/832f631d32e4f1211caa2ba368317739fe71f0b8530e4c9d15dc454bac2a/httpx2_jsfetch-1.0-py3-none-any.whl", hash = "sha256:cb916b707601e69a07721aabc8f3f6659be3a6893bc1ff5c6f9e02241df2da32", size = 6382, upload-time = "2026-08-07T00:13:06.567Z" }, +] + +[[package]] +name = "huggingface-hub" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "filelock", version = "4.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "filelock", version = "4.2.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'AMD64' or platform_machine == 'ARM64' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "httpx2", version = "2.14.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "httpx2", version = "2.16.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/dd/585639d95f6a987c0bdfb9045f050f4ad67240775644ba7a4fdc5aca3a3b/huggingface_hub-2.3.0.tar.gz", hash = "sha256:0b783b37f200f1d25bef2344a997c7d410f4437fbe9d8fd965f958e75cec7aef", size = 1063410, upload-time = "2026-10-23T08:52:06.594Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/89/5f6ef1162d0323f167b6baab04d1b4bd6a946161a8af6d86f622d9d79aa1/huggingface_hub-2.3.0-py3-none-any.whl", hash = "sha256:5da369600233568a126eb5578754935b2add9446b42d9e2fc0927d56840ac1a5", size = 855161, upload-time = "2026-10-23T08:52:04.78Z" }, +] + +[[package]] +name = "humanfriendly" +version = "10.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyreadline3", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cc/3f/2c29224acb2e2df4d2046e4c73ee2662023c58ff5b113c4c1adac0886c43/humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc", size = 360702, upload-time = "2021-09-17T21:40:43.31Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f0/0f/310fb31e39e2d734ccaa2c0fb981ee41f7bd5056ce9bc29b2248bd569169/humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477", size = 86794, upload-time = "2021-09-17T21:40:39.897Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6f/7e/1e7e8dc30634b93ebb3d58a3dea569ad146e656218d3960ab04f62047b29/importlib_metadata-9.0.1.tar.gz", hash = "sha256:ab830580bc0ef3db61ce8fae716389e5462b67e033018bab6d8f80ef17172f99", size = 59124, upload-time = "2026-08-28T15:30:34.646Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/55/ecca97ae19075f1fac62def77731e7f535e6c1fb8f92ff08160c5e6dade8/importlib_metadata-9.0.1-py3-none-any.whl", hash = "sha256:bba5600596a7e21f3eef53281cf28d6a5195634d2f2b78ff9501a3272c6eaab0", size = 27920, upload-time = "2026-08-28T15:30:33.433Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "10.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/98/f6/4eda8458eb00ec03e715c376c6b23b3def69687924c68d36d1c4003d3bc4/importlib_metadata-10.1.0.tar.gz", hash = "sha256:82b04047fa09792c1a8cfeddfe08bec79e4b13c29c8469b0d3949860f61017e8", size = 67761, upload-time = "2026-10-24T00:01:44.856Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/65/b6/495438ad95e0102aff8f6786b5474202f38cd5d4700d03a72b77977dec10/importlib_metadata-10.1.0-py3-none-any.whl", hash = "sha256:cf45ce66a929c64e994185a809c04840d0501db17e663810d993d0f4829265c7", size = 32221, upload-time = "2026-10-24T00:01:43.507Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jaraco-classes" +version = "3.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools", version = "11.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "more-itertools", version = "11.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7f/66/b15ce62552d84bbfcec9a4873ab79d993a1dd4edb922cbfccae192bd5b5f/jaraco.classes-3.4.0-py3-none-any.whl", hash = "sha256:f662826b6bed8cace05e7ff873ce0f9283b5c924470fe664fff1c2f00f581790", size = 6777, upload-time = "2024-03-31T07:27:34.792Z" }, +] + +[[package]] +name = "jaraco-context" +version = "6.1.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-tarfile", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/af/50/4763cd07e722bb6285316d390a164bc7e479db9d90daa769f22578f698b4/jaraco_context-6.1.2.tar.gz", hash = "sha256:f1a6c9d391e661cc5b8d39861ff077a7dc24dc23833ccee564b234b81c82dfe3", size = 16801, upload-time = "2026-03-20T22:13:33.922Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f2/58/bc8954bda5fcda97bd7c19be11b85f91973d67a706ed4a3aec33e7de22db/jaraco_context-6.1.2-py3-none-any.whl", hash = "sha256:bf8150b79a2d5d91ae48629d8b427a8f7ba0e1097dd6202a9059f29a36379535", size = 7871, upload-time = "2026-03-20T22:13:32.808Z" }, +] + +[[package]] +name = "jaraco-functools" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "more-itertools", version = "11.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "more-itertools", version = "11.2.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6c/1f/c23395957d41ccf27c4e535c3d334c4051e5395b3752057ba4cbaec35c56/jaraco_functools-4.6.0.tar.gz", hash = "sha256:880c577ec9720b3a052d5bc611fb9f2269b3d87902ef42440df443b88e443280", size = 20837, upload-time = "2026-07-14T01:28:02.544Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/36/ecc85bc96c273dc8a11273ed4782272975e6338d4a3e9228621175edf0e3/jaraco_functools-4.6.0-py3-none-any.whl", hash = "sha256:99e3dc0060c5cbe8fcd1cdb36258e2a65ca40f1566b2033b12abb1bb44dd3c30", size = 11677, upload-time = "2026-07-14T01:28:01.59Z" }, +] + +[[package]] +name = "jeepney" +version = "0.9.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7b/6f/357efd7602486741aa73ffc0617fb310a29b588ed0fd69c2399acbb85b0c/jeepney-0.9.0.tar.gz", hash = "sha256:cf0e9e845622b81e4a28df94c40345400256ec608d0e55bb8a3feaa9163f5732", size = 106758, upload-time = "2025-02-27T18:51:01.684Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b2/a3/e137168c9c44d18eff0376253da9f1e9234d0239e0ee230d2fee6cea8e55/jeepney-0.9.0-py3-none-any.whl", hash = "sha256:97e5714520c16fc0a45695e5365a2e11b81ea79bba796e26f9f1d178cb182683", size = 49010, upload-time = "2025-02-27T18:51:00.104Z" }, +] + +[[package]] +name = "keyring" +version = "25.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "importlib-metadata", version = "9.0.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "importlib-metadata", version = "10.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney", marker = "sys_platform == 'linux'" }, + { name = "pywin32-ctypes", marker = "sys_platform == 'win32'" }, + { name = "secretstorage", marker = "sys_platform == 'linux'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/db/e655086b7f3a705df045bf0933bdd9c2f79bb3c97bfef1384598bb79a217/keyring-25.7.0-py3-none-any.whl", hash = "sha256:be4a0b195f149690c166e850609a477c532ddbfbaed96a404d4e43f8d5e2689f", size = 39160, upload-time = "2025-11-16T16:26:08.402Z" }, +] + +[[package]] +name = "librt" +version = "0.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/04/f5/9dc696772d241814bacac7880bac32f2930b5a6ebc1f85317b83161a011c/librt-0.16.0.tar.gz", hash = "sha256:ac38d6d8d66bf3d744148dbbc0b8e193e195a51e364ed55e224631f5721891fc", size = 219839, upload-time = "2026-09-29T00:55:32.891Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/77/900294b3c9a81415323d81b3f3f271a7f5d7ed9d01e824fc38ffa49470b6/librt-0.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:96f576f2711f8519152ec76d0e599243555c1f07679fa73606ca8c8c868c0be6", size = 148668, upload-time = "2026-09-29T00:44:20.282Z" }, + { url = "https://files.pythonhosted.org/packages/55/3b/c301e8cc47758e4518b93e926a0111080155cc79fa03651d202ac2025065/librt-0.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2bec3818c7da7c96ceae0ef5915a3d16c52dd08f3ea913bf1fe8568c447c7978", size = 153562, upload-time = "2026-09-29T00:44:21.672Z" }, + { url = "https://files.pythonhosted.org/packages/62/b1/4d5b98114a58bf17e3832cd33400e40f2582f68c2fb7ce25b4468cb1afd3/librt-0.16.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:64c79520414a3fdfc6aabd7593e6169afa14d5f8d9908d4b498db068868b08dd", size = 494337, upload-time = "2026-09-29T00:44:23.096Z" }, + { url = "https://files.pythonhosted.org/packages/88/36/14223c9b0dc38982eb4f399732c8cb27b19c7e027ae0faef5ca51d08d19f/librt-0.16.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f81b5b19ce748ef68d4746656b7929762eb2fe99269b266e4be07e2ee4de7144", size = 485440, upload-time = "2026-09-29T00:44:24.555Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9e/d7155e6800d0c33e297e529b217649f7361d706491ebf9d2fc0fc627309e/librt-0.16.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c71d1b76210a36729fedfc5115069b50a3d8619054745f8758fe5d6f19e86671", size = 498363, upload-time = "2026-09-29T00:44:26.03Z" }, + { url = "https://files.pythonhosted.org/packages/d3/ce/d5f1fb9f913ac0979d6fc5db9fb9c0bf28cc3470988528957922f15ed40c/librt-0.16.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:473eebc7866bb0a0c8849a292b5e7157c1aba5d14d0f0f610c52158d6d964262", size = 515453, upload-time = "2026-09-29T00:44:27.566Z" }, + { url = "https://files.pythonhosted.org/packages/b4/d4/ca0fca1a27c26080d1a25b2b31f271e532078a5719878c3daca0c3d4c539/librt-0.16.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4eb1313a19847089ee81e88742abedf285c60538816640b99742d8534b81d26a", size = 509537, upload-time = "2026-09-29T00:44:29.14Z" }, + { url = "https://files.pythonhosted.org/packages/ee/c0/26807bf2221a53a2c66f2e23a5c4d57f1c0eaa4afed7cb81d841cf3d1903/librt-0.16.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ebefd60b42e2a82b32d136bb5f7c94eadfcd29f772b547df6f3291d1ed855a1c", size = 532541, upload-time = "2026-09-29T00:44:30.745Z" }, + { url = "https://files.pythonhosted.org/packages/0e/50/c329d509907e1bc061abeec3796f94d255d43ba25d28c3854d2138ed5ab2/librt-0.16.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:6c5da27e8056439f927ea896735da60e616c477a8293feaa3233d4e7781a6726", size = 537059, upload-time = "2026-09-29T00:44:32.102Z" }, + { url = "https://files.pythonhosted.org/packages/84/d6/4571b9c9e65d98e5503734166dce2fd3e216f526dc3c59a3773faa8a60e3/librt-0.16.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:67e718c7a43f8db325abbbf1404e2d535f12f8f7a1a82259568385cc5274b82a", size = 536614, upload-time = "2026-09-29T00:44:33.653Z" }, + { url = "https://files.pythonhosted.org/packages/c8/d3/a2ed8a292e4ab7889792a9c3f4ad5d1caf6557afce7f6b452e77f8ed20b7/librt-0.16.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:314e703f0c19320dc8094e7a784b9cf29e1b67402515abf580069a6363c0b4f1", size = 517199, upload-time = "2026-09-29T00:44:35.115Z" }, + { url = "https://files.pythonhosted.org/packages/9e/24/276e5218b4b7adb6258a42b7403cb1b7cef25616238d0c2152288a9d2f53/librt-0.16.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:943c6bbecbdf7fa575a4f2952fcfd848c88ef95507c3fca411e89d4ac3ff8143", size = 558746, upload-time = "2026-09-29T00:44:36.656Z" }, + { url = "https://files.pythonhosted.org/packages/7c/5c/9156df81a1726e1efc9567379def2b8777a6d56f464d2f1b760bf951b8af/librt-0.16.0-cp310-cp310-win32.whl", hash = "sha256:7cc365f006891afb006b52d5ee5ee74c09306ffa20e2f8705a32a4450af2f3ba", size = 104424, upload-time = "2026-09-29T00:44:38.123Z" }, + { url = "https://files.pythonhosted.org/packages/0b/62/4fd172cb3f49ab2cf5ef17de519a93cfb935202c1270ba9d44c6a64178c3/librt-0.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:0314058469f4d2fd279ce7c62ac274ac82c3918ef7db62ef0697c4c359370155", size = 124267, upload-time = "2026-09-29T00:44:39.455Z" }, + { url = "https://files.pythonhosted.org/packages/ba/0e/b04fd2d76b6a78a02286938251b2c119fb36ddece92c76cb4886ef7d44b8/librt-0.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fe4372c52d4849096c6cc1cda2817d293ec51440c890474ed59ef38d46556f18", size = 148058, upload-time = "2026-09-29T00:44:40.903Z" }, + { url = "https://files.pythonhosted.org/packages/a3/fc/e1ed24aadb32d38603c0c07f579d739eb4d90e64e90d525b024e4a999b4d/librt-0.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c72c5295a84bd249526da9bdca38f2e176d15c31c13bb0063c5053f4ca023421", size = 153073, upload-time = "2026-09-29T00:44:42.165Z" }, + { url = "https://files.pythonhosted.org/packages/be/38/133ab655409420e0c34a9a9836a7f4e5ae75fba758d7fe177099130d58ba/librt-0.16.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be56ba9c884143495b517f23fe794ae367d58cd89ea0fdd6d437e3c024a87f9f", size = 493052, upload-time = "2026-09-29T00:44:44.043Z" }, + { url = "https://files.pythonhosted.org/packages/94/42/aaa663bc9421f5bf7bbbe9d3316d7219749698ec7688ac3b519770a89c04/librt-0.16.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:ef46c1a29ffb8c72e882e22618ec618778eacd0578fb22c6e7cf9c11d15f357b", size = 485506, upload-time = "2026-09-29T00:44:45.479Z" }, + { url = "https://files.pythonhosted.org/packages/7b/59/83a6eb5087ba8b45b083859e2085256963e06d4c2531944cdd962670bfb5/librt-0.16.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d3c94211ee0c4f8d649ec06b7c115c0ec4eadb873a0e3154ca15cef3f814b071", size = 498708, upload-time = "2026-09-29T00:44:46.916Z" }, + { url = "https://files.pythonhosted.org/packages/a0/e4/15a8d62b2bc12935080ec7277e2e0b9b233047781eb784a51d3e25af669a/librt-0.16.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:94aed6a8308818b91677957d1bd03188869cd7aeb23c5dba7912a6c0402f7602", size = 515981, upload-time = "2026-09-29T00:44:48.316Z" }, + { url = "https://files.pythonhosted.org/packages/46/4f/287cc282ac5dd815204c0779e79401bb0a568c3a1335fb319bf0838fb566/librt-0.16.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:349c0bcb87ebd07481b6ff781e25cdc699723dbe2212e57dabb27f7a13b7b87d", size = 508670, upload-time = "2026-09-29T00:44:49.726Z" }, + { url = "https://files.pythonhosted.org/packages/bf/5b/ab7292add898ade0d2b5b75d32a923aae315861671aa5c39f5491309f7ae/librt-0.16.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:001bfd59a7d45b17e3e75f2a8c6405280b35e7b84471792778e718c4f368950e", size = 530393, upload-time = "2026-09-29T00:44:51.356Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9e/8e6bcf027d4bcbc16a4e864b3d158a1d3e5f55ffa53af0238020cad89271/librt-0.16.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:28e038895b998d7a0c7798922ce8a1dc157675df5cf1c9ef0aca809ed804b7a1", size = 534302, upload-time = "2026-09-29T00:44:52.893Z" }, + { url = "https://files.pythonhosted.org/packages/96/a4/8c5ab4f3b3a8e905ff8305d76976a2e666f52fe049edd398aed2402beb36/librt-0.16.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:0dbe4096a7ecc00fa835d24510ad8545a4efef738dac96e0e63516783ccde905", size = 536150, upload-time = "2026-09-29T00:44:54.421Z" }, + { url = "https://files.pythonhosted.org/packages/ea/5e/7c4bc267e3cd4b8bd288de9f62d61fff203829c9cc649ea2aa12e9218cf0/librt-0.16.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5cd5b092441053364af968ea12084692cb9d4a22f3ce9524e377880bf028761e", size = 514316, upload-time = "2026-09-29T00:44:55.998Z" }, + { url = "https://files.pythonhosted.org/packages/e0/75/c8bc6b50f43c73819334233f5a3259c81216742cef56d2140c3dd377c3f0/librt-0.16.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3ddeb3c9dedb461bb457c6c7d9aa7fbf35329da313d1a7543d00c8d0f3473c96", size = 557731, upload-time = "2026-09-29T00:44:57.581Z" }, + { url = "https://files.pythonhosted.org/packages/93/fb/e241f91bc8de6c7ac1c6a20ea6dd381bc52312b44d711ffcd97140db1e57/librt-0.16.0-cp311-cp311-win32.whl", hash = "sha256:e05108e0849966f53a8d2d3112a7af881d0efaa479bc735bba91108f9f2350a7", size = 104922, upload-time = "2026-09-29T00:44:59.078Z" }, + { url = "https://files.pythonhosted.org/packages/d1/38/c892383d2bb1a6a80b2ec8ede84970a265a792c56614a06282bf3008517c/librt-0.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:5f49cff01bd608ef7d97104cb035c75455e79c2d70bf4a506cf773338ac1860d", size = 125093, upload-time = "2026-09-29T00:49:01.621Z" }, + { url = "https://files.pythonhosted.org/packages/e4/56/8bbde1ed0b21480163617648f638fdaec9374cf5e9c846ebcee34ec02a42/librt-0.16.0-cp311-cp311-win_arm64.whl", hash = "sha256:1d28ae980ae2218f9c5b95d191e947296f918c9bf0b400d467a9430275bbe678", size = 115910, upload-time = "2026-09-29T00:52:40.131Z" }, + { url = "https://files.pythonhosted.org/packages/ad/76/bbdaeb87b7c47b5c7343e90222b9bfa4e4a8a83f647e02933ad0129225b1/librt-0.16.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:fe52bf4641069e7978a14253b036cb9002def1926317e710f2e249f8a8c47742", size = 151028, upload-time = "2026-09-29T00:52:41.508Z" }, + { url = "https://files.pythonhosted.org/packages/fd/0c/ab8ed3dab0085931aec4a792c7eaac8dc6c5ff4691fda3a5360d9d8a9cd2/librt-0.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5bcc2c4726ced915b00de0c9856a4eeabfb3fddb93e10e0b8f735b7709358b6d", size = 155283, upload-time = "2026-09-29T00:52:42.873Z" }, + { url = "https://files.pythonhosted.org/packages/eb/36/494e79d460c80c1f030661e8287c9eca5e1ad652dc2b2180b6cd42abce0a/librt-0.16.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff7baa55f8e7c69851419e50a666015d02a74198716fd45c0125a2112e0a389f", size = 503185, upload-time = "2026-09-29T00:52:44.638Z" }, + { url = "https://files.pythonhosted.org/packages/9b/34/a8464038dd9db6e4381fa2b6eb73dc9a50888d77102c4c139304ac35cddc/librt-0.16.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:b95d5d92ab83d39e760a52091bb1baba664f3a2351e39b1e16801e5747c2f0e9", size = 496738, upload-time = "2026-09-29T00:52:46.441Z" }, + { url = "https://files.pythonhosted.org/packages/6a/53/e0e5e334ef0c6ed27039d323819368b9ef6712be87d55ee2bf9799398afd/librt-0.16.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b6d085d70bce51d43c5c7c36d63490770180d8779e71c49305c87b4213918de7", size = 513818, upload-time = "2026-09-29T00:52:48.068Z" }, + { url = "https://files.pythonhosted.org/packages/ad/f7/7ce72cbf19d0addd05090b339152fd0548a02562c2866a603e6e3b3da2df/librt-0.16.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:36e53948e99bbe3ffea257124cfcae1cfb01831555c9a9c903c9f9a72db7fd07", size = 531952, upload-time = "2026-09-29T00:52:49.816Z" }, + { url = "https://files.pythonhosted.org/packages/83/22/0b1bcb6a8e723c8b4fd60dfc8ae8ec6461c54073fbc8685efeb8d900d407/librt-0.16.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:54d11f726aae9df5a6ffbbf0a03a52449bbac84a53ef03669cb41cdfd4ae41bf", size = 524465, upload-time = "2026-09-29T00:52:51.354Z" }, + { url = "https://files.pythonhosted.org/packages/64/2e/e9c23b8b9df1813da1be205deca9606beb7ddd033972246cd426d05374a0/librt-0.16.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4323193ac0cd025f85af531df8ba91bf24d1973b401697347a6282e8fd3fcf5e", size = 543191, upload-time = "2026-09-29T00:52:53.284Z" }, + { url = "https://files.pythonhosted.org/packages/bc/e5/6a8b21b342c03ed7e230fa3afbfd2edc58e6e87ef1f0d11fa2b9a748c252/librt-0.16.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e42f8e098b9c5396fefa05fb1cc7e33b0e08fc51da106b5de4a45fd22aac6743", size = 546979, upload-time = "2026-09-29T00:52:54.932Z" }, + { url = "https://files.pythonhosted.org/packages/84/9e/b5129023eced1be01e01c22757f53be551d463b1bb7264f787927404c1d6/librt-0.16.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:39ec1d5a14e37baf1450a6cabf03fe552340808bf1ad9d71824ab90117716459", size = 555317, upload-time = "2026-09-29T00:52:56.869Z" }, + { url = "https://files.pythonhosted.org/packages/71/89/28bba5938c725fe91f06bf93f7fa6c6b150229df53a87b454b0d5c2a796e/librt-0.16.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d1aabe3925cbb4a08d15b7b20ba4011b53019da0c4173a25155139b7b1baed65", size = 535846, upload-time = "2026-09-29T00:52:58.475Z" }, + { url = "https://files.pythonhosted.org/packages/22/92/63773026614f888c5d4e370e395ce42ca604b89f70b3acdfedbf94851b80/librt-0.16.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:300c3ffdc459f4a779a8411ecb188e3ac0b1ff3a3a7b099642555dedae06c69b", size = 573700, upload-time = "2026-09-29T00:53:00.127Z" }, + { url = "https://files.pythonhosted.org/packages/66/8f/347d4677eefb57cd9f8e01d95a1dcee9a91b4e44e664173c32ff6f3752e5/librt-0.16.0-cp312-cp312-win32.whl", hash = "sha256:c17194318e4c0c0348b36f36c2ec7534436fe0a4c15582403162a4f08c80797a", size = 106158, upload-time = "2026-09-29T00:53:02.031Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2c/5193dc81127cd5ddfad031391b046bf32dda219b38463ab872407ca30646/librt-0.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:25a58a19ea8d83b68209f04912df765e9260635ef77646542ed4b4abe6bc7940", size = 126176, upload-time = "2026-09-29T00:53:03.445Z" }, + { url = "https://files.pythonhosted.org/packages/ff/3d/9668a400c8dd81d162eba38b33fa49fa6205f1a64493570a13fbb815c3ee/librt-0.16.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7be7cf555bc30ec12622e9447299cc4a9b8ff307548b634794353db0c2065dc", size = 116572, upload-time = "2026-09-29T00:53:04.815Z" }, + { url = "https://files.pythonhosted.org/packages/46/cd/ae5e0e9dba45d1399aa04a5395bcc0bead40d9fa06dc903634a7b4d7473d/librt-0.16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c5e6144e68b577f157519f2ba88ca20e3ed61c29b00e5cdfa76cd2d45acf059a", size = 151036, upload-time = "2026-09-29T00:53:06.284Z" }, + { url = "https://files.pythonhosted.org/packages/41/5a/48a16e323c5f9447a94cce7b59babf60fa04e62c3365ecf060c77ed8b320/librt-0.16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:33f41443a1f4e1f099331b3d8120e409fbff84b9760bc1cc9ea496f37ddaa5cc", size = 155211, upload-time = "2026-09-29T00:53:07.72Z" }, + { url = "https://files.pythonhosted.org/packages/3f/29/0f59299eb4251a409b2e690ad4b7d9f8a676db829d7817ec961f32b44f7e/librt-0.16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e510b7770bee609617a3374a96548eb114cae048023e3f049ee449e7ff2db32", size = 502587, upload-time = "2026-09-29T00:53:09.191Z" }, + { url = "https://files.pythonhosted.org/packages/de/ba/d6fb4ef8d1537c396079d72289f16be7cd35a366e5065c51253fea2760b6/librt-0.16.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:efc49c462d4516b8a58b00b490078fa64689fd1fe66970cc190131d7afb8027e", size = 496146, upload-time = "2026-09-29T00:53:11.016Z" }, + { url = "https://files.pythonhosted.org/packages/52/fc/8c50dd4d7cc97c0ee8f252c8a3104980f234391cf1519b554e8b9de08b60/librt-0.16.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:92caf82ebef5e12d21c72242b70d1e92536f1711cf2a727a4c276de4b4469087", size = 513336, upload-time = "2026-09-29T00:53:12.655Z" }, + { url = "https://files.pythonhosted.org/packages/a9/59/16c409c56f708eda2db9a0553662845d45e3871c77d70a240dae3f3bdc56/librt-0.16.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:17bac7f7a16b328fff77e440287693eb017abde913595b5827ebccbc21ecd8a6", size = 531689, upload-time = "2026-09-29T00:53:14.39Z" }, + { url = "https://files.pythonhosted.org/packages/88/82/d34772a6c29d1446dcca6e64d74062efd508523ab351aa16625a4689d5cc/librt-0.16.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5b976054553670829985ed767feb78fb6bcede0175327c4844dd5c281c1be659", size = 524537, upload-time = "2026-09-29T00:53:16.064Z" }, + { url = "https://files.pythonhosted.org/packages/77/8f/24c5631313746131ccee53bc91fdc8374f9cf25e0082a1fee9c93bb98acc/librt-0.16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0058f9d68721094105917254c72ac0569117bb7b13b9769cf45d26d89f9d21cd", size = 543231, upload-time = "2026-09-29T00:53:17.939Z" }, + { url = "https://files.pythonhosted.org/packages/f2/cb/5f8e0d41dbd8b499c2265e939c31acc9ba59845565bf99539ad1c06aebcf/librt-0.16.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:30b7beaf3f4487b7d8adef1f158b49067cb4d5a19fa7a3bf31a4e7a820e435c5", size = 546499, upload-time = "2026-09-29T00:53:19.666Z" }, + { url = "https://files.pythonhosted.org/packages/be/61/063052de441d1385f59cea4223f184bf9e5d125de1ae3239b490aa1e486e/librt-0.16.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:468df902df016a06eb0e40b0747dc8d14e47d7a38b18b63b1fb167d85cb94d63", size = 555261, upload-time = "2026-09-29T00:53:21.292Z" }, + { url = "https://files.pythonhosted.org/packages/14/11/a2ada0529372268d6401afa9d457a095b68cd7753532b6f7f33049a19b43/librt-0.16.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:aea7b1f2b125dad5de85f049136651bff256c883c65e6b9209b2da0a1ac3cdef", size = 536029, upload-time = "2026-09-29T00:53:23.07Z" }, + { url = "https://files.pythonhosted.org/packages/23/9d/5bb6d38853382986dca702fc7e06c8256d30f5fa0676d882773b744610dc/librt-0.16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a8afb6557920860b7a3a596eb804cf37e09e7cf8a803db2478c202acc72d8c2e", size = 573748, upload-time = "2026-09-29T00:53:24.696Z" }, + { url = "https://files.pythonhosted.org/packages/99/f6/0025cde35ff7f607684dc775a2b2d732cce2561cec050a6ee1fb2e1fc6fe/librt-0.16.0-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:77c7a2b4fe2c1369e0d5aa1cade26740a7b14be32fbc9a5535d617d20065c39d", size = 79861, upload-time = "2026-09-29T00:53:26.089Z" }, + { url = "https://files.pythonhosted.org/packages/93/93/303b8592909bd583f83f02818ffbea3f7647ca1e22b1cd5465d04b8145fe/librt-0.16.0-cp313-cp313-win32.whl", hash = "sha256:02d89c813d5ff74b17df72d3a34819d132cd168e56b81bf755b809bd9e46b8c4", size = 106236, upload-time = "2026-09-29T00:53:27.43Z" }, + { url = "https://files.pythonhosted.org/packages/cf/24/80bbb463c60ed18e29cb26aba386ddb76609580e4e7160710e550587018c/librt-0.16.0-cp313-cp313-win_amd64.whl", hash = "sha256:14ed6ebe3e4f85f326d7920011ad30ff49ed9334e62cf88caef9ba973d9e3a92", size = 126180, upload-time = "2026-09-29T00:53:28.7Z" }, + { url = "https://files.pythonhosted.org/packages/43/80/b1a6fbdd7da825cdd55c71aa81eb6cfa82c513c360774152eacb50b4a771/librt-0.16.0-cp313-cp313-win_arm64.whl", hash = "sha256:83d4041a3d9b2fd053a8a4e1f22878b3e5833e2712956382d5c048d791454e91", size = 116557, upload-time = "2026-09-29T00:53:30.012Z" }, + { url = "https://files.pythonhosted.org/packages/1e/93/9e0cf7da129a93c3dc7f45bc3cd4a660f2aaa995aa8a6f95c2583ef41239/librt-0.16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:931a0bb0fcac88f263e269e46eb30ba8e21402cd3c62ca40cb97034c0693fab1", size = 149844, upload-time = "2026-09-29T00:53:31.391Z" }, + { url = "https://files.pythonhosted.org/packages/8f/26/8a90d2a8f2b2e471bb486b7aec117b8ae622715ed6c39853aec48ea20073/librt-0.16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:1bc17e54e5305f8d40b7ca203671ff5a9e59c1d0f8ea0f625dcca53a3984de11", size = 154111, upload-time = "2026-09-29T00:53:32.718Z" }, + { url = "https://files.pythonhosted.org/packages/35/ce/67abb46258da4d3e42ff5b141db6f38c59357bef84c7979f183b22f924f1/librt-0.16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:877698bf6bca5721d8be345f2fe09778e40ecadea8b58c73075f2b1a53666bf2", size = 494234, upload-time = "2026-09-29T00:53:34.466Z" }, + { url = "https://files.pythonhosted.org/packages/12/f9/ea7162414a16f8f1bbd3b493ad6d22b926c5471916e078350bdbca8c4e5f/librt-0.16.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5981c011b306781ce561e18e14230a14524a3d8109b97553666c942c18f31a96", size = 491173, upload-time = "2026-09-29T00:53:36.124Z" }, + { url = "https://files.pythonhosted.org/packages/b1/09/9b3e869060dd33f9989b80ba4fea306f6db8cecefcdfe6d7346ef0603f65/librt-0.16.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:afced3dfc17cd805ecf7a3d77996a71cf5f2c75aa66eb0c21a9930f4fc992f86", size = 505547, upload-time = "2026-09-29T00:53:37.686Z" }, + { url = "https://files.pythonhosted.org/packages/50/07/79007d2165f649ea93e08c0962d1d62c70af9cde77965255095bf9d96f9a/librt-0.16.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ca8052401c55d7511dda6760719fda7618067e83535d7d0010096d216c34b667", size = 523057, upload-time = "2026-09-29T00:53:39.301Z" }, + { url = "https://files.pythonhosted.org/packages/61/0c/8fbaff66d0ba376d8864653f5acce1569bae27e89648671f26f7eca67ab8/librt-0.16.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1e511762a074005bb0aa569166779834e75e438370226930d0ce1866d4b6a33b", size = 515158, upload-time = "2026-09-29T00:53:41.012Z" }, + { url = "https://files.pythonhosted.org/packages/df/2e/23ff0dece76f07a4124413a57682efa0bbeb5765ac0122bc0955513f82ca/librt-0.16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f1e8591bd8a5a628cd7f07954c6a1592359a878bf032957a8e9057a41d644311", size = 534183, upload-time = "2026-09-29T00:53:42.451Z" }, + { url = "https://files.pythonhosted.org/packages/26/c4/e11dea21d9a29486eba78887380374189d472734fa32cc50cb37ca44d3d0/librt-0.16.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a4aaefb4ba6c07e1aeebb2795c8958148f1d6f9af3b555b53d23d766edb6d67a", size = 540663, upload-time = "2026-09-29T00:53:44.272Z" }, + { url = "https://files.pythonhosted.org/packages/44/75/e873ae158a8b7f5359be33e7fd6c1fbe02d9a78a3e89a77de6b0e837f476/librt-0.16.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:d92db7a0f6aee44f1baee94750457e8d2d1c6ccea41842de6268d34e8dc7eddd", size = 545908, upload-time = "2026-09-29T00:53:45.812Z" }, + { url = "https://files.pythonhosted.org/packages/ba/36/8939d3f6a93e11bd9592e6fe28d2b44f1c2dc4bed6e22e72359a91e18ffb/librt-0.16.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:378dfaffb38e59c24a87cde5713cd865d51ff7383fa12947f3907f306ea1ca55", size = 523302, upload-time = "2026-09-29T00:53:47.596Z" }, + { url = "https://files.pythonhosted.org/packages/71/14/35309f44a077f0f42ade0e2e7cd88c0cea760c661af205c01ea90d3c0e1f/librt-0.16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:3e0c39bdc85370422e8b637be76eb1fd07d30967551b03e62267dd156f553152", size = 565911, upload-time = "2026-09-29T00:53:49.278Z" }, + { url = "https://files.pythonhosted.org/packages/78/0c/df6255b94967f3159ebc46f08d8e783c12da6ee269ddb74b2efed63c640c/librt-0.16.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:1b384b90ab79a7bc30b566895809a636e0666f21f3cf12b54823d025b7e83839", size = 79119, upload-time = "2026-09-29T00:53:50.938Z" }, + { url = "https://files.pythonhosted.org/packages/6b/44/d30d5a5461378c9d33f36736c6791c3b4c4ba4b1ffe0da7350aedcb2c9a0/librt-0.16.0-cp314-cp314-win32.whl", hash = "sha256:52327da75a94012e7f932f913d20d3876bed3c102be00e6c3e8600ff7bdd58a7", size = 100140, upload-time = "2026-09-29T00:53:52.205Z" }, + { url = "https://files.pythonhosted.org/packages/c2/98/769712f356a1e897df3581bb0c3100375d054a000de26099360ea65b5111/librt-0.16.0-cp314-cp314-win_amd64.whl", hash = "sha256:3f0b8114c44b2ac06ff5dacd08e07e8e807ff4f46083f2a1602685122559be41", size = 120464, upload-time = "2026-09-29T00:53:53.495Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d3/ae2abccc8bdc8b063c1613a77686e17b74e9d3d60cfe6f12c63fa2821b9f/librt-0.16.0-cp314-cp314-win_arm64.whl", hash = "sha256:8caf96a4ef8fb27d0ac0d1ad8337d26a240acd4a02fe4345d0a8f264753e8f99", size = 110889, upload-time = "2026-09-29T00:53:54.817Z" }, + { url = "https://files.pythonhosted.org/packages/e4/26/0737d4be058dd6376eade7dd8b380d4b869b6394cee929393a5a431c45bb/librt-0.16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:953107e2f68d0f3512c48f898b0dbf0ce5cc52bba0f318d847c985dc555ee4cc", size = 159838, upload-time = "2026-09-29T00:53:56.22Z" }, + { url = "https://files.pythonhosted.org/packages/01/96/9bc96531d7c620e9949af904470f02e3fa8f35129ab8e8f281c51eaa3788/librt-0.16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ad37d5b9abd49c9a655dcda7ea52a8a752884062ef1ee71ae17c2f2a0f81fe6a", size = 162018, upload-time = "2026-09-29T00:53:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/0e/fa/b0289dcb186eb3f97221ba00da5f4bd3ba7fa5e99752d48aa8d336615334/librt-0.16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c4aa329c17bd1aaea4f6e89335d8ccd494b3a5830b6654462273e50e11023f0", size = 703983, upload-time = "2026-09-29T00:53:59.024Z" }, + { url = "https://files.pythonhosted.org/packages/d9/ab/05ebbbde7530fc5eeb58fbd1581522a9f64f132fa703c4c595eed6e14760/librt-0.16.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0ead24d2562a49473dddd9efef8581f020007eb0054389c3ee3ffad38b1ca4c9", size = 683847, upload-time = "2026-09-29T00:54:00.671Z" }, + { url = "https://files.pythonhosted.org/packages/a3/75/f52aeecd4dbadbddf80725ba7de126d8bd5d0eb66247eae17a81ed90dd4d/librt-0.16.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02118f56a9c36ddd07dfd9b919d9ecc117ba20a90987d56aa4c429fa34509188", size = 698045, upload-time = "2026-09-29T00:54:02.247Z" }, + { url = "https://files.pythonhosted.org/packages/e6/55/fa277a835cd6eb42380591ceb85f48c5b4d2b2d7e2cb9869e1e17d24d237/librt-0.16.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4e29522c62e28595ff7e324c6834ade51127707f0e255b18d1c1cf03d39c1048", size = 724640, upload-time = "2026-09-29T00:54:04.078Z" }, + { url = "https://files.pythonhosted.org/packages/25/e4/2cf64354f3fde8ebd591b3b48f96510bee24ac5f7d1e567adbbe210abdbd/librt-0.16.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3ff4b2367926b69c6215635902cccb04048e73094e9862900d27cb2c6bbff143", size = 731748, upload-time = "2026-09-29T00:54:05.741Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c9/c180af3e94e01aa529fa93d7733fec2abc47f222345400cf21d5481d5f8a/librt-0.16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c6f1b27bf1632a7e016af9f145f82be95e1edd7721a646505c21059257cb5a04", size = 754960, upload-time = "2026-09-29T00:54:07.38Z" }, + { url = "https://files.pythonhosted.org/packages/95/d6/01073aa78c58f356b10d9c57b3fe9abb143df338142bcd316df417b89db0/librt-0.16.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:5696d7f52e7b37217cb3a8f92c744fe835942602fdd4c1a8bc4741d3bfdce15e", size = 747000, upload-time = "2026-09-29T00:54:09.06Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d8/1de3783908658d697a8cfc00582f61299ffba7796d7260c112e4700b1109/librt-0.16.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:6072e92dd876ff6ceeb6cf371e35e51f479349837391341f479b08df4564242b", size = 749569, upload-time = "2026-09-29T00:54:10.702Z" }, + { url = "https://files.pythonhosted.org/packages/b7/32/e817f66c96d6caa8bb8435ff93c4c220624d59efc506be59ab98fcd01d0c/librt-0.16.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:39ca4f2f2fe05de8e63493da592d84311adabe5bef52b193851981da9816b302", size = 729483, upload-time = "2026-09-29T00:54:12.25Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c9/23992ccd2b9d22798fdd0f61353183a47414e651da782ad83eb680f50833/librt-0.16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9807485a908f00355820f18e91e045ffdcdc5adb68aaec40a1e2b88c5f7bba1", size = 776584, upload-time = "2026-09-29T00:54:13.837Z" }, + { url = "https://files.pythonhosted.org/packages/67/3b/e8af957f08e6e2e8e566b099e43d2748418aa565df6ee1d9d3331209fdfe/librt-0.16.0-cp314-cp314t-win32.whl", hash = "sha256:94be5cb7bca4df6201f4183e9e4fa2086c655283d20b38cd84500a69057575a7", size = 104402, upload-time = "2026-09-29T00:54:15.568Z" }, + { url = "https://files.pythonhosted.org/packages/ca/1c/946e6443d7cd32347a086043395e421e52fd603c9163d2ec970ceab8eed6/librt-0.16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d46ca272b251d033dd4527b0dec5f261a28a52bd5fa0f99c117b0a1f8588cc2d", size = 126227, upload-time = "2026-09-29T00:54:17.165Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a3/bc4f9959d3c62bcbf9e5fd3470a8bbd8bf33224ed4c25d7fba173201b8ac/librt-0.16.0-cp314-cp314t-win_arm64.whl", hash = "sha256:b9d6d4b14e92d876f8026b54c20c445f36425214c1081dc76f74e40db386b82b", size = 116493, upload-time = "2026-09-29T00:54:18.567Z" }, + { url = "https://files.pythonhosted.org/packages/b6/4b/10fdb42dfab4c1533e1570e686b18e86ff4328b406361b39fb3016667638/librt-0.16.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:6fe436af2eaf630474f491af5d032cbe45f93fcff5c3b9fe4ab194a7255b20ff", size = 149829, upload-time = "2026-09-29T00:54:19.933Z" }, + { url = "https://files.pythonhosted.org/packages/8e/30/a90ca13f1d3d91af1680000a4038536907018fbd51764767287a05d28b8b/librt-0.16.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:8ff5d26c529336be9bd7ae04483235d77778ee7d6444a95353102b542601ce81", size = 154522, upload-time = "2026-09-29T00:54:21.306Z" }, + { url = "https://files.pythonhosted.org/packages/5c/dd/bcf364eacfa070bb1fc88d503111ae7177914197ba1fa717c748926e7930/librt-0.16.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:909d8e3c1faee44cb762b1c519ff8613dcc5ceae5c99987a00917b5a31fd1d6a", size = 497593, upload-time = "2026-09-29T00:54:22.798Z" }, + { url = "https://files.pythonhosted.org/packages/18/c1/2c4e81e347bdabfe8346bfc6dc37ae5e154d61c88e30848ec0606025a5e0/librt-0.16.0-cp315-cp315-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:6d4a64283ee61824b5790de882bc68e2d9d7a5143537cb7a966f7354f71646d4", size = 480459, upload-time = "2026-09-29T00:54:24.364Z" }, + { url = "https://files.pythonhosted.org/packages/ab/d7/fef2a3cb8400701be496f6e459876f650b3451f407e30cb243de571ae615/librt-0.16.0-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5810ba811297fdf37a1531a57667cb8ace0842013ca8606bf9eb7c24cf4be154", size = 507814, upload-time = "2026-09-29T00:54:25.997Z" }, + { url = "https://files.pythonhosted.org/packages/e1/6f/53762927a32e9dc9eb1d1c1f3528da281290c86d96929a8af652f671266e/librt-0.16.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e56aaf8c167548dc8e5d6f3bd0f48dcdd299a23c73be3f744aab79d99e9c7f5d", size = 525114, upload-time = "2026-09-29T00:54:27.747Z" }, + { url = "https://files.pythonhosted.org/packages/6c/67/0b9d031f303c4e8c691a9a8ef9d272f13b530c11cc563b819df621b6a348/librt-0.16.0-cp315-cp315-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8f36c58e33b304b525c6c9c5076399c6ebf1109e17b9051a05a407b091b9215b", size = 520465, upload-time = "2026-09-29T00:54:29.331Z" }, + { url = "https://files.pythonhosted.org/packages/ae/d5/2056a3a85864e882eb17a203a10ddb26fa748bc9718ec67e79059ab46cae/librt-0.16.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:242e00b3d4fa37c3d3c1ca5f5c9adb7d909ddb1eac9c41f2787320d00caa0af2", size = 537257, upload-time = "2026-09-29T00:54:30.915Z" }, + { url = "https://files.pythonhosted.org/packages/54/57/e0d79790c163cbc0909e209a6f62e30bb713b647f905a176cdc64848fd4d/librt-0.16.0-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:0253721561787b8df8443eb347b7a6461015354e5bdd37ee38a41fef220d2bb0", size = 527442, upload-time = "2026-09-29T00:54:32.478Z" }, + { url = "https://files.pythonhosted.org/packages/aa/50/1c0c95aba7af51f4752ea34fbf2eb79b36e7cae3a72536248e8c735de735/librt-0.16.0-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:3e483a8d69ede8067db70c0e83007423b6925de6fd53afed01d66160f2e9398c", size = 548139, upload-time = "2026-09-29T00:54:34.183Z" }, + { url = "https://files.pythonhosted.org/packages/98/91/a8a43dd5138d4f55f88846b8f0c85454a4fad69952cebfcff9948f831290/librt-0.16.0-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:69ba927445cfaaffb4081003ef5224c55a5c2ab67ef956f416ef744916e44121", size = 529708, upload-time = "2026-09-29T00:54:35.761Z" }, + { url = "https://files.pythonhosted.org/packages/2d/41/d5226881ab2b7c20d9d587b37bdd4a0ec8775a96d00ca87ac9f385587db4/librt-0.16.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:d6a365f2ab45a984d0e00eee0dd17f599ceab8cadab6ea07b6111c8132fc0e42", size = 567781, upload-time = "2026-09-29T00:54:37.409Z" }, + { url = "https://files.pythonhosted.org/packages/bb/bf/2345ba57a626e8c78c4ddcc724636a8df5a593fe46c1ee76bbf477e32b0d/librt-0.16.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:f01f3805f2dae4781c0c34b440e31740d082950bdaf89a6f601ad589a28af57a", size = 79177, upload-time = "2026-09-29T00:54:38.792Z" }, + { url = "https://files.pythonhosted.org/packages/1e/40/99e77936cc9207f629b077bf7cbc5e2f0827cddd7c29792f04ef881bd2c3/librt-0.16.0-cp315-cp315-win32.whl", hash = "sha256:b0e3e721c75d2e79a76d4422c79d7ba705fe1bbafec907037fe7a657a480a0e3", size = 100127, upload-time = "2026-09-29T00:54:40.251Z" }, + { url = "https://files.pythonhosted.org/packages/56/1e/801fe26bc622061b9dfd010e166d94142cb774b733217e6d98d1c0cf2638/librt-0.16.0-cp315-cp315-win_amd64.whl", hash = "sha256:bc02954b1295de798bbdb0b4e2d8a28c2117de8b5c73dcbeb27dc32572dfb971", size = 120480, upload-time = "2026-09-29T00:54:41.722Z" }, + { url = "https://files.pythonhosted.org/packages/bb/a9/d533983055bd36e112627384c2c038845d1df882540b8bcefb566475640b/librt-0.16.0-cp315-cp315-win_arm64.whl", hash = "sha256:c5db585d43449a5f54303d4b2774e45e1babd975cfe1630a3d708c0b80c3e560", size = 110915, upload-time = "2026-09-29T00:54:43.052Z" }, + { url = "https://files.pythonhosted.org/packages/55/fe/d62238fa9c653b0e0613290349467cb65711b5800e8e474f45e942a0ad95/librt-0.16.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:f06c689cb14afd9b612727553a5ec5a40febf113ca41c4413a2b0b334285884b", size = 159714, upload-time = "2026-09-29T00:54:44.497Z" }, + { url = "https://files.pythonhosted.org/packages/f3/ac/f31efe7818700be72ba4f9af8a80fa67c39808c8d26dacc55dc1f6f35172/librt-0.16.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:13b4e8aba90b0b1c82474e9844aa9ffe7ad3faa484350e1da64cb8188d903134", size = 162086, upload-time = "2026-09-29T00:54:45.968Z" }, + { url = "https://files.pythonhosted.org/packages/d9/16/4d7487bf86a9d7e8e18f37ba5538789233ea693637379b75701bd35ec9de/librt-0.16.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a269c46ae327d8e6f8c1f85f7516cb52c0fa48127565a1105a4f4a05ff2a0b4", size = 712727, upload-time = "2026-09-29T00:54:47.486Z" }, + { url = "https://files.pythonhosted.org/packages/77/74/50cd550ccc1a517b9ed62347625c01ddf8c4afad66490312677c011458f6/librt-0.16.0-cp315-cp315t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a33e0dae1f8592146a4764d54ce842b278732d21a84e17c3bbe6b1bc158a2248", size = 681106, upload-time = "2026-09-29T00:54:49.126Z" }, + { url = "https://files.pythonhosted.org/packages/df/5d/7293f712975ee6fdd2251411fd9ef1c62bc99c7b83ecbe62dbc999b1fab7/librt-0.16.0-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:47ada6ea32636492c61aa8ad27ae3b9404bfe7a97e3ba946d1984236cc741da0", size = 705921, upload-time = "2026-09-29T00:54:50.905Z" }, + { url = "https://files.pythonhosted.org/packages/67/f7/8aab946f11d59d1bece9ffc65d994b200c789a8ca5a95c17e17e609f912a/librt-0.16.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c43bd6e642d8a248c114327f98dd25ac5a7cb5aa168ef02f0559b91874df16b8", size = 731786, upload-time = "2026-09-29T00:54:52.584Z" }, + { url = "https://files.pythonhosted.org/packages/43/76/1c42ab31e7cb8384ebf6d3af607213c495222474f4940443ae7639ab7685/librt-0.16.0-cp315-cp315t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c3d1bb7841a816ace6449bb26d3f9560dbfa20e71c568d23f0f62bf1e68f50b1", size = 744964, upload-time = "2026-09-29T00:54:54.217Z" }, + { url = "https://files.pythonhosted.org/packages/6f/2e/4b19982d933d2dfced671e840b219e4c1cd3f507df6e6dabb51bbd4e3850/librt-0.16.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:3931f7a3db322e7f44e02a280e3949326ce9579ad388ee8d691dc7c76da9fb70", size = 765305, upload-time = "2026-09-29T00:54:55.815Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1b/e872583de2dcb3ac7746e7a2321aeeb168274f3952a87dc66e05ddb29faf/librt-0.16.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:f4462528b6000afe8f16907b5c7c2553abf1df005ba5140e6eb394541c3624c3", size = 744959, upload-time = "2026-09-29T00:54:57.532Z" }, + { url = "https://files.pythonhosted.org/packages/10/de/a18c6bcfb297af2674233e90b3c3661c3a0af0f1434a0c966d2ef708a835/librt-0.16.0-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:80039ba9b6a7d5f1a0175a4cca6bbefead87bd854c80abad1cb30afe47a830db", size = 758138, upload-time = "2026-09-29T00:54:59.484Z" }, + { url = "https://files.pythonhosted.org/packages/22/1c/0df1d732539c297bb1a093e1fe3204d2faf76a9022cf4e1d1c2fce059790/librt-0.16.0-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:7a1d272724b581bb6bc769dfdafed6da2ecc9886ba2450311de55a4ac2e1e9cd", size = 744268, upload-time = "2026-09-29T00:55:01.179Z" }, + { url = "https://files.pythonhosted.org/packages/a2/f7/ccaf31331f20c91a5bd9bd48ffc3f743f9c81bb5720cc7b2a720ca204f0a/librt-0.16.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:fbe4fb8c5445f7496d7f7f6bb0807875d09d47e6771ffa175fb2df2895fb86ba", size = 785783, upload-time = "2026-09-29T00:55:02.938Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ea/7421d9e6db894cd6cd788b604b3394a163ded6b942052b6f96c23ccf08e1/librt-0.16.0-cp315-cp315t-win32.whl", hash = "sha256:375bfe6b572a8f6cfc398709356046173bf27e64c4c5edaf5f7062f051fb4bf9", size = 104355, upload-time = "2026-09-29T00:55:04.533Z" }, + { url = "https://files.pythonhosted.org/packages/85/6d/7c31a506eb847bc58aeb2402d58e17605e821f68ab5df5e66fe274a6df41/librt-0.16.0-cp315-cp315t-win_amd64.whl", hash = "sha256:bd3150023d3dc2bc70f3784e59ffa1140d56ddba3d8125b3d6f9f85221279bfc", size = 126134, upload-time = "2026-09-29T00:55:06.017Z" }, + { url = "https://files.pythonhosted.org/packages/36/69/7a5d10ac409c4da0355e054a14371871da9b5557fcc42772cd00181c6cce/librt-0.16.0-cp315-cp315t-win_arm64.whl", hash = "sha256:8ceafb70f2a4f0826f11031942e59c0728fd98da112dc346d4352bde1e486866", size = 116391, upload-time = "2026-09-29T00:55:07.484Z" }, +] + +[[package]] +name = "more-itertools" +version = "11.1.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/de/1d/f4da6f02cdffe04d6362210b807146a26044c88d839208aec273bb0d9184/more_itertools-11.1.0.tar.gz", hash = "sha256:48e8f4d9e7e5878571ecf6f2b4e57634f93cd474cc8cfbd2376f2d11b396e30d", size = 145772, upload-time = "2026-05-22T14:14:29.909Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e8/3d/1087453384dbde46a8c7f9356eead2c58be8a7bf156bca40243377c85715/more_itertools-11.1.0-py3-none-any.whl", hash = "sha256:4b65538ae22f6fed0ce4874efd317463a7489796a0939fa66824dd542125a192", size = 72226, upload-time = "2026-05-22T14:14:28.824Z" }, +] + +[[package]] +name = "more-itertools" +version = "11.2.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/52/b8/c63995bebbb9ac9c059350e0fb8c82c2420c85aeca7d34e40aecf3df9281/more_itertools-11.2.1.tar.gz", hash = "sha256:cbf08fd0af284dc69718b9b76a8e6203df624d70209ea511e4219d350c856f63", size = 154133, upload-time = "2026-10-14T18:50:30.407Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/57/3c4b1c6f2e0cc29ba023802458ea3d2a996f87085559e4a5f2192d549532/more_itertools-11.2.1-py3-none-any.whl", hash = "sha256:35a7377edd1dd6608dcb2cdf534ded55ea32d49448875ad042cd3f879fb1ded0", size = 74405, upload-time = "2026-10-14T18:50:29.116Z" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/47/dd32fa426cc72114383ac549964eecb20ecfd886d1e5ccf5340b55b02f57/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f", size = 508106, upload-time = "2023-03-07T16:47:11.061Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/43/e3/7d92a15f894aa0c9c4b49b8ee9ac9850d6e63b03c9c32c0367a13ae62209/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c", size = 536198, upload-time = "2023-03-07T16:47:09.197Z" }, +] + +[[package]] +name = "mypy" +version = "2.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ast-serialize" }, + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/34/4e/64300736cf0a0373a27b94a91b664ee7382e36f77b0621bae6381da3e180/mypy-2.4.0.tar.gz", hash = "sha256:77bdaebd452f43fcfc4cc3ba94352a3ea537cd01e3f2d0879f48673d2ec00d6e", size = 4064425, upload-time = "2026-10-01T20:40:39.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5c/0a/78c9ac93933e2ecd51d807021f78c03ffe98640f33951a8be159f5fd55bc/mypy-2.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ffda5244fd1ad71a1e54405e35f50d09b80c3978efa120f58bd1252ae32c62d2", size = 14408618, upload-time = "2026-10-01T20:39:46.766Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4f/5f5f4429fd5a4218ce6268164a66afeed75c7e2ce5522a4d163faaa5fe85/mypy-2.4.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:615b03922d40e186fd1df73156473db0ba525c639bb4fd1cf28e1694879c9b23", size = 14552749, upload-time = "2026-10-01T20:40:08.325Z" }, + { url = "https://files.pythonhosted.org/packages/54/78/fa1c319cd51db7a6027b46117460d5a361c6bba0c0f0f0670a2dab8ce2a5/mypy-2.4.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:13fa24f439c0e48a290a3922fa14ccd22f2762bae99d2142931b3e40a9055080", size = 15505846, upload-time = "2026-10-01T20:39:15.475Z" }, + { url = "https://files.pythonhosted.org/packages/e2/5a/14c02690776fb04e9fa60b81173cb9ae6315e0745fad3813b303737f2f0c/mypy-2.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3adef556a19eb3b630bf86a79c29d7da3d61e541472d0d897ca01b171c0abf8f", size = 15823059, upload-time = "2026-10-01T20:39:35.429Z" }, + { url = "https://files.pythonhosted.org/packages/76/d8/d29afa819f8cb765018d6e2773e390a41ea4592f75abe417135969646857/mypy-2.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:1dc0f64b0a92ae27a49d2175f0bacfa56e15bdc5b420cf92e0c1f79292219cbb", size = 11312927, upload-time = "2026-10-01T20:39:28.509Z" }, + { url = "https://files.pythonhosted.org/packages/bc/c8/966dec4d80303855d824e6bf67fe1da812d88adfe4d75e24d8545dab4826/mypy-2.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a378fc15fb33e321f04652c166ce73eeb8833a97c3d218132844e938cd93220", size = 10879252, upload-time = "2026-10-01T20:38:41.545Z" }, + { url = "https://files.pythonhosted.org/packages/26/67/e53965e67d23d48e78dd603aa7525a8d77e7818c23954cc217ccde5cd5c0/mypy-2.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5d20e6c7c35fcbf2a0ebdd0eaeacfbc243009dfd33ab7822d54e213912e6dbbd", size = 14315745, upload-time = "2026-10-01T20:39:25.03Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5d/a588ccd57625822d8484d7aff4e9c70f88d042a91c2ec84324a2bc14b3f3/mypy-2.4.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3011537be6cf1de4511c0255a324362a812b58184bbe61e15f59c8b31033bd74", size = 14465652, upload-time = "2026-10-01T20:38:57.19Z" }, + { url = "https://files.pythonhosted.org/packages/05/af/b4978a5566cb829ca563dc08e3ad8d944f116078786ad54ba3dff2bcb64d/mypy-2.4.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a96b07a49b7b1d025ce59c1b3acbcf24bead9a83da4523c4a6bde1bb94e7a0e1", size = 15419180, upload-time = "2026-10-01T20:40:27.808Z" }, + { url = "https://files.pythonhosted.org/packages/b2/8c/52c71f31c54d0a749d832cc73b933c6e38c52d9b270d5503e031c73723dc/mypy-2.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7c4f8f8d1d1c0e2832d8ee7113dd08f6df6c7aad9e863fcbed9f25832be0b8c4", size = 15669212, upload-time = "2026-10-01T20:39:20.443Z" }, + { url = "https://files.pythonhosted.org/packages/e8/55/ba63121494404fd7d3787ec176ccd02820d6ec125ac4e7c4c0b79f2cc6c7/mypy-2.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:ba05652540bf12828e52abae807b024b09ca144ff4f75e2450a81d69c376425b", size = 11299572, upload-time = "2026-10-01T20:40:03.627Z" }, + { url = "https://files.pythonhosted.org/packages/9c/9c/385c81b5c0d3a2917f077c4da660d0493f9521ccfd4b058e33b860f72d02/mypy-2.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:6306086b87cf7f8a29aa618d9fd9bffb56c59247166b9660fdb54d86d7714ecd", size = 10869751, upload-time = "2026-10-01T20:40:25.483Z" }, + { url = "https://files.pythonhosted.org/packages/68/ed/e5d7cf4017e74a1c1e1c4058ce8f614fc1e3e7606564f47166e22bfc9f95/mypy-2.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e05ff2925d8b37ad26c80c1b9dc43ae5d455da2df1e23c24c095a6425917c57e", size = 14378593, upload-time = "2026-10-01T20:38:48.222Z" }, + { url = "https://files.pythonhosted.org/packages/30/7d/12d994886a922f0f1997becc9c6625198d61eeb5962558a886af7dd38d54/mypy-2.4.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:29243242cf72582b65f9582ad9e56e8cb281566ed3519f4cd70bb8b9f2977e90", size = 14464697, upload-time = "2026-10-01T20:39:11.059Z" }, + { url = "https://files.pythonhosted.org/packages/f3/9e/bcc9af755425ad17790bf11d73c2ea7592914cf309ee1340997670f9d57a/mypy-2.4.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29eb0b9427a6b11b992e452f6cceb8af724f4dceb47e779d0b35e405e996ea5e", size = 15552257, upload-time = "2026-10-01T20:39:56.269Z" }, + { url = "https://files.pythonhosted.org/packages/af/0c/3343fc4525d6f00d75ad17a93a9f052d5163641cb8911840d4a12cb59ff2/mypy-2.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e3ebe2f72a2a1156065a9851570ffbf50c0a93cdccadef9c6e05c508a4fd10b1", size = 15800443, upload-time = "2026-10-01T20:38:54.815Z" }, + { url = "https://files.pythonhosted.org/packages/8f/0e/69aac6b8159da7c53e6115a2be1bf48e85503402cadbf506dd708e8b2ad7/mypy-2.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:236e0d68f6941992b0811128e652590f590db444ab29ad8f1324765b9298b946", size = 11381574, upload-time = "2026-10-01T20:39:49.406Z" }, + { url = "https://files.pythonhosted.org/packages/6e/d3/d32ce4feb5993eec09d2024bef16cedc9b93701b1446b86092f08b24491b/mypy-2.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:82d0f94c8587ccb472622ee7795280aaa38a06640d5f45b3f16909d6dd86a989", size = 10944729, upload-time = "2026-10-01T20:40:15.203Z" }, + { url = "https://files.pythonhosted.org/packages/44/f2/eb15183c97c69d7cbfac990a6efd33a19ecfd97dab9e714c742fa78a784f/mypy-2.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7da85fbcff6dac1abcc636707bed38b45598131fb7a605d9719c70b5cc733af8", size = 14213395, upload-time = "2026-10-01T20:40:21.178Z" }, + { url = "https://files.pythonhosted.org/packages/8c/b5/ba91b6ff65e4d6b6ff53b2b3b3ac5f1babf0c7c27d0b43a0196b1c967926/mypy-2.4.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4209da39d85cf240f762af622d8180fcdfcb4727d021f44ade62d613a1a43324", size = 14373009, upload-time = "2026-10-01T20:39:58.86Z" }, + { url = "https://files.pythonhosted.org/packages/d5/c4/484275efc935c0003e55e4e8a33e4b8e99528ee956c12256ece4708f903f/mypy-2.4.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be721bd4bd57576193653b75b4af3461c9d0bf7dd8b528f782e9be210dc75bb", size = 15465557, upload-time = "2026-10-01T20:39:01.794Z" }, + { url = "https://files.pythonhosted.org/packages/50/30/66eb6fdd0875e3c9025a02f0bb0ea2e524b74274b658c37fde0068c4939d/mypy-2.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1fde197ae65be856a034a91b70ed747a16562ca69577785f06c661548424bf1", size = 15728673, upload-time = "2026-10-01T20:38:43.724Z" }, + { url = "https://files.pythonhosted.org/packages/58/bc/2aa98fd7f49c42dba8e9c065886fadffdd00f3c654cff3f2a7103a797ac8/mypy-2.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:295ecf2e57542cd836ca537486951289678c8c7d1ee6ad74ebe29b2168a003cf", size = 11389803, upload-time = "2026-10-01T20:39:37.547Z" }, + { url = "https://files.pythonhosted.org/packages/49/41/17b60df2d946792ef6af43b89351f5c9ddabc69053206b2304945572a744/mypy-2.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:bc378bdad4e9f12b5bd96466083d1e71acf00594ec9c7b2bdb5e02816f77f303", size = 10951060, upload-time = "2026-10-01T20:39:04.015Z" }, + { url = "https://files.pythonhosted.org/packages/e0/66/924be0b653372ed31ad5c48e26044cc00840e591943a56e61621cf05b60e/mypy-2.4.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:058165f564ccf559c68c70fec2091fca5891110480210c22594635e3f6683437", size = 14234230, upload-time = "2026-10-01T20:39:44.535Z" }, + { url = "https://files.pythonhosted.org/packages/56/39/c4f176880a4177123576de6cec6309feea8f42fca2bf2f6584e88054f656/mypy-2.4.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fa247e02b505a45a2775f69df38d360d197e3790bc60f717595db9eda358b6e", size = 14392944, upload-time = "2026-10-01T20:40:05.78Z" }, + { url = "https://files.pythonhosted.org/packages/bc/1c/26e16977e25ef2494a74f8ffc872a76ec2c3aa43c3156057cbdf88f352c5/mypy-2.4.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20e9a5cd875837520c43db98dea0b6d0c2197833d95c30127d8f570fb9b1f00b", size = 15441463, upload-time = "2026-10-01T20:40:32.412Z" }, + { url = "https://files.pythonhosted.org/packages/31/9c/9e4b049f0ecefbfd6817ca2a16eea55dd74a07950268edc6cffd29ccfe98/mypy-2.4.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9f03a7828cca2b0adcd6662aee8f2711ff8830e1027641fdea3ab0b787483566", size = 15705406, upload-time = "2026-10-01T20:40:34.844Z" }, + { url = "https://files.pythonhosted.org/packages/4a/5e/e861b5f6c5ef9ee6cd24683aed1edecf82a26dbd536049f9b7850b586267/mypy-2.4.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:9279488933040b638c0ab739084c0ca100efeea6db581bf5d7628d8e89de53fe", size = 7897523, upload-time = "2026-10-01T20:39:39.861Z" }, + { url = "https://files.pythonhosted.org/packages/3a/87/61ffee58b25a956532a6006fae84918a2de849ed25f397492b2e815fe7b3/mypy-2.4.0-cp314-cp314-win_amd64.whl", hash = "sha256:2106b55105ba5ea9be4f53a24517fc5fa927ff1585edc9bc1a975abb72caef89", size = 11576345, upload-time = "2026-10-01T20:39:41.553Z" }, + { url = "https://files.pythonhosted.org/packages/a1/88/a331c20698971c2ce8d1c30f317fd61b5be13a85b1f053e12dfa22ac6568/mypy-2.4.0-cp314-cp314-win_arm64.whl", hash = "sha256:528c8744b8b5e3ecb8774f86af38d2376216816e9908317ad055f3c9c2d74799", size = 11172062, upload-time = "2026-10-01T20:38:59.534Z" }, + { url = "https://files.pythonhosted.org/packages/47/c0/4f7daa73270dced8e86c6f4a911c68082d03a84e6c1ec9bd916028d66131/mypy-2.4.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0bb95cf34899e4619c61ab0a8667804e139e580b30d5df12af2102dfe44d0c97", size = 15711208, upload-time = "2026-10-01T20:39:30.597Z" }, + { url = "https://files.pythonhosted.org/packages/2f/05/f1afa303c678be24cf7a266d38fb24b3de4599a024c2f9ba0d5905a3efa3/mypy-2.4.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:86d616fe84c6eab8026f8c50ab5bcb90db780d2ccd233d971e34e92bede9b359", size = 15935442, upload-time = "2026-10-01T20:39:22.781Z" }, + { url = "https://files.pythonhosted.org/packages/9d/d6/6a1a45459b63716e0d035f4892a926d3054f0a8cbfa02551d228a9946083/mypy-2.4.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a3f86fd1313dd69d013e265f1fdcd12ea7a9d606f9875b2a3db946cd334555f3", size = 17240044, upload-time = "2026-10-01T20:39:32.95Z" }, + { url = "https://files.pythonhosted.org/packages/87/85/ae33bee66c13f98d421964d87bf0888be941063bc75c1204a4cf142cf1cc/mypy-2.4.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:720434d48542ecfe84d32d287b727569d3fc8f5769acd39051130e490a5c295c", size = 17545856, upload-time = "2026-10-01T20:39:08.827Z" }, + { url = "https://files.pythonhosted.org/packages/df/de/eeff209b65c3e267818d79333bb9f058da6e4e73761461bd94748a2eb628/mypy-2.4.0-cp314-cp314t-win_amd64.whl", hash = "sha256:a6e851b82c0661f69f1630fc16172c68787a6a9cf0991e7c6437d60976cdcd76", size = 12369342, upload-time = "2026-10-01T20:40:10.516Z" }, + { url = "https://files.pythonhosted.org/packages/2b/43/e62d8d5c1dd737aa248968302ff7d6eabf997c3301773ed8bcb64932ca77/mypy-2.4.0-cp314-cp314t-win_arm64.whl", hash = "sha256:3bd0e340f0ebe65c548210f53be3fd8192e83964760caf0c28bef368e68b0d37", size = 11849099, upload-time = "2026-10-01T20:39:51.834Z" }, + { url = "https://files.pythonhosted.org/packages/2e/5f/335b8980055118dc131355155883fb676bb2161a0d97e08658e479c776fb/mypy-2.4.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:afa89837d9be67e0cadfa33bca3bb7efdda98c3b07e74dc3b635ebfb1c8a926a", size = 14241302, upload-time = "2026-10-01T20:39:13.227Z" }, + { url = "https://files.pythonhosted.org/packages/18/37/1482fdc49332b145828912b15f16eee0c4ca70a8bce0f6514ece79b14680/mypy-2.4.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fb443e81057896132d3642d6be219e6efd158691ac7883e3ba8fcb469865f05d", size = 14408200, upload-time = "2026-10-01T20:38:52.576Z" }, + { url = "https://files.pythonhosted.org/packages/04/09/dce2e8f6c1b31053c430ef6963f6f7a38ccb49b90c5e01e37ed0129b7d5a/mypy-2.4.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7f38f57d344f8b6accb40e01c3d83cfc590498231724d16c07ffb7940f157818", size = 15444409, upload-time = "2026-10-01T20:39:18.1Z" }, + { url = "https://files.pythonhosted.org/packages/43/c5/91b68306da4cd280cb15be35dbb5ffc343cabd67c4b121b6625bf2d13177/mypy-2.4.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:e76172710bd4e5eeae061abfd68347e5264632e02778be61784671ae3a2132f5", size = 15731186, upload-time = "2026-10-01T20:40:23.426Z" }, + { url = "https://files.pythonhosted.org/packages/64/71/2d0340182a8f27352fb1e25531355951108b506097c433937e9eec452ffd/mypy-2.4.0-cp315-cp315-pyemscripten_2026_5_wasm32.whl", hash = "sha256:f83353e47ab520bf6fd4df8f5897d9fe081211f2fbc4b7d37736a3e3c166cbcf", size = 7897838, upload-time = "2026-10-01T20:38:50.779Z" }, + { url = "https://files.pythonhosted.org/packages/3e/08/32703c117e134c02efa2a82705bb40cee91eaedea10b6530e20eba651b1f/mypy-2.4.0-cp315-cp315-win_amd64.whl", hash = "sha256:970b221ed5842213d98e3c480c08f795ace4b1f81fb21e1b126bd0476bce1c34", size = 11575700, upload-time = "2026-10-01T20:39:53.982Z" }, + { url = "https://files.pythonhosted.org/packages/ab/08/08bb269feafdaad031046ee2d771528a64467e6a180f962afc28c4a3ccd8/mypy-2.4.0-cp315-cp315-win_arm64.whl", hash = "sha256:502b94b0b331f7dafe32fd6b151797ddbb4f32385b362e722c783a025e5954a3", size = 11172908, upload-time = "2026-10-01T20:40:12.91Z" }, + { url = "https://files.pythonhosted.org/packages/fb/3f/c5c92626006ca92c7686adfbece47fc6a0daa0e54753952a9ad13ce0561c/mypy-2.4.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c9de622fd397495695d0598ddc789222bfcfec9d7c9ec3a1e385c855e3bc5e01", size = 15705970, upload-time = "2026-10-01T20:40:17.79Z" }, + { url = "https://files.pythonhosted.org/packages/10/f3/863365f7997a76a5a1dd42d7902ab05afa4124e8419089cbca1ce2554db1/mypy-2.4.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9f459f0b4f0596d9d51fe7716b404b35287b99e77da98a7af90a65dd5fd61141", size = 15942234, upload-time = "2026-10-01T20:40:37.243Z" }, + { url = "https://files.pythonhosted.org/packages/f6/30/2f45b1f425a2c95dbe1a3f4d076bfd42b76e9615dba5906230703b14e4eb/mypy-2.4.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f9b028548b3af480e2b1ed8df14ccaac86f99c9f600d1580770ab7ba3dcd40f0", size = 17218364, upload-time = "2026-10-01T20:39:06.497Z" }, + { url = "https://files.pythonhosted.org/packages/43/8b/5b2bbfc69e84800b78fa2dba16d995b003f93b573558e412c5490d6e6c37/mypy-2.4.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:cb734b2668c1f40d07ce093bbeb4407e9527c67901627b0e1679825be3f09975", size = 17557934, upload-time = "2026-10-01T20:38:46.077Z" }, + { url = "https://files.pythonhosted.org/packages/df/c0/1a5dc601c22041a7bbfe1ff71cf097fbbd4fb49930867c6789baf5102106/mypy-2.4.0-cp315-cp315t-win_amd64.whl", hash = "sha256:172e30b8fea631fe310f0c665477f52d9ea40bb4e99e0c81dc30118563b13710", size = 12350955, upload-time = "2026-10-01T20:40:01.52Z" }, + { url = "https://files.pythonhosted.org/packages/1c/bc/697e9e26fc2a86c094ad67ee1e419971b7f01ded66ee66231b09e9f3e12e/mypy-2.4.0-cp315-cp315t-win_arm64.whl", hash = "sha256:5786ef987b3767e51aaa53f20aec104c0252b42ecda7aef8e8b4cbae279b05c5", size = 11842738, upload-time = "2026-10-01T20:40:30.026Z" }, + { url = "https://files.pythonhosted.org/packages/81/12/46ae8670c98a3cd0286ca5645c2f918f8f6be65edfed81b916010619f668/mypy-2.4.0-py3-none-any.whl", hash = "sha256:d01c5d26a352acc6d5cf3128225477e1e8465e8d3029d4c345807fbf7f3cf093", size = 2800734, upload-time = "2026-10-01T20:39:26.837Z" }, +] + +[[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.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" }, + { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" }, + { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" }, + { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" }, + { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" }, + { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" }, + { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" }, + { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" }, + { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" }, + { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" }, + { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" }, + { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" }, + { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" }, + { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" }, + { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" }, + { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" }, + { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" }, + { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" }, + { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" }, + { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" }, + { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" }, + { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" }, + { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" }, + { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" }, + { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" }, + { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" }, + { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" }, + { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" }, + { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" }, + { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", +] +sdist = { url = "https://files.pythonhosted.org/packages/95/b0/c7453d0b6e2073c3264468b106ee1563750cecc910965e67357e3698c83e/numpy-2.5.4.tar.gz", hash = "sha256:9a94cf751c9ad8ebaa835bcd3d40dacf8534ad086b88c38029b65123c7999d2a", size = 20866315, upload-time = "2026-10-10T20:05:31.422Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d0/97/ba2074e92b7befea137e77ea8471e768bbd87c339b7e8c9f5a931949f977/numpy-2.5.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c6342f54c67093cae5c0227eb0eb772fdb79f2a2c37a6eb278b9909ee06aa356", size = 17001609, upload-time = "2026-10-10T20:02:40.843Z" }, + { url = "https://files.pythonhosted.org/packages/ff/a9/bac826765e971d8e16e2064e9ac7525fd69b40ac17c905033a7f5442023f/numpy-2.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b11e8fda06a7d69f15ebf542660b74466c2e51094800c1fb794f47ad4faeef17", size = 12015718, upload-time = "2026-10-10T20:02:43.45Z" }, + { url = "https://files.pythonhosted.org/packages/31/2f/5ea3570fcb8ccd0882bea99436a513b2c85dad8f774a2057849130a8fb99/numpy-2.5.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9cb18a327b49c5c337f972b03682f6a49855525faaf3c0d3e9c96cd0fd8880a8", size = 5451717, upload-time = "2026-10-10T20:02:46.169Z" }, + { url = "https://files.pythonhosted.org/packages/34/f2/b4fc1bafca03868220b5eaf729d2f21ebd7d7b151c0f9e144fe212bbca35/numpy-2.5.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:aec3fc4b32ff82421274f5d205c559c51c840c8df66a78efd7f3612dd005a26a", size = 6789926, upload-time = "2026-10-10T20:02:48.139Z" }, + { url = "https://files.pythonhosted.org/packages/dc/96/8319e2457ae4333c62c815c7006b869a4f60985c1e01024c2f8c6c040fe5/numpy-2.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe4d21ab149f15e4e6043dfb0de87e6e5f34ac176cde83060e9802981fca2ac2", size = 15695312, upload-time = "2026-10-10T20:02:50.115Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/c799c62e19c337e6d3770b08e475887fb30ce8477d3c09efca6b2f0228a6/numpy-2.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fbde6962867ee75b48b0ee29b2b9372ec5d617799dbaf38e82dc0596f2f7738a", size = 16727283, upload-time = "2026-10-10T20:02:53.186Z" }, + { url = "https://files.pythonhosted.org/packages/39/6b/3604e53fb00314d0dc1b94ec9125a1484f649c0a17480b1f0f0c7a9d6250/numpy-2.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:381a7a3d2e65e64c0ec302795ab9dc12bb1e73f150904699c153716177eebdaf", size = 17047890, upload-time = "2026-10-10T20:02:56.038Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7a/e8b58a5289a0d464c52885de47c35a935cdd70c03a4c3ab94a5126416dd0/numpy-2.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b89d0aaae2fe498c648f4c4795c084db535af5bd98ef942b2a3681fb74ce8645", size = 18485839, upload-time = "2026-10-10T20:02:59.018Z" }, + { url = "https://files.pythonhosted.org/packages/6f/c9/47094f597015009f310b8c900def59065ef1ff5a6fe7b51fc65ec58ec2c6/numpy-2.5.4-cp312-cp312-win32.whl", hash = "sha256:9968ab7e49b93ac6e1c3b2239732183152c9150f16308d30b66a372cffe3483c", size = 6138936, upload-time = "2026-10-10T20:03:01.626Z" }, + { url = "https://files.pythonhosted.org/packages/12/33/fefe62073dc8acfd0f2b9ed7c003af2f50aa61555e113e6db02b8f79f145/numpy-2.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7b1b6353e36a7e50de2973a38d705c88ee93adcf120673cee7f45a4a3fa223a", size = 12573091, upload-time = "2026-10-10T20:03:04.349Z" }, + { url = "https://files.pythonhosted.org/packages/1a/07/161270b0c2eec56e4c905f6d6d22e1b836887b2cb189d3f5820aa588e9dd/numpy-2.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:aa1cce2ff3f8d953de38b76bf44602caeb69f101430208f64a10067f7cb4b1d3", size = 10521630, upload-time = "2026-10-10T20:03:06.767Z" }, + { url = "https://files.pythonhosted.org/packages/67/14/1c3ee0118a8fce08565a5d8482631608426a33af10a01077fada5dc7c119/numpy-2.5.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2377da2dd3ba2c1200956acbab2a358c83b8e1f8531191672d1cd6ad83250d53", size = 16997729, upload-time = "2026-10-10T20:03:09.291Z" }, + { url = "https://files.pythonhosted.org/packages/83/8c/b0ea9477fb1f0d4484bbc5cba21678cc9969704d8d7f3f158d1db35f8e14/numpy-2.5.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7415db95818b39ec475a5eea54d9e3b6bc83e3912158e46da3438cdce399804d", size = 12009826, upload-time = "2026-10-10T20:03:11.946Z" }, + { url = "https://files.pythonhosted.org/packages/e2/84/6a3d75b3ba3dfe84ac0053450753d1e6d250a8bf80f66474cc46d1fb643f/numpy-2.5.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6d6a71b9d9a97c03633aa12565ef2825ffa036cc1d99cfd50dacf0f128af4fe2", size = 5445803, upload-time = "2026-10-10T20:03:14.329Z" }, + { url = "https://files.pythonhosted.org/packages/61/18/bb993f267ca20b376e07092a16793a5b31ed3138751e9ba480011a14d742/numpy-2.5.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d8200f16437b289a5bb927c6e184eccc3e8389bc0070fea4cd5b9e13c1757959", size = 6786220, upload-time = "2026-10-10T20:03:16.602Z" }, + { url = "https://files.pythonhosted.org/packages/db/b6/135bb0953b61dc21c6cafa14b424ae666944e4899cf140e00c2b322a1a45/numpy-2.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2e71b04c6cad90026e544501bbe0ab9290fa8a4d845e7e8c0d124fb429c988", size = 15689178, upload-time = "2026-10-10T20:03:18.721Z" }, + { url = "https://files.pythonhosted.org/packages/da/24/3bd070f3269dc609d8f26b2643f62ef91bb415841c0b294805aaf7fe06da/numpy-2.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6ffa07666f8da0eef81d149934a626d0d95fbd6838432a33e66245423a9062c0", size = 16718044, upload-time = "2026-10-10T20:03:21.386Z" }, + { url = "https://files.pythonhosted.org/packages/c7/8e/9d15bd356b0a019c965312b1a3c6a727cac4cae5bc40045fbc12ce4cff9c/numpy-2.5.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2fa3328f784fc8277fc48026f6cad516f5c561c5d8e2e39b3c9e0c8f23223b34", size = 17048364, upload-time = "2026-10-10T20:03:24.468Z" }, + { url = "https://files.pythonhosted.org/packages/dc/fe/9d5b560db964f15871885f2250795d15945f8699e17ef90c0c2ff4c875b2/numpy-2.5.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b86966fbe4ad7de710422175572bcdc75fdedadfb54bc6fab7deabccddd7780b", size = 18474904, upload-time = "2026-10-10T20:03:27.895Z" }, + { url = "https://files.pythonhosted.org/packages/e9/98/d27552990f1bd611ef3e7466adadc78312ea2df63b83aad47fdc3d3ca8df/numpy-2.5.4-cp313-cp313-win32.whl", hash = "sha256:5258bc06526964be5face2fc6f756857a3f24f21ec3e72ca131337a75b165d6c", size = 6134537, upload-time = "2026-10-10T20:03:30.511Z" }, + { url = "https://files.pythonhosted.org/packages/90/8c/140a40398a66b4471211be1affdb6ed24c486d581bd28d07b7f2fcb69540/numpy-2.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:8b4d2fd2d34e5f8c9235ee787de5631a37a28402b15cb80814df973d2be54129", size = 12566113, upload-time = "2026-10-10T20:03:32.612Z" }, + { url = "https://files.pythonhosted.org/packages/34/52/01d205e5e8ccb27b2b0b141e801f22b830198c979111b0fa44771438d9a9/numpy-2.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:bc39ac66a7a9a3fbd6134fda43136b60ffde99c8f4501e64e0d2b24da137babf", size = 10519523, upload-time = "2026-10-10T20:03:35.163Z" }, + { url = "https://files.pythonhosted.org/packages/99/ba/005cb5edd580d2f84d7ca3206b92dc17d4388e56e6f87ffe8f2762f83139/numpy-2.5.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c668b2f0d651605b58892644b0e302c7157f7159544227758c896982ef384b18", size = 17005499, upload-time = "2026-10-10T20:03:37.961Z" }, + { url = "https://files.pythonhosted.org/packages/f3/49/fee7587c33ee35f7977f9051d7f2023d4e7246d62710c80f20c2361ea232/numpy-2.5.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ffa6ce09a1c6a08e9667dd9c97aa0b14184e8d18f2a14b78b2a2328c9147f076", size = 12019666, upload-time = "2026-10-10T20:03:40.606Z" }, + { url = "https://files.pythonhosted.org/packages/d5/b2/c6ce165acffceb15a82c07b9cc77d391f86b3f379ba62911908ae5d34b91/numpy-2.5.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:956555e0603a4d38019ae6925711cb9dc43195c076a928accf7ea5d50bddfe53", size = 5455617, upload-time = "2026-10-10T20:03:43.138Z" }, + { url = "https://files.pythonhosted.org/packages/77/7f/dd85ce260a669a89be06842cf355d7353a33e6cfbc590fb8ebb947d88dc9/numpy-2.5.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2c2c4afffdeb7920e445028dd71eb932cac3e704792e964bc2a232426d4f1255", size = 6791932, upload-time = "2026-10-10T20:03:44.874Z" }, + { url = "https://files.pythonhosted.org/packages/63/d6/34b0a2b0741386a63025a65a2c09caaaaaad6d0ca95b66cd65c30dd7fcb5/numpy-2.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4054173604cd8658796053f1f3bc0befb68ec1c0762c57fdad61e199256a8617", size = 15710899, upload-time = "2026-10-10T20:03:46.839Z" }, + { url = "https://files.pythonhosted.org/packages/16/d5/928078d2b28f26829b138b4a6c3980045022fb409f570657a224ae60ef4e/numpy-2.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d549420b8858885cea8838a727842249218b9c1da24dd517e25c9c7a948310a3", size = 16721710, upload-time = "2026-10-10T20:03:49.489Z" }, + { url = "https://files.pythonhosted.org/packages/f9/cf/673fd1b8f4cd78eb6320e87ec4c90ac19c095644259e3749853a405c70f4/numpy-2.5.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:823874a507a84af050493b622affde94b6f7c3a0dc22cb2801381bc03b871c00", size = 17066182, upload-time = "2026-10-10T20:03:52.25Z" }, + { url = "https://files.pythonhosted.org/packages/f3/92/a77b5061b1b3e2643928c37976d79ee173e1b171ed158b7a3c61056b41bc/numpy-2.5.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4e263278bfb5ee6409db8aedbc4cc32973b1b82bc1e8d3c668551d04d83a7e37", size = 18480315, upload-time = "2026-10-10T20:03:55.39Z" }, + { url = "https://files.pythonhosted.org/packages/bb/1d/1486ef3d3fb2279fd93c4c43c1bbbf1ca389a19816696684409f71babaab/numpy-2.5.4-cp314-cp314-win32.whl", hash = "sha256:cfd73180400042a7c532d30c5e287bdd03c59ff9ee1b4c0316af0539e29dfe23", size = 6185739, upload-time = "2026-10-10T20:03:58.186Z" }, + { url = "https://files.pythonhosted.org/packages/52/9a/e1e512ebc948d5b9dd33b08736760f0ebbed2848fd4eda1f553088a6dcee/numpy-2.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:2ca144f15135b6212a5c47b1e2aeca6e412f102f95a2d5d88d8aec77eb255de3", size = 12703552, upload-time = "2026-10-10T20:04:00.28Z" }, + { url = "https://files.pythonhosted.org/packages/2c/05/de709a982d7bbcd688a3fad71f002e9ff80c2db39e03ee726609b610f1d1/numpy-2.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:468397ba3c64427474706e5c9123fe266395496714dc684294eac75cd4930d1e", size = 10803901, upload-time = "2026-10-10T20:04:02.659Z" }, + { url = "https://files.pythonhosted.org/packages/13/34/083570ada3bb2a30fbe5d77c8c6fef9141144a15d33e6f793a67e9749ab8/numpy-2.5.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1ef3aa6d7e29bb13677323114280b05acc57607fa2300e66432d665d5418a162", size = 12138695, upload-time = "2026-10-10T20:04:05.012Z" }, + { url = "https://files.pythonhosted.org/packages/94/06/1f9c24db48eef0c2d1207e3b11fffb0478e39dfd8c1e1be7476936885eed/numpy-2.5.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:98b053943e5a0474ec0da309d2cb9d3f18ea57f8a2067c2ab7b5f763d1068380", size = 5574615, upload-time = "2026-10-10T20:04:07.316Z" }, + { url = "https://files.pythonhosted.org/packages/da/0f/593fba2e1560e949123bc7d2fc48b5893d56e58cd4bd5a273d2fbf60b220/numpy-2.5.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:b64a85f40e154983960a4167d4c1d57a50c7f109b3d3264a3a984154e90a8454", size = 6889383, upload-time = "2026-10-10T20:04:09.918Z" }, + { url = "https://files.pythonhosted.org/packages/eb/9f/b799dfdce4e05e80ed4bc815c71ff343a11533b2c0ffc221cae8538cda63/numpy-2.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a813ed7719bf45463c51779e6a98d0385fe905e48447526938a4b8337333d551", size = 15753763, upload-time = "2026-10-10T20:04:12.278Z" }, + { url = "https://files.pythonhosted.org/packages/34/88/16c5f12f86f5ad2817c4d103205131fc6c8acb3d1878af05a1a4f23ec859/numpy-2.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9b80cdf5cedba0e90d93fa5f9a333c4d65bd545cd669b71bb97ce2b703c9d73", size = 16757212, upload-time = "2026-10-10T20:04:14.799Z" }, + { url = "https://files.pythonhosted.org/packages/ff/4f/a1fe40e18a898e6a5089f4f0d891f0a493eb0574d5b34458f0fbe5aa3e5c/numpy-2.5.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2199ed071f460487c8db2c0e5c0b564494190edb4772fe80f9aad88b2604def5", size = 17116471, upload-time = "2026-10-10T20:04:17.58Z" }, + { url = "https://files.pythonhosted.org/packages/aa/46/e923a11c78e65c1722e7aaad817c06bd591324174b9d28ce5d31eee4d432/numpy-2.5.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:64f9c9878c1938476365e11ccfb6b770f3b9e5f045ccddc514235041e6959365", size = 18524063, upload-time = "2026-10-10T20:04:20.365Z" }, + { url = "https://files.pythonhosted.org/packages/5a/fa/84ab064514440c1f64a1b21088f2c82756defdd05e07c75ab233899565b2/numpy-2.5.4-cp314-cp314t-win32.whl", hash = "sha256:64d1c8ac28a4077cf987e0a71a7a0ef7e2df70722f07f0baa42dbb7eb6938647", size = 6340926, upload-time = "2026-10-10T20:04:22.865Z" }, + { url = "https://files.pythonhosted.org/packages/7e/7e/6cd886876f435b10685db9b9f7eeb70356f99e052116f4e5f11c5792c714/numpy-2.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:067374eb538c34c745436365cf7b0112595c1d326f21ce4ff340f61230239fbb", size = 12901584, upload-time = "2026-10-10T20:04:24.99Z" }, + { url = "https://files.pythonhosted.org/packages/38/1b/3c1684f6a06f7307f2335fca6e486cb162847fb97e91d65f8eb5cabad213/numpy-2.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:e94aef2c639da4a960ad0db8e06471208d8589974953d78b61d345b4eb99e394", size = 10891152, upload-time = "2026-10-10T20:04:27.52Z" }, + { url = "https://files.pythonhosted.org/packages/08/f4/3224deff3af2bef6bc0b175369698d8cb348f3d91d9bb0286cd5c9eae9e0/numpy-2.5.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:8dddfbee2e68d26d0d7d7d9cb247b1fd4409241cce32d815a11d97ec2cfde179", size = 17003231, upload-time = "2026-10-10T20:04:30.021Z" }, + { url = "https://files.pythonhosted.org/packages/be/75/fee0b8c6d94b44b2fdfae74f6a4ad5a138739589a8aebaec28ce4e713ed5/numpy-2.5.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:81e3420b27048b65eb14c3acf0c174a8cb0e023277716110347d2dcb26026dad", size = 12018300, upload-time = "2026-10-10T20:04:32.519Z" }, + { url = "https://files.pythonhosted.org/packages/47/c0/d0b335a499a04b65f532c3f034346ef390f81299060f928492dabc1e0272/numpy-2.5.4-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:0b4724a19de67bea8cfc4970798efa78bcbbe2ac2613cfac16721a42d44de2a5", size = 5454250, upload-time = "2026-10-10T20:04:34.943Z" }, + { url = "https://files.pythonhosted.org/packages/5a/0e/461b3783c03d668052e6a21b01b673db6ffcb7831fd32d9aa5368c1cd426/numpy-2.5.4-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:2132418bf8dd124a427ca9e6a1daf9ee1a87185344c95119ceae868b99466da1", size = 6789644, upload-time = "2026-10-10T20:04:37.258Z" }, + { url = "https://files.pythonhosted.org/packages/b3/02/5dad269b02166965a7b4ca14adaddd75dbee0de42435bfecf561b84ba5a6/numpy-2.5.4-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:325518d4245b9e331387702aa58c2ce1dc4cdcbb41dfb4ccd5dcbc7e08db1266", size = 15704353, upload-time = "2026-10-10T20:04:39.616Z" }, + { url = "https://files.pythonhosted.org/packages/93/3a/01360c8036822ed9f7aa32189a77d1476567ec1e8e1383522389e4faac45/numpy-2.5.4-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56733449d2544178beaa4545cee357370440cf056c197f9c7bfb19dbfdd0e86d", size = 16718648, upload-time = "2026-10-10T20:04:42.383Z" }, + { url = "https://files.pythonhosted.org/packages/7d/5c/b863a2c093c4d6f21a597fcaf24ead0835c09ab16a8312d5a5a8868af683/numpy-2.5.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:5ec3753760c1a6d8bb91200666e545c3a9728e6269dfb5d6ce02340996698aa3", size = 17059053, upload-time = "2026-10-10T20:04:44.976Z" }, + { url = "https://files.pythonhosted.org/packages/0a/60/ced4f57f9a1258a0af74f17cb0b0c2700b5c67cd6678823c803b263e4df3/numpy-2.5.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:b1185012870173de7ae33d370bd45b1cf5baee747ea4b97036b65f4e93016877", size = 18477406, upload-time = "2026-10-10T20:04:47.863Z" }, + { url = "https://files.pythonhosted.org/packages/f9/bd/0ef22dafaafcc7d4bb3ca26b8d2afbd55dedad8eaba99a8c864e1997456f/numpy-2.5.4-cp315-cp315-win32.whl", hash = "sha256:298eca75243f2cbbfdb460560b9fb2a1792a33cf2ab4286efd43d92e8d3df508", size = 6185133, upload-time = "2026-10-10T20:04:50.467Z" }, + { url = "https://files.pythonhosted.org/packages/50/bc/d2651b155ecc608a77e6f4d15495c11f14f19bb98f8bf0c5b0d38f86dda1/numpy-2.5.4-cp315-cp315-win_amd64.whl", hash = "sha256:332f3378fe077dd850e677ec01bdcc4f22368fb5d50ef10b2c79230b1bf5a592", size = 12703085, upload-time = "2026-10-10T20:04:52.63Z" }, + { url = "https://files.pythonhosted.org/packages/dc/d2/45e404f8abb26fb9eda12b94012936873e827b1be76f2ee7890be128312e/numpy-2.5.4-cp315-cp315-win_arm64.whl", hash = "sha256:d4cccbbc78717966f764cd3af4fb70276fa01fc7a2688af11c78901fa5c04f05", size = 10801451, upload-time = "2026-10-10T20:04:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/c6/c3/2ae14e09cfdb67dc187a342e15308a21c15bf4d2071f8079e6aee5fe56dc/numpy-2.5.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:950ea81d57ef070665581b6e1b5f6a029306423cd1739c5b95fe78aa30db6b9d", size = 17097121, upload-time = "2026-10-10T20:04:58.403Z" }, + { url = "https://files.pythonhosted.org/packages/f5/cf/305ae624ef8a039414317224abe9ec9c2fe7ea3c2e1cf204d43ff6b2ffb9/numpy-2.5.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c05ede731b03fb1b7591faca9389ade3267d2bddf1ad8882bb3f2cc5e101694f", size = 12135439, upload-time = "2026-10-10T20:05:01.65Z" }, + { url = "https://files.pythonhosted.org/packages/a9/a8/f75c63813aef95827bb2c0d13b12803016853056e8792c280058cdbfe783/numpy-2.5.4-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:5fbf7141bbfd63aea22f435c9062a032b9ea0082fe9845dad7f021d3f1234e71", size = 5571451, upload-time = "2026-10-10T20:05:04.135Z" }, + { url = "https://files.pythonhosted.org/packages/6f/0f/f17763f983868b5c49b4101ebd7e00760bd1769478a6bb6a8de6e085bbac/numpy-2.5.4-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:3573cd22564692a5b899ec344e5d5b9cc4576f2985b96f22af3564ed54f2710f", size = 6883356, upload-time = "2026-10-10T20:05:06.249Z" }, + { url = "https://files.pythonhosted.org/packages/67/a7/8af04c5a79e047996cfa38854dcfbececdd0343a7c933a46fdd03ef6f5da/numpy-2.5.4-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c109eac9cd439193678f69d70733c1108487546ca8eafc107b510ae10c1aecd", size = 15750991, upload-time = "2026-10-10T20:05:08.376Z" }, + { url = "https://files.pythonhosted.org/packages/57/7a/648254290d0c504faa8f2d07aa206660c728802c781a6f3fc68ab7cb5d71/numpy-2.5.4-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:80d6ef6e8620eb2c2b4c4caad50b5935d6db3cde2d51581b55dcc79e14016d1d", size = 16757675, upload-time = "2026-10-10T20:05:11.393Z" }, + { url = "https://files.pythonhosted.org/packages/b8/fe/4a8c3cdb0c70400cfe4c5bec42d3099a5673802a95064614b33e07b82aa1/numpy-2.5.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:77045a4b175bbf5316ec08003880804336c78f92281a1b72222b274ea85ec5ac", size = 17113846, upload-time = "2026-10-10T20:05:14.49Z" }, + { url = "https://files.pythonhosted.org/packages/1b/7e/619692bb67778702c0e9eb2d468568a7573f4e269386ea61aed01ee4e557/numpy-2.5.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:0f02a46e49cfb6c73bdb7aea1c0d3461dbae9aba613542b65f657cd3d17b9fab", size = 18522915, upload-time = "2026-10-10T20:05:17.33Z" }, + { url = "https://files.pythonhosted.org/packages/b7/b5/4da41c328788f575838f97a098fe8ca691ebc6f6fd73ad4a262ee40b184d/numpy-2.5.4-cp315-cp315t-win32.whl", hash = "sha256:ad62a416ddcf863bf44bba76fbf6b53366ab0692e294f51cae4b5fbe0d246788", size = 6335804, upload-time = "2026-10-10T20:05:19.921Z" }, + { url = "https://files.pythonhosted.org/packages/98/94/6482ddfa3d312490cb9358f375bf2ad56427dbea8769187158e94d653753/numpy-2.5.4-cp315-cp315t-win_amd64.whl", hash = "sha256:38f47be9f74ab870d2633b5456ae519c43758a8d1fd05342f0ce4ecc034396ee", size = 12890095, upload-time = "2026-10-10T20:05:21.875Z" }, + { url = "https://files.pythonhosted.org/packages/48/7f/c2d1b436b6e7cfebac140c2579a298344b85f2991a2ce5c3615cefb29400/numpy-2.5.4-cp315-cp315t-win_arm64.whl", hash = "sha256:7a14a461d9340f1b46b8648578aed9cdb8b3b018a8fac6c1dde2c9192a01a87f", size = 10883718, upload-time = "2026-10-10T20:05:28.547Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.23.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "coloredlogs" }, + { name = "flatbuffers" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" } }, + { name = "packaging" }, + { name = "protobuf" }, + { name = "sympy" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/d6/311b1afea060015b56c742f3531168c1644650767f27ef40062569960587/onnxruntime-1.23.2-cp310-cp310-macosx_13_0_arm64.whl", hash = "sha256:a7730122afe186a784660f6ec5807138bf9d792fa1df76556b27307ea9ebcbe3", size = 17195934, upload-time = "2025-10-27T23:06:14.143Z" }, + { url = "https://files.pythonhosted.org/packages/db/db/81bf3d7cecfbfed9092b6b4052e857a769d62ed90561b410014e0aae18db/onnxruntime-1.23.2-cp310-cp310-macosx_13_0_x86_64.whl", hash = "sha256:b28740f4ecef1738ea8f807461dd541b8287d5650b5be33bca7b474e3cbd1f36", size = 19153079, upload-time = "2025-10-27T23:05:57.686Z" }, + { url = "https://files.pythonhosted.org/packages/2e/4d/a382452b17cf70a2313153c520ea4c96ab670c996cb3a95cc5d5ac7bfdac/onnxruntime-1.23.2-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f7d1fe034090a1e371b7f3ca9d3ccae2fabae8c1d8844fb7371d1ea38e8e8d2", size = 15219883, upload-time = "2025-10-22T03:46:21.66Z" }, + { url = "https://files.pythonhosted.org/packages/fb/56/179bf90679984c85b417664c26aae4f427cba7514bd2d65c43b181b7b08b/onnxruntime-1.23.2-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4ca88747e708e5c67337b0f65eed4b7d0dd70d22ac332038c9fc4635760018f7", size = 17370357, upload-time = "2025-10-22T03:46:57.968Z" }, + { url = "https://files.pythonhosted.org/packages/cd/6d/738e50c47c2fd285b1e6c8083f15dac1a5f6199213378a5f14092497296d/onnxruntime-1.23.2-cp310-cp310-win_amd64.whl", hash = "sha256:0be6a37a45e6719db5120e9986fcd30ea205ac8103fd1fb74b6c33348327a0cc", size = 13467651, upload-time = "2025-10-27T23:06:11.904Z" }, + { url = "https://files.pythonhosted.org/packages/44/be/467b00f09061572f022ffd17e49e49e5a7a789056bad95b54dfd3bee73ff/onnxruntime-1.23.2-cp311-cp311-macosx_13_0_arm64.whl", hash = "sha256:6f91d2c9b0965e86827a5ba01531d5b669770b01775b23199565d6c1f136616c", size = 17196113, upload-time = "2025-10-22T03:47:33.526Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a8/3c23a8f75f93122d2b3410bfb74d06d0f8da4ac663185f91866b03f7da1b/onnxruntime-1.23.2-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:87d8b6eaf0fbeb6835a60a4265fde7a3b60157cf1b2764773ac47237b4d48612", size = 19153857, upload-time = "2025-10-22T03:46:37.578Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d8/506eed9af03d86f8db4880a4c47cd0dffee973ef7e4f4cff9f1d4bcf7d22/onnxruntime-1.23.2-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bbfd2fca76c855317568c1b36a885ddea2272c13cb0e395002c402f2360429a6", size = 15220095, upload-time = "2025-10-22T03:46:24.769Z" }, + { url = "https://files.pythonhosted.org/packages/e9/80/113381ba832d5e777accedc6cb41d10f9eca82321ae31ebb6bcede530cea/onnxruntime-1.23.2-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da44b99206e77734c5819aa2142c69e64f3b46edc3bd314f6a45a932defc0b3e", size = 17372080, upload-time = "2025-10-22T03:47:00.265Z" }, + { url = "https://files.pythonhosted.org/packages/3a/db/1b4a62e23183a0c3fe441782462c0ede9a2a65c6bbffb9582fab7c7a0d38/onnxruntime-1.23.2-cp311-cp311-win_amd64.whl", hash = "sha256:902c756d8b633ce0dedd889b7c08459433fbcf35e9c38d1c03ddc020f0648c6e", size = 13468349, upload-time = "2025-10-22T03:47:25.783Z" }, + { url = "https://files.pythonhosted.org/packages/1b/9e/f748cd64161213adeef83d0cb16cb8ace1e62fa501033acdd9f9341fff57/onnxruntime-1.23.2-cp312-cp312-macosx_13_0_arm64.whl", hash = "sha256:b8f029a6b98d3cf5be564d52802bb50a8489ab73409fa9db0bf583eabb7c2321", size = 17195929, upload-time = "2025-10-22T03:47:36.24Z" }, + { url = "https://files.pythonhosted.org/packages/91/9d/a81aafd899b900101988ead7fb14974c8a58695338ab6a0f3d6b0100f30b/onnxruntime-1.23.2-cp312-cp312-macosx_13_0_x86_64.whl", hash = "sha256:218295a8acae83905f6f1aed8cacb8e3eb3bd7513a13fe4ba3b2664a19fc4a6b", size = 19157705, upload-time = "2025-10-22T03:46:40.415Z" }, + { url = "https://files.pythonhosted.org/packages/3c/35/4e40f2fba272a6698d62be2cd21ddc3675edfc1a4b9ddefcc4648f115315/onnxruntime-1.23.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76ff670550dc23e58ea9bc53b5149b99a44e63b34b524f7b8547469aaa0dcb8c", size = 15226915, upload-time = "2025-10-22T03:46:27.773Z" }, + { url = "https://files.pythonhosted.org/packages/ef/88/9cc25d2bafe6bc0d4d3c1db3ade98196d5b355c0b273e6a5dc09c5d5d0d5/onnxruntime-1.23.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f9b4ae77f8e3c9bee50c27bc1beede83f786fe1d52e99ac85aa8d65a01e9b77", size = 17382649, upload-time = "2025-10-22T03:47:02.782Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b4/569d298f9fc4d286c11c45e85d9ffa9e877af12ace98af8cab52396e8f46/onnxruntime-1.23.2-cp312-cp312-win_amd64.whl", hash = "sha256:25de5214923ce941a3523739d34a520aac30f21e631de53bba9174dc9c004435", size = 13470528, upload-time = "2025-10-22T03:47:28.106Z" }, + { url = "https://files.pythonhosted.org/packages/3d/41/fba0cabccecefe4a1b5fc8020c44febb334637f133acefc7ec492029dd2c/onnxruntime-1.23.2-cp313-cp313-macosx_13_0_arm64.whl", hash = "sha256:2ff531ad8496281b4297f32b83b01cdd719617e2351ffe0dba5684fb283afa1f", size = 17196337, upload-time = "2025-10-22T03:46:35.168Z" }, + { url = "https://files.pythonhosted.org/packages/fe/f9/2d49ca491c6a986acce9f1d1d5fc2099108958cc1710c28e89a032c9cfe9/onnxruntime-1.23.2-cp313-cp313-macosx_13_0_x86_64.whl", hash = "sha256:162f4ca894ec3de1a6fd53589e511e06ecdc3ff646849b62a9da7489dee9ce95", size = 19157691, upload-time = "2025-10-22T03:46:43.518Z" }, + { url = "https://files.pythonhosted.org/packages/1c/a1/428ee29c6eaf09a6f6be56f836213f104618fb35ac6cc586ff0f477263eb/onnxruntime-1.23.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45d127d6e1e9b99d1ebeae9bcd8f98617a812f53f46699eafeb976275744826b", size = 15226898, upload-time = "2025-10-22T03:46:30.039Z" }, + { url = "https://files.pythonhosted.org/packages/f2/2b/b57c8a2466a3126dbe0a792f56ad7290949b02f47b86216cd47d857e4b77/onnxruntime-1.23.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8bace4e0d46480fbeeb7bbe1ffe1f080e6663a42d1086ff95c1551f2d39e7872", size = 17382518, upload-time = "2025-10-22T03:47:05.407Z" }, + { url = "https://files.pythonhosted.org/packages/4a/93/aba75358133b3a941d736816dd392f687e7eab77215a6e429879080b76b6/onnxruntime-1.23.2-cp313-cp313-win_amd64.whl", hash = "sha256:1f9cc0a55349c584f083c1c076e611a7c35d5b867d5d6e6d6c823bf821978088", size = 13470276, upload-time = "2025-10-22T03:47:31.193Z" }, + { url = "https://files.pythonhosted.org/packages/7c/3d/6830fa61c69ca8e905f237001dbfc01689a4e4ab06147020a4518318881f/onnxruntime-1.23.2-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9d2385e774f46ac38f02b3a91a91e30263d41b2f1f4f26ae34805b2a9ddef466", size = 15229610, upload-time = "2025-10-22T03:46:32.239Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ca/862b1e7a639460f0ca25fd5b6135fb42cf9deea86d398a92e44dfda2279d/onnxruntime-1.23.2-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2b9233c4947907fd1818d0e581c049c41ccc39b2856cc942ff6d26317cee145", size = 17394184, upload-time = "2025-10-22T03:47:08.127Z" }, +] + +[[package]] +name = "onnxruntime" +version = "1.31.1" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "flatbuffers" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "packaging" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/44/e9e04a60f726d16ba3abe30ab267e1569e061f7f6f0e175ee103661e1780/onnxruntime-1.31.1-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:60b6b69bfe580eab576cacc5d132a0e9cf2a37fcfd18d46dd191042b1d1ed0d7", size = 20871676, upload-time = "2026-10-26T19:26:00.372Z" }, + { url = "https://files.pythonhosted.org/packages/02/ee/b173a49293b146b54bd057bf8681a015aef764d8f56d999ad8c6e53ab18d/onnxruntime-1.31.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:da05378364c44d4407e463982d2bf8d5e4cfea873283757e48beeb41df97b7f3", size = 21413526, upload-time = "2026-10-26T19:26:03.573Z" }, + { url = "https://files.pythonhosted.org/packages/b4/1d/0f85ee31a3d93f2243a5cc29252becf858f53ac5cfa6c9c15d9ffe107eea/onnxruntime-1.31.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:5752bd508126ae7c49894d3b9d2e83f0c3d487319246d04c444b393308d7ad7f", size = 23753652, upload-time = "2026-10-26T19:26:06.944Z" }, + { url = "https://files.pythonhosted.org/packages/69/82/2e2bf967ade9567d77c307533566ef56a19c32e2114fc062a405703def88/onnxruntime-1.31.1-cp311-cp311-win_amd64.whl", hash = "sha256:c3d91b5de31e2fc82d71bd65b2b22bddee8b49057a3a36338e9a868e0ea90c05", size = 14885761, upload-time = "2026-10-26T19:26:09.8Z" }, + { url = "https://files.pythonhosted.org/packages/c4/c6/1995e04cc964c6abac426f59525b41c31f766c9392cabfb1e67c51718823/onnxruntime-1.31.1-cp311-cp311-win_arm64.whl", hash = "sha256:93800007a7023b3ab26ad72e6463d0d57d84ead49a2f6341954d91438e046bc0", size = 14735267, upload-time = "2026-10-26T19:26:12.915Z" }, + { url = "https://files.pythonhosted.org/packages/0e/f7/cecc0efeeea83bff2f7789ae1b80f27fa0f0210d6d9d66d1f0031a6b5e47/onnxruntime-1.31.1-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:96dd2564b10ea7153ad9c207e7cd8e5917cb3ba521e0e0a62ac03486fdc8d56c", size = 20882125, upload-time = "2026-10-26T19:26:16.256Z" }, + { url = "https://files.pythonhosted.org/packages/ba/e4/1ed1a7a5f4702d899091fa2b976d377995250c307326ec8dc9ae6378aa13/onnxruntime-1.31.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:0b9a492176886992e0e875f06bc0367e333f5fff11711a2d642e18b02f3009cc", size = 21420803, upload-time = "2026-10-26T19:26:19.487Z" }, + { url = "https://files.pythonhosted.org/packages/eb/27/c6a823bac55b2977bea2027c3ec9393a2c1002cb9a09eb40354563e02730/onnxruntime-1.31.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:1f3dea47f2f0e5117c2404cea7d21fd253ae7836a3bf167a501cdfbb2600d536", size = 23760988, upload-time = "2026-10-26T19:26:23.153Z" }, + { url = "https://files.pythonhosted.org/packages/45/b2/793b4051d8dc6acb379ead9b72050f0ffa283ca49a6904add2e218b83e2e/onnxruntime-1.31.1-cp312-cp312-win_amd64.whl", hash = "sha256:ae8a9a351efda685cc59a66226cdefaa37a126c1d66872ca23a2de9425326130", size = 14888466, upload-time = "2026-10-26T19:26:25.816Z" }, + { url = "https://files.pythonhosted.org/packages/ed/72/09d635ab4b6137d8ac63d4911a37dad8b1ef15a77d20b65d7ed40fdca012/onnxruntime-1.31.1-cp312-cp312-win_arm64.whl", hash = "sha256:fe8b9ac1ae8e894e12c47ee82e4f6dfc1835768133687257866469fda80d0bf1", size = 14740724, upload-time = "2026-10-26T19:26:28.682Z" }, + { url = "https://files.pythonhosted.org/packages/b2/93/d2b855793302ef57d55cc0583b72a00a8dcb01d9bdb3adac380f09b050e8/onnxruntime-1.31.1-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e4ad067d36e2220218e085d7223283b2ee1bc73d887e811fd14d21cf901a11ee", size = 20881825, upload-time = "2026-10-26T19:26:31.51Z" }, + { url = "https://files.pythonhosted.org/packages/e1/e1/633d4994db0620d31f34d9962119bc4ebd0b2ef4c9a030f91c7843fb9672/onnxruntime-1.31.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:dcaedc50333876f3829ab966b242147f0e548229e29c36fe44622ecf748c25ee", size = 21420628, upload-time = "2026-10-26T19:26:34.487Z" }, + { url = "https://files.pythonhosted.org/packages/fc/0a/c887bcb84a9455b2723825381a77af38611a80f996f804e20fde5f671b63/onnxruntime-1.31.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:74a6a52994616c4d18b33db1e13c226333a70a6ba07480a5cab9c2a50dff1430", size = 23760717, upload-time = "2026-10-26T19:26:37.721Z" }, + { url = "https://files.pythonhosted.org/packages/59/bf/a1d282b4c753ba3e9b31f4c11abd2bc2390513dc5e3792ca3b78e42401c3/onnxruntime-1.31.1-cp313-cp313-win_amd64.whl", hash = "sha256:0558f29d5f6ac09957390c9c5495931485ee8ae7f0ce781ccee86a0ae5c2348b", size = 14888304, upload-time = "2026-10-26T19:26:41.032Z" }, + { url = "https://files.pythonhosted.org/packages/7e/fd/529135287474dbaf19d9362ccda61998128ab18507f78bc82931e1bbaf22/onnxruntime-1.31.1-cp313-cp313-win_arm64.whl", hash = "sha256:075147c2e2430b4b29c436bffa78537b902a6ed58ed66f99ae3c6795e2081cb5", size = 14740772, upload-time = "2026-10-26T19:26:44.042Z" }, + { url = "https://files.pythonhosted.org/packages/0e/d4/56ea7d601695be4018ccc6bb9a47637a1deaccc5c4db6c6ad272e48d88e2/onnxruntime-1.31.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:ae0987aedb9ae589f3395615c58b22aad2eae6657b14508cec70c24b367cfad1", size = 21432641, upload-time = "2026-10-26T19:26:47.065Z" }, + { url = "https://files.pythonhosted.org/packages/05/10/e37d9f06dae61cecaad344aef213a19643b66761a06667bdfe5282c1fb37/onnxruntime-1.31.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:6711108bcddf8b401145fb31ac93776b8ca6e7e7e56acdfa9d478575b8df9a2f", size = 23773876, upload-time = "2026-10-26T19:26:50.371Z" }, + { url = "https://files.pythonhosted.org/packages/d7/55/b511099a435972b86b5d04ef374cdca8de920311cc979180029b80145bf5/onnxruntime-1.31.1-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:8536ac43682caa7492c46d6cfd4c3c8db288dcf0619508431a22170b670ee1d0", size = 20883427, upload-time = "2026-10-26T19:26:54.067Z" }, + { url = "https://files.pythonhosted.org/packages/06/ef/98f0060d6cf58f9f663268fef65fe729120b8fbe26ef35eaa2c8d9030d33/onnxruntime-1.31.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:c878686b75cade1ed59131aa018ab004b1e64368b0d54041912450b9642cf04f", size = 21421619, upload-time = "2026-10-26T19:26:57.332Z" }, + { url = "https://files.pythonhosted.org/packages/aa/74/a891a659ccc427469de0d7bdbd5ff770a35f73084ee590ce02456cf61f7f/onnxruntime-1.31.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:c20d7f15d84427db070b163f78c2c7146cc93edd6113fa7327671259a24184fe", size = 23762999, upload-time = "2026-10-26T19:27:00.865Z" }, + { url = "https://files.pythonhosted.org/packages/e5/e9/9112e9322aef42bff80e805915b61cdcbb82577589bdd42dedf73a5ff9b6/onnxruntime-1.31.1-cp314-cp314-win_amd64.whl", hash = "sha256:0a3998e18cb667ef54287556bd62291a788ed235723dd90c83b2294b24e71d81", size = 15268752, upload-time = "2026-10-26T19:27:03.629Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ee/b69384d9b94c6bf3beb030bcba25dc573e490d3136117be0f78d79078d35/onnxruntime-1.31.1-cp314-cp314-win_arm64.whl", hash = "sha256:fc01b4e7c0a81778fb741bcf5c16b7871d196275f6240720a8b8bfd9f0c0af14", size = 15153930, upload-time = "2026-10-26T19:27:06.159Z" }, + { url = "https://files.pythonhosted.org/packages/2b/5b/beeb6acb5a9e17311b4ebc36fe91ac4893200ddb290257fb072509a7c26b/onnxruntime-1.31.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:564d7b83fb3e94fb3d18629c6b339e9bce10966dd29a8442c433175aac3d60fd", size = 21432341, upload-time = "2026-10-26T19:27:09.131Z" }, + { url = "https://files.pythonhosted.org/packages/c6/3d/a5b15c4ab9d67a384da5a2c10fb569e643076c28179fe1a265af7d8f1b87/onnxruntime-1.31.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:4d5f5fcc01f0c334d282a8991eab44e7752ad01c47b336d848ba43eb38084958", size = 23772582, upload-time = "2026-10-26T19:27:12.025Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[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 = "platformdirs" +version = "4.12.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/90/a1/d5f9002a70298c64a789779077d8dd90c10aa1f47fe40c86802df874f2a6/platformdirs-4.12.4.tar.gz", hash = "sha256:63743c02414e755de4e31b8f68125c1407495b86c5a006e203c01ff8b9924250", size = 60010, upload-time = "2026-10-07T23:30:32.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/ba/223e00b885e960edd5d4b4d178c88acce019bd5b83786093681b8c393492/platformdirs-4.12.4-py3-none-any.whl", hash = "sha256:78bfb9db2a8471ed7eebe3c3c932da413911042994e699b384fbb4493fa872d7", size = 32596, upload-time = "2026-10-07T23:30:30.825Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.13.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/1a/43/8c4b5fe23f0e119cf4e1b16c2d16240ab9057cdbb138568c91d5a48abf81/platformdirs-4.13.6.tar.gz", hash = "sha256:211d176e24674b5895dedf9021c262bcf9fad008a70610bfb147d4a8d6d8fe1b", size = 62750, upload-time = "2026-10-27T08:19:11.538Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a8/24/b312a9466839b1f708eed42790b47e927dc7f774a528bb49b1cdf8b734b9/platformdirs-4.13.6-py3-none-any.whl", hash = "sha256:21fc198fb09f3e78cadcdfd8a6ae4fd65cadc64a3cba78b694321c2996114a3e", size = 32767, upload-time = "2026-10-27T08:19:10.405Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "polyglot" +version = "1.0.0.dev0" +source = { editable = "." } +dependencies = [ + { name = "faster-whisper" }, + { name = "keyring" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "onnxruntime", version = "1.23.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "onnxruntime", version = "1.31.1", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "platformdirs", version = "4.12.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "platformdirs", version = "4.13.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pyaudiowpatch", marker = "sys_platform == 'win32'" }, + { name = "pydantic" }, + { name = "pynput" }, + { name = "pyqt6" }, + { name = "sounddevice" }, + { name = "soxr" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] + +[package.dev-dependencies] +dev = [ + { name = "mypy" }, + { name = "pytest" }, + { name = "pytest-cov" }, + { name = "pytest-qt" }, + { name = "pytest-timeout" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "faster-whisper", specifier = ">=1.1" }, + { name = "keyring", specifier = ">=25.0" }, + { name = "numpy", specifier = ">=1.26" }, + { name = "onnxruntime", specifier = ">=1.17" }, + { name = "platformdirs", specifier = ">=4.2" }, + { name = "pyaudiowpatch", marker = "sys_platform == 'win32'", specifier = ">=0.2.12" }, + { name = "pydantic", specifier = ">=2.7" }, + { name = "pynput", specifier = ">=1.7" }, + { name = "pyqt6", specifier = ">=6.7" }, + { name = "sounddevice", specifier = ">=0.5" }, + { name = "soxr", specifier = ">=0.5" }, + { name = "tomli", marker = "python_full_version < '3.11'", specifier = ">=2.0" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "mypy", specifier = ">=1.11" }, + { name = "pytest", specifier = ">=8.2" }, + { name = "pytest-cov", specifier = ">=5.0" }, + { name = "pytest-qt", specifier = ">=4.4" }, + { name = "pytest-timeout", specifier = ">=2.3" }, + { name = "ruff", specifier = "==0.14.0" }, +] + +[[package]] +name = "protobuf" +version = "7.36.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d9/89/5b8517baa72f84a67b8a307ba953c91057af618bf40bf676f3c03551f8f0/protobuf-7.36.2.tar.gz", hash = "sha256:497d0463ff3316681da6c0b9e8d06cb465d61abce00b613ab42226175644d1bb", size = 512737, upload-time = "2026-09-17T20:07:59.326Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/72/98342feb672507c8f3a69e34b4fa8961f608edba5c1a48a6f47156d92cb5/protobuf-7.36.2-cp310-abi3-macosx_10_9_universal2.whl", hash = "sha256:cbc70b17ee27e28894c7fee8bb04be1abead49e936bc70eb60052531eee2079e", size = 456039, upload-time = "2026-09-17T20:07:51.542Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ea/91fdf7c2b8bbd49cde056f00a9df6773532987e1c00fe2830b895af95c7e/protobuf-7.36.2-cp310-abi3-manylinux2014_aarch64.whl", hash = "sha256:e11e1f0180583a2af89db6a2ecd9e8dc40aa6d2988ca175bfd0e6d12ea72d74e", size = 344219, upload-time = "2026-09-17T20:07:52.914Z" }, + { url = "https://files.pythonhosted.org/packages/17/ab/5fd5f8ece73fad885c5a09aa849b32d70472f954ba3a92d3bb5974ea953b/protobuf-7.36.2-cp310-abi3-manylinux2014_s390x.whl", hash = "sha256:f4fee11ec330d238b34a05c9b675f693c20415d1c5bd7d5320cc2f8a798eb9cf", size = 357223, upload-time = "2026-09-17T20:07:53.985Z" }, + { url = "https://files.pythonhosted.org/packages/db/f3/3996583dd2906297a637af12114deddf7658af6e683fedb83be061983fb5/protobuf-7.36.2-cp310-abi3-manylinux2014_x86_64.whl", hash = "sha256:89f23aa53c24553a2416fd4fd1ec06f74fa42b14b546d8883128813f775bbfd2", size = 343223, upload-time = "2026-09-17T20:07:54.931Z" }, + { url = "https://files.pythonhosted.org/packages/fc/1b/dcc64f358fcb51811b58ae40b3d28f820725f116d86487cc20bd4b130701/protobuf-7.36.2-cp310-abi3-win32.whl", hash = "sha256:912c1221170e16c08d1f086762f563dd61ff83c18b5fa6652952dfaded66f728", size = 442998, upload-time = "2026-09-17T20:07:55.826Z" }, + { url = "https://files.pythonhosted.org/packages/8a/55/b77bda4e5e5f5971fb51b07663694690e9afdb9402136c16a522bd621cad/protobuf-7.36.2-cp310-abi3-win_amd64.whl", hash = "sha256:a300819d441e078a5608c0d3c709796bb548136058fda017ae51d425b44fd353", size = 456514, upload-time = "2026-09-17T20:07:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/e4/04/d52c7016b04b6c5108f26691f9d33ec82a9b65d041f1a9c771137693d618/protobuf-7.36.2-py3-none-any.whl", hash = "sha256:bdb3a345d48db958e6ce1f18e508beb0cc981d64f24088427549c866cd039f1e", size = 179806, upload-time = "2026-09-17T20:07:58.211Z" }, +] + +[[package]] +name = "pyaudiowpatch" +version = "0.2.12.9" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/74/96/07cbc0388e67b8f8dee260f3cfc1424c16f546f41d14ec7f6f1c86288096/pyaudiowpatch-0.2.12.9-cp310-cp310-win32.whl", hash = "sha256:3b6248a479e02f839a110240a56edf3f3605a396ce84a4ef2ca95175baebf645", size = 97667, upload-time = "2026-10-06T16:13:10.495Z" }, + { url = "https://files.pythonhosted.org/packages/6d/5f/76d3558d65bc815c889dc97171d1f2b15bae4d984b36517baa30d97a14b6/pyaudiowpatch-0.2.12.9-cp310-cp310-win_amd64.whl", hash = "sha256:79e0059085fad1713bf5d728a9d2cb2fbd6c5b2a3fd13d74ca2a1e5056d69d69", size = 99876, upload-time = "2026-10-06T16:13:11.865Z" }, + { url = "https://files.pythonhosted.org/packages/c6/7b/6b42798a26042c0c904207d759d871fd4b168a45a107465508aad90a9ffe/pyaudiowpatch-0.2.12.9-cp311-cp311-win32.whl", hash = "sha256:0cf14a1945e53ab64e2f3d89a899563c5af02a0869a4d17ea0c6f27f321788d6", size = 97669, upload-time = "2026-10-06T16:13:13.394Z" }, + { url = "https://files.pythonhosted.org/packages/47/72/a4e7496e70bbf1c279ac571654654789a7f752a6600ee07dedb1cca69768/pyaudiowpatch-0.2.12.9-cp311-cp311-win_amd64.whl", hash = "sha256:46aacc940069157b80d5ba07159f2d86c3a560ae8c1878091802f8b223377f7a", size = 99878, upload-time = "2026-10-06T16:13:14.852Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a3/acb33103ec3bf1be0255bf423791d3ffcb4c194a1d2b66aaceb311bc8269/pyaudiowpatch-0.2.12.9-cp312-cp312-win32.whl", hash = "sha256:ac7d187b2c470bc5c76cbc9e30c8127564fc3a653fcae9c820d6b3ddf417b6e4", size = 97853, upload-time = "2026-10-06T16:13:16.214Z" }, + { url = "https://files.pythonhosted.org/packages/4f/4a/b3040ab051c3d2ee6b123e67db7a3e980fbf8e71f9d3b822366e8b380eb2/pyaudiowpatch-0.2.12.9-cp312-cp312-win_amd64.whl", hash = "sha256:963376e94f46c84e994eda4d25ffd62b712881ad5d611a4f4433bb5aa0bf7fa4", size = 100137, upload-time = "2026-10-06T16:13:17.67Z" }, + { url = "https://files.pythonhosted.org/packages/ca/02/542a39af9f7ee589d039ed41714539ff7db08541256deaf0c04f64c5a213/pyaudiowpatch-0.2.12.9-cp313-cp313-win32.whl", hash = "sha256:f747213885420a6b46f5d4d8dd0b441c14591893e3fcc740d2f0961bb16c2b4c", size = 97844, upload-time = "2026-10-06T16:13:18.96Z" }, + { url = "https://files.pythonhosted.org/packages/89/d7/2cf4d426d823e0931dd8830ed0751570997fba92d2596b25c22bd842b1da/pyaudiowpatch-0.2.12.9-cp313-cp313-win_amd64.whl", hash = "sha256:aaa847f5f76e11b42242b51293d872f811ab8925146c34ca79f21c9b18bda551", size = 100127, upload-time = "2026-10-06T16:13:20.602Z" }, + { url = "https://files.pythonhosted.org/packages/e7/5c/c45444bc928b6c40e2c36af9f2f721bb7ad3057debffe50f34e4081ab5d8/pyaudiowpatch-0.2.12.9-cp314-cp314-win32.whl", hash = "sha256:85b011276c882c6d302425a0a5d6bb3f00be45ef80a6c362d04b8d7234f5f5de", size = 99764, upload-time = "2026-10-06T16:13:22.148Z" }, + { url = "https://files.pythonhosted.org/packages/87/4e/ce82cdfdcc37eadb7f405f278182d6b8bb8f6a7d177c83537ddfd53aee24/pyaudiowpatch-0.2.12.9-cp314-cp314-win_amd64.whl", hash = "sha256:dc3ae964530ffe70119a1e2f5b76c661b676aa1cf1b9755d8ecafe081ee85f53", size = 101621, upload-time = "2026-10-06T16:13:23.518Z" }, + { url = "https://files.pythonhosted.org/packages/94/8e/fe6a70dac52966fe54d34aea4373deb8ac3226e27b96641a78bf0d716ae7/pyaudiowpatch-0.2.12.9-cp315-cp315-win32.whl", hash = "sha256:f76cdf7dd0a9deb74e95f0e9f04c2af0898eb055e1d3572bed0eb75a37de03dd", size = 99789, upload-time = "2026-10-06T16:13:24.806Z" }, + { url = "https://files.pythonhosted.org/packages/06/9e/583c053cc5580b07a2a3ff4511bce40be32167c56b948893b728b5260d31/pyaudiowpatch-0.2.12.9-cp315-cp315-win_amd64.whl", hash = "sha256:81d51b5b88c9e2124c33d0f9f22bf51392b93a4328f34e135e861e0c2c953c7f", size = 101620, upload-time = "2026-10-06T16:13:26.186Z" }, +] + +[[package]] +name = "pycparser" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/da/a8/c5fdbeee588bb8ada9458774f43adf1bdd30bd59157055142183e769a024/pycparser-3.11.tar.gz", hash = "sha256:d875f09c3507d00e1aba0eecc6dcadc1352f30fff09dc6bff2f1c2935e97c2bc", size = 113796, upload-time = "2026-10-09T12:56:59.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/90/11/0e6f11117525ff0eec40ebac3d313376f102df93ca44ad9e893ee85e4f89/pycparser-3.11-py3-none-any.whl", hash = "sha256:51d5a8ba2be0bbe440b99d2112604c95bbbc3c2748a64260186c541e1729cd80", size = 51178, upload-time = "2026-10-09T12:56:58.131Z" }, +] + +[[package]] +name = "pycparser" +version = "3.12" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version >= '3.12' and python_full_version < '3.15'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/27/eeb9f307bf07060f3d9f9aa0fb8c15b01bdfded0a941e4b2719c7f94cacd/pycparser-3.12.tar.gz", hash = "sha256:f03387877eab82ce01bbdfd0ba7252ee55a90b1c708d5129e2ce915475cf1db6", size = 158785, upload-time = "2026-10-22T13:40:03.56Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b6/ae/315bbeee126a769cbde43cf4908acb4b40408d8bf8bbf334dd7368d8dadf/pycparser-3.12-py3-none-any.whl", hash = "sha256:a076f3f489b39b43ed13563a1dafe42447445bec2e294154ec5c57fcdda4c85e", size = 62600, upload-time = "2026-10-22T13:40:02.021Z" }, +] + +[[package]] +name = "pydantic" +version = "2.14.1" +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/7c/0b/8e10b2e693af8ec54346a14caf36221334775975a747c9ceaa3f8371d96d/pydantic-2.14.1.tar.gz", hash = "sha256:94f478203dd03404682a1ada216965651dd74b1d2d5ffd62e00e0837caab5c26", size = 900362, upload-time = "2026-10-11T18:37:55.396Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/ea/a56b9fe5066f3537b7882f77e9c5dfb26d8c2eefdaed9b5fc73d57b4dc22/pydantic-2.14.1-py3-none-any.whl", hash = "sha256:9195d967ec791692a04438115466764fb8b9a27b31f14a760437694f40d6b454", size = 488106, upload-time = "2026-10-11T18:37:53.437Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.50.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/24/af4ec4be49fbc810f35b0bdcacc3d433b56bbfa469fd3bfd4ae116cd9bf1/pydantic_core-2.50.1.tar.gz", hash = "sha256:e50d7b94baac6c7d09927fa5ca5800a0c7ee5015c7fcff65beb3a1931b5a6e09", size = 513515, upload-time = "2026-10-11T18:35:44.82Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/09/db/c9cc34707ba2c23ce90d54e8a4ee9307583ad054b9df2ce570ba550cb576/pydantic_core-2.50.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:b281a3b0f0822618fe5e3e0d8a2048b6356b14388505dc9374ccffeb69989713", size = 2154222, upload-time = "2026-10-11T18:31:38.345Z" }, + { url = "https://files.pythonhosted.org/packages/c1/17/6963f4ee55b7df7658f5c036c0f90baf8cd3d413f5d8b551f227e8467afc/pydantic_core-2.50.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fa4c8bc12c1354c5550c0c35c1852c8c1901e89e06561724e03f8d0342e1f87", size = 2048126, upload-time = "2026-10-11T18:31:41.061Z" }, + { url = "https://files.pythonhosted.org/packages/bf/be/f75637e222085d29a3076edbc5cfd0dd9b77d145e310ff7dc1150f07558a/pydantic_core-2.50.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3aa9de446b793de2beb6fa2d9d0961803126c4e2a99c2f25ab59b9fd6ea125c0", size = 2052460, upload-time = "2026-10-11T18:31:42.321Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/3d192ffa39ce3bd0e98e988fb5c055cfbf4af6e6e155a4ca5baa86d1f2cc/pydantic_core-2.50.1-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:de531ce1e2a3364e8767878b58f4ff728a434b4fde089781fe30b1e08e2396e0", size = 2190750, upload-time = "2026-10-11T18:31:43.572Z" }, + { url = "https://files.pythonhosted.org/packages/b2/7e/12ea94df5220ab316ee5bb498ebcf710cff2db352653039fb6033f6997d1/pydantic_core-2.50.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a7c58106de36ac6a56314182958de20db8d3a29dfd5db527192cc754e4f8e7fb", size = 2390043, upload-time = "2026-10-11T18:31:44.745Z" }, + { url = "https://files.pythonhosted.org/packages/f6/bc/4fbb6dc90af038628ec824434a9841be9d46854f9267bb658f09e315024d/pydantic_core-2.50.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8b4c3df25bd323bf1d36a648d563cf1fc69d717451569927151bdad7cad07a77", size = 2432397, upload-time = "2026-10-11T18:31:46.186Z" }, + { url = "https://files.pythonhosted.org/packages/1b/1a/21a58791021397d9ca35295e3f4291c16e319155c5904334b89eb07e97e1/pydantic_core-2.50.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f77ac30b19221cd9bd3fcfa3d4614eff93140d0572ab730cded17b64adca05f3", size = 2160719, upload-time = "2026-10-11T18:31:47.557Z" }, + { url = "https://files.pythonhosted.org/packages/73/6a/d5b2c5876162fd2c444eaed0064b5d9d9d0ef0d31530fc6a7997e8685ad8/pydantic_core-2.50.1-cp310-cp310-manylinux_2_31_riscv64.whl", hash = "sha256:d939de9c82e2126f7f48a7e658f8a85ed46d57662d53f44c49b8895fe94a3eb7", size = 2256164, upload-time = "2026-10-11T18:31:48.797Z" }, + { url = "https://files.pythonhosted.org/packages/af/e8/1a6625d6e99250388dd0ae817c5d75839cd6103e7b790f59e0ffff74955d/pydantic_core-2.50.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:30ddf019d082c117b5d309e5b86710c2a78909907ec1a9381feec3eec02eca0b", size = 2271176, upload-time = "2026-10-11T18:31:49.987Z" }, + { url = "https://files.pythonhosted.org/packages/19/9f/bbdd137d7ec41284701dab4d1489ea597d401dff2f5f3e6b41ea872e0b12/pydantic_core-2.50.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:2ab756b72bd5054e4c7ef3ded331b35786cbd3cf931531a508f79a9537517064", size = 2304637, upload-time = "2026-10-11T18:31:51.251Z" }, + { url = "https://files.pythonhosted.org/packages/49/5d/7bd322e649b41b45130bc00bfa34dc57498c853aa8e6fc9604e33bc7087c/pydantic_core-2.50.1-cp310-cp310-musllinux_1_1_armv7l.whl", hash = "sha256:b087b1c5be7ac687cf22eabfe4b6b608d40df23610651e93611e1f49118baf84", size = 2467374, upload-time = "2026-10-11T18:31:52.587Z" }, + { url = "https://files.pythonhosted.org/packages/53/48/41a91111590eb7ba68a7c64c03139235a4b8349930abcb87931aa80da796/pydantic_core-2.50.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a44101320cfe99432db74237545a63057dc7a88dfe792cbcad0647f2af56cb81", size = 2480832, upload-time = "2026-10-11T18:31:54.06Z" }, + { url = "https://files.pythonhosted.org/packages/2a/02/4ac93a3d3f0ff412df1a36a9619743336fe6eec68c0df8a914163a3d22b4/pydantic_core-2.50.1-cp310-cp310-win32.whl", hash = "sha256:a4aaaa791bdae1c972a7e81765f4f3571c926b8e0b9b6e47346499fb80079665", size = 2123154, upload-time = "2026-10-11T18:31:55.396Z" }, + { url = "https://files.pythonhosted.org/packages/6d/ba/3a7af3dcd480c4739aa82cd9fedee79a5531a7c553346abcf095bd05f0de/pydantic_core-2.50.1-cp310-cp310-win_amd64.whl", hash = "sha256:2eedf82ee4753cdab8e50044c6bd569577eebc3859b11fecf4eb9223761ff966", size = 2179366, upload-time = "2026-10-11T18:31:56.697Z" }, + { url = "https://files.pythonhosted.org/packages/45/1b/ca81811da3d2aea724fb3c4ba6b83f50ab8f210576306ccd601973142d35/pydantic_core-2.50.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:c531166c42ea7bdfecc8c50049581f05dd1993b09cc7c52bb36a14e96deaec7d", size = 2152145, upload-time = "2026-10-11T18:31:58.046Z" }, + { url = "https://files.pythonhosted.org/packages/59/20/938ef7e0541af0a314e2f9d63848dbd1656ba2ebfe5ca0469f7ebee00d5e/pydantic_core-2.50.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b6d0c2183008c188e19f4906d426b293bdc4f67ab17df8e180fe16cda208fa71", size = 2045761, upload-time = "2026-10-11T18:31:59.35Z" }, + { url = "https://files.pythonhosted.org/packages/2f/4b/456497fe2affa18f49b226e89bde31e8a204751ee343dd9beaac5438123e/pydantic_core-2.50.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94be440c03fede26969a5ce75468e0e6a9927a1b46d9b679ee8adc1b057b0350", size = 2049557, upload-time = "2026-10-11T18:32:01.121Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9d/cd5dfe13928f55e236dff3a1bee06721d318ca6c955d9ca993b0a5d09f39/pydantic_core-2.50.1-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:36c426eac0af8d1529ff8467e612b933346caec1fdc0d774f78f67a1a11e16c1", size = 2188153, upload-time = "2026-10-11T18:32:02.442Z" }, + { url = "https://files.pythonhosted.org/packages/fb/8d/d0b25bc484f8d9136ea76ece69e0b2d24ab370cc2e7bbd1b79e61723b763/pydantic_core-2.50.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:028e2f212273d4a39b1ec1e0de8166b1165a65fc0f1111452a9d94fc7c625c63", size = 2388308, upload-time = "2026-10-11T18:32:03.767Z" }, + { url = "https://files.pythonhosted.org/packages/c5/64/6513cac7c9f78492abafa01d57a69de1d246bf3085fd7b0330bf14b025b3/pydantic_core-2.50.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e6f0cc1bb9900dc558960894adeb30b0c083366fc1d69b856209fb2ca5c36fe5", size = 2431187, upload-time = "2026-10-11T18:32:05.159Z" }, + { url = "https://files.pythonhosted.org/packages/ed/60/7f2ae89c37e69a3dc0da9ff57b0388c285542c688d05f36767770429de85/pydantic_core-2.50.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8812592c85d0edf423f10eadcef42716d71e8219085ad9e85b775057b7306133", size = 2157623, upload-time = "2026-10-11T18:32:06.616Z" }, + { url = "https://files.pythonhosted.org/packages/87/02/e3a71373b85a7973099b9a229a4302c7792262717e0b4997e41c01f7dd16/pydantic_core-2.50.1-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:bbce99252ba3167b2b6277f1829d5bf4b43b754524bddf7f944707c3db7d2253", size = 2254539, upload-time = "2026-10-11T18:32:07.968Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d5/5b620aaf40dc631d911565b64d49d3fa8422027c046a7a96dc4e4921ae98/pydantic_core-2.50.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:476f6ed8e43cd1e0b460920e23571700872b284e77331cb30c4faf459cf48a4b", size = 2267344, upload-time = "2026-10-11T18:32:09.399Z" }, + { url = "https://files.pythonhosted.org/packages/e0/48/f46baf4580d8a56ca4782aa65842e16d3cf39736b29fcce8e9c0521b3422/pydantic_core-2.50.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:2cbd1b75b09e976ed0d6b6ca297675632ca35df86130088457cdc60ef36970ae", size = 2300877, upload-time = "2026-10-11T18:32:10.903Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9d/e7d28505e6092c1fe075838a4f793ccbe6dd676e44ab16175815ee06cfe0/pydantic_core-2.50.1-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:5958c72adb417c39b12ac87525ac60b0d73315fcdc59e21f44ee4a5e2512c9ef", size = 2464270, upload-time = "2026-10-11T18:32:12.329Z" }, + { url = "https://files.pythonhosted.org/packages/22/b1/3bf63b82efd93ebc9968f9c12fc46037a28bcb452c88e4688f33e5ff7dca/pydantic_core-2.50.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:d8f9e8a6c4ab04b78d61f78627370d834eb004b2869dcb28cfffa647b4ea1980", size = 2478653, upload-time = "2026-10-11T18:32:13.735Z" }, + { url = "https://files.pythonhosted.org/packages/28/17/26d1e4b9c2ba6a92b7dc75bbcb99ef44456b7e3af1bced868403667ea7d3/pydantic_core-2.50.1-cp311-cp311-win32.whl", hash = "sha256:4be846f55c9477f5f3ddde8f2ce941137e16862a56d018ed885d422bb6ae02f2", size = 2120246, upload-time = "2026-10-11T18:32:15.591Z" }, + { url = "https://files.pythonhosted.org/packages/24/65/3e875e7991eaecd4d70686293ff0d8a99aa8f93dc295e6a21c3d702912fb/pydantic_core-2.50.1-cp311-cp311-win_amd64.whl", hash = "sha256:0048b6dddc8ef4b64fccaad878bd143b0c3882ea9936279dc11d613f6b7dd1bc", size = 2176332, upload-time = "2026-10-11T18:32:17.153Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5c/58dbd17c61f209d91c70f549eb7a3bbec7023e89ea12dead091462d6d658/pydantic_core-2.50.1-cp311-cp311-win_arm64.whl", hash = "sha256:6a733778df2f7087ec1100ed0b41533e4f3001976e99570fa34f57c66e7f8e3e", size = 2182471, upload-time = "2026-10-11T18:32:18.49Z" }, + { url = "https://files.pythonhosted.org/packages/ee/94/101b49a6c63f99586755690696eae14532772587d9e39e93f7b8d28a49da/pydantic_core-2.50.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:704075d10b74f2f3c6e15407c696d88701df35fc8953f434a431add0d0074db0", size = 2222428, upload-time = "2026-10-11T18:32:20.228Z" }, + { url = "https://files.pythonhosted.org/packages/db/a3/f8b1b39349c33037c73d7a1b794c9c29d8f07d5bd2b74399c1375a529cc6/pydantic_core-2.50.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e8e1d6ce820aa23317e8209a86bd65a540973c12dc7552b48a4f6c8e9926815e", size = 2025779, upload-time = "2026-10-11T18:32:21.723Z" }, + { url = "https://files.pythonhosted.org/packages/d2/2d/862a7d115305cc621358e51ba13f296e0ffdf4fbd984be9f63bc7862730b/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c18db21573bd2c6489f9a544b7499f0df2853958c568e5e783536ee1f690af41", size = 2048429, upload-time = "2026-10-11T18:32:23.3Z" }, + { url = "https://files.pythonhosted.org/packages/c0/7d/fed95d18bf2b5abe2d5ab2bbec4184bfc22b6805994a33ccdae8edffd25a/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb57f304525a5e3c13333b772bf9a473f36326e9c821b2e8e1b2fd36f80ae2c3", size = 2173274, upload-time = "2026-10-11T18:32:24.697Z" }, + { url = "https://files.pythonhosted.org/packages/93/1e/c6f22ceac65dc3d291ff79bea0eb74cbd1de8b128f01fee48af03bcea1e1/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a27c09d86600f1bf2fe3f37e1ae697faf3143931c09322cd799da94deee923b5", size = 2360403, upload-time = "2026-10-11T18:32:26.281Z" }, + { url = "https://files.pythonhosted.org/packages/2c/97/190b5b6bfe4c72f265feb657913eb30749193927a5ad7b83cfa7866a25a2/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:46b3301d3b5c886f77de7546e47274a5842c622ea2020b8c6524c6b66913b4a6", size = 2439799, upload-time = "2026-10-11T18:32:27.844Z" }, + { url = "https://files.pythonhosted.org/packages/90/24/48cd98388e4ac2c08d0800af36d15413db15e20387f1038123a2c86cb2f6/pydantic_core-2.50.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93ba4e9d8210d941c200431a56b2c0400b131865947903937ed3ec5404307d2e", size = 2160157, upload-time = "2026-10-11T18:32:29.553Z" }, + { url = "https://files.pythonhosted.org/packages/00/86/d909133d0b9979ed14c20f110f21124a0e346caf071bd66ac5af3009062b/pydantic_core-2.50.1-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:e5faeaee74a57d32b3ab3aebad2e348f06d3ba946fc5d28c1728455f00a3d13a", size = 2229523, upload-time = "2026-10-11T18:32:31.027Z" }, + { url = "https://files.pythonhosted.org/packages/90/31/4b43f08131b2098e73a852fd932063385f3103b33839fd9d1abdb89e673d/pydantic_core-2.50.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a3cda0e538208e5d722bbf3698b24f19c0a7d05bc8d5f8a7f9b121ea7fa243d9", size = 2242700, upload-time = "2026-10-11T18:32:32.622Z" }, + { url = "https://files.pythonhosted.org/packages/88/77/de39658569dc7a4c293d110a89629f61145e7538f00d1e4280c28debefd3/pydantic_core-2.50.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:57f51b31ff826e2859120cf4737c5a758a48d96f3e97da40ccee1796d58078ff", size = 2278452, upload-time = "2026-10-11T18:32:34.165Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/1eeb9e4e791e81210ef9096f58080b32ba15b5b13c108d50aaa3f8ce9f73/pydantic_core-2.50.1-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:8daa7ee75245d43ad7d747e5c9ecc1b1d06552f72b14887e9276f787d57375f4", size = 2450098, upload-time = "2026-10-11T18:32:35.547Z" }, + { url = "https://files.pythonhosted.org/packages/1c/e6/b2accfdff17e5a88d6358536702146de00f9339adaa4d5bbe1ee93cb4832/pydantic_core-2.50.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:acbf31f37c53a5ac0c34706c80b4f5107ba20b05fdd3816124bf236ef0c57dd2", size = 2476839, upload-time = "2026-10-11T18:32:37.119Z" }, + { url = "https://files.pythonhosted.org/packages/3b/7e/c8a83eb5d2cd42c2e13507150fb777b1edea5a018adc9cbf2858a1d08285/pydantic_core-2.50.1-cp312-cp312-win32.whl", hash = "sha256:45b11cac094aa25725581d9304eee93c9028516b9ea80dd9e175e13a5a2c840e", size = 2101425, upload-time = "2026-10-11T18:32:38.593Z" }, + { url = "https://files.pythonhosted.org/packages/c5/17/8bbd530b8659e9d963f5b16f6cb8e159f4cd174b4d6304e48969ab12dba8/pydantic_core-2.50.1-cp312-cp312-win_amd64.whl", hash = "sha256:132529c83901437ff642f585216831bf5fd7a91df66829907e155192ead62498", size = 2172522, upload-time = "2026-10-11T18:32:40.112Z" }, + { url = "https://files.pythonhosted.org/packages/af/9f/a79d690b127e4e3cff143d031538ab9aa715f6b2fbeecbd07cd6f2bf9fb7/pydantic_core-2.50.1-cp312-cp312-win_arm64.whl", hash = "sha256:4e834f6a8e4ff772dcc34f58ef5504147a3ea5b0f4eeb13b0f8eb2ca75ac57f1", size = 2161366, upload-time = "2026-10-11T18:32:41.606Z" }, + { url = "https://files.pythonhosted.org/packages/ae/57/0e237d7091d2cd44a35d243b7344227f90440166860469cd036afc23a04d/pydantic_core-2.50.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:d5e062c01286d861fd6a1c4ff6e063547b3e713067f2df033c0ff97ac2ca006b", size = 2222774, upload-time = "2026-10-11T18:32:43.103Z" }, + { url = "https://files.pythonhosted.org/packages/f7/b9/c720e56858d4e1539503297ed37063e0c08e0f3541c41b777f6a800f75fa/pydantic_core-2.50.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0c003c3b7f49debb893d2d85ae099ac5959c9839e2f330fadb1fcdf7a6594482", size = 2024738, upload-time = "2026-10-11T18:32:44.587Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b8/fbfc25875219cc060e613170ff10e850c6d8924beb4910da57c2ee3ba1d2/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:409e0ea40ec30d9158f33574fd758e689f6045a0f2596701828c27816ca9687d", size = 2047049, upload-time = "2026-10-11T18:32:46.164Z" }, + { url = "https://files.pythonhosted.org/packages/d7/43/34210124d504c553688f2f04b48500b131237528ac545b445e0d6d30e0d5/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:131059670f1d2444269b8585cb888963994871932447c08b39ac6a51fcfef658", size = 2173415, upload-time = "2026-10-11T18:32:47.722Z" }, + { url = "https://files.pythonhosted.org/packages/65/cf/6e178e8fdc11da5965bef980983bf46326a42f436871dd51ba0a57f39df1/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6dbcbee53bf17196a7f745aa9bf5a9603953a1e365b1f020be3207c676a3e7c4", size = 2361719, upload-time = "2026-10-11T18:32:49.217Z" }, + { url = "https://files.pythonhosted.org/packages/11/14/bd5169d356aa91bf777e28ba0b281c192d286d03c2812c9c9db023a2f00e/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:325c23f3e35cfbf0fe3486fa5f7260d1e45885173002d30a28ca019994124255", size = 2439803, upload-time = "2026-10-11T18:32:51.025Z" }, + { url = "https://files.pythonhosted.org/packages/1c/bc/d79d000e5203ebef39af839f2ce77a777fcad6e08ad26af9a2fcd114ffc8/pydantic_core-2.50.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:17e722e156d0444ecaefbe640bdb60928752bf2013e2b7a11cdb099aaae19bec", size = 2158402, upload-time = "2026-10-11T18:32:52.714Z" }, + { url = "https://files.pythonhosted.org/packages/1b/a5/4902cb5fd599422c130bd3124ab31ee8b771199bd56662702eed07d3fec7/pydantic_core-2.50.1-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:aa8224f10880d9bf1b5993988ba153d42a8b4f3f4f511f93b1f09c93ff613c72", size = 2229755, upload-time = "2026-10-11T18:32:54.126Z" }, + { url = "https://files.pythonhosted.org/packages/1a/f5/c1481f8669f6060d89110c9b1374173fc8767ca276b84f4870bd8acd5e3f/pydantic_core-2.50.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:41bc8237121bd8dc8d888dfd6279fc166ffc88c1f1bf3a8bf00869680533ca4c", size = 2242303, upload-time = "2026-10-11T18:32:55.641Z" }, + { url = "https://files.pythonhosted.org/packages/04/f9/77fc3c7653ba9b6e42049e17e96b25388187d4a7c274ab1cb07f58ac8419/pydantic_core-2.50.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:45c6266d071c241f2a168d45bf8c54344f0effce35e7e6b73afdec11f3687568", size = 2278345, upload-time = "2026-10-11T18:32:57.38Z" }, + { url = "https://files.pythonhosted.org/packages/95/9b/0579c5d12e7f2b16b27e6782427987341fcce07b0725e02ddb0b74add0c4/pydantic_core-2.50.1-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:1deeacb112d14d3f4fcb16b165f7dbaf76c70ba6e82f37ba042bdab51970a0b8", size = 2449947, upload-time = "2026-10-11T18:32:58.896Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ac/1b677db91eba54cc5922f4de6edc46ba45c2bd712dfdc0130382d158e214/pydantic_core-2.50.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:1c96fd793b73d1b92e65570132505498fe7b21eaef73cdf74e67e5dfba7ac9e4", size = 2476889, upload-time = "2026-10-11T18:33:00.665Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2a/3a9f6624ee3ea9ccba5249dde11418bb4c35780a7a92608f8768bd3fea39/pydantic_core-2.50.1-cp313-cp313-win32.whl", hash = "sha256:06ead20d39ffd6f2f6f2a8f8a6de67ff8bb1b4f14a8a30e058502514ee2ac685", size = 2101118, upload-time = "2026-10-11T18:33:02.329Z" }, + { url = "https://files.pythonhosted.org/packages/2d/1f/323f78ddd9d9938aac420c1abb4e8ba799fc8bdab0acc67c0593b837c979/pydantic_core-2.50.1-cp313-cp313-win_amd64.whl", hash = "sha256:7816e98acc08119dc0f340ab167048ecc54126316330c1f0caf7c6756c88e28f", size = 2170840, upload-time = "2026-10-11T18:33:03.919Z" }, + { url = "https://files.pythonhosted.org/packages/cb/09/8497c52a739ae425c3ac2f7f56414cbc711c67d374346174f40fe2062644/pydantic_core-2.50.1-cp313-cp313-win_arm64.whl", hash = "sha256:c17799a62c142d61b8a3c51752a7cbc87fe2ad4ccfab10e628a77b405075c662", size = 2161633, upload-time = "2026-10-11T18:33:05.518Z" }, + { url = "https://files.pythonhosted.org/packages/49/33/28b96e81677153715e3eafb9f26663a80841e859fde282a380359b0d3fa1/pydantic_core-2.50.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:1cf41f1ae3fa155cf167a72689ad044bcc1e3c97e064123677149bdfb5dafc4a", size = 2224428, upload-time = "2026-10-11T18:33:07.153Z" }, + { url = "https://files.pythonhosted.org/packages/94/40/15c06410c9b7b8da5805d27b64e09bd3f900e986728106db2689dbc51513/pydantic_core-2.50.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4df197990c15b5a37c5a277d131d9f2c67de6133f2e5dafd80d9bba4b99f46f9", size = 2023740, upload-time = "2026-10-11T18:33:08.763Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4e/5eb629f6efc2a27e421d789dd4bfacbb5f6d09c80c28b13d1e87d73163d5/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0036473f5583e6a60e50b8b21651511564277a3f05cc5dab8cf579f552cd5f6c", size = 2049435, upload-time = "2026-10-11T18:33:10.366Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8e/f195aebec49ad12318876ac2368c197a7939f5d52f8e156d2238ef8a4588/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:992c3514ec891fa7858099183e4d64e6bd5a5d4ff452fae29df22faa77a006bb", size = 2172975, upload-time = "2026-10-11T18:33:12.368Z" }, + { url = "https://files.pythonhosted.org/packages/e0/f5/7ad9fb83010cd5ea0948409db105676ed779c4e709e2d3d89b9fe2558794/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:739dc730e6be3bd5ec2f4ab5cfc7eb047cc45fc1497b3bafec74ff2ed07df597", size = 2364197, upload-time = "2026-10-11T18:33:14.244Z" }, + { url = "https://files.pythonhosted.org/packages/ca/fb/bf0aab3e78301d202b82a0322ec968cd703b11fc0623fde9a28708936f62/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:32fad3a91e51b6d2039c572db04a5a873260b399f6bd62c3552671fa7a4a2899", size = 2444259, upload-time = "2026-10-11T18:33:15.79Z" }, + { url = "https://files.pythonhosted.org/packages/45/35/38f6d6564fae57d9b12e5676dfa947e0e7d5c46dbeaa7eb3352261d6d299/pydantic_core-2.50.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42b54c2c90ad348b5e3a85e03e715d572c1fde357ef104cdfe3b03b697a404ea", size = 2159857, upload-time = "2026-10-11T18:33:17.51Z" }, + { url = "https://files.pythonhosted.org/packages/65/a0/fb0a3ca10f139dcf765b2d312d10cf0f65c57c59993229d00ad12b14ceff/pydantic_core-2.50.1-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:2df1ff41884de2bc4b307bafd7c40a691094fad2ff8e767e5b45a319257bcf4e", size = 2233954, upload-time = "2026-10-11T18:33:19.591Z" }, + { url = "https://files.pythonhosted.org/packages/8c/6a/e63842252702aa4ec6e6b7178ca85e541a77459076592c23ebe2d9840b33/pydantic_core-2.50.1-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe90228920fd8ff2be62622b6bb8a2b11acd65046d50c6b130614b5879605a20", size = 2243876, upload-time = "2026-10-11T18:33:21.393Z" }, + { url = "https://files.pythonhosted.org/packages/39/25/5991cf8318b37e0dfab47b87541619a1df8501a793cba0d978846cba37a7/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:844b869f118e22a41a091bdcedda8a71bc1b0f62c38d1a0c3211cece47e1d8fc", size = 2277908, upload-time = "2026-10-11T18:33:23.324Z" }, + { url = "https://files.pythonhosted.org/packages/a7/3e/3ee8baaa6cc25a6961c69168cf9ff0f002d56f4e0d541ad6724c18fb61f3/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:2eb75304506894a281d346220a4f7481a1b8729577c5ed2a05395991966a8396", size = 2449285, upload-time = "2026-10-11T18:33:24.942Z" }, + { url = "https://files.pythonhosted.org/packages/c0/c7/acbec6deac13fe697a80c275a9b6661db62c4d323bac8a47347b1f39c7cd/pydantic_core-2.50.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6b20a4bffabdad0db2927ac034ae3b8a681b1f7a0182f3e60b479ad2fde21ebb", size = 2479013, upload-time = "2026-10-11T18:33:26.925Z" }, + { url = "https://files.pythonhosted.org/packages/10/08/21a3f237b264389f6219d053ee78fc1b5c2fd402c1b1cb2b6cb8b85f9834/pydantic_core-2.50.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:99ba9bc2b8062ea0c326a990f7f00e6530c23579de66dd246e72c4cafef950a5", size = 1484400, upload-time = "2026-10-11T18:33:28.693Z" }, + { url = "https://files.pythonhosted.org/packages/09/ce/077a6d262d12ef09108377ac0717f029f420d773ace63cafd6143af75568/pydantic_core-2.50.1-cp314-cp314-win32.whl", hash = "sha256:cf356f70551d40374eaffb1aa63f1eb6d2006681cbd7a9faea173ce0f4dd7cd2", size = 2103222, upload-time = "2026-10-11T18:33:30.326Z" }, + { url = "https://files.pythonhosted.org/packages/14/4c/350a2415209c43d670eb71d3c040f332c04a30583d39e311b05c7ac15762/pydantic_core-2.50.1-cp314-cp314-win_amd64.whl", hash = "sha256:d32f3acc081cc3923386d88f422cde8892335e95f034e0104bb4cf9310d9915f", size = 2171586, upload-time = "2026-10-11T18:33:32.139Z" }, + { url = "https://files.pythonhosted.org/packages/bf/92/9bea6ca96580a0902fed366f064f0829e404f41889b34543279a1162b888/pydantic_core-2.50.1-cp314-cp314-win_arm64.whl", hash = "sha256:bed5163e03b98bc1fa2eb05d74c63d9c5c95d8ed6254985481640fbf5e237dea", size = 2155773, upload-time = "2026-10-11T18:33:33.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/8c/f121f073cf32bdd5cba7e6230b1ce0ac845b0cf43e44dd597d95af272db2/pydantic_core-2.50.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:9572c1369e9c9da2d64a7b7992c786d90ff295abc93964cfe3125e4290768070", size = 2234017, upload-time = "2026-10-11T18:33:35.588Z" }, + { url = "https://files.pythonhosted.org/packages/a4/69/2bb2bcd6146cffe98d760a46c42ae71efd5151d9b2f9c9bf6619a3b32083/pydantic_core-2.50.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2005207aafe1231315718bf6ed5d064a7300fb4772754af35ee72fc68159492e", size = 2001016, upload-time = "2026-10-11T18:33:37.57Z" }, + { url = "https://files.pythonhosted.org/packages/20/b3/fbf854c7d07ec114260c26e9e2071a4381740f9ae09641dbfcbdf2a18c45/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:64f6047f62a6c5ae08d0a6afb035667aa2d97c3d20d69762e034c5ea144d92a5", size = 2023015, upload-time = "2026-10-11T18:33:39.433Z" }, + { url = "https://files.pythonhosted.org/packages/65/20/6de55b2f92cdb614b745c6e9ced639fc4fd7e1e77604825a88bdece6fcbd/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1ef800dd7d85bcdadf4c3076e4c94e43939493558a3b69a1ea830c706d4617bb", size = 2192543, upload-time = "2026-10-11T18:33:41.381Z" }, + { url = "https://files.pythonhosted.org/packages/0c/d9/19e91c94bd5c405945ce2f15526808aea37e162c253160de8ed7bf70b406/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b0135bcdcaa0f23573f286e4cb5e0fd2962700964ed13df085b85f2b97aeab9e", size = 2388704, upload-time = "2026-10-11T18:33:43.167Z" }, + { url = "https://files.pythonhosted.org/packages/b6/bc/2e24c8415eae1a25ee5a5484946a917123bad2e9d01689a759236928175a/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0b3a6f334c6a2345ca15318ff894502a90012536404b37c844a976c76c846e0b", size = 2464118, upload-time = "2026-10-11T18:33:44.856Z" }, + { url = "https://files.pythonhosted.org/packages/bd/1f/945b8053cb061c64e102bcaf7bfb9ed740c0bd4349f9bb978a7d4ddff4ab/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06e01fbbfdb9be777b316a71b6c49efaf4a08b615d0a98d678cda3023f79d019", size = 2150142, upload-time = "2026-10-11T18:33:46.661Z" }, + { url = "https://files.pythonhosted.org/packages/2b/78/96a3e50bf0d64aaae781107eb9335b7529d05a85793ed6e7241c4cd1d931/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:a29a061fec0b4e2d714f277e70a3a18125ecff803f2fea6eade2f2e53711d112", size = 2245577, upload-time = "2026-10-11T18:33:48.574Z" }, + { url = "https://files.pythonhosted.org/packages/7a/5d/a6038a0322232758a6ebfa709f4ca14a60bf5b93940cd0b345056a557da4/pydantic_core-2.50.1-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f5187624823423e1d1b82b1072ac41dc837389e18d3d0572cc19bbee46cd550a", size = 2263728, upload-time = "2026-10-11T18:33:50.527Z" }, + { url = "https://files.pythonhosted.org/packages/0d/4b/76ded3333a457a9344c4f2d63f2d82d0101654b05178fa4ddfe7d3627674/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3e46a9eb0a0901dd6275e6b06ac3a464885ef350ec4121fe486869de8053e4bb", size = 2293630, upload-time = "2026-10-11T18:33:52.362Z" }, + { url = "https://files.pythonhosted.org/packages/a9/00/9eca378335c9c1b72bc779bf6e4c2a82ce784f14ec48a0e87102c9870e05/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:756d669f04e62ec4148ecfe22be6a4484d9b1181a6ef32e205ebfd200540858b", size = 2468048, upload-time = "2026-10-11T18:33:54.118Z" }, + { url = "https://files.pythonhosted.org/packages/35/ca/e3832e9cf93651251de43c8c5c029ed680a3c1a0a1b17ee26c81bed08cbd/pydantic_core-2.50.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:c516cc5367ca3448995d42cb994bf3f4c9002d2a7c22eac9622551269ad1b807", size = 2512159, upload-time = "2026-10-11T18:33:55.99Z" }, + { url = "https://files.pythonhosted.org/packages/4b/f2/773469b5a10a39116a2cb17edaf6d722f017dd8da07161b371465311c542/pydantic_core-2.50.1-cp314-cp314t-win32.whl", hash = "sha256:9d1bed94af6a63835461f3cf7502058eb166c58c4778e11d0f433cfb1bd69e19", size = 2098406, upload-time = "2026-10-11T18:33:58.043Z" }, + { url = "https://files.pythonhosted.org/packages/ee/42/0bb74f8f25204b259b11ab7c12dc7f180893b6bd706118b385147fb6efd5/pydantic_core-2.50.1-cp314-cp314t-win_amd64.whl", hash = "sha256:c8dce1f1e0e5358b682a6ad3fa5e31b31d4560997b8e61417e9217c8d60f8a0c", size = 2148481, upload-time = "2026-10-11T18:33:59.913Z" }, + { url = "https://files.pythonhosted.org/packages/47/0d/d801646c9679a4e630e15cf521d4108b93854b42a6e6e02391bd4c6b1095/pydantic_core-2.50.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ceff0acc940be2715bd6ad17b24c0e5304abf44f6efd0f81ee8499e640f9dc86", size = 2174972, upload-time = "2026-10-11T18:34:01.875Z" }, + { url = "https://files.pythonhosted.org/packages/b2/84/23984b763d8862a02a13d27a44b6e8169428fd85ecfed88f54c29108604d/pydantic_core-2.50.1-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:8a6791afa2245e6c6b180122d105941644f5bd410bb18623b408808cc41a3102", size = 2224599, upload-time = "2026-10-11T18:34:04.016Z" }, + { url = "https://files.pythonhosted.org/packages/4d/90/a63cf8586abc1d1a3f6d9b18f0224789ebf003851f092ebda3c7c863fd32/pydantic_core-2.50.1-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:84f34323a61a365b4e9295de6028474754829aaddd59c7bf1a040e7487ef8f3c", size = 2024191, upload-time = "2026-10-11T18:34:05.901Z" }, + { url = "https://files.pythonhosted.org/packages/a6/6a/f34bff9808ffb4907fbf5f5040457d253cacf2da7fce9efbc99ca1b1a44d/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:23edad659e8dbd8ca7e4e877fe6c81573abbdf215bd25a68b53e1272f58b80c7", size = 2048252, upload-time = "2026-10-11T18:34:07.757Z" }, + { url = "https://files.pythonhosted.org/packages/b2/54/13f419bf1eb59852003818e25935aaf175687d978f4c4bca70e08fe40a3b/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a5fce22f1e87d181e924e12da7d81cfe031fb3881a5ddf26ad28f141756ca43", size = 2173376, upload-time = "2026-10-11T18:34:09.592Z" }, + { url = "https://files.pythonhosted.org/packages/6d/6c/b5a34d24cd0c81669d8f8339d74e6815abcf2f8fb48ab4b49b84c09be1d5/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c73622ef819328873b53109ee4f77ceb598bffedd02daf916102be3228866b78", size = 2364559, upload-time = "2026-10-11T18:34:11.534Z" }, + { url = "https://files.pythonhosted.org/packages/eb/8d/d64d6216a8df365082665927ff923f183056f9049fee08e9777c9ac05296/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ce8c25ca38cc0e3d7753ba180808de2c0c8cb24eae0df64491e40921454e9831", size = 2444697, upload-time = "2026-10-11T18:34:13.535Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0d/1b1149f60a00ea21ba5f70e28acbd40feb4598af414f80f53c921fac07c9/pydantic_core-2.50.1-cp315-cp315-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7689580e72a642ab5ec64d5f55b2e33636fa43b4ebe63c0c2c965ef307c7d1aa", size = 2159961, upload-time = "2026-10-11T18:34:15.56Z" }, + { url = "https://files.pythonhosted.org/packages/1e/35/f236549299dcc78e71e945495d7ec67e78d20844d0999c60601685003031/pydantic_core-2.50.1-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:d5c0e32fdbce7f1e8ef4d11f655694bf5f4175c757a9f1dc2be09b8864e5bcf5", size = 2234581, upload-time = "2026-10-11T18:34:17.502Z" }, + { url = "https://files.pythonhosted.org/packages/6a/85/26901a490522b7f75ef9bb9a7afb73e5bb550f0e1cb5b99a0069183e2eb9/pydantic_core-2.50.1-cp315-cp315-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:40f523349960fa30f3ea51404308ff50f9997a90df639590f47a057c1f32b415", size = 2244090, upload-time = "2026-10-11T18:34:19.402Z" }, + { url = "https://files.pythonhosted.org/packages/ca/2c/481bcfc70ceeb77a778ca6e5b705fe592cb64735c108157f81b7dd9c280e/pydantic_core-2.50.1-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:d4193206b6587047437f6f11d7e776df23e1c1e23af2a54d9347275614791e10", size = 2277948, upload-time = "2026-10-11T18:34:21.317Z" }, + { url = "https://files.pythonhosted.org/packages/24/eb/f1e09333faa7ba447cde967310f758430cc7c5e987bdab5228816c70030d/pydantic_core-2.50.1-cp315-cp315-musllinux_1_1_armv7l.whl", hash = "sha256:84bc765b282a9d5b7fe0348b8648904f25a6a04b2139da52b1dd30c8ac3a2c8f", size = 2449688, upload-time = "2026-10-11T18:34:23.321Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b3/036bde636db8f76d92996e81aefc75678ab5cec4a07eea1ad0c72a893fc3/pydantic_core-2.50.1-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:ed1e728b39a383c81035b2459cfcb35d99dfb01f7d6ebe3a913bc1cc5b81e459", size = 2479286, upload-time = "2026-10-11T18:34:25.214Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a3/07f018294ee18d144afeb6df1a47d9e92960f014be45c5ed13519fa5af95/pydantic_core-2.50.1-cp315-cp315-win32.whl", hash = "sha256:bc94f474417604bd383d2cd445d071b07dd55fedceed3ce33407bf1fcc107290", size = 2103683, upload-time = "2026-10-11T18:34:27.42Z" }, + { url = "https://files.pythonhosted.org/packages/5f/98/f9bd7e1f9b6709f155acb9ef826d9c3884fe925f811fd8e55b9b52280bad/pydantic_core-2.50.1-cp315-cp315-win_amd64.whl", hash = "sha256:983a662de2571cb2502fc8ff47b6770b03d025d2eb314c92f77b3f07c74720ed", size = 2171681, upload-time = "2026-10-11T18:34:29.508Z" }, + { url = "https://files.pythonhosted.org/packages/10/87/4bb3e1e7f385c076ab5af4d6dd0571b22042cd8207eb810d5b9fef15ae31/pydantic_core-2.50.1-cp315-cp315-win_arm64.whl", hash = "sha256:94845ff54dc5193f228cab81b2662a04bfbb892e95bdc15edf7399000ce57d54", size = 2156251, upload-time = "2026-10-11T18:34:31.455Z" }, + { url = "https://files.pythonhosted.org/packages/47/47/83643225b08f2aef6c8cc4bbe6e3f79c5e139c4364a6e450d0f399d87774/pydantic_core-2.50.1-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:4a53d13cdfbedbfa87f08b83c1a0a5efcc767d785a4b41934fa9cb672670493a", size = 2234363, upload-time = "2026-10-11T18:34:33.65Z" }, + { url = "https://files.pythonhosted.org/packages/5e/66/127ca649ba2f2462039dc1e694c6c01e00a3689f023a617364d3507e6d97/pydantic_core-2.50.1-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:efbecf43d321f7b9281441f1f213f7c21c66988b0e06c2730ba13ed47a46bb08", size = 2000972, upload-time = "2026-10-11T18:34:36.037Z" }, + { url = "https://files.pythonhosted.org/packages/5e/4f/e421e0a5d653b1203b090b2e48745976988d7338a647940704b5b9c2b399/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bc1f08f68dac9f9e83845a8039880aba2ab553eb9b2259c3243a313182c253fe", size = 2022925, upload-time = "2026-10-11T18:34:37.972Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4e/ea5568e2491e1a71100f15ae8c2d01ef52db42a184a2d4e716bc79e5eb8f/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5dfe41f232befddb9c4377f6cfc702b51595e2d78ed082672adf8758d2c4619f", size = 2192867, upload-time = "2026-10-11T18:34:39.921Z" }, + { url = "https://files.pythonhosted.org/packages/ae/5e/3b8c3a35acbe219909ada5defad5d7d9fed845fb2b37bd5ec518f453c119/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:adc06d218a1cadfd2ec4628424d7d79ce4eba69c2965e7e7b55106f0da5208c8", size = 2388687, upload-time = "2026-10-11T18:34:42.184Z" }, + { url = "https://files.pythonhosted.org/packages/b6/aa/7889b4e515f91a2e8c0ae6b5081fec0feb30c4398d1434e14793c60f173a/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2cf91809d0721ab81592ba67bea7694821679c10b1a2e3c3460082b286c1918a", size = 2464415, upload-time = "2026-10-11T18:34:44.384Z" }, + { url = "https://files.pythonhosted.org/packages/08/78/93449e628eb8a6fdcce3eff9043081179d1bc7ce6f1bff32dc5006f41e00/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:23923ab9292c40da026330b1ecf4dc2618c8e86e0422e5d1fbf50d94d64ca4f8", size = 2150823, upload-time = "2026-10-11T18:34:46.392Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f1/72c5bc129fceb0d00f05dc1e67f518c1728de1928c55f81fc13d7690de39/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:f3377c8c2b3ce898423c5e5dd94c7982e30aa7717a7e6ab2470b9de364963709", size = 2245806, upload-time = "2026-10-11T18:34:48.805Z" }, + { url = "https://files.pythonhosted.org/packages/28/2a/922a0e78f3aa6ab837b59f88190233fb8dad546c17995fde9bb3ed3b9b49/pydantic_core-2.50.1-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:455a773617b5913bf5c20d0692e5787b119e52c4d40ea644ca31f5758fd31be2", size = 2264160, upload-time = "2026-10-11T18:34:50.876Z" }, + { url = "https://files.pythonhosted.org/packages/52/a8/0f1449e3e1b20941c9372faa18e7b6a092e30cdfa841902473f7989532ac/pydantic_core-2.50.1-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:1a9006395dece0e32e704c315eff8a00bede494f6108546cfc5539c89fef4f9a", size = 2294031, upload-time = "2026-10-11T18:34:52.876Z" }, + { url = "https://files.pythonhosted.org/packages/d1/d0/1031f492857de70355fb16524bbb03efce5fd34c93ed4a1ec60be07e0d4b/pydantic_core-2.50.1-cp315-cp315t-musllinux_1_1_armv7l.whl", hash = "sha256:d2d82aa62521c55ddfb000ae70f88cdd8de974078f6024e821dfe5addd0c818f", size = 2468423, upload-time = "2026-10-11T18:34:54.995Z" }, + { url = "https://files.pythonhosted.org/packages/46/52/269ffffa645b8e47906395a39cf9db1151ae9fa4bcd7f47b960bc31baf37/pydantic_core-2.50.1-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:009634b83993777ddcd69cad0ffcace43dabde692109528e35f0fde91e386a8b", size = 2512598, upload-time = "2026-10-11T18:34:57.149Z" }, + { url = "https://files.pythonhosted.org/packages/31/5c/e47e28281f20326ff6f3c31d626f0a83e615d2d94ba41bb0ad6ec237184a/pydantic_core-2.50.1-cp315-cp315t-win32.whl", hash = "sha256:3fde4fdc6487a58d944ca87cf5adc95d5f266e872c19599f5f4c0a8a1b1f9f9f", size = 2098535, upload-time = "2026-10-11T18:34:59.313Z" }, + { url = "https://files.pythonhosted.org/packages/03/ad/759e181e69c1b472c60b2049e5f61d5da1deefdd5ce1df4bb2ebcf771f25/pydantic_core-2.50.1-cp315-cp315t-win_amd64.whl", hash = "sha256:1c8632d4ac04e6f91128fca584b3a8a507d81604c24eeaaad00d4be42765c32b", size = 2148645, upload-time = "2026-10-11T18:35:01.571Z" }, + { url = "https://files.pythonhosted.org/packages/6d/56/8a702c27e5be9f47e5f19d8669227424290e4c024e7c370279cbaf244b4e/pydantic_core-2.50.1-cp315-cp315t-win_arm64.whl", hash = "sha256:c3ede305158e75510be50869b319550ab072008c13d64d4ab1e094fb286b6f44", size = 2175297, upload-time = "2026-10-11T18:35:04.079Z" }, + { url = "https://files.pythonhosted.org/packages/e7/73/a23a327237d9bb985298ce47702e196f995ce850224c12c70886bd66bb5c/pydantic_core-2.50.1-graalpy311-graalpy242_311_native-macosx_10_12_x86_64.whl", hash = "sha256:062e891facce5ca296a1c37098e5e466780457f86413894b399f0cf22934f769", size = 2162560, upload-time = "2026-10-11T18:35:06.274Z" }, + { url = "https://files.pythonhosted.org/packages/df/b2/33b37b5e82408f402a5e82649a43e7c95cd5dab7beaeef2c35cedbfd18f2/pydantic_core-2.50.1-graalpy311-graalpy242_311_native-macosx_11_0_arm64.whl", hash = "sha256:49c2cbb2397fe4d0987e84606e691af6cb87bc0ee1bd3e7b737f7e10b4c142f9", size = 2075250, upload-time = "2026-10-11T18:35:08.455Z" }, + { url = "https://files.pythonhosted.org/packages/04/62/c7d5b9249466ccab90f3ce4790c2399dbfb8172ae9e74a7753dd295fe65a/pydantic_core-2.50.1-graalpy311-graalpy242_311_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9e4472072de0137ee0d8e72d6620e85939c271d2f90f6bbb4b15c24638b79f92", size = 2107891, upload-time = "2026-10-11T18:35:10.918Z" }, + { url = "https://files.pythonhosted.org/packages/d4/7e/28d29bc1657195933147f772dee0558d9e0f045bbc11db7f992f40c37bb5/pydantic_core-2.50.1-graalpy311-graalpy242_311_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ed4f3cef55164b026fefb41341b7754cc6b624c75dfe7142d2ecceb5ad21c87", size = 2268026, upload-time = "2026-10-11T18:35:13.336Z" }, + { url = "https://files.pythonhosted.org/packages/a5/09/1bcf160f3cd6333e2a76982fae5963e5032de0bcaaba38464223dc266bfe/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:76e2e83fa6ec8cdc972d438dafc2522b3a47bee4ec0ae668b29cfb1977ab5242", size = 2217070, upload-time = "2026-10-11T18:35:15.688Z" }, + { url = "https://files.pythonhosted.org/packages/3d/81/f02de95eec7794dfc7a5bc69a834f0e834b31b3009014ce6de903855f775/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:a51eee75939cf811ac09b278745a6cee7dc873ccfbc8b9af3cc88fe4b7ce25b5", size = 2039027, upload-time = "2026-10-11T18:35:18.07Z" }, + { url = "https://files.pythonhosted.org/packages/4d/16/227746ed3771d9bf2304568b55134849ece34e13b38b1d76de763015c77f/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae28183297fb0d2b8dc46a1f01d51f5e45825fc5afe76a835a6cb7fb34821295", size = 2109009, upload-time = "2026-10-11T18:35:20.218Z" }, + { url = "https://files.pythonhosted.org/packages/e5/b9/7664d1592a0e5a74903f357cd5b28ceb7336f3473256c5a4e8c8432f1881/pydantic_core-2.50.1-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88e492e8b9d0312e7dc13667c30222abf284dc3b79b5302b3607b41a5784ce61", size = 2269883, upload-time = "2026-10-11T18:35:22.48Z" }, + { url = "https://files.pythonhosted.org/packages/bd/35/002a378302ff91d2a7f149bc8d22363faf581ba40ac39d0123444315a32d/pydantic_core-2.50.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:7456d699b13954e9c0164dcb267250a10ae0dfb03e6e26d6796ab0d46e189c84", size = 2154076, upload-time = "2026-10-11T18:35:24.743Z" }, + { url = "https://files.pythonhosted.org/packages/4b/5c/7a034330082c00f3c9795052bd9b161aaaf6e1951e897ac00a094823ef7e/pydantic_core-2.50.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:b0d955195bbbe489ad343fcc956eacea9357b79cb22192c66cacdefcbc14b32f", size = 2085850, upload-time = "2026-10-11T18:35:27.009Z" }, + { url = "https://files.pythonhosted.org/packages/57/fa/d5b44a7d3d4eceed6ef8713a0003af56fefde6ec75915513bcdd5d730cd9/pydantic_core-2.50.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f2c634642694e6a0dad2ab1d375589fa671fd442edd5caf7d9737b8f6ca22906", size = 2259754, upload-time = "2026-10-11T18:35:29.763Z" }, + { url = "https://files.pythonhosted.org/packages/b6/88/e01dd37301710bd8b3b2daf34ec9e2a6e83a333130831c0d468b0292a48c/pydantic_core-2.50.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ee6db2fbed51a7991302e8fac498cd67e336246026d0dfa84cf5166ce1412760", size = 2268712, upload-time = "2026-10-11T18:35:32.654Z" }, + { url = "https://files.pythonhosted.org/packages/3e/43/5bb80d4a4d2b2d84612a30205662cc521a20d209c94abc079ea48b4e0df2/pydantic_core-2.50.1-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:79490e33c4c0fcb933bbbcfc3a62184d8803b99f535863dfbb925e1bcb6945ad", size = 2305049, upload-time = "2026-10-11T18:35:35.392Z" }, + { url = "https://files.pythonhosted.org/packages/e8/7b/e3ef76b269cfe4a5bd3bdcf5d7124cf05e5a8909d443b91639307116bdae/pydantic_core-2.50.1-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:48569b0ade9edfbe065cad1d700175546592aebbb42f02adcebcc26e75b896fe", size = 2466001, upload-time = "2026-10-11T18:35:37.791Z" }, + { url = "https://files.pythonhosted.org/packages/8f/7a/ea0947aadc1d9f72d4be00d2e19939611ec17363bcb5e6eb9ec7d8221c34/pydantic_core-2.50.1-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:5f3cae32fc46121f787cb2486de9cf95a8bf72aec5cc78f64c606fa1735a6ef5", size = 2481777, upload-time = "2026-10-11T18:35:40.287Z" }, + { url = "https://files.pythonhosted.org/packages/24/f3/d15bc0b1fb0c4f1e07b3326ffb7489f7ae70da2b56a0884d22641b0eb47c/pydantic_core-2.50.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:7f476456ac2bb0d937f75191494a09c83a30765fea4f70f3b404942fe25f6cdf", size = 2336787, upload-time = "2026-10-11T18:35:42.558Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pynput" +version = "1.8.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "evdev", version = "1.9.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' and 'linux' in sys_platform" }, + { name = "evdev", version = "2.0.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and 'linux' in sys_platform" }, + { name = "pyobjc-framework-applicationservices", marker = "sys_platform == 'darwin'" }, + { name = "pyobjc-framework-quartz", marker = "sys_platform == 'darwin'" }, + { name = "python-xlib", marker = "'linux' in sys_platform" }, + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/c6/e2d415610cfbc78308bee44218a46124aaa3301b1df08814df819b2254a1/pynput-1.8.2.tar.gz", hash = "sha256:f493c87157cd3861b4468f7f896857051762f44ed26f1b641e7cc5840a457087", size = 82818, upload-time = "2026-05-12T19:11:39.464Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/98/bbeb760852adb27f166ce1617f0e51aabb15f21b1e60ea703f2aed3c78ac/pynput-1.8.2-py2.py3-none-any.whl", hash = "sha256:8cc38cf13a6ab2749cb375678be8a0fd705d7ce49c8001ff5db4007a723bbef1", size = 92028, upload-time = "2026-05-12T19:11:37.89Z" }, +] + +[[package]] +name = "pyobjc-core" +version = "12.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a5/78/abc4ce5920305780aeb36b4067a86253378b36e29ba96673a3deb02eb03a/pyobjc_core-12.2.2.tar.gz", hash = "sha256:3906452339cd06a3bb07df103c2511d4cb0f7a22d8771c0b802eba15d9a642b6", size = 1067701, upload-time = "2026-08-11T19:43:39.059Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/1d/baf7197cee12f32a8eb9f8633093da1ec1ea702b0e1346bc1c7bfe022673/pyobjc_core-12.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:56c6c39f1de059fcbb174ebca5525505fc8feaa89be2a28c329bf09b6b25ee75", size = 6483051, upload-time = "2026-08-11T13:55:45.262Z" }, + { url = "https://files.pythonhosted.org/packages/ce/8e/18284fec7913ef78b25a1c97f9689ebef98bc14038386191491516abeb25/pyobjc_core-12.2.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:b9cdd686e32db8e451feb19f8a85bc4cd52c2893103881d04aca51e1f35371d1", size = 6481574, upload-time = "2026-08-11T14:13:27.153Z" }, + { url = "https://files.pythonhosted.org/packages/86/b2/bbf7f049880ab40d110e66f25122342a1f6c98d6fe3c59bb98985503c660/pyobjc_core-12.2.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:122e6ad302a2abf5d4d4adb0156db751600ddf2768441696cba17b31323085e7", size = 6427637, upload-time = "2026-08-11T14:51:36.038Z" }, + { url = "https://files.pythonhosted.org/packages/1b/ed/a8bf040caf3704023d74086b7fb96cf4ed2e844e24bd94e5248ba214b700/pyobjc_core-12.2.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:950bd2d9c74634398c4e3d24ef2f213d4e23d705083697464fa67afedc53c1ad", size = 6427113, upload-time = "2026-08-11T15:04:39.424Z" }, + { url = "https://files.pythonhosted.org/packages/e7/5a/760f8b9e116edd43c57e33844dc17619158fbdd311250d4209910192d72d/pyobjc_core-12.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3772b406edb3ff78171530a17cda1c4a7817f87b87ded0d8715b3fa664df16db", size = 6666817, upload-time = "2026-08-11T19:30:17.01Z" }, + { url = "https://files.pythonhosted.org/packages/13/37/486d38a173b0b8dce973a3e13c74cf402ed1b8621586b5963bc9efd49a48/pyobjc_core-12.2.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:2062e8ad30a310441cd022544a897553408bebeaa7820d5edba3c96fd7fd693b", size = 6421184, upload-time = "2026-08-11T19:30:21.081Z" }, + { url = "https://files.pythonhosted.org/packages/04/f1/d138fd9b9a66ea8db56a8138b77d3413b85da3defe13363a19f364f85529/pyobjc_core-12.2.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:2c7ef3d2f865b4b3ebb14ec3556f7a3e8abb6d130c67275cd9daa08dbd6e4e4e", size = 6671824, upload-time = "2026-08-11T19:30:25.005Z" }, + { url = "https://files.pythonhosted.org/packages/d5/85/577e2265cccf59daf48c460f0a8deeaf7dbe2991227a8859ab1eeab4945e/pyobjc_core-12.2.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:89acc6bc13aaa6e3f52b0ce652ede7e201edb6bf062741b246b0c5a44582f25f", size = 6477694, upload-time = "2026-08-11T19:30:28.821Z" }, + { url = "https://files.pythonhosted.org/packages/77/0a/bd9f830c64c6f334530831e75c01bfe0a770a3fbb00fddc70329223118b3/pyobjc_core-12.2.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:59a77038ebe0ab1240f61c341e7fb67b8674f2b4cd41bc71a6472511a12b50f7", size = 6712233, upload-time = "2026-08-11T19:30:33.032Z" }, +] + +[[package]] +name = "pyobjc-framework-applicationservices" +version = "12.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyobjc-core" }, + { name = "pyobjc-framework-cocoa" }, + { name = "pyobjc-framework-coretext" }, + { name = "pyobjc-framework-quartz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/29/40/b792ecc88a9fa639318509c127f0b153cd334bd27b47df373f4b7362a36d/pyobjc_framework_applicationservices-12.2.2.tar.gz", hash = "sha256:0bcc09531d5854598fd74706d999e4ae3b7c503204d318910d02eba30e8eecef", size = 109668, upload-time = "2026-08-11T19:43:45.347Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/85/ef/5a105ab3388a286982b41f15adfce27fff5a2b1e11a3c29143817e99809c/pyobjc_framework_applicationservices-12.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:e525167b28560d1cbadadcaee4bcdd20c999f6af3e489cc63bacde4ed1a6b549", size = 32709, upload-time = "2026-08-11T19:30:54.864Z" }, + { url = "https://files.pythonhosted.org/packages/76/84/50b6ef800cb7d2c4e0e081dbc536023bbf71010894b5a724aff2ee2b756c/pyobjc_framework_applicationservices-12.2.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:82275ea56be975ee84fafdb340dcfee6b5289422c3f674c1982d3fcd47ba68c9", size = 32703, upload-time = "2026-08-11T19:30:55.803Z" }, + { url = "https://files.pythonhosted.org/packages/00/ed/9d85751400f1cd23d71c824a57352ec4d216a8728255dc00c032c431d3ad/pyobjc_framework_applicationservices-12.2.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:5506bd6b5268a97fcb79b5b021f6cbbaaf5cdff3ec87094d8870268d8cf096ed", size = 32765, upload-time = "2026-08-11T19:30:56.696Z" }, + { url = "https://files.pythonhosted.org/packages/b1/9d/fe660a822cc66a4261227b1597855c802b04dee56e5c8c153b9d5e6bcf0d/pyobjc_framework_applicationservices-12.2.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3b5693a377480cf127caa1c8c835b8620896971029c545d99d01aa31a2c38159", size = 32787, upload-time = "2026-08-11T19:30:57.52Z" }, + { url = "https://files.pythonhosted.org/packages/18/8c/deec4cdf8bc7b21bc2fb9e0e25e3cf99acb645d46207e8e6298a70b7f310/pyobjc_framework_applicationservices-12.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:93ba63aad6607f369c1b38bf91306731da6306fdde5eb67afa407b3f8a87dda7", size = 33043, upload-time = "2026-08-11T19:30:58.669Z" }, + { url = "https://files.pythonhosted.org/packages/f8/cb/44f11b0c2c9fde80eff62e761ac006735811acadac007ffd5d33a97d7530/pyobjc_framework_applicationservices-12.2.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:1af01a271b85eae2a327e93cf3ec46de0199a1a933594f78d4c2b9b9c2240e5e", size = 32921, upload-time = "2026-08-11T19:30:59.608Z" }, + { url = "https://files.pythonhosted.org/packages/ec/05/e3935a3d49c9e289c7229a49ea96757a54bab075dd8b41b3f28f60e1415f/pyobjc_framework_applicationservices-12.2.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:4188a79f2774778dd5f2bcfb49b856d08dd824862f072924be40274b5a5cad95", size = 33160, upload-time = "2026-08-11T19:31:00.759Z" }, + { url = "https://files.pythonhosted.org/packages/1e/9e/23ff404a3ae067746465bcf162b12b8c892ae25a66c72231c702ae1e874e/pyobjc_framework_applicationservices-12.2.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:fc861e14f78e7370e982202b21db8bcb562dc14cd4098e557a17961d3411de45", size = 32912, upload-time = "2026-08-11T19:31:01.612Z" }, + { url = "https://files.pythonhosted.org/packages/78/f6/e68ae3cc13ff08b5e8aaef754f884fb4afb394dbc17ebb3858e65e9d095e/pyobjc_framework_applicationservices-12.2.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:3f9dde6d8e8fb8ebd79ac6e84212c1d294eba48fa2d4c467a29614c3ca5ef2f8", size = 33155, upload-time = "2026-08-11T19:31:02.579Z" }, +] + +[[package]] +name = "pyobjc-framework-cocoa" +version = "12.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyobjc-core" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/75/76/49c6da2c6a831020b4854ba20079d5a1030474bffc776b7b73c2eeff8c15/pyobjc_framework_cocoa-12.2.2.tar.gz", hash = "sha256:c96c0ef69a71afbbb0e6a7d594b455c5fe47d62e0db376ee7a2b4b828c16ace9", size = 3132831, upload-time = "2026-08-11T19:44:02.288Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e1/dd/aba439652cae293a736680ef5ed5cc29419adbbac1c6d4555b910741d516/pyobjc_framework_cocoa-12.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5a751c8033a3b51f7996f0327e0675eb44dcfdfe7920fae01e3d78b662723fff", size = 387296, upload-time = "2026-08-11T19:32:40.684Z" }, + { url = "https://files.pythonhosted.org/packages/f6/a7/370f12143661dff66f2c68a735938afab6530aa3b153f6a7a6f12b5eabab/pyobjc_framework_cocoa-12.2.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:851dca4c16e70b405e5cd5a8c166cf7c445ae54a4cdd95ce9a523803172f32d1", size = 387300, upload-time = "2026-08-11T19:32:42.043Z" }, + { url = "https://files.pythonhosted.org/packages/fd/2f/b67e73d8bc367e03fe7861cd9c49fff9dcfa6db83bc0630c0adcfb25b7fa/pyobjc_framework_cocoa-12.2.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e106f395531e67694376b0f1184612cbeea3ec8b9bf56b55ef41d026171d2a2d", size = 388117, upload-time = "2026-08-11T19:32:43.161Z" }, + { url = "https://files.pythonhosted.org/packages/db/e1/5d9b04ebb60042b9cb49adc2d33115e2f2c2e4ff7d548017bfaff8b7f536/pyobjc_framework_cocoa-12.2.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:600b1723184ca094931330e79355274949965460e23de38628d601b5a967baf9", size = 388181, upload-time = "2026-08-11T19:32:44.537Z" }, + { url = "https://files.pythonhosted.org/packages/b4/25/2a343357d5fe09bbe9c0e294dc03450866a0d6c1792fad36b6bcc00174c0/pyobjc_framework_cocoa-12.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:875f2aad73963faa81a6b36ae674fd494a4658d6d999e1075e0e2aca3d2391df", size = 392275, upload-time = "2026-08-11T19:32:45.631Z" }, + { url = "https://files.pythonhosted.org/packages/1f/1a/b99521999b9f54b89aad928ddff0faad507abfe33bc46599454bfa48a4b2/pyobjc_framework_cocoa-12.2.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:889d7bbd4ba2d4941078bfbbfb882138e51dbead27df006abfe0f2e0d49b5b2e", size = 388368, upload-time = "2026-08-11T19:32:46.781Z" }, + { url = "https://files.pythonhosted.org/packages/6d/26/0c697dbc73dcc76bc0f68ea5aeed25bf7b05217df5102659e878501b2d5f/pyobjc_framework_cocoa-12.2.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:de69c5933750f3a4599ed962eccd92b6a71914c7e4318dacc7895738a8ae60d7", size = 392404, upload-time = "2026-08-11T19:32:47.918Z" }, + { url = "https://files.pythonhosted.org/packages/df/82/502f740fd8f4e9ef741c9d40ba67467ab2c8196f2c09dcba12936d28a4fd/pyobjc_framework_cocoa-12.2.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:0e8ace0d44a00d281281a723d17fcd05eea7544a38a6a512e1fd018ddb7aece2", size = 388585, upload-time = "2026-08-11T19:32:49.171Z" }, + { url = "https://files.pythonhosted.org/packages/7d/3b/07ce3c0ab8d1e9e1bed74fea1bf1cce73527a365a7a23c755051d3be9865/pyobjc_framework_cocoa-12.2.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:8fe5b2e79c9530f667b4e58a87a3a15ea62f86a5d19eec405517ecbd4f454868", size = 392693, upload-time = "2026-08-11T19:32:50.283Z" }, +] + +[[package]] +name = "pyobjc-framework-coretext" +version = "12.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyobjc-core" }, + { name = "pyobjc-framework-cocoa" }, + { name = "pyobjc-framework-quartz" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6d/66/405006d3502ffcd3bc69e0b7249ab7c05a5b43a07fa3959ce6b2a84f3278/pyobjc_framework_coretext-12.2.2.tar.gz", hash = "sha256:64ddc02303217028e32e22c7cc00b5112d84e9d9a67c37d00c2e54f9172284ab", size = 97658, upload-time = "2026-08-11T19:44:17.207Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e9/52/491235fa0450ff90a9d84792c77d7908fa25e2d5e6a96ebab91542852618/pyobjc_framework_coretext-12.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8af29c8f5fd3404b2ce3730ac1166c5b66e206830603facb85d0ad3ede5309dc", size = 30019, upload-time = "2026-08-11T19:34:40.202Z" }, + { url = "https://files.pythonhosted.org/packages/8e/27/248f417d419520d9ff9997b37012e41cfb1b4bd35650b15fbd7f1f3c4749/pyobjc_framework_coretext-12.2.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:77a379ff47c599cb2bab918eb75680d30d950692ec19d67b734d11ded090b4e1", size = 30023, upload-time = "2026-08-11T19:34:41.111Z" }, + { url = "https://files.pythonhosted.org/packages/1c/88/e85a9268285fc0c28284dbdc869a27f5d3f2e436d2838221a6704b4f8eee/pyobjc_framework_coretext-12.2.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a69611de569d92776e6391ca25492a5bbb4a05ba744006349e377a4fc5f7c8a5", size = 30120, upload-time = "2026-08-11T19:34:41.94Z" }, + { url = "https://files.pythonhosted.org/packages/6c/6d/e1a4c572c867bd40b705687c741a747083c6dbc63bd797bb6ed5c5108f6e/pyobjc_framework_coretext-12.2.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dbd0f288a859e359ee8e7ccf45bc2c489f38ae1087c21468b61d700433e0c91b", size = 30117, upload-time = "2026-08-11T19:34:42.88Z" }, + { url = "https://files.pythonhosted.org/packages/aa/de/ffdf698b69a2b26af73d32ba1bcc06bc6efc0699f5936995017a66c42efb/pyobjc_framework_coretext-12.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:1324d91305022b1de03a12cf82de2b42c87dafe9b12cde6237253658a8637139", size = 30663, upload-time = "2026-08-11T19:34:43.635Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7d/e1bcc7acdbe431d3bc2d8a7a8e807e99f552a9e1479f936d6318cfd7c0c0/pyobjc_framework_coretext-12.2.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:295d1037494630527acc24d116b0301ab5cf5e918952f49f7bf4f76ebae24d0c", size = 30101, upload-time = "2026-08-11T19:34:44.577Z" }, + { url = "https://files.pythonhosted.org/packages/50/f4/8d489c3bd31644a8f1fc5f6416e27ccb0252cc6eb535788bebfa9ef43d9d/pyobjc_framework_coretext-12.2.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:b585f0db77280930cb32e71cf8d27f5203d8c0f42a65fba690294530ab6e1aa6", size = 30644, upload-time = "2026-08-11T19:34:45.357Z" }, + { url = "https://files.pythonhosted.org/packages/6f/f4/8b5a1e09b4cf938a3c27474c84f9cbd4ac14d411b6d59a6d7653290f26e4/pyobjc_framework_coretext-12.2.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:f1ad871d761bad9a0d461cceeeff7375a39f4d181c2a206dada6fc05307fec12", size = 30103, upload-time = "2026-08-11T19:34:46.155Z" }, + { url = "https://files.pythonhosted.org/packages/e8/81/392f9054dc897ed0db83b09775c3eb4906b189c1a6f62903105ac7fbddcd/pyobjc_framework_coretext-12.2.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:1dc50de18346c4d6c89a51df066f03beea81e3557e3090ddc2a7a59395332fd8", size = 30666, upload-time = "2026-08-11T19:34:46.92Z" }, +] + +[[package]] +name = "pyobjc-framework-quartz" +version = "12.2.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyobjc-core" }, + { name = "pyobjc-framework-cocoa" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/35/b1/426a37c7ae37280b3ffca2571fb48f211946aee2f4ca31a603ed1943c4a7/pyobjc_framework_quartz-12.2.2.tar.gz", hash = "sha256:810f97b210cfd93704d240860286dfd6df09f9f1c52525fc5c2166723aea3f9e", size = 3218295, upload-time = "2026-08-11T19:45:15.189Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3c/94/2c9839958b0a2a040e22cca145040a8fc2612f099eda7524900d741f560d/pyobjc_framework_quartz-12.2.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d89a5f47c079b5c340d2b1cbb83eb6c4c92d4bb17cd4daf7d8c02c91a49f5399", size = 218007, upload-time = "2026-08-11T19:40:22.077Z" }, + { url = "https://files.pythonhosted.org/packages/b9/e8/16d07170d4e1bd182a8e6084abdf283fac90979384b8f53107be9eb110e6/pyobjc_framework_quartz-12.2.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:4b01e325b0cdc121e78730dde9756e971b23069bf141cd62efbcaac76d7b6dbb", size = 218008, upload-time = "2026-08-11T19:40:23.36Z" }, + { url = "https://files.pythonhosted.org/packages/ed/e4/8be95d2ff850f82fb55b44c63333a00a920bf8a73642e7d9c2f3638a26d2/pyobjc_framework_quartz-12.2.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7f668979d0c7320bf8f7ed6e030da578f93ab0f5dd619b295ec735cd8d5faa34", size = 219003, upload-time = "2026-08-11T19:40:24.425Z" }, + { url = "https://files.pythonhosted.org/packages/bb/ae/b515852dbe491171f2f2e2eb7739588a5eb7f36720a739545337b8c0d706/pyobjc_framework_quartz-12.2.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:0ec9751904ef975bf0789d760dc4fadcb400edc4ffe4a736eb54971968babe5c", size = 219404, upload-time = "2026-08-11T19:40:25.461Z" }, + { url = "https://files.pythonhosted.org/packages/ff/5f/c7ee66f4483385396d91f65036c62f3dd20bccaa07354643ef17b259aa75/pyobjc_framework_quartz-12.2.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:63f6f0f3233dcf650aac1374781e78961b0b17b33e3351953bacf8bd0c430593", size = 224462, upload-time = "2026-08-11T19:40:26.647Z" }, + { url = "https://files.pythonhosted.org/packages/b1/33/230ae7777b0909fe2c24f28413c51c860faebf762d824b097a0e2fb48304/pyobjc_framework_quartz-12.2.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:1f7f3d9010e38f03ea1fa266664c10ea349cd7492bd603b403584f49d713dbed", size = 219773, upload-time = "2026-08-11T19:40:27.64Z" }, + { url = "https://files.pythonhosted.org/packages/25/eb/7482fdd384521916e98a6164be220494b1f7794792b1d60fa3f5207d84a4/pyobjc_framework_quartz-12.2.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ebf8167ca2096cf3a05199decfa517be0df4c56048f49cf132bd6b1a6ab9c086", size = 224726, upload-time = "2026-08-11T19:40:28.718Z" }, + { url = "https://files.pythonhosted.org/packages/33/67/b4b0ffc486b08492bfef4b33731d044b295f1696c8fb7d119c8367079139/pyobjc_framework_quartz-12.2.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:cee63b891c2b6b7ccf98f233175411529f3e80286f58438793b3634af79858f1", size = 219827, upload-time = "2026-08-11T19:40:29.764Z" }, + { url = "https://files.pythonhosted.org/packages/aa/eb/5fb627c2457046883c6fd12d25c44db40c12bcde4622dc0f30851108e106/pyobjc_framework_quartz-12.2.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:8f58c589b5a76ba98f186b1f3b19fb1c8b730e82351f81fb62e6194f64a71622", size = 224767, upload-time = "2026-08-11T19:40:30.991Z" }, +] + +[[package]] +name = "pyqt6" +version = "6.11.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pyqt6-qt6" }, + { name = "pyqt6-sip" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8b/47/b25c13eca5bebc6505394d0223e46d7ebf0c57dcac2ed908d7d19b18ab6b/pyqt6-6.11.0.tar.gz", hash = "sha256:45dd60aa69976de1918b5ced6b4e7b6a25abd2a919ecef5fd5826ecc76718889", size = 1087430, upload-time = "2026-03-30T09:16:13.543Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/44/fcd3dd3f64c83c96bf9bce76ec16cca64bd9b91702c3d08fd8e3dafc73d9/pyqt6-6.11.0-cp310-abi3-macosx_10_14_universal2.whl", hash = "sha256:f7100bc7f72b12581ec479a733f4ad11b8002668e6786e8a445ab6f4d1c743d4", size = 12429735, upload-time = "2026-03-30T09:16:03.713Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a0/bd1399740dfa80c0a94d20b02d89962a31458233dcf70eaa09bfbccf3d0f/pyqt6-6.11.0-cp310-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:8555277989fa7d114cb3c3443fd261d566909f7268ceedd41d93a5f02d37ec05", size = 8334632, upload-time = "2026-03-30T09:16:06.066Z" }, + { url = "https://files.pythonhosted.org/packages/d3/db/425b184ac2430ba1978bb507ffd285ec007a872644e2ae5df13332dbcb05/pyqt6-6.11.0-cp310-abi3-manylinux_2_39_aarch64.whl", hash = "sha256:0734959955adde095af9a074213a7f73386d1bbbddfc27346b4c0621641a692e", size = 8321484, upload-time = "2026-03-30T09:16:08.135Z" }, + { url = "https://files.pythonhosted.org/packages/6f/85/dd9f03d78d87460e109e0121cd6201c5802bdd655656bf2780e964870fea/pyqt6-6.11.0-cp310-abi3-win_amd64.whl", hash = "sha256:bd11b459c54dca068e988a42cf838303334f0d441b9d16d92ae6719fcb5ac6ba", size = 6844358, upload-time = "2026-03-30T09:16:09.766Z" }, + { url = "https://files.pythonhosted.org/packages/cd/75/970b041bde4372cc6739c5ef9db1de83a6b36e788e4992e598baa35b2255/pyqt6-6.11.0-cp310-abi3-win_arm64.whl", hash = "sha256:b6324e3501b19b4292c7a55b1f22e82d3e80e519e383ce4fe79b4a754c6f0288", size = 5933984, upload-time = "2026-03-30T09:16:11.817Z" }, +] + +[[package]] +name = "pyqt6-qt6" +version = "6.11.2" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d6/d2/79c88102ff88efcdae338a0ffbb5fa40b70194e0095db5ddec490106bcc6/pyqt6_qt6-6.11.2-py3-none-macosx_10_14_x86_64.whl", hash = "sha256:6a4372baa674ca91de5caf31f241b0660fd3da90fe27fefed9a7a459e630ea89", size = 70517918, upload-time = "2026-08-23T12:59:34.419Z" }, + { url = "https://files.pythonhosted.org/packages/a0/72/f49e11b46eaa887e1250658b9c038f13c654ca7478c7c904ada13bb5133e/pyqt6_qt6-6.11.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:4f21ff2ffaacfb8a8df6ab1d619d0da7aa4e808e86f41b6daa1a7bff9c0d6eab", size = 64259572, upload-time = "2026-08-23T12:59:40.759Z" }, + { url = "https://files.pythonhosted.org/packages/69/ef/e34054e814c874f5230326ffc791f602a13b2f5590ca9599ba45b5fc4bc0/pyqt6_qt6-6.11.2-py3-none-manylinux_2_34_x86_64.whl", hash = "sha256:da7d747ad917f044d841ff834f17d2c50a0cc5d0e3b16479d8662544207d0567", size = 86012424, upload-time = "2026-08-23T12:59:45.97Z" }, + { url = "https://files.pythonhosted.org/packages/45/01/86f3c30ceee9384d905424a28abbcba6e9489f44ca15b2f4ae74921f079c/pyqt6_qt6-6.11.2-py3-none-manylinux_2_39_aarch64.whl", hash = "sha256:2c38ee8b797c0d7f327afef4cfbb97c73676954ef2d1d503779d62c982bf5a66", size = 85506374, upload-time = "2026-08-23T12:59:51.195Z" }, + { url = "https://files.pythonhosted.org/packages/f6/56/62457dd9b5738f65b9fb4ac6b3120bc0bfa0bc335857fdd456b94b0a6079/pyqt6_qt6-6.11.2-py3-none-win_amd64.whl", hash = "sha256:4b424ed1babbef07133eb2a4174c56c848d518767bca8e759aca2c8c9c313636", size = 78000994, upload-time = "2026-08-23T12:59:56.429Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/3ce7dc9172b798e191b82296d90f7b89fcd94f111dd249b71cf7acaa803b/pyqt6_qt6-6.11.2-py3-none-win_arm64.whl", hash = "sha256:8c49432936681f325f2925f20ceef35b8fb7599e0c3e63e76d6e50397354ee1f", size = 61679846, upload-time = "2026-08-23T13:00:01.138Z" }, +] + +[[package]] +name = "pyqt6-sip" +version = "13.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/78/35/bed43ff7cf040ced6b62a17b272abecb94914755284b54e8d06844e1ed23/pyqt6_sip-13.13.0.tar.gz", hash = "sha256:2cd55f575cde208c398d6cfdecc5a13394ed2afb54226210c50e3a6df7c3a997", size = 95006, upload-time = "2026-10-04T12:26:46.405Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0f/3a/6c1e9e25c66463b62d11ec7d518aa822bb75ce6096a6d4ce7fc0909487df/pyqt6_sip-13.13.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:958e4068a95ef36b0758fd62403855ff9d2c7ee5735e9eb92f3c805183acd9e7", size = 112693, upload-time = "2026-10-04T12:26:10.1Z" }, + { url = "https://files.pythonhosted.org/packages/d3/57/b75c2bbdedb832e46869f816aba09e2111c998efc87a5b51df53a228be4b/pyqt6_sip-13.13.0-cp310-cp310-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0f4329bcf7c4bbfd1f34b51f9fe417f839b18ae5035b6e9de1c7718b821f45aa", size = 282976, upload-time = "2026-10-04T12:26:12.729Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/70464efb37a7394c4ead0438e0089beecc30c10832c69c8839ed9bd4d6c7/pyqt6_sip-13.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf73a187600708ef69225a25be53d71e918fa853f9b992c3720e8dbf657e49bc", size = 306092, upload-time = "2026-10-04T12:26:11.452Z" }, + { url = "https://files.pythonhosted.org/packages/eb/d8/fb22a6a77f9b53d260fef759211ea720e05931f8b0f1ad83af40c2f0fc73/pyqt6_sip-13.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:9e0303221d2c4f6fbe8f1b9a0dc8eea601647ed22e15e5d1f582a42e732f59e1", size = 54184, upload-time = "2026-10-04T12:26:14.303Z" }, + { url = "https://files.pythonhosted.org/packages/44/70/549e69eb610f473c85122d57b755cb6411907d73ab0330420488dffa248f/pyqt6_sip-13.13.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fb51d482483d2b5e78df013e76d5495aa9557c8dbf351d51be9269f1bd26f8cd", size = 112709, upload-time = "2026-10-04T12:26:15.391Z" }, + { url = "https://files.pythonhosted.org/packages/f2/d2/8044d15dd01cff02cd5aa9989e99cea2afe41edf183dca8d8e5ab2a88476/pyqt6_sip-13.13.0-cp311-cp311-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:19044f546ca397ed315e59077b0761e86c5129a23ac95d39166a46b740a6065e", size = 291995, upload-time = "2026-10-04T12:26:18.269Z" }, + { url = "https://files.pythonhosted.org/packages/3a/04/1412b7a12f8a76f6531f1f2a8c589c1d61f463814611c687e2f8998ccba0/pyqt6_sip-13.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e30bec75c82886a3846e593570e6e71d7a417743867cc356c99acb849e27bfc2", size = 317510, upload-time = "2026-10-04T12:26:16.965Z" }, + { url = "https://files.pythonhosted.org/packages/fb/75/d34dd327fbbc4fbd2f22325455e62f33192349b18860df39b51f4e9b1573/pyqt6_sip-13.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:75d02cae78b43330917692cfd5b25c69e30d73e6e22ba8cfd53d7614fbb2774a", size = 54169, upload-time = "2026-10-04T12:26:21.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/2e/84d50d40dc3ac2d9a7c70f051965341478d82e27a7689f1308fc90bb125a/pyqt6_sip-13.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:fe966368ecd09319d7b6df31cb3dc484128e2b36177fb814faa5b8b7e6525b37", size = 48540, upload-time = "2026-10-04T12:26:22.792Z" }, + { url = "https://files.pythonhosted.org/packages/14/75/75c6ba37daabcbd810d2d23248017ee9cfb23c0a2f55eb47447d323cc5a1/pyqt6_sip-13.13.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:da1a8e350b927c281d4f155fb3b84859e6e8c04ea36fe159cf9b939ee957d151", size = 113445, upload-time = "2026-10-04T12:26:25.557Z" }, + { url = "https://files.pythonhosted.org/packages/e3/d2/f2c77662be1f4ca6e35a8897d573b51a9e662e6b86a0d42c50afa9d46acf/pyqt6_sip-13.13.0-cp312-cp312-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7429e63fc8279a0508ed5cbc1b33da76c15a61a06a745825e807a3604fbde4f2", size = 301294, upload-time = "2026-10-04T12:26:28.062Z" }, + { url = "https://files.pythonhosted.org/packages/64/f4/4ce0629bf6780c62d3bb4ebe33dfe1aa9523888baab5a8d0a4b13708c5ab/pyqt6_sip-13.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42544406d4519122ad9ee7a79bc9195cdceba6d777d2e481d346e6ad2801f38a", size = 322837, upload-time = "2026-10-04T12:26:26.802Z" }, + { url = "https://files.pythonhosted.org/packages/37/d4/ea91156975216008e5fbfb8158478fc6f0b1b4d8c4de63e8819a8a69d6f0/pyqt6_sip-13.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:c6b67d301ef64e13d313c728020616315c952473abb27029b2e5857b44a7b3e6", size = 53464, upload-time = "2026-10-04T12:26:31.563Z" }, + { url = "https://files.pythonhosted.org/packages/85/de/e9edaf5990240ee608566429447478de2d71311d43d165d966122540565b/pyqt6_sip-13.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:ff5d5bd3920d1e2bc251a931233c7909df08fa12786c2ddbcef935b6105bfb0c", size = 48845, upload-time = "2026-10-04T12:26:32.538Z" }, + { url = "https://files.pythonhosted.org/packages/20/db/f3a31964c09ee4af20638ce92ff5bcf4ff4fa1d593104b4048828ca5e905/pyqt6_sip-13.13.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b4dd82f38f3eb736bf5176058dd5cf36299c93db72148480e32d6249f6dbabdc", size = 113417, upload-time = "2026-10-04T12:26:33.769Z" }, + { url = "https://files.pythonhosted.org/packages/71/e5/aaaa629a17f5abd9d6f80d5bd8cbbc8b91434f017d03eb5df7d4258ecb41/pyqt6_sip-13.13.0-cp313-cp313-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:c42dcf3fa0b8bb9985423850971064323a3a4aa97efdc3fa69161b37088d795c", size = 301659, upload-time = "2026-10-04T12:26:36.558Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ff/2e07d6b008226fc118956cbbd96a305c88a60ee2d7e361523f4f294d5937/pyqt6_sip-13.13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7d0f75205c29c21ea23e6dd96f9cd9b6c1a729e48db0bd4a77325ab24e227276", size = 322879, upload-time = "2026-10-04T12:26:35.144Z" }, + { url = "https://files.pythonhosted.org/packages/9a/9c/ef3ffad75ef85067789d8bfd253785c2ca997e78872ba0d61250c8ff6458/pyqt6_sip-13.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:b202f08bf0d68c0bd80def5c273acd0e1fe3deee8eda9ad8244b8286bc333e0a", size = 53485, upload-time = "2026-10-04T12:26:38.331Z" }, + { url = "https://files.pythonhosted.org/packages/c8/4b/9c5ac6f29eed30ee06a5e575819a164c48d5f47ac799cafddf1effb3a9c0/pyqt6_sip-13.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:b99a72eacb3d67e2277b22c6162d48ac0e9c03b5540159b35d241ebe083285e9", size = 48849, upload-time = "2026-10-04T12:26:39.634Z" }, + { url = "https://files.pythonhosted.org/packages/ef/52/2ff2181c360501fa530e2f223442946d0f7bc4ce8b58af42ed17cb0268e8/pyqt6_sip-13.13.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:10ed8841786fe1a26c72cef8de070a56a495388ab2938b8cffff87ac1a104044", size = 113653, upload-time = "2026-10-04T12:26:40.763Z" }, + { url = "https://files.pythonhosted.org/packages/b0/46/c323b1627144379f4ca5ebd4a70c440b6c21a5936aa981450a54b7b2f770/pyqt6_sip-13.13.0-cp314-cp314-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6037f5f122b190ec1c3f53fdc796b68a9fbf83824b2d1c11f0ecbb787989a542", size = 301669, upload-time = "2026-10-04T12:26:43.376Z" }, + { url = "https://files.pythonhosted.org/packages/1f/f9/023daa2a633cde62b2f7452e62d53273a8b23c3ce5dc31d7ecdc6b797897/pyqt6_sip-13.13.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:70199e2b37ac83a4799df2a2a2ec8358e1d20dfdf011f2baec17a8867c34fe12", size = 323559, upload-time = "2026-10-04T12:26:41.919Z" }, + { url = "https://files.pythonhosted.org/packages/08/0b/1c8ebeb9184c9f017173ae952e89f5191571c680f3e18875217a1c00860b/pyqt6_sip-13.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:26ee16a9b53aa7c8271a19154c35ab2e17514dbae85ac9a770ba40feac347be2", size = 55130, upload-time = "2026-10-04T12:26:44.552Z" }, + { url = "https://files.pythonhosted.org/packages/35/b9/9bdfa5222e42aba61205847721d1b4c53145ffcb740952272a4fbe33289f/pyqt6_sip-13.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:88e3bbc1a6bb1632ead7b15f77769f09b9a581eb77eb41a6862c32396f47b4a4", size = 49706, upload-time = "2026-10-04T12:26:45.471Z" }, + { url = "https://files.pythonhosted.org/packages/91/8c/a68a45e2a651795c9b5bcd95eec4ef9cb945c35af238f7ef0369a39a7e72/pyqt6_sip-13.13.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:e3b47eaab721871177148f4771a8b2259de5356e30cbcf04e88acfe55b57f257", size = 113961, upload-time = "2026-10-10T14:50:58.283Z" }, + { url = "https://files.pythonhosted.org/packages/f8/20/eebfef3e76175553f5049f2dd54d3e2e940b116ddb61d1ecdec12b93eb3a/pyqt6_sip-13.13.0-cp315-cp315-manylinux1_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f856e077035bd0316e26396fa70100b6ff13405d017464bbb501ae73070f3dce", size = 304973, upload-time = "2026-10-10T14:51:01.158Z" }, + { url = "https://files.pythonhosted.org/packages/09/44/a944b91a94c9745cfce05174d4a2dab4faa67b03b23c160948505993b1b0/pyqt6_sip-13.13.0-cp315-cp315-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78fd781938d09797db6d0b23ac070a91d567c9170581dba3ca87630abb69055b", size = 327367, upload-time = "2026-10-10T14:50:59.831Z" }, + { url = "https://files.pythonhosted.org/packages/2e/b3/939df28667fd61f4d04abb7adab93f034fd4f62a7d3e0dac82ea58268532/pyqt6_sip-13.13.0-cp315-cp315-win_amd64.whl", hash = "sha256:67b37ae7d238462a89908b1c3e3a4bc9551fc9b8d3e8be05ff3314b7a24a3e53", size = 55311, upload-time = "2026-10-10T14:51:02.736Z" }, + { url = "https://files.pythonhosted.org/packages/89/48/a640f06a065655cc0286fc16a7fed8b09bfe3a8291e4223d483e834d0c05/pyqt6_sip-13.13.0-cp315-cp315-win_arm64.whl", hash = "sha256:a1cd42fdbb191d3ee0a0c8858348e18ddb5ea4bbc009af34da4a536db1f92e63", size = 49744, upload-time = "2026-10-10T14:51:04.017Z" }, +] + +[[package]] +name = "pyreadline3" +version = "3.5.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/6d/f94028646d7bbe6d9d873c47ee7c246f2d29129d253f0d96cb6fcab70733/pyreadline3-3.5.6.tar.gz", hash = "sha256:61e53218b99656091ddb077df9e71f25850e72e030b6183b39c9b7e6e4f4a9bf", size = 100368, upload-time = "2026-05-14T17:55:04.471Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f7/5e/35c856e186b74678c24927847ad9895a51f1bc02a0c6126477a6c6040064/pyreadline3-3.5.6-py3-none-any.whl", hash = "sha256:8449b734232e42a5dcd74048e39b60db2839a4c38cf3ae2bf7707d58b5389c0d", size = 85243, upload-time = "2026-05-14T17:55:03.262Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", version = "7.16.2", source = { registry = "https://pypi.org/simple" }, extra = ["toml"], marker = "python_full_version < '3.11'" }, + { name = "coverage", version = "7.17.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, +] + +[[package]] +name = "pytest-qt" +version = "4.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pluggy" }, + { name = "pytest" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/d3/61/8bdec02663c18bf5016709b909411dce04a868710477dc9b9844ffcf8dd2/pytest_qt-4.5.0.tar.gz", hash = "sha256:51620e01c488f065d2036425cbc1cbcf8a6972295105fd285321eb47e66a319f", size = 128702, upload-time = "2025-07-01T17:24:39.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cc/d0/8339b888ad64a3d4e508fed8245a402b503846e1972c10ad60955883dcbb/pytest_qt-4.5.0-py3-none-any.whl", hash = "sha256:ed21ea9b861247f7d18090a26bfbda8fb51d7a8a7b6f776157426ff2ccf26eff", size = 37214, upload-time = "2025-07-01T17:24:38.226Z" }, +] + +[[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-xlib" +version = "0.33" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/86/f5/8c0653e5bb54e0cbdfe27bf32d41f27bc4e12faa8742778c17f2a71be2c0/python-xlib-0.33.tar.gz", hash = "sha256:55af7906a2c75ce6cb280a584776080602444f75815a7aff4d287bb2d7018b32", size = 269068, upload-time = "2022-12-25T18:53:00.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fc/b8/ff33610932e0ee81ae7f1269c890f697d56ff74b9f5b2ee5d9b7fa2c5355/python_xlib-0.33-py2.py3-none-any.whl", hash = "sha256:c3534038d42e0df2f1392a1b30a15a4ff5fdc2b86cfa94f072bf11b10a164398", size = 182185, upload-time = "2022-12-25T18:52:58.662Z" }, +] + +[[package]] +name = "pywin32-ctypes" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/85/9f/01a1a99704853cb63f253eea009390c88e7131c67e66a0a02099a8c917cb/pywin32-ctypes-0.2.3.tar.gz", hash = "sha256:d162dc04946d704503b2edc4d55f3dba5c1d539ead017afa00142c38b9885755", size = 29471, upload-time = "2024-08-14T10:15:34.626Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/3d/8161f7711c017e01ac9f008dfddd9410dff3674334c233bde66e7ba65bbf/pywin32_ctypes-0.2.3-py3-none-any.whl", hash = "sha256:8a1513379d709975552d202d942d9837758905c8d01eb82b8bcc30918929e7b8", size = 30756, upload-time = "2024-08-14T10:15:33.187Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "ruff" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/41/b9/9bd84453ed6dd04688de9b3f3a4146a1698e8faae2ceeccce4e14c67ae17/ruff-0.14.0.tar.gz", hash = "sha256:62ec8969b7510f77945df916de15da55311fade8d6050995ff7f680afe582c57", size = 5452071, upload-time = "2025-10-07T18:21:55.763Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/4e/79d463a5f80654e93fa653ebfb98e0becc3f0e7cf6219c9ddedf1e197072/ruff-0.14.0-py3-none-linux_armv6l.whl", hash = "sha256:58e15bffa7054299becf4bab8a1187062c6f8cafbe9f6e39e0d5aface455d6b3", size = 12494532, upload-time = "2025-10-07T18:21:00.373Z" }, + { url = "https://files.pythonhosted.org/packages/ee/40/e2392f445ed8e02aa6105d49db4bfff01957379064c30f4811c3bf38aece/ruff-0.14.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:838d1b065f4df676b7c9957992f2304e41ead7a50a568185efd404297d5701e8", size = 13160768, upload-time = "2025-10-07T18:21:04.73Z" }, + { url = "https://files.pythonhosted.org/packages/75/da/2a656ea7c6b9bd14c7209918268dd40e1e6cea65f4bb9880eaaa43b055cd/ruff-0.14.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:703799d059ba50f745605b04638fa7e9682cc3da084b2092feee63500ff3d9b8", size = 12363376, upload-time = "2025-10-07T18:21:07.833Z" }, + { url = "https://files.pythonhosted.org/packages/42/e2/1ffef5a1875add82416ff388fcb7ea8b22a53be67a638487937aea81af27/ruff-0.14.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ba9a8925e90f861502f7d974cc60e18ca29c72bb0ee8bfeabb6ade35a3abde7", size = 12608055, upload-time = "2025-10-07T18:21:10.72Z" }, + { url = "https://files.pythonhosted.org/packages/4a/32/986725199d7cee510d9f1dfdf95bf1efc5fa9dd714d0d85c1fb1f6be3bc3/ruff-0.14.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e41f785498bd200ffc276eb9e1570c019c1d907b07cfb081092c8ad51975bbe7", size = 12318544, upload-time = "2025-10-07T18:21:13.741Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ed/4969cefd53315164c94eaf4da7cfba1f267dc275b0abdd593d11c90829a3/ruff-0.14.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30a58c087aef4584c193aebf2700f0fbcfc1e77b89c7385e3139956fa90434e2", size = 14001280, upload-time = "2025-10-07T18:21:16.411Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ad/96c1fc9f8854c37681c9613d825925c7f24ca1acfc62a4eb3896b50bacd2/ruff-0.14.0-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:f8d07350bc7af0a5ce8812b7d5c1a7293cf02476752f23fdfc500d24b79b783c", size = 15027286, upload-time = "2025-10-07T18:21:19.577Z" }, + { url = "https://files.pythonhosted.org/packages/b3/00/1426978f97df4fe331074baf69615f579dc4e7c37bb4c6f57c2aad80c87f/ruff-0.14.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:eec3bbbf3a7d5482b5c1f42d5fc972774d71d107d447919fca620b0be3e3b75e", size = 14451506, upload-time = "2025-10-07T18:21:22.779Z" }, + { url = "https://files.pythonhosted.org/packages/58/d5/9c1cea6e493c0cf0647674cca26b579ea9d2a213b74b5c195fbeb9678e15/ruff-0.14.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:16b68e183a0e28e5c176d51004aaa40559e8f90065a10a559176713fcf435206", size = 13437384, upload-time = "2025-10-07T18:21:25.758Z" }, + { url = "https://files.pythonhosted.org/packages/29/b4/4cd6a4331e999fc05d9d77729c95503f99eae3ba1160469f2b64866964e3/ruff-0.14.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb732d17db2e945cfcbbc52af0143eda1da36ca8ae25083dd4f66f1542fdf82e", size = 13447976, upload-time = "2025-10-07T18:21:28.83Z" }, + { url = "https://files.pythonhosted.org/packages/3b/c0/ac42f546d07e4f49f62332576cb845d45c67cf5610d1851254e341d563b6/ruff-0.14.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:c958f66ab884b7873e72df38dcabee03d556a8f2ee1b8538ee1c2bbd619883dd", size = 13682850, upload-time = "2025-10-07T18:21:31.842Z" }, + { url = "https://files.pythonhosted.org/packages/5f/c4/4b0c9bcadd45b4c29fe1af9c5d1dc0ca87b4021665dfbe1c4688d407aa20/ruff-0.14.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:7eb0499a2e01f6e0c285afc5bac43ab380cbfc17cd43a2e1dd10ec97d6f2c42d", size = 12449825, upload-time = "2025-10-07T18:21:35.074Z" }, + { url = "https://files.pythonhosted.org/packages/4b/a8/e2e76288e6c16540fa820d148d83e55f15e994d852485f221b9524514730/ruff-0.14.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:4c63b2d99fafa05efca0ab198fd48fa6030d57e4423df3f18e03aa62518c565f", size = 12272599, upload-time = "2025-10-07T18:21:38.08Z" }, + { url = "https://files.pythonhosted.org/packages/18/14/e2815d8eff847391af632b22422b8207704222ff575dec8d044f9ab779b2/ruff-0.14.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:668fce701b7a222f3f5327f86909db2bbe99c30877c8001ff934c5413812ac02", size = 13193828, upload-time = "2025-10-07T18:21:41.216Z" }, + { url = "https://files.pythonhosted.org/packages/44/c6/61ccc2987cf0aecc588ff8f3212dea64840770e60d78f5606cd7dc34de32/ruff-0.14.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a86bf575e05cb68dcb34e4c7dfe1064d44d3f0c04bbc0491949092192b515296", size = 13628617, upload-time = "2025-10-07T18:21:44.04Z" }, + { url = "https://files.pythonhosted.org/packages/73/e6/03b882225a1b0627e75339b420883dc3c90707a8917d2284abef7a58d317/ruff-0.14.0-py3-none-win32.whl", hash = "sha256:7450a243d7125d1c032cb4b93d9625dea46c8c42b4f06c6b709baac168e10543", size = 12367872, upload-time = "2025-10-07T18:21:46.67Z" }, + { url = "https://files.pythonhosted.org/packages/41/77/56cf9cf01ea0bfcc662de72540812e5ba8e9563f33ef3d37ab2174892c47/ruff-0.14.0-py3-none-win_amd64.whl", hash = "sha256:ea95da28cd874c4d9c922b39381cbd69cb7e7b49c21b8152b014bd4f52acddc2", size = 13464628, upload-time = "2025-10-07T18:21:50.318Z" }, + { url = "https://files.pythonhosted.org/packages/c6/2a/65880dfd0e13f7f13a775998f34703674a4554906167dce02daf7865b954/ruff-0.14.0-py3-none-win_arm64.whl", hash = "sha256:f42c9495f5c13ff841b1da4cb3c2a42075409592825dada7c5885c2c844ac730", size = 12565142, upload-time = "2025-10-07T18:21:53.577Z" }, +] + +[[package]] +name = "secretstorage" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cryptography" }, + { name = "jeepney" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/46/f5af3402b579fd5e11573ce652019a67074317e18c1935cc0b4ba9b35552/secretstorage-3.5.0-py3-none-any.whl", hash = "sha256:0ce65888c0725fcb2c5bc0fdb8e5438eece02c523557ea40ce0703c266248137", size = 15554, upload-time = "2025-11-23T19:02:51.545Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "sounddevice" +version = "0.5.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ec/db/0c890e2d9aab9ba284021efc02e1d3aebfecab1b611762d7434602209bcf/sounddevice-0.5.6.tar.gz", hash = "sha256:8ec9fbfde2e32f020b167e348f3ab3bac6625a5f15af524d790108ac7147a410", size = 1120094, upload-time = "2026-08-17T07:55:05.048Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/72/1f/62eef605172bddc1017508469a12f75bc7c4194ece35c734f822795f53b1/sounddevice-0.5.6-py3-none-any.whl", hash = "sha256:de099612311ad81e55d31ccbd83f43ea6bf4d87b48f9b6ea55a1fbcde0eee4e0", size = 32793, upload-time = "2026-08-17T07:54:57.507Z" }, + { url = "https://files.pythonhosted.org/packages/b6/84/85e719d49cf98b2f406d9ac9c338892286c4448eb42ef0b2625ccf159616/sounddevice-0.5.6-py3-none-macosx_10_6_x86_64.macosx_10_6_universal2.whl", hash = "sha256:e3aef00ad8b1d1740eb66d9a7671eab88a4d2b8fa4ab33498d742e63b65c309c", size = 1009647, upload-time = "2026-08-17T07:54:58.814Z" }, + { url = "https://files.pythonhosted.org/packages/c5/6f/6292145099f72a153a710245f46ae43e5fb6c77bec1b6086cb76c12dc280/sounddevice-0.5.6-py3-none-win32.whl", hash = "sha256:b36b807eb02abd257198bf84b2af05e4fea199a9d2f0019014169c7136d45e9c", size = 1009627, upload-time = "2026-08-17T07:55:00.401Z" }, + { url = "https://files.pythonhosted.org/packages/8d/3e/cbc593c31a5f0d817b3fe97e64aa8461bd0f55cb07b67ce1b776296ae336/sounddevice-0.5.6-py3-none-win_amd64.whl", hash = "sha256:7f4162f514f007b0bf25a3ccfed3f1705bc2ec311888a90232729eec4f57a4f4", size = 1009630, upload-time = "2026-08-17T07:55:02.088Z" }, + { url = "https://files.pythonhosted.org/packages/60/a4/b0c21c9f215a6fd9606b8f8748c21212dc098e5d5a2d93068c50edcf19b4/sounddevice-0.5.6-py3-none-win_arm64.whl", hash = "sha256:c8ae19173e5f27f8c12d4b5eee2dbfe542cee125d591e663e0fb4dfb75246d45", size = 1009630, upload-time = "2026-08-17T07:55:03.689Z" }, +] + +[[package]] +name = "soxr" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version == '3.11.*'" }, + { name = "numpy", version = "2.5.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ed/11/27cebce4a108f77afea7c80545115536b45e3f11ebfb914f638fdd9ba847/soxr-1.1.0.tar.gz", hash = "sha256:9f228ae21c78fa9359ca98d8a5e8e91f30639e438e574133dace62c5b5309e44", size = 173067, upload-time = "2026-05-03T00:15:18.214Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/96/6b335638dd3ef4e5d50b9a0a7497e8433ab10fb45457497010074dd3c734/soxr-1.1.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:9564d82f7fa6bf548e5f18bb86235dff20eea8bd30727b64d49783c95c34fb8d", size = 205270, upload-time = "2026-05-03T00:14:38.391Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0e/79e479b38f014757af877755c6eeea10c8750f66ef1e2231709f1d5dc7ab/soxr-1.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9443e5eb82152d8952422b7285692192cc7dcffa5218bb511b096203018bc273", size = 167049, upload-time = "2026-05-03T00:14:40.226Z" }, + { url = "https://files.pythonhosted.org/packages/b3/aa/52759e223bd5b4923e518d6312161887c96d42b81df5425198cf9f3371e2/soxr-1.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:588c7de1abafe59e66face9a074514658ac0398c85a774cdbb8efac131192692", size = 210589, upload-time = "2026-05-03T00:14:41.863Z" }, + { url = "https://files.pythonhosted.org/packages/38/89/a6550d26ebeb17f83e03cf6cde2d084b8d292900a027d43a6696cbce5c5a/soxr-1.1.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26925618945f1a44dfbd783cc572874f0685e9ecdf46b96f4000f6b8c9c8b825", size = 245032, upload-time = "2026-05-03T00:14:43.341Z" }, + { url = "https://files.pythonhosted.org/packages/79/c6/2e47f17fa4461ba047f5f38a592f39120c21e6af8786268b0be2ef870318/soxr-1.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:b2e94c713b7d96fb92841947b785bcee6606124bc852273fab70454b51bfe270", size = 176571, upload-time = "2026-05-03T00:14:45.035Z" }, + { url = "https://files.pythonhosted.org/packages/8e/49/3e6bc84f87439f222f40b616e9a29a170f41fb564710ea510df19dc26907/soxr-1.1.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:34cc92208c3c412c046813e69da639c04a792c6a41fbfd7d909d359cd3e97a2d", size = 205699, upload-time = "2026-05-03T00:14:46.67Z" }, + { url = "https://files.pythonhosted.org/packages/2f/94/216f46096a85b07d1e6ba7fd44491402e912a3d688cd4f36f0a600ca155f/soxr-1.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bd30f7201eac896ebf5db7b09156e6f1a1b82601900d29d9c8449bdad8365b11", size = 167381, upload-time = "2026-05-03T00:14:48.012Z" }, + { url = "https://files.pythonhosted.org/packages/94/cb/06caa463b8181ec1981bd6376d4a873748b7008193188b8cfb60391eb131/soxr-1.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1577865e993f98ffb261257c3060fa76ec3db44ed3f181b16464268000424464", size = 210938, upload-time = "2026-05-03T00:14:49.768Z" }, + { url = "https://files.pythonhosted.org/packages/86/47/d5964551ca818b7f0c7ef7f3899056263b60ef098a801066350a9672ca8f/soxr-1.1.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3da87e3ffa3e41823d873b051c7ecb2acebd8d1b6b46b752f5facf10a0d84ab9", size = 245268, upload-time = "2026-05-03T00:14:51.422Z" }, + { url = "https://files.pythonhosted.org/packages/8f/29/371467eb86c7ba6810df0bfe9409bcd9c52ec5615b111190fafe23e4d2e1/soxr-1.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:ae30c48ac795378cf23ba3c7c640b8ff794af714ac388b9fd6b31a40b39e6e86", size = 176779, upload-time = "2026-05-03T00:14:53.09Z" }, + { url = "https://files.pythonhosted.org/packages/06/8a/f3da7973b5f1b05d2d7e94d5376b881dcbc05297900cae6c3d33d95b209b/soxr-1.1.0-cp312-abi3-macosx_10_14_x86_64.whl", hash = "sha256:e0e09fa633ce2e67df08b298afced4d184f6e753fc330f241022250f1d0d61da", size = 204124, upload-time = "2026-05-03T00:14:54.505Z" }, + { url = "https://files.pythonhosted.org/packages/03/dc/200013a74641f8774664bbcd2346c695c05c2e300ea792adcb40a293eed0/soxr-1.1.0-cp312-abi3-macosx_11_0_arm64.whl", hash = "sha256:d6a7ad82b8d5f3fcc04b1d2ca055562b96af571e1d4fa7c6c61d0fb509ac43b4", size = 165457, upload-time = "2026-05-03T00:14:56.007Z" }, + { url = "https://files.pythonhosted.org/packages/88/2b/2e5eba817a762a2ec589ff165b8bc5955b25a0ad140045f7cd8e45410543/soxr-1.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf98c0d7b7d5ef5bf072fee8d3020e8b664f2d195933ea7bc5089267c2e22a06", size = 206529, upload-time = "2026-05-03T00:14:57.646Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f1/0e55195893228609c9a08c3b13b7a83a46c3a992cd00d3304f0f320cfb07/soxr-1.1.0-cp312-abi3-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3b033078e86f3c4a658e5697fac8995764fad9e799563616b630136b613167f1", size = 240413, upload-time = "2026-05-03T00:14:59.363Z" }, + { url = "https://files.pythonhosted.org/packages/b0/4d/621e4150e4815246ad552d215a8a294a90143fedd19ee442cf82d3b3abc8/soxr-1.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:6ae2a174bffea94e8ead857dad85999d3f49f091774dbad5b046c0417d7092f4", size = 174357, upload-time = "2026-05-03T00:15:00.724Z" }, + { url = "https://files.pythonhosted.org/packages/76/cd/77b74f1e95af0e11e52e9a034421aece7f7b45afd15a909afd41d5a5d102/soxr-1.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a941f5aaa0b8abced24318105c1ea22576afcc1138c19f625716ce4e2f76ad64", size = 207990, upload-time = "2026-05-03T00:15:02.1Z" }, + { url = "https://files.pythonhosted.org/packages/30/86/600cc31f982288167a59972746f117790162012546f995a32b5a55394b16/soxr-1.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:feebcba99ac99adb8009d46c8f4c1956b8c167576b0ae8a6fb47502e9a6f78e7", size = 169288, upload-time = "2026-05-03T00:15:03.75Z" }, + { url = "https://files.pythonhosted.org/packages/39/e4/80cd9aae0645513db1076d4384e8b2d895faf5009218b4a04348012c54fc/soxr-1.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:52c9ca84e3dc656d83acc424574770e20ea8e0704dc3842d4e27b0fe9d3ba449", size = 211405, upload-time = "2026-05-03T00:15:05.395Z" }, + { url = "https://files.pythonhosted.org/packages/a6/d6/cc3c80ac9b2289da4cf46c5d53b05e4327e6f5560a25868d06f9e2213af1/soxr-1.1.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f4977323ef9c3aa3c2a26ff5fe0191c84b8fd759daf7afb1f25a91a55ad8b730", size = 244617, upload-time = "2026-05-03T00:15:07.134Z" }, + { url = "https://files.pythonhosted.org/packages/d3/9e/f7af5fae841ffe32ed8440234ea2ad6adecca3bd92b6101076268c429000/soxr-1.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:e17d4ef9b0185214b2c0935605ae63f827ea423bc74964be44763d68d2b6c21e", size = 187253, upload-time = "2026-05-03T00:15:08.813Z" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a2/09/77d55d46fd61b4a135c444fc97158ef34a095e5681d0a6c10b75bf356191/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5", size = 6299353, upload-time = "2025-04-27T18:04:59.103Z" }, +] + +[[package]] +name = "tokenizers" +version = "0.23.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e0/7c/2cabb2174e772636683008f2c5621949b645da7d303c596589e84516a184/tokenizers-0.23.3.tar.gz", hash = "sha256:cded33237c77caeef62944d32aa9a7ef42bdce2b3497e18d137e072a8c4be438", size = 385286, upload-time = "2026-10-09T10:16:55.759Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/aa/2e/4ce5b9716f26e526eff6b0502ebed4ea8d7161f03b3c77617c9f25528e97/tokenizers-0.23.3-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:9d2b5c97daf61688c2ad1803ca851800feaba50fb68d5821779e9ea5880d968c", size = 3148800, upload-time = "2026-10-09T10:00:51.457Z" }, + { url = "https://files.pythonhosted.org/packages/b2/72/01e49f032bb346e5aaf06c10c74fe8aeec847173adbadd66eb7c53054bf2/tokenizers-0.23.3-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:68649e97d5b43c44c031d8d848874a6eecae8f8fe40ea989aa777a5a83aca716", size = 3101381, upload-time = "2026-10-09T10:00:54.063Z" }, + { url = "https://files.pythonhosted.org/packages/15/fc/ae987741829b1cd547668c4c94be732ae3eefd1d74344e64c3d2ca714acd/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ec82e80e65a862275b97c3d90b7a523df8d9519ee48aeb4e9625b2cc909274e0", size = 3519944, upload-time = "2026-10-09T10:00:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/1c/da/cc8f6c030afaf05fbddc608158fbb761dca46913cbeba6b112e59fc82e2a/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c64a0713180ff16829d4e7f39a658b77ea11443af4e1aa46523692943c9b1414", size = 3397695, upload-time = "2026-10-09T10:00:57.444Z" }, + { url = "https://files.pythonhosted.org/packages/ec/f1/256f78d1365fa2cd3ea6db716883d74667c8cbb6a21f15fa5b89a773cdc2/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ddedfd4b3b4be6be24ff6ca645c4a37fddfd305f6f3e354c54cf10b715c48215", size = 3753125, upload-time = "2026-10-09T10:01:00.165Z" }, + { url = "https://files.pythonhosted.org/packages/60/93/eee007ac2fcbf4ecfce7fbc354826cf3611f56bdb886f3e91b1f7dd06b8f/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2a89614730d7b80940a5d2ed9320e1ec8add5a745c6151d8d05071b7215505b6", size = 4018598, upload-time = "2026-10-09T10:01:02.05Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f9/0c96c4739461fce9d8d865b416728081bf6230022d7163bd6244f35f4b31/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e88646b8580c5ad7f4361477f1298e9cc01771a1ee9aecfe32c47b8ff614cc38", size = 3602442, upload-time = "2026-10-09T10:01:03.77Z" }, + { url = "https://files.pythonhosted.org/packages/3a/40/6706b82693715581457c6d5423eaa7faae576bb0526c5738a57085eb4449/tokenizers-0.23.3-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:376851d22bcf9d650a5c3090bb83e6cf9e895fbf0595369fa4cd43c1f69b5f87", size = 3396193, upload-time = "2026-10-09T10:01:05.48Z" }, + { url = "https://files.pythonhosted.org/packages/fe/0c/85946de40e25b7364b8f1bcf56def129069acd5bb364b7c86a32919e1a23/tokenizers-0.23.3-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:bf501c40b72d2d5c8623620210430e9cac1ce47a46e45b34107b70a1557d46b0", size = 3553483, upload-time = "2026-10-09T10:01:07.387Z" }, + { url = "https://files.pythonhosted.org/packages/f1/6b/8d615d92cad1d511ca5ab188d1c7c167f0b3d295cc0d96207f9f82d486d8/tokenizers-0.23.3-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:114e2b55ed177179d59f4ab98200a4471e11e78f9e4b5a922d146740f96fcf52", size = 9972248, upload-time = "2026-10-09T10:01:09.437Z" }, + { url = "https://files.pythonhosted.org/packages/c9/7d/a922e37ddd58d1b463bbc2ad08120c8f59c60b814cd353519a116b24f8ba/tokenizers-0.23.3-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:d3407fb7b9c4d75dd68850ffd7180bc0a5d2dbaf0762d888e612f31fec3f9c6b", size = 9802957, upload-time = "2026-10-09T10:01:11.869Z" }, + { url = "https://files.pythonhosted.org/packages/4b/06/5d3f506a86ae0699a0e4ea05c05978f9aee169ef2c1d844e68c971cf8194/tokenizers-0.23.3-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:84513ef0aeb8bf8f4ea11a2e8a7ac163ec5288aa115e649a59b470ac5c3107df", size = 10145487, upload-time = "2026-10-09T10:01:14.268Z" }, + { url = "https://files.pythonhosted.org/packages/26/e5/065625317690ea3548d834dad81f48ea1fd32e4964610e658e195d7fe28e/tokenizers-0.23.3-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e05ab7baf7f47b406a95fea6f3b0a484b2ddcd9e1d14b68844c457eb755085a3", size = 10266026, upload-time = "2026-10-09T10:16:33.054Z" }, + { url = "https://files.pythonhosted.org/packages/77/4e/babede85d0d19f5e3deeef0063e01848141329934d3d77c31b5cab5ac2b4/tokenizers-0.23.3-cp310-abi3-win32.whl", hash = "sha256:1ebf28794e7e4954e20a7f70fbea410b2d1f0418f7dbbca97ca384fcfef38c25", size = 2588086, upload-time = "2026-10-09T10:16:35.686Z" }, + { url = "https://files.pythonhosted.org/packages/d1/6c/24f074c9a0efb98e61b20aafe6b2641922d5db24e447d5d6daffd9e17555/tokenizers-0.23.3-cp310-abi3-win_amd64.whl", hash = "sha256:1f0823bb00c5fdc98e487354d54dd55a03848d61a1a0bf29a68c77f24f3b26c3", size = 2872101, upload-time = "2026-10-09T10:16:37.533Z" }, + { url = "https://files.pythonhosted.org/packages/53/77/a476b6f73a661c11d113a342d2326b91506cf2285f0995d1212a6bb2022d/tokenizers-0.23.3-cp310-abi3-win_arm64.whl", hash = "sha256:7e48734d2de9260d86f03ab056d2cfeeff3869f61dbd49aaa15a2793b5f3458b", size = 2742580, upload-time = "2026-10-09T10:16:39.244Z" }, + { url = "https://files.pythonhosted.org/packages/65/46/f66baaedd42414a3f583c47379dc350e3e1f858a690d2574fd85ae70681b/tokenizers-0.23.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:efa3d7318406b4d115dce61ad5061953f1f44b128e79c020ce4615d763e23b6e", size = 3154274, upload-time = "2026-10-09T10:16:40.876Z" }, + { url = "https://files.pythonhosted.org/packages/c6/41/8de8c63b2d935eee5a0f42011fb7b786ffafeab0b8eb6d17acb8af2293b7/tokenizers-0.23.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a4fbb3662f9f59d199d61338e54b4bcc11d07ebbb1aeb3540dacb2be9c521cb7", size = 3077805, upload-time = "2026-10-09T10:16:42.856Z" }, + { url = "https://files.pythonhosted.org/packages/e3/08/b1cbae8dc8fc7c91f992ac2d87a086e9b3f25a28814047ca16a82fe8c87b/tokenizers-0.23.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:de536665495cb4b409d25bade41963f801aff4225c19a6b804b048f7d14e34c7", size = 3491678, upload-time = "2026-10-09T10:16:45.093Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0d/aac0cb2f3a1fdbef514145b4c5f2df4d05deeb1ee8f73ae641a1b4a62a85/tokenizers-0.23.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5cc24bb457dd4a8af89c8fcb40074d570129ec473df2a866c276ee55db4749d7", size = 3367420, upload-time = "2026-10-09T10:16:47.112Z" }, + { url = "https://files.pythonhosted.org/packages/1e/1d/41a697d0c193a320b243fbd68b2057b6eb2f01ecf80899e1a16e646ff699/tokenizers-0.23.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:acd5c57b4bd3e56e246e2731a3a3a6825a7a7d89b7e3b761ba80bc521710f04b", size = 9945973, upload-time = "2026-10-09T10:16:49.326Z" }, + { url = "https://files.pythonhosted.org/packages/37/e9/b56e619fcd583000a2b1254bb46af8dc6a174d3ba3329f454ad5a95a2be2/tokenizers-0.23.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82eb480f6f1c21cea3349dec32cf1a6384c6c1e775f00f83b0d51197bc013687", size = 10237491, upload-time = "2026-10-09T10:16:51.943Z" }, + { url = "https://files.pythonhosted.org/packages/6f/68/f58b3beb95f3b62816e91e5e768e684cd63e58f9cbece22036dae3b1c971/tokenizers-0.23.3-cp314-cp314t-win_amd64.whl", hash = "sha256:1554a6eed34d9d6a78d23360f4e06df8dffab1ae08c7e8488e0b3e3b36cc266f", size = 2847654, upload-time = "2026-10-09T10:16:54.166Z" }, +] + +[[package]] +name = "tomli" +version = "2.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/78/9ad63712633ed3ab5cc1a648d863d7e7da371e9425e209555a0fe711b695/tomli-2.5.0.tar.gz", hash = "sha256:264507556cd8b8c8e7c6ee037cdf443a463f03f4c958e57195e3d369711b8ff6", size = 17662, upload-time = "2026-10-07T12:23:37.892Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/ab99b60ee52acd949684febabc3005d0045d0f66bebd9cdebd67372d26dd/tomli-2.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c4dc1c1781f2f716de763d1e9a7b34c6a894e167e291c7c5d16c72f7a9538545", size = 163901, upload-time = "2026-10-07T12:22:15.601Z" }, + { url = "https://files.pythonhosted.org/packages/bc/00/ee01b7ed4579180fff07142d290257f25ba786f23f3ec6005f620933c2f5/tomli-2.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eff8babca5a7999bc137acbc7482a8b7e17ffca5075ab41f5d770ab408c7bfef", size = 163756, upload-time = "2026-10-07T12:22:16.957Z" }, + { url = "https://files.pythonhosted.org/packages/72/c2/4efebf65372f6583185f79799312109dddb61102d47e5c33dcfd1a297aca/tomli-2.5.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:86665cee9c4835b7a7f1e8ec2c719b5258d4dc782887aded5a8ae7352a96843b", size = 268038, upload-time = "2026-10-07T12:22:18.135Z" }, + { url = "https://files.pythonhosted.org/packages/53/07/5850468e925d898abb36038666f9c333a94d2a223e802a8ba5b6d319d23f/tomli-2.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d7e369fd63331746182360977b1892bfc215476a30d61612d732425311639f56", size = 276422, upload-time = "2026-10-07T12:22:19.567Z" }, + { url = "https://files.pythonhosted.org/packages/b4/87/f293984cdcf83c054196d4fd3dad44fc68ae55b4b8c44bc76cef360c3150/tomli-2.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ad1ea345759240d6463efa0ed1c704402752e49aa21476620738d74d72d8aa1", size = 272616, upload-time = "2026-10-07T12:22:20.794Z" }, + { url = "https://files.pythonhosted.org/packages/ce/ce/db582886b3c1219d3fec93ebd669332482e5aee7a91e0f7838d84f2d1759/tomli-2.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:96243987194634bd411066ce40c952e108f86af04db533ecd8ac3ff2a85b1885", size = 276593, upload-time = "2026-10-07T12:22:22.12Z" }, + { url = "https://files.pythonhosted.org/packages/bf/72/7619b87dea4261fc27dd7b54c4461c129c1f7d9bb7ba3aec89c797a431b8/tomli-2.5.0-cp311-cp311-win32.whl", hash = "sha256:610b27d99f28ec5f191c7064a48f3ddb179a1fe6ca73d571483ae859f57b605e", size = 101830, upload-time = "2026-10-07T12:22:23.651Z" }, + { url = "https://files.pythonhosted.org/packages/1e/74/220106da34502304b6751a2a9b8a9fbca6c3fd47e737a2e2e3da7c61c9db/tomli-2.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:c804ae44fe7b4bab5da295e4f980a1ff04670bca9d23fe0a4e887e08ebd741a8", size = 112742, upload-time = "2026-10-07T12:22:24.972Z" }, + { url = "https://files.pythonhosted.org/packages/27/99/7d9c8b41837a7773613e169504147375c157a290167aa59ad74a085f521f/tomli-2.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:cfac177ebd6236003846ea339981f71457cb6eb748f23381eb257e45092e3980", size = 109332, upload-time = "2026-10-07T12:22:26.117Z" }, + { url = "https://files.pythonhosted.org/packages/52/ed/7baa86f87493646a594de388c7c1c40a39dd0461f7e9c0359cbeefc91fe8/tomli-2.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1f4a40d03fb9f63424f0979855bdeaf44dd7696b8d59501822c10ed30ba532df", size = 164854, upload-time = "2026-10-07T12:22:27.444Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b1/44c0341f2224397855723c7a8a39f718ea6fcbcc3dacc66e5aeca0f334e3/tomli-2.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9ebf8d19b17bd0daeb7b7dec81a946a439b753942fd0210d6e96c532249eea6b", size = 164074, upload-time = "2026-10-07T12:22:28.679Z" }, + { url = "https://files.pythonhosted.org/packages/23/04/e2d5b7d3fba47adedb23de616c16d428ea076c79a3d8e1d95d649ffe197e/tomli-2.5.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf0b5e8e0f68ebb494356e577c06c139161efd8d3b9050f93b39b7c26cc54ff0", size = 274274, upload-time = "2026-10-07T12:22:29.804Z" }, + { url = "https://files.pythonhosted.org/packages/43/90/6090e706ff27a6f89f4a40578e3324b95c3cd8c4150868aabf33a8f414c3/tomli-2.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cf74416bdc94ae458b14e37286c1073081850ac8459a00d0c5efef5d44294c6", size = 286435, upload-time = "2026-10-07T12:22:31.297Z" }, + { url = "https://files.pythonhosted.org/packages/0a/9e/a2c40768df16c408f22430afb0a73e9d7e5f79c950884954649d1146b74d/tomli-2.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:61ea1ebe1e55a34ea8199cc8dbff398d35027b82271c8ac4802fd3a1fd5b1bcc", size = 278119, upload-time = "2026-10-07T12:22:32.601Z" }, + { url = "https://files.pythonhosted.org/packages/12/25/3c0cb485b98e9cfac495629b1c93c87ccf0b72fbe9d2689fd8fe62c6d5a3/tomli-2.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed53f7e89bb04f6d9e8e7799112360b0c4d5cbff067de0814c98c37c39b920f7", size = 286177, upload-time = "2026-10-07T12:22:33.745Z" }, + { url = "https://files.pythonhosted.org/packages/77/8b/0144c65f0e37e51c18d04ae15c21b19431c165002d0131fe9aa8b0b8b1e8/tomli-2.5.0-cp312-cp312-win32.whl", hash = "sha256:e7ad033e27a516a233bea839cdb77b80146facb3b4f40bf02cd0cac165cdd5c2", size = 102760, upload-time = "2026-10-07T12:22:34.887Z" }, + { url = "https://files.pythonhosted.org/packages/de/32/5d6d8f42fc9a05fce69354e00ff256484192f5f2fc9a2165718fa0de61ec/tomli-2.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:bd05de8c1698f8413dd7d869492693a0bf2211543b787ac78cd5e7536af1a6d7", size = 112722, upload-time = "2026-10-07T12:22:36.162Z" }, + { url = "https://files.pythonhosted.org/packages/30/65/df18032218db0fb9b769fb23c8039a051f15c811993995ea04c350273a32/tomli-2.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:069435bd5480429b98c5e5afb02ab21c219b6f0064680671c6dc0d46817346ea", size = 109534, upload-time = "2026-10-07T12:22:37.296Z" }, + { url = "https://files.pythonhosted.org/packages/42/e5/51736d70da209350969e15aca5c5ab6e2ce1ea87a0a892a6c13aec172a86/tomli-2.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:943276cf269e0071948d9ff697159c1735e623c1151d88abb09b74659ef0cbea", size = 163328, upload-time = "2026-10-07T12:22:38.373Z" }, + { url = "https://files.pythonhosted.org/packages/ec/55/086f80dab4ab497602644274e6dea7ec5dd0b4e262e443a8ad3bb7edee2d/tomli-2.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:463b16086865b97facd8d0b3fb4cb7c544e3f58d2a69dc3113d6db9653fdb043", size = 162246, upload-time = "2026-10-07T12:22:39.673Z" }, + { url = "https://files.pythonhosted.org/packages/aa/eb/3ecc94459f3635c92321f4e7bde571323fdb2267c50e19e3188a281eae3b/tomli-2.5.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1245a6638fc4bb0a60af38a7d45413db34a13842027c77597c712c998c62fdf0", size = 272655, upload-time = "2026-10-07T12:22:41.08Z" }, + { url = "https://files.pythonhosted.org/packages/c0/d7/494fd1f0c37a621f1ad9975c2efadb523e8101f144ed6edb2e7fe64738f2/tomli-2.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5d8bac3d603c97e6854424e5b2b5b741bdbde387e09f162fb0446812b4a8362b", size = 283595, upload-time = "2026-10-07T12:22:42.222Z" }, + { url = "https://files.pythonhosted.org/packages/70/51/bb8d62b1317e6640866f6949b2d5855e5300f2c99d46de1cd245570bba65/tomli-2.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:21e4cae4114aba25aa0d4f85cdf486d290fb35c0954d7bba536248da64d43066", size = 276253, upload-time = "2026-10-07T12:22:43.625Z" }, + { url = "https://files.pythonhosted.org/packages/66/f4/f46bd7f0763cd47de2db697dca9257c6a4adfd1a93b018cc75c8190ed5a8/tomli-2.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bbaefc84548d754be821bba7c4141c4787dda182f9e77f2f87b71213529efa7b", size = 283582, upload-time = "2026-10-07T12:22:44.983Z" }, + { url = "https://files.pythonhosted.org/packages/ac/03/70f2bcb2923a6db37818d917e124270a7f4cfd38ea576f5aa753a91c0ef5/tomli-2.5.0-cp313-cp313-win32.whl", hash = "sha256:abdbf6313b8d9efe157edeb7ab6eae4de064b1300ad31abf73755154b30abe68", size = 102628, upload-time = "2026-10-07T12:22:46.508Z" }, + { url = "https://files.pythonhosted.org/packages/dc/98/d52024bb5b0ff68b4f0d276d867f634c84a67319a7e9f6b7708a37742333/tomli-2.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:fd4dc129784e0c5335bd4e61dfcc4487499a013419e655cf2da1d091b7e0efdc", size = 113301, upload-time = "2026-10-07T12:22:47.647Z" }, + { url = "https://files.pythonhosted.org/packages/6f/f2/540db3a70572a8c23a28aba3e9c358ce0ffffbafc990905c1343aa265b31/tomli-2.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:69491c143d2fe063046e0301e62a810bed338fa4d1ce0fd870c27dc1e09b0d84", size = 109744, upload-time = "2026-10-07T12:22:48.925Z" }, + { url = "https://files.pythonhosted.org/packages/e4/49/caf6b307766eb9567664a8707e9d6be5fcc0e8903f18781c6677a60d80c7/tomli-2.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d3182ee2d887e507bd67319a0a61105d1dd33facc111329559a233b772c1a105", size = 162899, upload-time = "2026-10-07T12:22:50.088Z" }, + { url = "https://files.pythonhosted.org/packages/d3/c8/68cfce773a2733a49c74f99d627fb461bd990756860099eac25617889585/tomli-2.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:521345fd1f19d45b8df87657aaa38b6f2ca3800059fadf428e7ebf479a383646", size = 162080, upload-time = "2026-10-07T12:22:51.558Z" }, + { url = "https://files.pythonhosted.org/packages/7e/b2/e5bb8651fdad593f670501a7d718b1a7f73f064d44dea15e04c04dfef45d/tomli-2.5.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e95c7614e705bfe2b04b27aa124adec59752d15813df37e2156747cab3a006b", size = 273380, upload-time = "2026-10-07T12:22:52.918Z" }, + { url = "https://files.pythonhosted.org/packages/8d/d2/9e2d7f8b1dfe0e2b34c245986ebd55c4c553ea4ce6c47c443b332673253f/tomli-2.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7ac2027d37c3afbdf4bdd377f2676f6f1d2122a5be1f1137b49dced590b37e75", size = 283228, upload-time = "2026-10-07T12:22:54.173Z" }, + { url = "https://files.pythonhosted.org/packages/ba/df/ec7b876b7b1a2718bd74a3743c076fff565b04029ba33e8f61fac262739f/tomli-2.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c414be4ed9d3cac80c42e348fa5a956117d1a48227f48026e31f59cb4a7671eb", size = 277189, upload-time = "2026-10-07T12:22:55.342Z" }, + { url = "https://files.pythonhosted.org/packages/7d/7b/e192d9eed0b9cb80da799f4d77052297fb9a2c3cc9b19f571f56ea88add6/tomli-2.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9b03d7dc168353b4132965bde20feceabaa470e570c6f59660dfae59b1f9eeb3", size = 283632, upload-time = "2026-10-07T12:22:56.735Z" }, + { url = "https://files.pythonhosted.org/packages/84/50/ff94454e75461d75623e47401ed323d65c10aab8fe9033242c20cd2fdf32/tomli-2.5.0-cp314-cp314-win32.whl", hash = "sha256:6f041843c4d3a37245c0c056fd955b186bf8b1fb85690cbe40b81230891dc34b", size = 103535, upload-time = "2026-10-07T12:22:58.084Z" }, + { url = "https://files.pythonhosted.org/packages/54/0b/bdacf05f963bd6026ebf6eeb0beda847d1d60e03e440725c64a4e08a0afd/tomli-2.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:f4b653094e18f9031102d3a1da5c729c8f222d85225b18037dac621695e46e1a", size = 114621, upload-time = "2026-10-07T12:22:59.2Z" }, + { url = "https://files.pythonhosted.org/packages/61/99/53f438fa6ae4f9d4ed0ddde3e7242b3bdc34b48c8f9948b72b9e9b127676/tomli-2.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:3f89d10c1ff6a38d992c27fc8a4816af71a909e08a40ec66934240b1e74347c3", size = 111572, upload-time = "2026-10-07T12:23:00.479Z" }, + { url = "https://files.pythonhosted.org/packages/b9/20/1f88f19427d380a40e90a770e087489eaafe4aeee070ae88ed2bbec00acd/tomli-2.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:e9e15b4a6c7dd6b85b5fbab29488a73f1f70de516942308daa266bf0e0aeb0d4", size = 171814, upload-time = "2026-10-07T12:23:01.914Z" }, + { url = "https://files.pythonhosted.org/packages/d0/56/cbe5079c9f9a54b9b3e27fc82f08f3cb36edee75561679f53d2380c801d6/tomli-2.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e12bbcd32897272fb05929110362ae9ff4c1b9bb26bd9e971e71dcd3275b4c3d", size = 171324, upload-time = "2026-10-07T12:23:03.18Z" }, + { url = "https://files.pythonhosted.org/packages/2b/30/1d53fd3b0f1cb3ba542e345ec32c26aefdddc4e829e4f3429af8a4f27782/tomli-2.5.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20aa36de8f2cf87237143bc1fa1aae8d6612c09118f4da21c6a684db5dd1f6f9", size = 297441, upload-time = "2026-10-07T12:23:04.345Z" }, + { url = "https://files.pythonhosted.org/packages/66/d9/0800acb6a111686f764c1b91ef15cc42a20a66a46013bb42220f1d2c61c1/tomli-2.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22185fad8a1e622f064e78008018a0dd3323550dcb479cb7a1d296888d74024f", size = 307476, upload-time = "2026-10-07T12:23:05.671Z" }, + { url = "https://files.pythonhosted.org/packages/e8/63/30a8f3cd51b5bec37f04744bad0b0dc6160df84aad4f27b0e9283d66f221/tomli-2.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:984012f71908165449a951de2050d52f276bfe3aa5d5f570f63ddad814370374", size = 296113, upload-time = "2026-10-07T12:23:07.202Z" }, + { url = "https://files.pythonhosted.org/packages/ab/18/0b9ffc597e69c5a1e20a7823cb60d54b39a9f54e91edcb8574f022186758/tomli-2.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f79203b3965b4000e91808aaa7c040206093f2b8bf86f455982f2274c9ccf442", size = 307725, upload-time = "2026-10-07T12:23:08.508Z" }, + { url = "https://files.pythonhosted.org/packages/ab/c7/18f8baae0b5607a60e8e19b4a7fedee43a8ff6458e3896dcbbadeeac9c22/tomli-2.5.0-cp314-cp314t-win32.whl", hash = "sha256:91294a9fb94a75542f6e46e4a2ae709bd8d9b51134098cae5cf3bea5478b6d03", size = 108546, upload-time = "2026-10-07T12:23:09.956Z" }, + { url = "https://files.pythonhosted.org/packages/72/34/4cca9739254130627bde87500b3f2b512154fe2f278efa7e2a5e10ad4bcb/tomli-2.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:f15e3e0b835a6d68b10c86bf80a3149780498d6911c93c3ffd1861d19f9200f1", size = 117814, upload-time = "2026-10-07T12:23:11.486Z" }, + { url = "https://files.pythonhosted.org/packages/7d/fb/afa530d47dd80a78fce43beac6bc6e00f84558eafcffbc6f37b21e80d056/tomli-2.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:6664b7ae7af7294256c53960a6103077f4914cec8ff98479c352f622c6f6b2f0", size = 115188, upload-time = "2026-10-07T12:23:12.728Z" }, + { url = "https://files.pythonhosted.org/packages/66/98/316fdc00f8c0939e6fe50461dd343c162d3ad51d1286eb25b7db54361d50/tomli-2.5.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a525685c2f97da40762b8695eb7aa0af4c8344ca1905c73e4e29cb04d34607dc", size = 162775, upload-time = "2026-10-07T12:23:13.941Z" }, + { url = "https://files.pythonhosted.org/packages/c5/22/7b10fa5bb01c9539f53f69b619361b19350acc73657772ea7ac70ba309a8/tomli-2.5.0-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:9dbb18c1cfb2f6517942fc9314437f66aa06d94436ffb1f06102ef3572f35276", size = 161406, upload-time = "2026-10-07T12:23:15.215Z" }, + { url = "https://files.pythonhosted.org/packages/9c/e7/1a069d86dfd20f1f84f71c63faed9f83c1d890bc06c27d82dc7d888fb573/tomli-2.5.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:752e8b1aa6a4367ef8bf6a1a1e005540f7ed055ba36d7193796812ca5404eb52", size = 273855, upload-time = "2026-10-07T12:23:16.471Z" }, + { url = "https://files.pythonhosted.org/packages/ae/83/d1ef43d1687d092ab9c235455c76e6e709483b346b056f086095c7c263a5/tomli-2.5.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c47300f9bf791808f77d82747691c4bb09cb14bdf3060cca99b42cdc4361d5a7", size = 284910, upload-time = "2026-10-07T12:23:18.166Z" }, + { url = "https://files.pythonhosted.org/packages/cc/05/f4d9cf7de61822ece0c3873f30d291e324911c71a378b8bfe5ced13fd9f5/tomli-2.5.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:19b0dd8749f4ea2f112c5fcfb3c5248390c899d7e2e173f1d91abee1fa0ff391", size = 277723, upload-time = "2026-10-07T12:23:19.355Z" }, + { url = "https://files.pythonhosted.org/packages/42/28/78262493141fa543151cf005760c3cb01d09fc28a11f993c05109902cb8c/tomli-2.5.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:57b1c3b01fab802e2899bc3d168dca320e14165e2fd9fd584760fb4ca5826859", size = 285115, upload-time = "2026-10-07T12:23:20.698Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b9/e1dab9a30bcb677b5cc5cee810609cfd64f24306a3055767dd3fda00b1e0/tomli-2.5.0-cp315-cp315-win32.whl", hash = "sha256:667e521b37a6c5ccaa044202c235b530f90177ffe2cd4a64ecc213c7dd535feb", size = 103475, upload-time = "2026-10-07T12:23:21.941Z" }, + { url = "https://files.pythonhosted.org/packages/4c/bd/31a3790c11d6ea95fcf5e6022ac0f8d0543c9b61120b730fc481bd43d3b4/tomli-2.5.0-cp315-cp315-win_amd64.whl", hash = "sha256:d747252933c8a65ef6bd8da0fbb7ce28a90eb6119d8cd00772cd528aa07b68d5", size = 114589, upload-time = "2026-10-07T12:23:23.098Z" }, + { url = "https://files.pythonhosted.org/packages/47/a2/4f6310fa699364f0e3af7ee3af88dddd9af066d33e716a0265bbe2b3ea84/tomli-2.5.0-cp315-cp315-win_arm64.whl", hash = "sha256:75dbcde8751b0a960aa3de173aa5e894d590755c6d7758b7e774c06f1dc3cbdd", size = 111493, upload-time = "2026-10-07T12:23:24.233Z" }, + { url = "https://files.pythonhosted.org/packages/68/14/00853f0b396d8971107ae1921bb5b322fdee1650d2f16bf06c20adb532e5/tomli-2.5.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:2419c2a189551987b59d80e63ec355671283336f41c6b9b89462df679c7d0c57", size = 171380, upload-time = "2026-10-07T12:23:25.512Z" }, + { url = "https://files.pythonhosted.org/packages/89/ad/fa6949321dadee46b27363974fb197b94c911c3b0f7a5fd26d7dc18fc2a0/tomli-2.5.0-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:0dc598040da8d42cf20f0be588ed7004f46db12a0ac6c32e03a59dccedaaadcd", size = 170553, upload-time = "2026-10-07T12:23:26.855Z" }, + { url = "https://files.pythonhosted.org/packages/53/aa/3056c919eb3e084df3752b2cf5f865dcc04af0b27dba2f66d7b28af4633a/tomli-2.5.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49096930c8d886c9bbdab62d2d0d17ce823ddeea522309a190b36245d5b49e01", size = 294428, upload-time = "2026-10-07T12:23:28.132Z" }, + { url = "https://files.pythonhosted.org/packages/96/b2/faeeb5d8769ea3832021d73e892c8391eae7b4b4f8b55a789127bd8b18a9/tomli-2.5.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8ade5023067f99fe72b88accd30d0ea05a158e9e32a11f124e731ea9695313f", size = 304909, upload-time = "2026-10-07T12:23:29.381Z" }, + { url = "https://files.pythonhosted.org/packages/f6/52/f094c09e73fb654b621716d019acb5d29bdfd1be01df80c281d552bda48d/tomli-2.5.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:b69564772b5c8f22ea5f498dff08cfa825045b4d4c4400529000bdf818aa3b2a", size = 293220, upload-time = "2026-10-07T12:23:30.608Z" }, + { url = "https://files.pythonhosted.org/packages/86/f5/0c30541078ca4b505ce3bd76ed931facbfec524dd018535d691d1af0a6d2/tomli-2.5.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:8ff3a2ca028c7eee0c777f9a092038d0a594a9fa04e215f929a22c329e2cb142", size = 305705, upload-time = "2026-10-07T12:23:32.181Z" }, + { url = "https://files.pythonhosted.org/packages/05/74/590e7d19d6a118fc5cc5704ff358e21d95b8573f6b9443b1519f29ca8825/tomli-2.5.0-cp315-cp315t-win32.whl", hash = "sha256:62fc1bc8eb03e3a9cadfca713d65614ed8e09d974a283295ffe3a831976b4dc5", size = 108432, upload-time = "2026-10-07T12:23:33.496Z" }, + { url = "https://files.pythonhosted.org/packages/1c/b8/63a75cfb27a17c38550e44025d3a6e7be64516fd8608a3b75703bf37d81b/tomli-2.5.0-cp315-cp315t-win_amd64.whl", hash = "sha256:f3fcbc57b1791fa6cbe5d8434179d51de12be1a4811469529f47f6e7487a2571", size = 117281, upload-time = "2026-10-07T12:23:34.648Z" }, + { url = "https://files.pythonhosted.org/packages/72/01/e8c1debb2173973372934c68fc8e46170ab60ef23ed4592dff4dec6e8993/tomli-2.5.0-cp315-cp315t-win_arm64.whl", hash = "sha256:d2ba24db8a9376921b5e87b4762b9adb0f3f1deaea68f2b8b0bb2c11efb9c3e7", size = 115069, upload-time = "2026-10-07T12:23:35.77Z" }, + { url = "https://files.pythonhosted.org/packages/60/3f/3e3f8fd0919249b0200c80fbc4f9a1e70be19f9883da71dfb7f8b9ab8aca/tomli-2.5.0-py3-none-any.whl", hash = "sha256:32a7b79ac57a2e83670ce329ccf675798bc5a2094783a63676866b70503f2e2b", size = 14765, upload-time = "2026-10-07T12:23:36.875Z" }, +] + +[[package]] +name = "tqdm" +version = "4.70.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/ea/b2a5bd54b28a324dae8211928b2d730b6547500342c7e6c6dea08bd0a485/tqdm-4.70.1.tar.gz", hash = "sha256:cefd0eca11b2a37a3aee776544d4f4ae913f02688135b5556b8788dfa474afc4", size = 171846, upload-time = "2026-09-11T07:25:16.601Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/03/921a3d3c75785aca9ebfbfcabfbc3a1be12e2ab5265deb026d55a5a3f83e/tqdm-4.70.1-py3-none-any.whl", hash = "sha256:c293e525e6fef9c20e8728fd4612df02a0aa31bb5fe91ecd93e123b1b7bffa73", size = 80199, upload-time = "2026-09-11T07:25:14.599Z" }, +] + +[[package]] +name = "truststore" +version = "0.10.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ee/9f/c5201d42a484c061e528825fc8e2d565f5abd50a4ced6fb7d29c4ec99b2b/truststore-0.10.5.tar.gz", hash = "sha256:30d36967ccaded5cbb38d602c433f53600036c79d502f4533a49b60a03bbefcd", size = 28091, upload-time = "2026-10-12T22:27:31.808Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/e9/3a7820be2bb0fe53b6bc9c3be26d3d1158004e4c3ab953aa6840b955b1e9/truststore-0.10.5-py3-none-any.whl", hash = "sha256:9aaaedaefaf06d8b206278cf8b5012bc897f485a874503501e12d776df78951c", size = 19017, upload-time = "2026-10-12T22:27:30.377Z" }, +] + +[[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.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a3/26/b09b8010994eccc3c09092e6b34058f36a460eea2d4c3e8b910c695975a0/typing_inspection-0.4.4.tar.gz", hash = "sha256:547274fa6b0a561ccf549cc9524b999a578e737d015d8709d021f9d0d13bea47", size = 76928, upload-time = "2026-08-12T12:37:25.997Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl", hash = "sha256:65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147", size = 14750, upload-time = "2026-08-12T12:37:24.648Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/18/05/ba1458dee0ac485b2a01071c1b88f5199fe878a485df482e10e1ef2205cc/zipp-4.1.2.tar.gz", hash = "sha256:cf474b90b07ea932637e17c6b9479de2b2882900b0d311bdaf4f5c000a15a97f", size = 27864, upload-time = "2026-10-21T18:57:04.743Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b8/44/7bd2007260da11cccca29ba2d4c345f1287aa663db38ee7cefeabf6386a5/zipp-4.1.2-py3-none-any.whl", hash = "sha256:b30cb6cd253122169c47de245ca24a86bac2a5d3802ba15bf7ba6414eb9e144d", size = 10581, upload-time = "2026-10-21T18:57:03.79Z" }, +]