initial commit

.codacy.yaml

@@ -0,0 +1,7 @@
+---
+# Keep Codacy focused on the shipped library code: the lockfile is
+# machine-generated, and pytest test code legitimately uses bare asserts.
+exclude_paths:
+  - "uv.lock"
+  - "coverage.xml"
+  - "tests/**"

.github/workflows/codacy-analysis.yml

@@ -0,0 +1,61 @@
+name: Codacy Security Scan
+
+# Run Codacy static analysis on every commit reaching main — by direct push,
+# by pull request, or via a merge (a merge is a push to main). Results are
+# uploaded to GitHub's Security > Code scanning tab.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  security-events: write
+  actions: read
+
+jobs:
+  codacy-analysis:
+    name: Codacy static analysis
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      # Runs the full Codacy Analysis CLI (multiple linters/tools) and emits
+      # SARIF. max-allowed-issues forces exit 0 so the SARIF is always produced;
+      # PR gating is handled on GitHub's side from the uploaded results.
+      - name: Run Codacy Analysis CLI
+        uses: codacy/codacy-analysis-cli-action@562ee3e92b8e92df8b67e0a5ff8aa8e261919c08 # v4.4.7
+        with:
+          output: results.sarif
+          format: sarif
+          gh-code-scanning-compat: true
+          max-allowed-issues: 2147483647
+
+      # Codacy emits one SARIF with a run per tool, all sharing a category;
+      # GitHub rejects that since 2025-07. Keep only the security tools'
+      # runs (lint results live on the Codacy dashboard) and give each run
+      # a stable per-tool category — name + occurrence, never the run
+      # index, because Codacy's tool order varies between runs and a
+      # category that stops receiving uploads leaves its alerts open
+      # forever.
+      - name: Filter to security tools and assign stable categories
+        run: |
+          jq '.runs = (reduce (.runs[]
+                | select((.tool.driver.name // "" | ascii_downcase)
+                    | test("bandit|semgrep|opengrep|checkov|trivy")))
+                as $r ({c: {}, o: []};
+                  (($r.tool.driver.name // "tool")
+                    | ascii_downcase | gsub("[^a-z0-9]+"; "-")) as $n
+                  | .c[$n] += 1
+                  | .o += [$r + {automationDetails:
+                      {id: ("codacy-" + $n + "-"
+                            + (.c[$n] | tostring) + "/")}}])
+                | .o)' results.sarif > results-categorized.sarif
+
+      - name: Upload SARIF results to GitHub
+        uses: github/codeql-action/upload-sarif@54f647b7e1bb85c95cddabcd46b0c578ec92bc1a # v4.36.3
+        with:
+          sarif_file: results-categorized.sarif

.github/workflows/codacy-coverage.yml

@@ -0,0 +1,44 @@
+name: Codacy Coverage
+
+# Runs the test suite with coverage and reports it to Codacy (feeds the grade
+# and coverage badge). Triggers on every commit reaching main and on PRs.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  coverage:
+    name: Tests + coverage
+    runs-on: ubuntu-latest
+    env:
+      CODACY_PROJECT_TOKEN: ${{ secrets.CODACY_PROJECT_TOKEN }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5
+        with:
+          python-version: "3.14"
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run tests with coverage
+        run: uv run pytest --cov --cov-report=xml
+
+      # Only uploads when the CODACY_PROJECT_TOKEN secret is configured, so the
+      # job still passes (tests + coverage) before Codacy is wired up. Add the
+      # token under Settings > Secrets and variables > Actions to enable upload.
+      - name: Upload coverage to Codacy
+        if: env.CODACY_PROJECT_TOKEN != ''
+        uses: codacy/codacy-coverage-reporter-action@89d6c85cfafaec52c72b6c5e8b2878d33104c699 # v1.3.0
+        with:
+          project-token: ${{ secrets.CODACY_PROJECT_TOKEN }}
+          coverage-reports: coverage.xml

.github/workflows/gitleaks.yml

@@ -0,0 +1,29 @@
+name: gitleaks
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  scan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0 # full history — gitleaks scans every commit
+
+      - name: Install gitleaks
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release download v8.30.1 --repo gitleaks/gitleaks \
+            --pattern '*linux_x64.tar.gz' --output gitleaks.tar.gz
+          tar -xzf gitleaks.tar.gz gitleaks
+
+      - name: Scan full history
+        run: ./gitleaks git . --no-banner --redact

.github/workflows/lint.yml

@@ -0,0 +1,35 @@
+name: Lint
+
+# Ruff lint + format checks on Python 3.14, driven by uv. Triggers on every
+# commit reaching main and on PRs.
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    name: ruff (Python 3.14)
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Set up uv
+        uses: astral-sh/setup-uv@d4b2f3b6ecc6e67c4457f6d3e41ec42d3d0fcb86 # v5
+        with:
+          python-version: "3.14"
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Lint
+        run: uv run ruff check src tests
+
+      - name: Format check
+        run: uv run ruff format --check src tests

.gitignore

@@ -0,0 +1,63 @@
+# Byte-compiled / optimized
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+
+# Distribution / packaging
+build/
+dist/
+develop-eggs/
+eggs/
+.eggs/
+sdist/
+wheels/
+*.egg-info/
+*.egg
+MANIFEST
+
+# Test / coverage
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Environments
+.env
+.venv
+env/
+venv/
+
+# Type checkers / linters
+.mypy_cache/
+.dmypy.json
+.pyre/
+.pytype/
+.ruff_cache/
+
+# IDEs / OS
+.idea/
+.vscode/
+*.swp
+.DS_Store
+
+# Local agent working files
+.claude/
+docs/superpowers/
+
+# Secrets — real device credentials, never commit
+config.toml
+config.yml
+config.yaml
+configir.yaml
+devices.json
+tuya-raw.json
+snapshot.json
+*.snapshot.json
+tinytuya.json

.gitleaks.toml

@@ -0,0 +1,15 @@
+# gitleaks config — see SECURITY.md.
+# Extends the default ruleset; allowlists the synthetic credentials used in
+# unit tests and in config.example.toml so real findings stand out.
+
+[extend]
+useDefault = true
+
+[allowlist]
+description = "Synthetic test credentials and documented placeholders"
+regexes = [
+  '''abcdef0123456789''',
+  '''testdevice0000000000\d\d''',
+  '''uuidTESTtest\d\d\d\d''',
+  '''YOUR_[A-Z_]+''',
+]

.python-version

@@ -0,0 +1 @@
+3.14

README.md

@@ -0,0 +1,196 @@
+# tuya-re
+
+Control your Tuya devices locally — no cloud, no phone app, and (for the
+direct paths) no gateway. tuya-re is a from-scratch implementation of Tuya's
+local protocols: after a one-time credential pull, your commands never leave
+your machine or your LAN.
+
+The project merges three earlier proofs of concept into one tool. It drives
+four device paths:
+
+| Device family | Transport | Command group |
+|---|---|---|
+| Fingerbots | Bluetooth LE (Tuya BLE v3) | `ble` |
+| Wi-Fi switches and plugs | LAN (Tuya local v3.3 and v3.4) | `switch` |
+| IR blasters (GWW-RC03 / JMIR05) | Bluetooth LE (Tuya BLE v3) | `ir` |
+| Fingerbots behind a Tuya BLE gateway | LAN, via [tinytuya](https://github.com/jasonacox/tinytuya) | `gateway` |
+
+The BLE and LAN stacks (framing, crypto, sessions) are hand-written on top of
+`bleak` and `pycryptodome`. Only the gateway path delegates protocol work to
+`tinytuya`.
+
+## Prerequisites
+
+- [uv](https://docs.astral.sh/uv/) — all commands run through it.
+- Python 3.11 or later (development and CI use 3.14; uv installs it for you).
+- For BLE commands on macOS: run from Terminal or iTerm and approve the
+  Bluetooth permission prompt on first use. A process launched without a GUI
+  parent is stopped by the OS instead of prompted.
+
+## Install
+
+```bash
+git clone https://github.com/swackhamer/tuya-re.git
+cd tuya-re
+uv sync
+```
+
+## Configure the project
+
+1. Copy the template:
+
+   ```bash
+   cp config.example.toml config.toml
+   ```
+
+2. Get your device credentials. At <https://iot.tuya.com>, create a cloud
+   project, link your Smart Life app account (**Devices** > **Link App
+   Account**, then scan the QR code from the app), and open **Cloud** >
+   **API Explorer** > **Query Device Details** (`GET /v1.0/devices/{id}`).
+   The response contains `local_key`, `uuid`, and `product_id`.
+
+3. Fill in `config.toml`. Configure only the sections you need — each maps to
+   one command group. `config.toml` is git-ignored and is the only place real
+   credentials belong. For what's secret and how to rotate keys, see
+   [SECURITY.md](SECURITY.md).
+
+Notes:
+
+- The cloud response's `ip` is your public WAN address, not the device's LAN
+  address. Leave `ip` unset and let UDP discovery find the real one.
+- The `local_key` rotates when a device is re-paired in the app. If control
+  starts failing, re-pull the key and update `config.toml`.
+- For the gateway path, the gateway's `local_key` and the Fingerbot's
+  `node_id` come from `uv run python -m tinytuya wizard` (delete its output
+  files after copying the values).
+
+## Usage
+
+Global flags (`-v`, `--device`, `--timeout`, `--config`) go before the
+command. `--device` selects a named device, `all` for every configured device
+of that type, or omit it for the configured default.
+
+Every command group is available under the unified entry point,
+`uv run tuya-re <group> <command>`. The standalone `fingerbot`, `switch`, and
+`ir` scripts are shortcuts that skip the group prefix.
+
+### Fingerbot over Bluetooth
+
+```bash
+uv run fingerbot scan                # find the device, print its address
+uv run fingerbot status              # connect, pair, dump datapoints
+uv run fingerbot click               # one press
+uv run fingerbot press --duration 3  # press and hold about 3 seconds
+uv run fingerbot --device all click --repeat 10   # both robots, in parallel
+```
+
+The tool scans for the Tuya BLE service, matches the uuid decrypted from the
+advertisement, runs the handshake (`DEVICE_INFO`, derive the AES session key
+from `srand`, then `PAIR`), and writes the click datapoint with a guaranteed
+rising edge. `--repeat` and `--interval` fire multiple clicks over one
+connection; the arm needs about 1.5 seconds per press-and-release cycle.
+
+### Switch over the LAN
+
+```bash
+uv run switch status                 # discover, connect, report on or off
+uv run switch on
+uv run switch off
+uv run switch toggle
+uv run switch --device all off       # every switch, concurrently
+```
+
+`switch` finds the device by UDP broadcast (ports 6666/6667), then opens an
+encrypted TCP session on port 6668 keyed by `local_key`. Protocol v3.3 uses
+AES-ECB framed messages; v3.4 negotiates a session key first, then uses
+HMAC-SHA256-framed messages. The relay is DP 1. (v3.5 is detected but not
+implemented.)
+
+### IR blaster over Bluetooth
+
+```bash
+uv run ir scan                       # find the blaster(s)
+uv run ir status                     # connect, pair, dump datapoints
+uv run ir learn                      # study mode: capture a code from a remote
+uv run ir send "8iOQERoC"            # replay a captured code
+```
+
+`learn` puts the blaster in study mode; point the original remote at it and
+press a button. The captured code prints as base64 — Tuya's format of
+little-endian 16-bit microsecond pulse durations — and `send` replays it.
+DP defaults (send 201 as string, learn/study 202) are confirmed for the
+JMIR05 module; override them with `--send-dp`, `--send-dp-type`,
+`--learn-dp`, and `--study-dp` if your model differs. Unlike the global
+flags, these four go after the `learn` or `send` command — for example,
+`uv run ir send --send-dp 105 "8iOQERoC"`.
+
+### Fingerbot through the Tuya gateway
+
+```bash
+uv run tuya-re gateway status        # dump sub-device status via the gateway
+uv run tuya-re gateway click         # set click mode, then press
+```
+
+This path keeps Tuya's gateway in the loop: the Fingerbot is addressed as a
+sub-device (`cid` = the wizard's `node_id`) of the gateway, and tinytuya
+handles the LAN protocol. Status reads on BLE sub-devices often fail through
+the gateway even though writes work (tinytuya issue #677) — the click command
+prints the status but doesn't stop on it. If the handshake fails, try
+`version = "3.4"` first, then `"3.5"`, then `"3.3"`.
+
+## How the pieces fit
+
+- `crypto`, `packet`, `protocol` — Tuya BLE v3: CRC16, MD5-derived
+  login/session keys, AES-CBC frames, GATT chunking and reassembly.
+- `ble` — scanning, advertisement uuid decryption, connected sessions.
+- `devices` — per-product Fingerbot datapoint maps.
+- `lan_protocol`, `lan_session`, `lan_discovery` — Tuya local v3.3/v3.4:
+  `0x000055AA` framing, session-key negotiation, UDP discovery.
+- `ir` — IR pulse codec and the learn/send flow.
+- `gateway` — tinytuya sub-device addressing for the gateway path.
+- `config`, `cli` — TOML credential loading and the argparse front end.
+
+The protocol layers are transport-agnostic and unit-tested against fakes that
+do real crypto, with framing pinned to byte-exact golden vectors from
+`tinytuya` and `ha_tuya_ble`.
+
+## Develop
+
+```bash
+uv run pytest                        # run the test suite
+uv run pytest --cov                  # with coverage
+uv run ruff check src tests          # lint
+uv run ruff format --check src tests # formatting
+```
+
+`ble.py`, `lan_discovery.py`, and `cli.py` are hardware and entry-point
+boundaries, exercised against real devices rather than unit tests; they're
+excluded from coverage.
+
+## Continuous integration
+
+Four GitHub Actions workflows run on every push and pull request to `main`:
+
+- **Lint** — ruff lint and format checks on Python 3.14.
+- **Codacy Coverage** — runs the tests with coverage and uploads the report
+  to Codacy. Until the `CODACY_PROJECT_TOKEN` repository secret is set, the
+  job still runs the tests and passes; it just skips the upload.
+- **Codacy Security Scan** — static analysis; results appear under
+  **Security** > **Code scanning**.
+- **gitleaks** — scans the full git history for leaked secrets on every push.
+
+## Troubleshooting
+
+| Symptom | Fix |
+|---|---|
+| `device ... not seen on UDP` (switch) | Make sure the plug is powered and on the same LAN, or set a static `ip` in `config.toml`. |
+| Switch set fails or decrypt error | The `local_key` is stale — re-pull it from the API Explorer. |
+| `device not found (N Tuya devices seen)` (BLE) | BLE advertising is intermittent; retry or raise `--timeout`. Power off the gateway and close the phone app — BLE allows one central. |
+| BLE command stops immediately on macOS | Bluetooth permission — run from a real terminal and approve the prompt. |
+| Gateway handshake fails or `Error 914` | Try `version = "3.4"`, then `"3.5"`, then `"3.3"`. |
+| Gateway status shows an error but clicks work | Expected for BLE sub-devices (tinytuya issue #677) — trust the write result. |
+
+## Disclaimer
+
+This is an independent project for controlling devices you own. It isn't
+affiliated with or endorsed by Tuya.

SECURITY.md

@@ -0,0 +1,60 @@
+# Security
+
+## What is secret in this project
+
+| Value | Sensitivity | Why |
+|---|---|---|
+| `local_key` (per device) | **Secret** | The AES key material for the BLE and LAN sessions. Anyone holding it (within radio/LAN range of the device) can control it. |
+| `local_key` (gateway) | **Secret** | One key authorizes **every sub-device behind the gateway**, so treat it as the most sensitive value in the file. |
+| `device_id`, `uuid`, `node_id` | Private identifier | Permanently identify your specific unit. Useless for control without a `local_key`, but there is no reason to publish them — and unlike a key, they can never be rotated. |
+| `product_id` | Public | Shared by every unit of a model (for example, `mknd4lci` is *all* Finger Robot 2s), so it identifies the product, not you. |
+| Tuya IoT **Access ID / Secret** | **Secret** | Cloud API credentials used for the one-time `local_key` pull (API Explorer or `tinytuya wizard`). They are never needed at runtime — don't store them in this repo at all. |
+
+## Where secrets live
+
+All device credentials go in `config.toml` in the repo root, which is
+**git-ignored**. Start from the committed template:
+
+```bash
+cp config.example.toml config.toml
+```
+
+Rules:
+
+- Never commit `config.toml` (or force-add it).
+- Never paste real values into code, tests, commit messages, issues, or PRs.
+  Unit tests use synthetic credentials only (`testdevice000000000001`,
+  `uuidTESTtest0000`, `abcdef0123456789`).
+- Files produced by credential-pulling tools (such as `tinytuya wizard`'s
+  `devices.json`, `tuya-raw.json`, `snapshot.json`, `tinytuya.json`) contain
+  secrets — keep them out of the repo and delete them once `config.toml` is
+  populated. `.gitignore` covers the known names.
+
+## Rotation
+
+`local_key` rotates whenever the device is re-paired in the Smart Life app.
+If a key is ever exposed: re-pair the device, then re-pull the new key from
+the Tuya IoT console (**Cloud → API Explorer →** `GET /v1.0/devices/{id}`).
+`device_id`, `uuid`, and `node_id` are burned into the device and cannot be
+rotated.
+
+## Scanning
+
+[gitleaks](https://github.com/gitleaks/gitleaks) scans the **full git
+history** in CI on every push and pull request
+([`.github/workflows/gitleaks.yml`](.github/workflows/gitleaks.yml)).
+Run it locally before pushing:
+
+```bash
+gitleaks git . --no-banner
+```
+
+[`.gitleaks.toml`](.gitleaks.toml) allowlists the synthetic test credentials
+and the `YOUR_*` placeholders from `config.example.toml` so real findings
+stand out.
+
+## Reporting
+
+If you believe you've found a security issue in the protocol implementations,
+open a GitHub issue — nothing here touches infrastructure beyond your own LAN
+and your own devices.

config.example.toml

@@ -0,0 +1,58 @@
+# Copy this file to config.toml (git-ignored) and fill in real values.
+# The README "Configure the project" section explains where each value comes
+# from; SECURITY.md explains which values are secret and how rotation works.
+#
+# Every section is optional — configure only the device classes you own.
+
+# --- BLE Fingerbots (direct Bluetooth, no gateway) -------------------------
+
+[fingerbots]
+default = "robot1"
+
+[fingerbots.devices.robot1]
+device_id = "YOUR_DEVICE_ID"   # ~22 chars, from iot.tuya.com API Explorer
+uuid = "YOUR_DEVICE_UUID"      # 16 chars, same API response
+local_key = "YOUR_LOCAL_KEY"   # 16 chars — SECRET
+product_id = "mknd4lci"        # Finger Robot 2; see devices.py for others
+
+# --- LAN switches / smart plugs (WiFi, no gateway) -------------------------
+
+[switches]
+default = "smartplug"
+
+[switches.devices.smartplug]
+device_id = "YOUR_DEVICE_ID"
+local_key = "YOUR_LOCAL_KEY"   # SECRET
+product_id = "o7ve1lp3gfjvsvyo"
+# version and ip are auto-detected via UDP discovery; set them to skip it.
+# The cloud-reported ip is your WAN address — use the LAN one or omit it.
+# version = "3.4"
+# ip = "192.168.1.50"
+
+# --- BLE IR blasters (direct Bluetooth) ------------------------------------
+
+[ir_blasters]
+default = "blaster1"
+
+[ir_blasters.devices.blaster1]
+device_id = "YOUR_DEVICE_ID"
+uuid = "YOUR_DEVICE_UUID"
+local_key = "YOUR_LOCAL_KEY"   # SECRET
+product_id = "xgahj3gjk3ftaejt"  # GWW-RC03 / JMIR05
+
+# --- Tuya BLE gateway path (LAN, via tinytuya) -----------------------------
+# Alternative to direct BLE: click a Fingerbot through the official gateway.
+# The gateway local_key authorizes EVERY sub-device behind it — SECRET.
+
+[gateway]
+device_id = "YOUR_GATEWAY_ID"
+ip = "192.168.1.2"                    # the gateway's LAN address
+local_key = "YOUR_GATEWAY_LOCAL_KEY"  # SECRET
+version = "3.4"   # try 3.4 first; retry 3.5 then 3.3 on handshake errors
+
+[gateway.fingerbots]
+default = "robot1"
+
+[gateway.fingerbots.devices.robot1]
+device_id = "YOUR_DEVICE_ID"
+node_id = "YOUR_NODE_ID"   # the tinytuya wizard's node_id (= the cid)

pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "tuya-re"
+version = "0.1.0"
+description = "Local control of Tuya devices (BLE Fingerbots, LAN switches, BLE IR blasters, gateway sub-devices), no cloud"
+requires-python = ">=3.11"
+dependencies = [
+    "bleak>=0.22",
+    "pycryptodome>=3.20",
+    "tinytuya>=1.18.0",
+]
+
+[project.scripts]
+tuya-re = "tuya_re.cli:main"
+fingerbot = "tuya_re.cli:ble_main"
+switch = "tuya_re.cli:switch_main"
+ir = "tuya_re.cli:ir_main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "pytest-asyncio>=0.24",
+    "pytest-cov>=5",
+    "ruff>=0.9",
+]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.coverage.run]
+source = ["src/tuya_re"]
+# Hardware/network/CLI boundary modules are exercised by live tests, not units.
+omit = [
+    "src/tuya_re/ble.py",
+    "src/tuya_re/lan_discovery.py",
+    "src/tuya_re/cli.py",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

src/tuya_re/ble.py

@@ -0,0 +1,116 @@
+"""BLE transport: find the device and run a connected Session."""
+
+import asyncio
+import hashlib
+import logging
+
+from bleak import BleakClient, BleakScanner
+from bleak.backends.device import BLEDevice
+
+from . import crypto
+from .config import Credentials
+from .const import (
+    CHARACTERISTIC_NOTIFY,
+    CHARACTERISTIC_WRITE,
+    MANUFACTURER_DATA_ID,
+    SERVICE_UUID,
+)
+from .protocol import Session
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _uuid_from_advertisement(adv) -> str | None:
+    """Decrypt the device uuid from advertisement data, if present."""
+    service_data = adv.service_data.get(SERVICE_UUID)
+    mfr = adv.manufacturer_data.get(MANUFACTURER_DATA_ID)
+    if not (
+        service_data
+        and len(service_data) > 1
+        and service_data[0] == 0
+        and mfr
+        and len(mfr) > 6
+    ):
+        return None
+    key = hashlib.md5(
+        service_data[1:],  # nosemgrep
+        usedforsecurity=False,
+    ).digest()
+    try:
+        return crypto.aes_cbc_decrypt(key, key, mfr[6:]).decode()
+    except (ValueError, UnicodeDecodeError):
+        return None
+
+
+async def find_device(creds: Credentials, timeout: float = 10.0) -> BLEDevice:
+    """Scan for our device; match by decrypted uuid, else fall back to
+    the only device advertising the Tuya service."""
+    candidates: dict[str, BLEDevice] = {}
+    found = asyncio.Event()
+    target: list[BLEDevice] = []
+
+    def on_adv(device: BLEDevice, adv) -> None:
+        if (
+            SERVICE_UUID not in (adv.service_uuids or [])
+            and SERVICE_UUID not in adv.service_data
+            and MANUFACTURER_DATA_ID not in adv.manufacturer_data
+        ):
+            return
+        uuid = _uuid_from_advertisement(adv)
+        _LOGGER.debug(
+            "tuya adv from %s rssi=%s uuid=%s", device.address, adv.rssi, uuid
+        )
+        candidates[device.address] = device
+        if uuid == creds.uuid:
+            target.append(device)
+            found.set()
+
+    scanner = BleakScanner(on_adv, service_uuids=[SERVICE_UUID])
+    async with scanner:
+        try:
+            await asyncio.wait_for(found.wait(), timeout)
+        except asyncio.TimeoutError:
+            pass
+    if target:
+        return target[0]
+    if len(candidates) == 1:
+        device = next(iter(candidates.values()))
+        _LOGGER.warning("uuid not matched; using sole Tuya device %s", device.address)
+        return device
+    raise RuntimeError(
+        f"device not found ({len(candidates)} Tuya devices seen). "
+        "BLE allows one central: make sure the Tuya gateway is powered off "
+        "or the device is unlinked from it, and the phone app is closed."
+    )
+
+
+async def connected_session(
+    creds: Credentials, device: BLEDevice, timeout: float = 10.0
+):
+    """Connect and wire notifications; returns (client, session)."""
+    client = BleakClient(device, timeout=timeout)
+    await client.connect()
+    try:
+
+        async def send(chunk: bytes) -> None:
+            _LOGGER.debug("write %s", chunk.hex())
+            await client.write_gatt_char(CHARACTERISTIC_WRITE, chunk, response=False)
+
+        session = Session(creds, send)
+
+        def on_notify(_sender, data: bytearray) -> None:
+            _LOGGER.debug("notify %s", bytes(data).hex())
+            try:
+                session.handle_notification(bytes(data))
+            except Exception:
+                _LOGGER.exception(
+                    "failed to handle notification (CRC mismatch usually "
+                    "means a stale local_key — re-pull device details from "
+                    "the Tuya API Explorer and update config.toml)"
+                )
+
+        await client.start_notify(CHARACTERISTIC_NOTIFY, on_notify)
+        return client, session
+    except BaseException:
+        await client.disconnect()
+        raise

src/tuya_re/cli.py

@@ -0,0 +1,505 @@
+"""tuya_re CLI with four command groups: ble | switch | ir | gateway.
+
+`ble` carries the BLE Fingerbot commands (scan | status | click | press);
+`switch` carries LAN switch commands (on | off | toggle | status);
+`ir` carries BLE IR-blaster commands (scan | status | probe | learn | send);
+`gateway` clicks a Fingerbot through a Tuya BLE gateway via tinytuya.
+
+Each command operates on one or more devices selected with --device:
+a device name, omitted (the configured default), or "all".
+"""
+
+import argparse
+import asyncio
+import logging
+import sys
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+
+from bleak.exc import BleakError
+
+from . import ble, gateway, lan_discovery, packet
+from .config import (
+    Credentials,
+    DEFAULT_PATH,
+    load_fingerbots,
+    load_gateway,
+    load_ir_blasters,
+    load_switches,
+    select_devices,
+    SwitchCredentials,
+)
+from .const import DPType
+from .devices import dp_map_for
+from .ir import IRBlaster
+from .lan_protocol import LanFrameError
+from .lan_session import LanSwitch
+from .protocol import Session
+
+# errors from one device that shouldn't abort the others in an "all" run
+_DEVICE_ERRORS = (TimeoutError, RuntimeError, BleakError, packet.FrameError)
+
+# which config section feeds the BLE-session groups
+_BLE_LOADERS = {"ble": load_fingerbots, "ir": load_ir_blasters}
+
+
+async def cmd_scan(args) -> int:
+    rc = 0
+    for creds in _selected(args):
+        try:
+            device = await ble.find_device(creds, timeout=args.timeout)
+            print(f"[{creds.name}] found: {device.address} ({device.name})")
+        except _DEVICE_ERRORS as exc:
+            print(f"[{creds.name}] error: {exc}", file=sys.stderr)
+            rc = 1
+    return rc
+
+
+async def cmd_status(args) -> int:
+    async def report(creds: Credentials, session: Session) -> None:
+        await session.request_status()  # prompt the device to report DPs
+        await asyncio.sleep(args.settle)
+        if not session.dps:
+            print(f"[{creds.name}] paired OK, but no datapoints reported")
+        for dp_id, value in sorted(session.dps.items()):
+            print(f"[{creds.name}] dp {dp_id:3d} = {value!r}")
+
+    return await _for_each(args, report)
+
+
+async def cmd_click(args) -> int:
+    async def click(creds: Credentials, session: Session) -> None:
+        dp_id = _trigger_dp(creds, args)
+        for i in range(args.repeat):
+            await _fire_trigger(creds, session, dp_id)
+            print(f"[{creds.name}] click {i + 1}/{args.repeat} sent")
+            if i + 1 < args.repeat:
+                await asyncio.sleep(args.interval)
+
+    return await _for_each(args, click)
+
+
+async def cmd_press(args) -> int:
+    async def press(creds: Credentials, session: Session) -> None:
+        dps = dp_map_for(creds.product_id)
+        print(f"[{creds.name}] setting hold time dp {dps.hold_time} = {args.duration}s")
+        await session.set_dp(dps.hold_time, DPType.VALUE, args.duration)
+        dp_id = _trigger_dp(creds, args)
+        for i in range(args.repeat):
+            await _fire_trigger(creds, session, dp_id)
+            print(f"[{creds.name}] press {i + 1}/{args.repeat} sent")
+            if i + 1 < args.repeat:
+                await asyncio.sleep(args.interval)
+
+    return await _for_each(args, press)
+
+
+def _blaster(session: Session, args) -> IRBlaster:
+    return IRBlaster(
+        session,
+        send_dp=args.send_dp,
+        learn_dp=args.learn_dp,
+        study_dp=args.study_dp,
+        send_dp_type=DPType[args.send_dp_type],
+    )
+
+
+async def cmd_ir_learn(args) -> int:
+    async def learn(creds: Credentials, session: Session) -> None:
+        print(
+            f"[{creds.name}] study mode — point the remote at the blaster "
+            "and press a button..."
+        )
+        code = await _blaster(session, args).learn(timeout=args.timeout)
+        print(f"[{creds.name}] learned: {code}")
+
+    return await _for_each(args, learn)
+
+
+async def cmd_ir_send(args) -> int:
+    async def send(creds: Credentials, session: Session) -> None:
+        await _blaster(session, args).send_ir(args.code)
+        print(f"[{creds.name}] sent IR code ({len(args.code)} b64 chars)")
+
+    return await _for_each(args, send)
+
+
+def _selected(args) -> list[Credentials]:
+    return select_devices(_BLE_LOADERS[args.group](args.config), args.device)
+
+
+def _selected_switches(args) -> list[SwitchCredentials]:
+    return select_devices(load_switches(args.config), args.device)
+
+
+_SWITCH_ERRORS = (LanFrameError, TimeoutError, OSError)
+
+
+async def _run_switch(creds, args, action) -> int:
+    try:
+        ip, version = creds.ip, creds.version
+        if ip is None or version is None:
+            disc_ip, disc_version = await lan_discovery.discover(
+                creds.device_id, timeout=args.timeout
+            )
+            ip = ip or disc_ip
+            version = version or disc_version
+        switch = LanSwitch(creds.device_id, creds.local_key, version, ip)
+        await action(creds, switch)
+        return 0
+    except _SWITCH_ERRORS as exc:
+        print(f"[{creds.name}] error: {exc}", file=sys.stderr)
+        return 1
+
+
+async def _for_each_switch(args, action) -> int:
+    results = await asyncio.gather(
+        *(_run_switch(c, args, action) for c in _selected_switches(args))
+    )
+    return max(results, default=0)
+
+
+async def cmd_switch_status(args) -> int:
+    async def report(creds, switch):
+        state = await switch.status()
+        print(f"[{creds.name}] dp 1 = {'on' if state else 'off'}")
+
+    return await _for_each_switch(args, report)
+
+
+async def cmd_switch_on(args) -> int:
+    async def act(creds, switch):
+        await switch.turn_on()
+        print(f"[{creds.name}] switch -> on")
+
+    return await _for_each_switch(args, act)
+
+
+async def cmd_switch_off(args) -> int:
+    async def act(creds, switch):
+        await switch.turn_off()
+        print(f"[{creds.name}] switch -> off")
+
+    return await _for_each_switch(args, act)
+
+
+async def cmd_switch_toggle(args) -> int:
+    async def act(creds, switch):
+        await switch.toggle()
+        state = await switch.status()
+        print(f"[{creds.name}] switch -> {'on' if state else 'off'}")
+
+    return await _for_each_switch(args, act)
+
+
+def _gateway_targets(args):
+    gw_cfg = load_gateway(args.config)
+    if gw_cfg is None:
+        raise ValueError("no [gateway] section configured in config.toml")
+    return gw_cfg, select_devices(gw_cfg.fingerbots, args.device)
+
+
+_GATEWAY_ERRORS = (gateway.GatewayError, TimeoutError, OSError)
+
+
+async def cmd_gateway_click(args) -> int:
+    gw_cfg, targets = _gateway_targets(args)
+    if args.verbose:
+        gateway.set_debug(True)
+    gw = gateway.open_gateway(gw_cfg)
+    rc = 0
+    for fb in targets:
+        try:
+            dev = gateway.sub_device(gw, fb)
+            # Status is informational only: BLE sub-devices often can't be
+            # read through the gateway even though writes work (tinytuya
+            # #677).
+            print(f"[{fb.name}] status: {dev.status()}")
+            gateway.click(dev)
+            print(f"[{fb.name}] click sent — did it physically click?")
+        except _GATEWAY_ERRORS as exc:
+            print(f"[{fb.name}] error: {exc}", file=sys.stderr)
+            rc = 1
+    return rc
+
+
+async def cmd_gateway_status(args) -> int:
+    gw_cfg, targets = _gateway_targets(args)
+    if args.verbose:
+        gateway.set_debug(True)
+    gw = gateway.open_gateway(gw_cfg)
+    rc = 0
+    for fb in targets:
+        try:
+            dev = gateway.sub_device(gw, fb)
+            print(f"[{fb.name}] status: {dev.status()}")
+        except _GATEWAY_ERRORS as exc:
+            print(f"[{fb.name}] error: {exc}", file=sys.stderr)
+            rc = 1
+    return rc
+
+
+def _trigger_dp(creds: Credentials, args) -> int:
+    if args.dp is not None:
+        return args.dp
+    return dp_map_for(creds.product_id).click
+
+
+async def _fire_trigger(creds: Credentials, session: Session, dp_id: int) -> None:
+    """Actuate the arm with a guaranteed rising edge on the trigger DP.
+
+    The Fingerbot presses only on a False->True transition; a falling edge
+    does nothing. Driving the DP low first (when it isn't already low) makes
+    the click work even if a previous run left the DP latched at True.
+    """
+    if session.dps.get(dp_id) is not False:
+        await session.set_dp(dp_id, DPType.BOOL, False)
+        await asyncio.sleep(0.3)
+    print(f"[{creds.name}] sending dp {dp_id} = True")
+    await session.set_dp(dp_id, DPType.BOOL, True)
+
+
+async def _run_one(
+    creds: Credentials,
+    args,
+    action: Callable[[Credentials, Session], Awaitable[None]],
+) -> int:
+    try:
+        device = await ble.find_device(creds, timeout=args.timeout)
+        client, session = await ble.connected_session(creds, device)
+        try:
+            await session.handshake()
+            await action(creds, session)
+        finally:
+            await client.disconnect()
+        return 0
+    except _DEVICE_ERRORS as exc:
+        print(f"[{creds.name}] error: {exc}", file=sys.stderr)
+        return 1
+
+
+async def _for_each(
+    args,
+    action: Callable[[Credentials, Session], Awaitable[None]],
+) -> int:
+    """Run action against every selected device concurrently.
+
+    Each device gets its own BLE connection and Session, so `--device all`
+    fires them simultaneously. Per-device errors are isolated and reflected
+    in the exit code.
+    """
+    results = await asyncio.gather(
+        *(_run_one(creds, args, action) for creds in _selected(args))
+    )
+    return max(results, default=0)
+
+
+_HANDLERS = {
+    ("ble", "scan"): cmd_scan,
+    ("ble", "status"): cmd_status,
+    ("ble", "click"): cmd_click,
+    ("ble", "press"): cmd_press,
+    ("switch", "on"): cmd_switch_on,
+    ("switch", "off"): cmd_switch_off,
+    ("switch", "toggle"): cmd_switch_toggle,
+    ("switch", "status"): cmd_switch_status,
+    ("ir", "scan"): cmd_scan,
+    ("ir", "status"): cmd_status,
+    ("ir", "probe"): cmd_status,
+    ("ir", "learn"): cmd_ir_learn,
+    ("ir", "send"): cmd_ir_send,
+    ("gateway", "click"): cmd_gateway_click,
+    ("gateway", "status"): cmd_gateway_status,
+}
+
+
+def _add_global_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--config", type=Path, default=DEFAULT_PATH, help="path to config.toml"
+    )
+    parser.add_argument(
+        "--device",
+        default=None,
+        help="device name, or 'all' (default: configured default device)",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=20.0,
+        help="scan/discovery/learn timeout seconds",
+    )
+    parser.add_argument(
+        "--settle",
+        type=float,
+        default=2.0,
+        help="seconds to wait for DP status after pairing",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="verbose logging (hex-dump traffic and frames)",
+    )
+
+
+def _add_ble_commands(sub) -> None:
+    sub.add_parser("scan", help="find the device, print address")
+    sub.add_parser("status", help="connect, pair, dump reported datapoints")
+    for name, helptext in [
+        ("click", "trigger one or more clicks"),
+        ("press", "click with a hold duration"),
+    ]:
+        p = sub.add_parser(name, help=helptext)
+        p.add_argument(
+            "--dp",
+            type=int,
+            default=None,
+            help="override the trigger DP id (default per model)",
+        )
+        p.add_argument(
+            "--repeat",
+            type=int,
+            default=1,
+            help="number of clicks per device (one connection)",
+        )
+        p.add_argument(
+            "--interval",
+            type=float,
+            default=1.5,
+            help="seconds between repeated clicks (the arm needs "
+            "~1.5s per full press/release cycle)",
+        )
+        if name == "press":
+            p.add_argument(
+                "--duration", type=int, required=True, help="hold time in seconds"
+            )
+
+
+def _add_switch_commands(sub) -> None:
+    sub.add_parser("on", help="turn the switch on")
+    sub.add_parser("off", help="turn the switch off")
+    sub.add_parser("toggle", help="toggle the switch")
+    sub.add_parser("status", help="report the switch state")
+
+
+def _add_ir_dp_flags(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--send-dp",
+        type=int,
+        default=201,
+        dest="send_dp",
+        help="ir_send DP id (201 confirmed for JMIR05)",
+    )
+    parser.add_argument(
+        "--send-dp-type",
+        default="STRING",
+        dest="send_dp_type",
+        choices=[t.name for t in DPType],
+        help="DP type used for send",
+    )
+    parser.add_argument(
+        "--learn-dp",
+        type=int,
+        default=202,
+        dest="learn_dp",
+        help="ir_study_code DP id (202 confirmed for JMIR05)",
+    )
+    parser.add_argument(
+        "--study-dp",
+        type=int,
+        default=202,
+        dest="study_dp",
+        help="study-mode enter/exit DP id",
+    )
+
+
+def _add_ir_commands(sub) -> None:
+    sub.add_parser("scan", help="find the device(s), print address")
+    sub.add_parser("status", help="connect, pair, dump datapoints")
+    sub.add_parser("probe", help="alias for status")
+    learn = sub.add_parser("learn", help="enter study mode, capture an IR code")
+    send = sub.add_parser("send", help="transmit a base64 IR code")
+    send.add_argument("code", help="base64 Tuya IR code to send")
+    for p in (learn, send):
+        _add_ir_dp_flags(p)
+
+
+def _add_gateway_commands(sub) -> None:
+    sub.add_parser("click", help="click a Fingerbot through the Tuya gateway")
+    sub.add_parser("status", help="dump sub-device status via the gateway")
+
+
+def _dispatch(args) -> None:
+    logging.basicConfig(
+        level=logging.DEBUG if args.verbose else logging.INFO,
+        format="%(asctime)s %(name)s %(message)s",
+    )
+    handler = _HANDLERS[(args.group, args.command)]
+    try:
+        sys.exit(asyncio.run(handler(args)))
+    except (FileNotFoundError, ValueError, NotImplementedError) as exc:
+        # config-level errors (missing file, unknown --device) abort the run
+        print(f"error: {exc}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main() -> None:
+    """Unified entry point: `tuya-re <ble|switch|ir|gateway> <command>`."""
+    parser = argparse.ArgumentParser(prog="tuya-re")
+    _add_global_flags(parser)
+    groups = parser.add_subparsers(dest="group", required=True)
+    _add_ble_commands(
+        groups.add_parser("ble", help="BLE Fingerbot commands").add_subparsers(
+            dest="command", required=True
+        )
+    )
+    _add_switch_commands(
+        groups.add_parser("switch", help="LAN switch commands").add_subparsers(
+            dest="command", required=True
+        )
+    )
+    _add_ir_commands(
+        groups.add_parser("ir", help="BLE IR-blaster commands").add_subparsers(
+            dest="command", required=True
+        )
+    )
+    _add_gateway_commands(
+        groups.add_parser(
+            "gateway", help="Fingerbot via Tuya gateway (tinytuya)"
+        ).add_subparsers(dest="command", required=True)
+    )
+    _dispatch(parser.parse_args())
+
+
+def switch_main() -> None:
+    """Dedicated entry point so `switch on` works without the group prefix."""
+    parser = argparse.ArgumentParser(prog="switch")
+    _add_global_flags(parser)
+    _add_switch_commands(parser.add_subparsers(dest="command", required=True))
+    args = parser.parse_args()
+    args.group = "switch"
+    _dispatch(args)
+
+
+def ble_main() -> None:
+    """Dedicated entry point so `fingerbot click` works without the prefix."""
+    parser = argparse.ArgumentParser(prog="fingerbot")
+    _add_global_flags(parser)
+    _add_ble_commands(parser.add_subparsers(dest="command", required=True))
+    args = parser.parse_args()
+    args.group = "ble"
+    _dispatch(args)
+
+
+def ir_main() -> None:
+    """Dedicated entry point so `ir learn` works without the group prefix."""
+    parser = argparse.ArgumentParser(prog="ir")
+    _add_global_flags(parser)
+    _add_ir_commands(parser.add_subparsers(dest="command", required=True))
+    args = parser.parse_args()
+    args.group = "ir"
+    _dispatch(args)
+
+
+if __name__ == "__main__":
+    main()

src/tuya_re/config.py

@@ -0,0 +1,154 @@
+"""Credential loading from config.toml.
+
+The file is namespaced with one section per device class:
+
+    [fingerbots]        default + devices.<name>:
+                        device_id / uuid / local_key / product_id
+    [switches]          default + devices.<name>:
+                        device_id / local_key / product_id (+ version / ip)
+    [ir_blasters]       default + devices.<name>:
+                        device_id / uuid / local_key / product_id
+    [gateway]           device_id / ip / local_key / version, plus
+                        [gateway.fingerbots] default + devices.<name>:
+                        device_id / node_id
+
+Extra per-device keys (model, tuya_name, ...) are ignored.
+"""
+
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+
+DEFAULT_PATH = Path(__file__).resolve().parents[2] / "config.toml"
+
+
+@dataclass(frozen=True)
+class Credentials:
+    device_id: str
+    uuid: str
+    local_key: str
+    product_id: str
+    name: str = ""
+
+
+@dataclass(frozen=True)
+class SwitchCredentials:
+    device_id: str
+    local_key: str
+    product_id: str
+    name: str = ""
+    version: str | None = None
+    ip: str | None = None
+
+
+@dataclass(frozen=True)
+class GatewayFingerbot:
+    device_id: str
+    node_id: str
+    name: str = ""
+
+
+@dataclass(frozen=True)
+class Config:
+    devices: dict
+    default: str | None
+
+
+@dataclass(frozen=True)
+class GatewayConfig:
+    device_id: str
+    ip: str
+    local_key: str
+    version: str
+    fingerbots: Config
+
+
+def _load(path: Path) -> dict:
+    with open(path, "rb") as fh:
+        return tomllib.load(fh)
+
+
+def _section(data: dict, key: str, make) -> Config:
+    section = data.get(key) or {}
+    devices = {name: make(d, name) for name, d in section.get("devices", {}).items()}
+    return Config(devices=devices, default=section.get("default"))
+
+
+def _credentials(data: dict, name: str) -> Credentials:
+    return Credentials(
+        device_id=data["device_id"],
+        uuid=data["uuid"],
+        local_key=data["local_key"],
+        product_id=data["product_id"],
+        name=name,
+    )
+
+
+def _switch_credentials(data: dict, name: str) -> SwitchCredentials:
+    version = data.get("version")
+    return SwitchCredentials(
+        device_id=data["device_id"],
+        local_key=data["local_key"],
+        product_id=data["product_id"],
+        name=name,
+        version=str(version) if version is not None else None,
+        ip=data.get("ip"),
+    )
+
+
+def _gateway_fingerbot(data: dict, name: str) -> GatewayFingerbot:
+    return GatewayFingerbot(
+        device_id=data["device_id"], node_id=data["node_id"], name=name
+    )
+
+
+def load_fingerbots(path: Path = DEFAULT_PATH) -> Config:
+    return _section(_load(path), "fingerbots", _credentials)
+
+
+def load_switches(path: Path = DEFAULT_PATH) -> Config:
+    return _section(_load(path), "switches", _switch_credentials)
+
+
+def load_ir_blasters(path: Path = DEFAULT_PATH) -> Config:
+    return _section(_load(path), "ir_blasters", _credentials)
+
+
+def load_gateway(path: Path = DEFAULT_PATH) -> GatewayConfig | None:
+    section = _load(path).get("gateway")
+    if not section:
+        return None
+    return GatewayConfig(
+        device_id=section["device_id"],
+        ip=section["ip"],
+        local_key=section["local_key"],
+        version=str(section["version"]),
+        fingerbots=_section(section, "fingerbots", _gateway_fingerbot),
+    )
+
+
+def select_devices(config: Config, name: str | None) -> list:
+    """Resolve a --device selector to one or more devices.
+
+    ``"all"`` returns every device; ``None`` returns the default (or the sole
+    device if only one is configured); any other value selects by name.
+    """
+    if not config.devices:
+        raise ValueError("no matching devices configured in config.toml")
+    if name == "all":
+        return list(config.devices.values())
+    if name is None:
+        if config.default and config.default in config.devices:
+            return [config.devices[config.default]]
+        if len(config.devices) == 1:
+            return [next(iter(config.devices.values()))]
+        raise ValueError(
+            "multiple devices configured; pass --device <name> or --device "
+            f"all. known: {sorted(config.devices)}"
+        )
+    try:
+        return [config.devices[name]]
+    except KeyError:
+        raise ValueError(
+            f"unknown device {name!r}; known: {sorted(config.devices)} (or 'all')"
+        ) from None

src/tuya_re/const.py

@@ -0,0 +1,67 @@
+"""Tuya BLE protocol constants. Values verified against ha_tuya_ble."""
+
+from enum import IntEnum
+
+SERVICE_UUID = "0000a201-0000-1000-8000-00805f9b34fb"
+CHARACTERISTIC_NOTIFY = "00002b10-0000-1000-8000-00805f9b34fb"
+CHARACTERISTIC_WRITE = "00002b11-0000-1000-8000-00805f9b34fb"
+MANUFACTURER_DATA_ID = 0x07D0
+GATT_MTU = 20
+RESPONSE_TIMEOUT = 10.0
+
+
+class Code(IntEnum):
+    SENDER_DEVICE_INFO = 0x0000
+    SENDER_PAIR = 0x0001
+    SENDER_DPS = 0x0002
+    SENDER_DEVICE_STATUS = 0x0003
+    RECEIVE_DP = 0x8001
+    RECEIVE_TIME_DP = 0x8003
+    RECEIVE_SIGN_DP = 0x8004
+    RECEIVE_SIGN_TIME_DP = 0x8005
+    RECEIVE_TIME1_REQ = 0x8011
+    RECEIVE_TIME2_REQ = 0x8012
+
+
+class DPType(IntEnum):
+    RAW = 0
+    BOOL = 1
+    VALUE = 2
+    STRING = 3
+    ENUM = 4
+    BITMAP = 5
+
+
+SECURITY_FLAG_LOGIN = 0x04
+SECURITY_FLAG_SESSION = 0x05
+
+# --- Tuya LAN (local network) protocol ---
+TUYA_TCP_PORT = 6668
+UDP_PORTS = (6666, 6667)
+PREFIX_55AA = 0x000055AA
+SUFFIX_55AA = 0x0000AA55
+UDP_KEY_SEED = b"yGAdlopoPVldABfn"
+VERSION_HEADER_33 = b"3.3" + 12 * b"\x00"  # 15 bytes
+
+
+class LanCommand(IntEnum):
+    SESS_KEY_NEG_START = 3
+    SESS_KEY_NEG_RESP = 4
+    SESS_KEY_NEG_FINISH = 5
+    CONTROL = 7
+    STATUS = 8
+    HEART_BEAT = 9
+    DP_QUERY = 0x0A
+    CONTROL_NEW = 0x0D
+    DP_QUERY_NEW = 0x10
+    UDP = 0x13
+
+
+HEADERLESS_CMDS = {
+    LanCommand.DP_QUERY,
+    LanCommand.DP_QUERY_NEW,
+    LanCommand.HEART_BEAT,
+    LanCommand.SESS_KEY_NEG_START,
+    LanCommand.SESS_KEY_NEG_RESP,
+    LanCommand.SESS_KEY_NEG_FINISH,
+}

src/tuya_re/crypto.py

@@ -0,0 +1,59 @@
+"""Key derivation and primitives for the Tuya BLE protocol."""
+
+import hashlib
+import zlib
+
+# pycryptodome, not the abandoned pycrypto (same import namespace)
+from Crypto.Cipher import AES  # nosec B413
+from Crypto.Util.Padding import pad as _pad, unpad  # nosec B413
+
+
+def crc16(data: bytes) -> int:
+    """CRC-16, init 0xFFFF, reflected poly 0xA001 (Tuya BLE frame check)."""
+    crc = 0xFFFF
+    for byte in data:
+        crc ^= byte
+        for _ in range(8):
+            tmp = crc & 1
+            crc >>= 1
+            if tmp:
+                crc ^= 0xA001
+    return crc
+
+
+def login_key(local_key: str) -> bytes:
+    """Pre-session key: MD5 of the first 6 chars of the cloud local_key."""
+    return hashlib.md5(
+        local_key[:6].encode(),  # nosemgrep
+        usedforsecurity=False,
+    ).digest()
+
+
+def session_key(local_key: str, srand: bytes) -> bytes:
+    """Session key derived from srand in the device-info response."""
+    return hashlib.md5(
+        local_key[:6].encode() + srand,  # nosemgrep
+        usedforsecurity=False,
+    ).digest()
+
+
+def aes_cbc_encrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+    return AES.new(key, AES.MODE_CBC, iv).encrypt(data)
+
+
+def aes_cbc_decrypt(key: bytes, iv: bytes, data: bytes) -> bytes:
+    return AES.new(key, AES.MODE_CBC, iv).decrypt(data)
+
+
+def aes_ecb_encrypt(key: bytes, data: bytes, pad: bool = True) -> bytes:
+    if pad:
+        data = _pad(data, 16)
+    return AES.new(key, AES.MODE_ECB).encrypt(data)
+
+
+def aes_ecb_decrypt(key: bytes, data: bytes) -> bytes:
+    return unpad(AES.new(key, AES.MODE_ECB).decrypt(data), 16)
+
+
+def crc32(data: bytes) -> int:
+    return zlib.crc32(data) & 0xFFFFFFFF

src/tuya_re/devices.py

@@ -0,0 +1,64 @@
+"""Per-product datapoint maps.
+
+mknd4lci values come from ha_tuya_ble PR #89 (author owns a BS-FB-V3.1).
+'click' is the DP the official push-button toggles; for szjqr devices it
+is the same DP as switch, for mknd4lci it is a dedicated DP 108.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class FingerbotDPs:
+    switch: int
+    mode: int  # enum: 0=click, 1=switch, 2=program
+    down_position: int
+    hold_time: int
+    reverse: int
+    up_position: int
+    click: int
+
+
+_MKND4LCI = FingerbotDPs(
+    switch=1,
+    mode=101,
+    down_position=102,
+    hold_time=103,
+    reverse=104,
+    up_position=106,
+    click=108,
+)
+
+_SZJQR_FINGERBOT = FingerbotDPs(
+    switch=2, mode=8, down_position=9, hold_time=10, reverse=11, up_position=15, click=2
+)
+
+_DP_MAPS: dict[str, FingerbotDPs] = {
+    "mknd4lci": _MKND4LCI,
+    # original Fingerbot + Plus (category szjqr), same control DPs
+    **dict.fromkeys(
+        [
+            "ltak7e1p",
+            "y6kttvd6",
+            "yrnk7mnn",
+            "nvr2rocq",
+            "bnt7wajf",
+            "rvdceqjh",
+            "5xhbk964",
+            "blliqpsj",
+            "ndvkgsrm",
+            "yiihr7zh",
+            "neq16kgd",
+        ],
+        _SZJQR_FINGERBOT,
+    ),
+}
+
+
+def dp_map_for(product_id: str) -> FingerbotDPs:
+    try:
+        return _DP_MAPS[product_id]
+    except KeyError:
+        raise ValueError(
+            f"unknown product_id {product_id!r}; known: {sorted(_DP_MAPS)}"
+        ) from None

src/tuya_re/gateway.py

@@ -0,0 +1,57 @@
+"""Fingerbot control through a Tuya BLE gateway on the LAN (via tinytuya).
+
+The gateway path complements the direct-BLE path: the Fingerbot is addressed
+as a sub-device (cid = the wizard's node_id) of the gateway, and the
+gateway's single local_key authorizes every sub-device behind it. All LAN
+protocol work (AES, v3.3-v3.5 handshake, sub-device framing) is delegated to
+tinytuya.
+"""
+
+import time
+
+import tinytuya
+
+from .config import GatewayConfig, GatewayFingerbot
+
+DP_SWITCH = "1"  # bool: true = press
+DP_MODE = "101"  # enum: 0 = click, 1 = switch, 2 = program
+MODE_CLICK = 0
+
+
+class GatewayError(RuntimeError):
+    """A tinytuya call returned an error payload."""
+
+
+def _check(result, action: str):
+    if isinstance(result, dict) and result.get("Error"):
+        raise GatewayError(f"{action} failed: {result}")
+    return result
+
+
+def open_gateway(cfg: GatewayConfig) -> tinytuya.Device:
+    return tinytuya.Device(
+        cfg.device_id,
+        address=cfg.ip,
+        local_key=cfg.local_key,
+        version=float(cfg.version),
+        persist=True,
+    )
+
+
+def sub_device(gw: tinytuya.Device, fb: GatewayFingerbot) -> tinytuya.Device:
+    return tinytuya.Device(fb.device_id, cid=fb.node_id, parent=gw)
+
+
+def click(dev, *, settle: float = 1.0, sleep=time.sleep) -> None:
+    """Set click mode, wait for the gateway to relay it, then press.
+
+    Some firmwares need a beat between the mode write and the press; the
+    original PoC used 1 second and that is kept as the default.
+    """
+    _check(dev.set_value(DP_MODE, MODE_CLICK), "set click mode")
+    sleep(settle)
+    _check(dev.set_value(DP_SWITCH, True), "click")
+
+
+def set_debug(enabled: bool = True) -> None:
+    tinytuya.set_debug(enabled)

src/tuya_re/ir.py

@@ -0,0 +1,103 @@
+"""src/tuya_re/ir.py — Tuya IR codec and BLE learn/send orchestration."""
+
+import asyncio
+import base64
+from struct import pack, unpack
+
+from .const import DPType
+from .protocol import Session
+
+# Confirmed from the cloud thing-model for product xgahj3gjk3ftaejt (JMIR05):
+#   DP 201 ir_send (string), DP 202 ir_study_code (raw).
+# The study-mode *enter* value is NOT documented and is confirmed by `ir probe`.
+DEFAULT_SEND_DP = 201
+DEFAULT_LEARN_DP = 202
+DEFAULT_STUDY_DP = 202
+STUDY_ON = 1
+STUDY_OFF = 0
+
+
+def pulses_to_base64(pulses: list[int]) -> str:
+    """Pack microsecond durations as little-endian u16 and base64-encode."""
+    raw = bytearray()
+    for p in pulses:
+        if not 0 <= p <= 0xFFFF:
+            raise ValueError(f"pulse {p} out of u16 range (0..65535)")
+        raw += pack("<H", p)
+    return base64.b64encode(bytes(raw)).decode()
+
+
+def base64_to_pulses(data: str) -> list[int]:
+    """Inverse of pulses_to_base64."""
+    raw = base64.b64decode(data)
+    if len(raw) % 2:
+        raise ValueError("decoded IR data is not a whole number of u16 values")
+    return [v for (v,) in (unpack("<H", raw[i : i + 2]) for i in range(0, len(raw), 2))]
+
+
+def _as_base64(value) -> str:
+    """A learned DP value is base64 text (STRING DP) or raw bytes (RAW DP)."""
+    if isinstance(value, bytes):
+        return base64.b64encode(value).decode()
+    return str(value)
+
+
+class IRBlaster:
+    """IR learn/send over a connected Tuya BLE Session.
+
+    Send/learn DP ids and types are confirmed for JMIR05 (201 string /
+    202 raw). The study-mode enter/exit values are still a guess, exposed as
+    constructor args because `ir probe` confirms them on real hardware.
+    """
+
+    def __init__(
+        self,
+        session: Session,
+        *,
+        send_dp: int = DEFAULT_SEND_DP,
+        send_dp_type: DPType = DPType.STRING,
+        learn_dp: int = DEFAULT_LEARN_DP,
+        study_dp: int = DEFAULT_STUDY_DP,
+        study_on=STUDY_ON,
+        study_off=STUDY_OFF,
+        study_dp_type: DPType = DPType.ENUM,
+    ) -> None:
+        self._s = session
+        self._send_dp = send_dp
+        self._send_dp_type = send_dp_type
+        self._learn_dp = learn_dp
+        self._study_dp = study_dp
+        self._study_on = study_on
+        self._study_off = study_off
+        self._study_dp_type = study_dp_type
+
+    async def send_ir(self, b64: str) -> None:
+        """Transmit a base64 Tuya IR code via the send DP.
+
+        The confirmed send DP (201) is STRING. If overridden to a byte-typed
+        DP (RAW/BITMAP), the base64 text is carried as raw bytes.
+        """
+        value: str | bytes = b64
+        if self._send_dp_type in (DPType.RAW, DPType.BITMAP):
+            value = b64.encode()
+        await self._s.set_dp(self._send_dp, self._send_dp_type, value)
+
+    async def learn(self, timeout: float = 30.0, poll_interval: float = 0.2) -> str:
+        """Enter study mode, return the first fresh learn-DP value reported
+        (as a base64 string), and always exit study mode afterwards."""
+        baseline = self._s.dps.get(self._learn_dp)
+        await self._s.set_dp(self._study_dp, self._study_dp_type, self._study_on)
+        loop = asyncio.get_running_loop()
+        deadline = loop.time() + timeout
+        try:
+            while loop.time() < deadline:
+                value = self._s.dps.get(self._learn_dp)
+                if value is not None and value != baseline:
+                    return _as_base64(value)
+                await asyncio.sleep(poll_interval)
+            raise TimeoutError(
+                f"no IR code learned within {timeout}s "
+                "(point the remote at the blaster and press a button)"
+            )
+        finally:
+            await self._s.set_dp(self._study_dp, self._study_dp_type, self._study_off)

src/tuya_re/lan_discovery.py

@@ -0,0 +1,81 @@
+"""Tuya LAN UDP discovery: find a device's LAN ip + protocol version."""
+
+import asyncio
+import hashlib
+import json
+import logging
+import socket
+
+from . import crypto, lan_protocol
+from .const import UDP_KEY_SEED, UDP_PORTS
+
+_LOGGER = logging.getLogger(__name__)
+UDP_KEY = hashlib.md5(
+    UDP_KEY_SEED,  # nosemgrep
+    usedforsecurity=False,
+).digest()
+
+
+def decode_broadcast_payload(payload: bytes) -> dict:
+    """Decode a broadcast JSON payload, decrypting with the global UDP key
+    unless it is already plaintext JSON."""
+    if payload.lstrip().startswith(b"{"):
+        return json.loads(payload)
+    return json.loads(crypto.aes_ecb_decrypt(UDP_KEY, payload))
+
+
+def decode_broadcast(datagram: bytes) -> dict:
+    """Decode a full UDP datagram (a 0x55AA frame, or raw payload)."""
+    try:
+        msg = lan_protocol.unpack_frame(datagram)
+        payload = msg.payload
+    except lan_protocol.LanFrameError:
+        payload = datagram
+    return decode_broadcast_payload(payload)
+
+
+async def discover(
+    device_id: str, timeout: float = 10.0, ports=UDP_PORTS
+) -> tuple[str, str]:
+    """Listen for the device's broadcast; return (ip, version_string).
+
+    Raises TimeoutError if the device isn't seen within `timeout`."""
+    loop = asyncio.get_running_loop()
+    found: asyncio.Future = loop.create_future()
+
+    class _Proto(asyncio.DatagramProtocol):
+        def datagram_received(self, data, addr):
+            if found.done():
+                return
+            try:
+                info = decode_broadcast(data)
+            except Exception:  # ignore foreign/garbage datagrams
+                return
+            if info.get("gwId") == device_id and not found.done():
+                ip = info.get("ip")
+                version = str(info.get("version", "3.3"))
+                found.set_result((ip, version))
+
+    transports = []
+    for port in ports:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # nosemgrep
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+        except (AttributeError, OSError):
+            pass
+        # must listen on all interfaces to catch the device's LAN broadcast
+        sock.bind(("0.0.0.0", port))  # nosec B104 # nosemgrep
+        transport, _ = await loop.create_datagram_endpoint(_Proto, sock=sock)
+        transports.append(transport)
+    try:
+        return await asyncio.wait_for(found, timeout)
+    except asyncio.TimeoutError:
+        raise TimeoutError(
+            f"device {device_id} not seen on UDP {ports} within {timeout}s; "
+            "is it powered on and on this LAN? You can set a static ip in "
+            "config.toml to skip discovery."
+        ) from None
+    finally:
+        for t in transports:
+            t.close()

src/tuya_re/lan_protocol.py

@@ -0,0 +1,176 @@
+"""Tuya LAN 0x55AA message framing and v3.3/v3.4 payload codec."""
+
+import hashlib
+import hmac as _hmac
+import json
+import struct
+from dataclasses import dataclass
+
+from . import crypto
+from .const import (
+    HEADERLESS_CMDS,
+    PREFIX_55AA,
+    SUFFIX_55AA,
+    VERSION_HEADER_33,
+    LanCommand,
+)
+
+
+class LanFrameError(Exception):
+    """Raised on malformed or corrupt LAN frames."""
+
+
+@dataclass(frozen=True)
+class LanMessage:
+    seqno: int
+    command: int
+    retcode: int | None
+    payload: bytes
+
+
+def pack_frame(
+    seqno: int,
+    command: LanCommand,
+    body: bytes,
+    retcode: int | None = None,
+    hmac_key: bytes | None = None,
+) -> bytes:
+    """Build a complete 0x55AA framed packet.
+
+    Wire layout (CRC32 mode):
+        4B prefix | 4B seqno | 4B command | 4B length
+        [payload]
+        4B crc32 | 4B suffix
+    where length = len(payload) + 8  (covers crc + suffix)
+
+    Wire layout (HMAC mode, hmac_key provided):
+        4B prefix | 4B seqno | 4B command | 4B length
+        [payload]
+        32B hmac-sha256 | 4B suffix
+    where length = len(payload) + 36  (covers hmac + suffix)
+
+    payload = [optional 4B retcode] + body
+    """
+    payload = (struct.pack(">I", retcode) if retcode is not None else b"") + body
+    if hmac_key is not None:
+        length = len(payload) + 36  # +32 hmac +4 suffix
+        header = struct.pack(">4I", PREFIX_55AA, seqno, int(command), length)
+        mac = _hmac.new(hmac_key, header + payload, hashlib.sha256).digest()
+        return header + payload + mac + struct.pack(">I", SUFFIX_55AA)
+    else:
+        length = len(payload) + 8  # +4 crc +4 suffix
+        header = struct.pack(">4I", PREFIX_55AA, seqno, int(command), length)
+        crc = crypto.crc32(header + payload)
+        return header + payload + struct.pack(">2I", crc, SUFFIX_55AA)
+
+
+def unpack_frame(frame: bytes, hmac_key: bytes | None = None) -> LanMessage:
+    """Parse and validate a 0x55AA framed packet into a LanMessage.
+
+    Retcode heuristic: device replies carry a >I retcode right after the header.
+    Our outgoing frames don't.  Encrypted bodies and the VERSION_HEADER_33 both
+    start with a u32 >= 0x10000 (the first bytes "3.3\\x00" give 0x332e3300),
+    while real retcodes are small values (0, 1, ...).  If the first 4 bytes of
+    the body decode to a u32 < 0x10000, treat them as the retcode.
+    """
+    if len(frame) < 16:
+        raise LanFrameError("frame too short for header")
+
+    prefix, seqno, command, length = struct.unpack(">4I", frame[:16])
+    if prefix != PREFIX_55AA:
+        raise LanFrameError(f"bad prefix: {prefix:#010x}")
+
+    end = 16 + length
+    if len(frame) < end:
+        raise LanFrameError("truncated frame")
+
+    if hmac_key is not None:
+        # HMAC mode: 32B mac + 4B suffix = 36B tail
+        tail = 36
+        payload_end = end - tail
+        mac_received = frame[payload_end : end - 4]
+        suffix = struct.unpack(">I", frame[end - 4 : end])[0]
+        if suffix != SUFFIX_55AA:
+            raise LanFrameError(f"bad suffix: {suffix:#010x}")
+        mac_expected = _hmac.new(
+            hmac_key, frame[:16] + frame[16:payload_end], hashlib.sha256
+        ).digest()
+        if not _hmac.compare_digest(mac_received, mac_expected):
+            raise LanFrameError("hmac mismatch")
+        rest = frame[16:payload_end]
+    else:
+        crc_data = frame[: end - 8]
+        crc, suffix = struct.unpack(">2I", frame[end - 8 : end])
+        if crc != crypto.crc32(crc_data):
+            raise LanFrameError("crc mismatch")
+        if suffix != SUFFIX_55AA:
+            raise LanFrameError(f"bad suffix: {suffix:#010x}")
+        rest = frame[16 : end - 8]
+
+    # Retcode heuristic (see docstring)
+    retcode: int | None = None
+    if len(rest) >= 4:
+        candidate = struct.unpack(">I", rest[:4])[0]
+        if candidate < 0x10000:
+            retcode = candidate
+            rest = rest[4:]
+
+    return LanMessage(seqno=seqno, command=command, retcode=retcode, payload=rest)
+
+
+def derive_session_key_v34(
+    real_key: bytes, local_nonce: bytes, remote_nonce: bytes
+) -> bytes:
+    """Derive the v3.4 session key from real_key, local_nonce, and remote_nonce."""
+    xor = bytes(a ^ b for a, b in zip(local_nonce, remote_nonce))
+    return crypto.aes_ecb_encrypt(real_key, xor, pad=False)
+
+
+def encode_command(
+    key: bytes, command: LanCommand, payload_dict: dict, version: str = "3.3"
+) -> bytes:
+    """JSON-encode *payload_dict*, AES-ECB encrypt, with version-appropriate framing."""
+    raw = json.dumps(payload_dict, separators=(",", ":")).encode()
+    if version in ("3.4", "3.5"):
+        if command not in HEADERLESS_CMDS:
+            raw = version.encode()[:3] + b"\x00" * 12 + raw
+        return crypto.aes_ecb_encrypt(key, raw)
+    else:
+        enc = crypto.aes_ecb_encrypt(key, raw)
+        if command not in HEADERLESS_CMDS:
+            enc = VERSION_HEADER_33 + enc
+        return enc
+
+
+def decode_payload(key: bytes, payload: bytes, version: str = "3.3") -> dict:
+    """Decrypt and JSON-decode a payload. Returns {} for empty payloads."""
+    if not payload:
+        return {}
+    if version in ("3.4", "3.5"):
+        dec = crypto.aes_ecb_decrypt(key, payload)
+        if dec[:3] in (b"3.1", b"3.2", b"3.3", b"3.4", b"3.5"):
+            dec = dec[15:]
+        try:
+            return json.loads(dec)
+        except Exception as e:
+            raise LanFrameError(f"json decode error: {e}")
+    else:
+        return decode_v33_payload(key, payload)
+
+
+def encode_v33_command(key: bytes, command: LanCommand, payload_dict: dict) -> bytes:
+    """JSON-encode *payload_dict*, AES-ECB encrypt, and optionally prepend the
+    v3.3 version header (15 bytes) for commands that aren't headerless."""
+    return encode_command(key, command, payload_dict, version="3.3")
+
+
+def decode_v33_payload(key: bytes, payload: bytes) -> dict:
+    """Decrypt and JSON-decode a v3.3 payload.  Returns {} for empty payloads."""
+    if not payload:
+        return {}
+    if payload.startswith(b"3.3"):
+        payload = payload[15:]
+    try:
+        return json.loads(crypto.aes_ecb_decrypt(key, payload))
+    except (ValueError, KeyError, Exception) as e:
+        raise LanFrameError(f"decode failed: {e}") from e

src/tuya_re/lan_session.py

@@ -0,0 +1,210 @@
+"""Async TCP session for controlling a Tuya WiFi switch over the LAN (v3.3/v3.4)."""
+
+import asyncio
+import hashlib
+import hmac as _hmac
+import logging
+import struct
+import time
+
+from . import crypto, lan_protocol
+from .const import LanCommand, TUYA_TCP_PORT
+from .lan_protocol import LanFrameError
+
+_log = logging.getLogger(__name__)
+
+_SUPPORTED_VERSIONS = {"3.1", "3.2", "3.3", "3.4"}
+
+# Fixed local nonce used in every v3.4 session-key negotiation.
+_LOCAL_NONCE = b"0123456789abcdef"
+
+
+async def _read_frame(reader: asyncio.StreamReader) -> bytes:
+    """Read one complete 0x55AA frame from *reader*."""
+    try:
+        header = await reader.readexactly(16)
+    except asyncio.IncompleteReadError as e:
+        raise LanFrameError("connection closed while reading header") from e
+    length = struct.unpack(">4I", header)[3]
+    try:
+        rest = await reader.readexactly(length)
+    except asyncio.IncompleteReadError as e:
+        raise LanFrameError("connection closed while reading body") from e
+    return header + rest
+
+
+class LanSwitch:
+    """One Tuya LAN switch reachable at *host*:*port*."""
+
+    def __init__(
+        self,
+        device_id: str,
+        local_key: str,
+        version: str,
+        host: str,
+        port: int = TUYA_TCP_PORT,
+        timeout: float = 5.0,
+    ) -> None:
+        self.device_id = device_id
+        self._key = local_key.encode()
+        self.version = str(version)
+        self.host = host
+        self.port = port
+        self.timeout = timeout
+        self._seq = 0
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _now(self) -> str:
+        return str(int(time.time()))
+
+    def _next_seq(self) -> int:
+        self._seq += 1
+        return self._seq
+
+    def _query_dict(self) -> dict:
+        t = self._now()
+        return {
+            "gwId": self.device_id,
+            "devId": self.device_id,
+            "uid": self.device_id,
+            "t": t,
+        }
+
+    def _control_request(self, dps: dict) -> tuple[LanCommand, dict]:
+        """Pick the set command + payload for this protocol version.
+
+        v3.4/3.5 devices require CONTROL_NEW with a nested ``data.dps`` payload
+        (and an integer ``t``); v3.3 uses the legacy CONTROL with a flat ``dps``.
+        """
+        if self.version in ("3.4", "3.5"):
+            return LanCommand.CONTROL_NEW, {
+                "protocol": 5,
+                "t": int(time.time()),
+                "data": {"dps": dps},
+            }
+        return LanCommand.CONTROL, {
+            "devId": self.device_id,
+            "uid": self.device_id,
+            "t": self._now(),
+            "dps": dps,
+        }
+
+    async def _negotiate(
+        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
+    ) -> tuple[bytes, bytes]:
+        """Perform v3.4 session-key negotiation.
+
+        Returns (aes_key, hmac_key) — both are the derived session key.
+        """
+        real_key = self._key
+
+        # Step 2: send SESS_KEY_NEG_START
+        start_body = crypto.aes_ecb_encrypt(real_key, _LOCAL_NONCE)
+        writer.write(
+            lan_protocol.pack_frame(
+                self._next_seq(),
+                LanCommand.SESS_KEY_NEG_START,
+                start_body,
+                hmac_key=real_key,
+            )
+        )
+        await writer.drain()
+
+        # Step 3: read SESS_KEY_NEG_RESP
+        frame = await asyncio.wait_for(_read_frame(reader), self.timeout)
+        msg = lan_protocol.unpack_frame(frame, hmac_key=real_key)
+        dec = crypto.aes_ecb_decrypt(real_key, msg.payload)
+        remote_nonce = dec[:16]
+
+        # Optionally verify the HMAC of local_nonce that the device echoes back
+        if len(dec) >= 48:
+            expected_mac = _hmac.new(real_key, _LOCAL_NONCE, hashlib.sha256).digest()
+            if not _hmac.compare_digest(dec[16:48], expected_mac):
+                raise LanFrameError(
+                    "v3.4 negotiation: local_nonce HMAC mismatch in RESP"
+                )
+
+        # Step 4: send SESS_KEY_NEG_FINISH
+        finish_mac = _hmac.new(real_key, remote_nonce, hashlib.sha256).digest()
+        finish_body = crypto.aes_ecb_encrypt(real_key, finish_mac)
+        writer.write(
+            lan_protocol.pack_frame(
+                self._next_seq(),
+                LanCommand.SESS_KEY_NEG_FINISH,
+                finish_body,
+                hmac_key=real_key,
+            )
+        )
+        await writer.drain()
+
+        # Step 5: derive session key
+        session_key = lan_protocol.derive_session_key_v34(
+            real_key, _LOCAL_NONCE, remote_nonce
+        )
+        return session_key, session_key
+
+    async def _request(self, command: LanCommand, payload_dict: dict) -> dict:
+        if self.version not in _SUPPORTED_VERSIONS:
+            raise NotImplementedError(f"LAN protocol {self.version} not yet supported")
+
+        reader, writer = await asyncio.wait_for(
+            asyncio.open_connection(self.host, self.port),
+            self.timeout,
+        )
+        try:
+            if self.version == "3.4":
+                aes_key, hmac_key = await self._negotiate(reader, writer)
+            else:
+                aes_key, hmac_key = self._key, None
+
+            body = lan_protocol.encode_command(
+                aes_key, command, payload_dict, self.version
+            )
+            writer.write(
+                lan_protocol.pack_frame(
+                    self._next_seq(), command, body, hmac_key=hmac_key
+                )
+            )
+            await writer.drain()
+
+            frame = await asyncio.wait_for(_read_frame(reader), self.timeout)
+            msg = lan_protocol.unpack_frame(frame, hmac_key=hmac_key)
+            return lan_protocol.decode_payload(aes_key, msg.payload, self.version)
+        finally:
+            writer.close()
+            try:
+                await writer.wait_closed()
+            except OSError:
+                pass
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    async def status(self) -> bool:
+        """Return the current on/off state of the switch (DP 1)."""
+        r = await self._request(LanCommand.DP_QUERY, self._query_dict())
+        return bool(r["dps"]["1"])
+
+    async def turn_on(self) -> None:
+        """Turn the switch on."""
+        await self._set({"1": True})
+
+    async def turn_off(self) -> None:
+        """Turn the switch off."""
+        await self._set({"1": False})
+
+    async def _set(self, dps: dict) -> None:
+        command, payload = self._control_request(dps)
+        await self._request(command, payload)
+
+    async def toggle(self) -> None:
+        """Toggle the switch: read current state, then invert it."""
+        cur = await self.status()
+        if cur:
+            await self.turn_off()
+        else:
+            await self.turn_on()

src/tuya_re/packet.py

@@ -0,0 +1,119 @@
+"""Tuya BLE frame building/parsing and GATT chunking."""
+
+import secrets
+from struct import pack, unpack
+
+from . import crypto
+from .const import GATT_MTU
+
+
+class FrameError(Exception):
+    """Malformed, truncated, or CRC-failing frame data."""
+
+
+def pack_varint(value: int) -> bytes:
+    out = bytearray()
+    while True:
+        cur = value & 0x7F
+        value >>= 7
+        if value:
+            cur |= 0x80
+        out.append(cur)
+        if not value:
+            return bytes(out)
+
+
+def unpack_varint(data: bytes, pos: int) -> tuple[int, int]:
+    result = 0
+    for offset in range(4):
+        if pos + offset >= len(data):
+            raise FrameError("truncated varint")
+        cur = data[pos + offset]
+        result |= (cur & 0x7F) << (offset * 7)
+        if not cur & 0x80:
+            return result, pos + offset + 1
+    raise FrameError("varint too long")
+
+
+def build_frame(seq_num: int, response_to: int, code: int, payload: bytes) -> bytes:
+    raw = bytearray(pack(">IIHH", seq_num, response_to, int(code), len(payload)))
+    raw += payload
+    raw += pack(">H", crypto.crc16(raw))
+    while len(raw) % 16:
+        raw += b"\x00"
+    return bytes(raw)
+
+
+def parse_frame(frame: bytes) -> tuple[int, int, int, bytes]:
+    if len(frame) < 14:
+        raise FrameError("frame too short")
+    seq_num, response_to, code, length = unpack(">IIHH", frame[:12])
+    end = 12 + length
+    if len(frame) < end + 2:
+        raise FrameError("frame shorter than declared payload")
+    (frame_crc,) = unpack(">H", frame[end : end + 2])
+    if crypto.crc16(frame[:end]) != frame_crc:
+        raise FrameError("CRC mismatch")
+    return seq_num, response_to, code, frame[12:end]
+
+
+def encrypt_frame(
+    frame: bytes, key: bytes, security_flag: int, iv: bytes | None = None
+) -> bytes:
+    iv = secrets.token_bytes(16) if iv is None else iv
+    return bytes([security_flag]) + iv + crypto.aes_cbc_encrypt(key, iv, frame)
+
+
+def decrypt_frame(blob: bytes, key_for_flag) -> bytes:
+    if len(blob) < 17:
+        raise FrameError("encrypted blob too short")
+    key = key_for_flag(blob[0])
+    if key is None:
+        raise FrameError(f"no key for security flag {blob[0]:#x}")
+    return crypto.aes_cbc_decrypt(key, blob[1:17], blob[17:])
+
+
+def split_packets(blob: bytes, protocol_version: int = 3) -> list[bytes]:
+    chunks: list[bytes] = []
+    packet_num = 0
+    pos = 0
+    while pos < len(blob):
+        chunk = bytearray(pack_varint(packet_num))
+        if packet_num == 0:
+            chunk += pack_varint(len(blob))
+            chunk += bytes([protocol_version << 4])
+        part = blob[pos : pos + GATT_MTU - len(chunk)]
+        chunk += part
+        chunks.append(bytes(chunk))
+        pos += len(part)
+        packet_num += 1
+    return chunks
+
+
+class Reassembler:
+    """Rebuilds the encrypted blob from notification chunks."""
+
+    def __init__(self) -> None:
+        self._reset()
+
+    def _reset(self) -> None:
+        self._buffer = bytearray()
+        self._expected_num = 0
+        self._expected_len = 0
+
+    def feed(self, data: bytes) -> bytes | None:
+        packet_num, pos = unpack_varint(data, 0)
+        if packet_num == 0:
+            self._reset()
+            self._expected_len, pos = unpack_varint(data, pos)
+            pos += 1  # version byte
+        elif packet_num != self._expected_num:
+            self._reset()
+            return None
+        self._buffer += data[pos:]
+        self._expected_num = packet_num + 1
+        if len(self._buffer) >= self._expected_len:
+            blob = bytes(self._buffer[: self._expected_len])
+            self._reset()
+            return blob
+        return None

src/tuya_re/protocol.py

@@ -0,0 +1,237 @@
+"""Transport-agnostic Tuya BLE session: handshake and datapoint exchange."""
+
+import asyncio
+import logging
+import time
+from collections.abc import Awaitable, Callable
+from struct import pack
+
+from . import crypto, packet
+from .config import Credentials
+from .const import (
+    Code,
+    DPType,
+    RESPONSE_TIMEOUT,
+    SECURITY_FLAG_LOGIN,
+    SECURITY_FLAG_SESSION,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def encode_dp_value(dp_type: DPType, value) -> bytes:
+    match dp_type:
+        case DPType.RAW | DPType.BITMAP:
+            return bytes(value)
+        case DPType.BOOL:
+            return b"\x01" if value else b"\x00"
+        case DPType.VALUE:
+            return pack(">i", int(value))
+        case DPType.ENUM:
+            value = int(value)
+            if value > 0xFFFF:
+                return pack(">I", value)
+            if value > 0xFF:
+                return pack(">H", value)
+            return pack(">B", value)
+        case DPType.STRING:
+            return str(value).encode()
+    raise ValueError(f"unsupported dp type {dp_type}")
+
+
+def decode_dp_value(dp_type: DPType, raw: bytes):
+    match dp_type:
+        case DPType.RAW | DPType.BITMAP:
+            return raw
+        case DPType.BOOL:
+            return int.from_bytes(raw, "big") != 0
+        case DPType.VALUE | DPType.ENUM:
+            return int.from_bytes(raw, "big", signed=True)
+        case DPType.STRING:
+            return raw.decode()
+
+
+class Session:
+    def __init__(
+        self,
+        creds: Credentials,
+        send: Callable[[bytes], Awaitable[None]],
+        response_timeout: float = RESPONSE_TIMEOUT,
+    ) -> None:
+        self._creds = creds
+        self._send = send
+        self._timeout = response_timeout
+        self._login_key = crypto.login_key(creds.local_key)
+        self._session_key: bytes | None = None
+        self._protocol_version = 3
+        self._seq = 0
+        self._pending: dict[int, asyncio.Future[bytes]] = {}
+        self._reassembler = packet.Reassembler()
+        self._write_lock = asyncio.Lock()
+        self._ack_tasks: set[asyncio.Task] = set()
+        self.paired = False
+        self.dps: dict[int, object] = {}
+
+    # ---- outgoing ----
+
+    def _key_for_send(self, code: Code) -> tuple[bytes, int]:
+        if code == Code.SENDER_DEVICE_INFO:
+            return self._login_key, SECURITY_FLAG_LOGIN
+        if not self._session_key:
+            raise RuntimeError("handshake not completed")
+        return self._session_key, SECURITY_FLAG_SESSION
+
+    async def _request(self, code: Code, payload: bytes) -> bytes:
+        self._seq += 1
+        seq = self._seq
+        future: asyncio.Future[bytes] = asyncio.get_running_loop().create_future()
+        self._pending[seq] = future
+        await self._write(seq, 0, code, payload)
+        try:
+            return await asyncio.wait_for(future, self._timeout)
+        except asyncio.TimeoutError:
+            raise TimeoutError(
+                f"no response to {code.name} within {self._timeout}s"
+            ) from None
+        finally:
+            self._pending.pop(seq, None)
+
+    async def _respond(self, response_to: int, code: Code, payload: bytes) -> None:
+        self._seq += 1
+        await self._write(self._seq, response_to, code, payload)
+
+    async def _write(
+        self, seq: int, response_to: int, code: Code, payload: bytes
+    ) -> None:
+        key, flag = self._key_for_send(code)
+        frame = packet.build_frame(seq, response_to, code, payload)
+        blob = packet.encrypt_frame(frame, key, flag)
+        _LOGGER.debug("-> #%d %s payload=%s", seq, code.name, payload.hex())
+        async with self._write_lock:
+            for chunk in packet.split_packets(blob, self._protocol_version):
+                await self._send(chunk)
+
+    # ---- public API ----
+
+    async def handshake(self) -> None:
+        info = await self._request(Code.SENDER_DEVICE_INFO, b"")
+        if len(info) < 46:
+            raise packet.FrameError("device info response too short")
+        self._protocol_version = info[2]
+        srand = info[6:12]
+        self._session_key = crypto.session_key(self._creds.local_key, srand)
+        _LOGGER.debug(
+            "device ver %d.%d, protocol %d, bound=%d",
+            info[0],
+            info[1],
+            info[2],
+            info[5],
+        )
+
+        pair = bytearray()
+        pair += self._creds.uuid.encode()
+        pair += self._creds.local_key[:6].encode()
+        pair += self._creds.device_id.encode()
+        pair += bytes(44 - len(pair))
+        result = await self._request(Code.SENDER_PAIR, bytes(pair))
+        # 0 = newly paired, 2 = already paired; anything else is an error
+        if result and result[0] not in (0, 2):
+            raise packet.FrameError(f"pairing failed, code {result[0]}")
+        self.paired = True
+
+    async def set_dp(self, dp_id: int, dp_type: DPType, value) -> None:
+        encoded = encode_dp_value(dp_type, value)
+        payload = bytes([dp_id, dp_type, len(encoded)]) + encoded
+        result = await self._request(Code.SENDER_DPS, payload)
+        if result and result[0] != 0:
+            raise packet.FrameError(
+                f"device rejected dp {dp_id} write, code {result[0]}"
+            )
+
+    async def request_status(self) -> None:
+        result = await self._request(Code.SENDER_DEVICE_STATUS, b"")
+        if result and result[0] != 0:
+            raise packet.FrameError(f"device rejected status request, code {result[0]}")
+
+    # ---- incoming ----
+
+    def handle_notification(self, data: bytes) -> None:
+        blob = self._reassembler.feed(data)
+        if blob is None:
+            return
+        frame = packet.decrypt_frame(blob, self._key_for_flag)
+        seq, response_to, code_value, payload = packet.parse_frame(frame)
+        try:
+            code = Code(code_value)
+        except ValueError:
+            _LOGGER.debug(
+                "<- #%d unknown code %#06x %s", seq, code_value, payload.hex()
+            )
+            return
+        _LOGGER.debug(
+            "<- #%d %s resp_to=%d payload=%s",
+            seq,
+            code.name,
+            response_to,
+            payload.hex(),
+        )
+        self._dispatch(seq, response_to, code, payload)
+
+    def _key_for_flag(self, flag: int) -> bytes | None:
+        if flag == SECURITY_FLAG_LOGIN:
+            return self._login_key
+        if flag == SECURITY_FLAG_SESSION:
+            return self._session_key
+        return None
+
+    def _dispatch(self, seq: int, response_to: int, code: Code, payload: bytes) -> None:
+        match code:
+            case Code.RECEIVE_DP:
+                self._parse_dps(payload, 0)
+                self._ack(seq, code, b"")
+            case Code.RECEIVE_SIGN_DP:
+                dp_seq = int.from_bytes(payload[:2], "big")
+                flags = payload[2]
+                self._parse_dps(payload, 3)
+                self._ack(seq, code, pack(">HBB", dp_seq, flags, 0))
+            case Code.RECEIVE_TIME1_REQ:
+                tz = -int(time.timezone / 36)
+                data = str(int(time.time() * 1000)).encode() + pack(">h", tz)
+                self._ack(seq, code, data)
+            case Code.RECEIVE_TIME2_REQ:
+                t = time.localtime()
+                tz = -int(time.timezone / 36)
+                data = pack(
+                    ">BBBBBBBh",
+                    t.tm_year % 100,
+                    t.tm_mon,
+                    t.tm_mday,
+                    t.tm_hour,
+                    t.tm_min,
+                    t.tm_sec,
+                    t.tm_wday,
+                    tz,
+                )
+                self._ack(seq, code, data)
+
+        if response_to:
+            future = self._pending.get(response_to)
+            if future and not future.done():
+                future.set_result(payload)
+
+    def _ack(self, response_to: int, code: Code, payload: bytes) -> None:
+        task = asyncio.ensure_future(self._respond(response_to, code, payload))
+        self._ack_tasks.add(task)
+        task.add_done_callback(self._ack_tasks.discard)
+
+    def _parse_dps(self, data: bytes, pos: int) -> None:
+        while len(data) - pos >= 4:
+            dp_id = data[pos]
+            dp_type = DPType(data[pos + 1])
+            length = data[pos + 2]
+            pos += 3
+            raw = data[pos : pos + length]
+            pos += length
+            value = decode_dp_value(dp_type, raw)
+            self.dps[dp_id] = value
+            _LOGGER.debug("dp %d (%s) = %r", dp_id, dp_type.name, value)

tests/test_config.py

@@ -0,0 +1,175 @@
+"""TOML config loading: namespaced sections per device class."""
+
+import textwrap
+
+import pytest
+
+from tuya_re.config import (
+    GatewayFingerbot,
+    SwitchCredentials,
+    load_fingerbots,
+    load_gateway,
+    load_ir_blasters,
+    load_switches,
+    select_devices,
+)
+
+FULL = textwrap.dedent("""
+    [fingerbots]
+    default = "robot2"
+    [fingerbots.devices.robot1]
+    device_id = "testdevice000000000001"
+    uuid = "uuidTESTtest0000"
+    local_key = "abcdef0123456789"
+    product_id = "mknd4lci"
+    [fingerbots.devices.robot2]
+    device_id = "testdevice000000000002"
+    uuid = "uuidTESTtest0002"
+    local_key = "abcdef0123456789"
+    product_id = "mknd4lci"
+
+    [switches]
+    default = "plug"
+    [switches.devices.plug]
+    device_id = "testdevice000000000003"
+    local_key = "abcdef0123456789"
+    product_id = "o7ve1lp3gfjvsvyo"
+    version = "3.4"
+    ip = "192.0.2.10"
+
+    [ir_blasters]
+    default = "blaster"
+    [ir_blasters.devices.blaster]
+    device_id = "testdevice000000000004"
+    uuid = "uuidTESTtest0004"
+    local_key = "abcdef0123456789"
+    product_id = "xgahj3gjk3ftaejt"
+
+    [gateway]
+    device_id = "testdevice000000000005"
+    ip = "192.0.2.20"
+    local_key = "abcdef0123456789"
+    version = "3.4"
+    [gateway.fingerbots]
+    default = "robot1"
+    [gateway.fingerbots.devices.robot1]
+    device_id = "testdevice000000000001"
+    node_id = "uuidTESTtest0000"
+""")
+
+
+@pytest.fixture
+def cfg_path(tmp_path):
+    p = tmp_path / "config.toml"
+    p.write_text(FULL)
+    return p
+
+
+def test_load_fingerbots_default_selection(cfg_path):
+    cfg = load_fingerbots(cfg_path)
+    [creds] = select_devices(cfg, None)
+    assert creds.name == "robot2"
+    assert creds.device_id == "testdevice000000000002"
+
+
+def test_select_by_name_and_all(cfg_path):
+    cfg = load_fingerbots(cfg_path)
+    assert select_devices(cfg, "robot1")[0].uuid == "uuidTESTtest0000"
+    assert {c.name for c in select_devices(cfg, "all")} == {"robot1", "robot2"}
+
+
+def test_unknown_device_raises(cfg_path):
+    with pytest.raises(ValueError, match="unknown device"):
+        select_devices(load_fingerbots(cfg_path), "nope")
+
+
+def test_load_switches(cfg_path):
+    [sw] = select_devices(load_switches(cfg_path), None)
+    assert sw == SwitchCredentials(
+        device_id="testdevice000000000003",
+        local_key="abcdef0123456789",
+        product_id="o7ve1lp3gfjvsvyo",
+        name="plug",
+        version="3.4",
+        ip="192.0.2.10",
+    )
+
+
+def test_switch_optional_fields_default_none(tmp_path):
+    p = tmp_path / "config.toml"
+    p.write_text(
+        textwrap.dedent("""
+        [switches.devices.plug]
+        device_id = "testdevice000000000003"
+        local_key = "abcdef0123456789"
+        product_id = "o7ve1lp3gfjvsvyo"
+    """)
+    )
+    [sw] = select_devices(load_switches(p), None)
+    assert sw.version is None and sw.ip is None
+
+
+def test_switch_numeric_version_coerced_to_str(tmp_path):
+    p = tmp_path / "config.toml"
+    p.write_text(
+        textwrap.dedent("""
+        [switches.devices.plug]
+        device_id = "testdevice000000000003"
+        local_key = "abcdef0123456789"
+        product_id = "o7ve1lp3gfjvsvyo"
+        version = 3.4
+    """)
+    )
+    [sw] = select_devices(load_switches(p), None)
+    assert sw.version == "3.4"
+
+
+def test_load_ir_blasters(cfg_path):
+    [blaster] = select_devices(load_ir_blasters(cfg_path), None)
+    assert blaster.product_id == "xgahj3gjk3ftaejt"
+
+
+def test_missing_section_gives_empty_config(tmp_path):
+    p = tmp_path / "config.toml"
+    p.write_text(
+        '[fingerbots.devices.r]\ndevice_id = "x"\nuuid = "u"\n'
+        'local_key = "k"\nproduct_id = "p"\n'
+    )
+    with pytest.raises(ValueError, match="no .* devices configured"):
+        select_devices(load_ir_blasters(p), None)
+
+
+def test_multiple_devices_without_default_raises(tmp_path):
+    p = tmp_path / "config.toml"
+    p.write_text(
+        textwrap.dedent("""
+        [fingerbots.devices.a]
+        device_id = "x"
+        uuid = "u"
+        local_key = "k"
+        product_id = "p"
+        [fingerbots.devices.b]
+        device_id = "y"
+        uuid = "u2"
+        local_key = "k"
+        product_id = "p"
+    """)
+    )
+    with pytest.raises(ValueError, match="multiple devices"):
+        select_devices(load_fingerbots(p), None)
+
+
+def test_load_gateway(cfg_path):
+    gw = load_gateway(cfg_path)
+    assert gw.ip == "192.0.2.20"
+    assert gw.version == "3.4"
+    [fb] = select_devices(gw.fingerbots, None)
+    assert fb == GatewayFingerbot(
+        device_id="testdevice000000000001", node_id="uuidTESTtest0000", name="robot1"
+    )
+
+
+def test_load_gateway_absent_returns_none(tmp_path):
+    p = tmp_path / "config.toml"
+    p.write_text("[fingerbots]\n")
+    assert load_gateway(p) is None

tests/test_crypto.py

@@ -0,0 +1,61 @@
+"""tests/test_crypto.py"""
+
+from tuya_re import crypto
+
+
+def test_crc16_known_answer():
+    # CRC-16 with init=0xFFFF, poly 0xA001 (MODBUS variant) — matches the
+    # device firmware (verified against ha_tuya_ble's implementation).
+    assert crypto.crc16(b"123456789") == 0x4B37
+
+
+def test_crc16_empty():
+    assert crypto.crc16(b"") == 0xFFFF
+
+
+def test_login_key_uses_first_6_chars_only():
+    import hashlib
+
+    key = crypto.login_key("abcdef0123456789")
+    assert key == hashlib.md5(b"abcdef").digest()
+    assert len(key) == 16
+
+
+def test_session_key():
+    import hashlib
+
+    srand = bytes(range(6))
+    key = crypto.session_key("abcdef0123456789", srand)
+    assert key == hashlib.md5(b"abcdef" + srand).digest()
+
+
+def test_encrypt_decrypt_roundtrip():
+    key = bytes(16)
+    iv = bytes(range(16))
+    plain = b"A" * 32  # must be 16-aligned
+    ct = crypto.aes_cbc_encrypt(key, iv, plain)
+    assert ct != plain
+    assert crypto.aes_cbc_decrypt(key, iv, ct) == plain
+
+
+def test_aes_ecb_known_vector():
+    key = b"0123456789abcdef"
+    ct = crypto.aes_ecb_encrypt(key, b"hello tuya 12345")
+    assert (
+        ct.hex() == "892dc5a803b72acfcbacb4f40ace9064377222e061a924c591cd9c27ea163ed4"
+    )
+    assert crypto.aes_ecb_decrypt(key, ct) == b"hello tuya 12345"
+
+
+def test_aes_ecb_pkcs7_roundtrip():
+    key = bytes(16)
+    for n in (0, 1, 15, 16, 17, 32):
+        msg = b"x" * n
+        assert crypto.aes_ecb_decrypt(key, crypto.aes_ecb_encrypt(key, msg)) == msg
+
+
+def test_crc32_matches_zlib():
+    import zlib
+
+    data = b"\x00\x00\x55\xaa\x00\x00\x00\x01"
+    assert crypto.crc32(data) == (zlib.crc32(data) & 0xFFFFFFFF)

tests/test_devices.py

@@ -0,0 +1,25 @@
+"""tests/test_devices.py"""
+
+import pytest
+
+from tuya_re.devices import dp_map_for
+
+
+def test_mknd4lci_map():
+    dps = dp_map_for("mknd4lci")
+    assert dps.click == 108
+    assert dps.switch == 1
+    assert dps.mode == 101
+    assert dps.hold_time == 103
+
+
+def test_fingerbot_plus_szjqr_map():
+    dps = dp_map_for("blliqpsj")
+    assert dps.click == 2
+    assert dps.switch == 2
+    assert dps.mode == 8
+
+
+def test_unknown_product_raises():
+    with pytest.raises(ValueError):
+        dp_map_for("nope")

tests/test_gateway.py

@@ -0,0 +1,39 @@
+"""Gateway click sequencing against a fake tinytuya device."""
+
+import pytest
+
+from tuya_re import gateway
+
+
+class FakeDevice:
+    def __init__(self, results=None):
+        self.calls = []
+        self._results = dict(results or {})
+
+    def set_value(self, dp, value):
+        self.calls.append((dp, value))
+        return self._results.get(dp, {"dps": {dp: value}})
+
+
+def test_click_sets_mode_then_presses_with_settle():
+    dev = FakeDevice()
+    sleeps = []
+    gateway.click(dev, settle=1.0, sleep=sleeps.append)
+    assert dev.calls == [
+        (gateway.DP_MODE, gateway.MODE_CLICK),
+        (gateway.DP_SWITCH, True),
+    ]
+    assert sleeps == [1.0]
+
+
+def test_click_raises_on_mode_error():
+    dev = FakeDevice(results={gateway.DP_MODE: {"Error": "914"}})
+    with pytest.raises(gateway.GatewayError, match="set click mode"):
+        gateway.click(dev, sleep=lambda _: None)
+    assert dev.calls == [(gateway.DP_MODE, gateway.MODE_CLICK)]
+
+
+def test_click_raises_on_press_error():
+    dev = FakeDevice(results={gateway.DP_SWITCH: {"Error": "905"}})
+    with pytest.raises(gateway.GatewayError, match="click"):
+        gateway.click(dev, sleep=lambda _: None)

tests/test_ir_blaster.py

@@ -0,0 +1,139 @@
+"""tests/test_ir_blaster.py"""
+
+import asyncio
+
+import pytest
+
+from tuya_re import crypto, packet
+from tuya_re.config import Credentials
+from tuya_re.const import Code, DPType, SECURITY_FLAG_LOGIN, SECURITY_FLAG_SESSION
+from tuya_re.ir import IRBlaster
+from tuya_re.protocol import Session
+
+CREDS = Credentials(
+    device_id="testdevice000000000001",
+    uuid="uuidTESTtest0000",
+    local_key="abcdef0123456789",
+    product_id="xgahj3gjk3ftaejt",
+)
+SRAND = b"\x01\x02\x03\x04\x05\x06"
+LOGIN_KEY = crypto.login_key(CREDS.local_key)
+SESSION_KEY = crypto.session_key(CREDS.local_key, SRAND)
+
+
+class FakeDevice:
+    """Decrypts what Session writes; answers as the device. Mirrors the
+    sibling repo's protocol-test harness."""
+
+    def __init__(self):
+        self.reassembler = packet.Reassembler()
+        self.dp_writes: list[bytes] = []  # payloads of SENDER_DPS
+        self.session: Session | None = None
+        self._device_seq = 100
+
+    async def send(self, chunk: bytes) -> None:
+        blob = self.reassembler.feed(chunk)
+        if blob is None:
+            return
+        key = LOGIN_KEY if blob[0] == SECURITY_FLAG_LOGIN else SESSION_KEY
+        frame = crypto.aes_cbc_decrypt(key, blob[1:17], blob[17:])
+        seq, _, code, payload = packet.parse_frame(frame)
+        if code == Code.SENDER_DEVICE_INFO:
+            info = bytes([1, 0, 3, 0, 0, 1]) + SRAND + bytes(2) + bytes(32)
+            self._respond(
+                seq, Code.SENDER_DEVICE_INFO, info, LOGIN_KEY, SECURITY_FLAG_LOGIN
+            )
+        elif code == Code.SENDER_PAIR:
+            self._respond(
+                seq, Code.SENDER_PAIR, b"\x00", SESSION_KEY, SECURITY_FLAG_SESSION
+            )
+        elif code == Code.SENDER_DPS:
+            self.dp_writes.append(payload)
+            self._respond(
+                seq, Code.SENDER_DPS, b"\x00", SESSION_KEY, SECURITY_FLAG_SESSION
+            )
+
+    def _respond(self, response_to, code, payload, key, flag) -> None:
+        self._device_seq += 1
+        frame = packet.build_frame(self._device_seq, response_to, code, payload)
+        blob = packet.encrypt_frame(frame, key, flag)
+        for chunk in packet.split_packets(blob):
+            self.session.handle_notification(chunk)
+
+    def push_dp(self, dp_id: int, dp_type: DPType, value) -> None:
+        """Device-initiated DP report (response_to=0)."""
+        from tuya_re.protocol import encode_dp_value
+
+        enc = encode_dp_value(dp_type, value)
+        payload = bytes([dp_id, dp_type, len(enc)]) + enc
+        self._device_seq += 1
+        frame = packet.build_frame(self._device_seq, 0, Code.RECEIVE_DP, payload)
+        blob = packet.encrypt_frame(frame, SESSION_KEY, SECURITY_FLAG_SESSION)
+        for chunk in packet.split_packets(blob):
+            self.session.handle_notification(chunk)
+
+
+@pytest.fixture
+def linked():
+    device = FakeDevice()
+    session = Session(CREDS, device.send, response_timeout=1.0)
+    device.session = session
+    return device, session
+
+
+def _decode_dp_write(payload: bytes):
+    dp_id, dp_type, length = payload[0], payload[1], payload[2]
+    return dp_id, DPType(dp_type), payload[3 : 3 + length]
+
+
+async def test_send_ir_writes_base64_to_send_dp(linked):
+    device, session = linked
+    await session.handshake()
+    blaster = IRBlaster(session)  # defaults: send DP 201, STRING
+    await blaster.send_ir("8iOQERoC")
+    assert len(device.dp_writes) == 1
+    dp_id, dp_type, raw = _decode_dp_write(device.dp_writes[0])
+    assert dp_id == 201
+    assert dp_type == DPType.STRING
+    assert raw == b"8iOQERoC"
+
+
+async def test_send_ir_honors_custom_dp_and_type(linked):
+    device, session = linked
+    await session.handshake()
+    blaster = IRBlaster(session, send_dp=7, send_dp_type=DPType.RAW)
+    await blaster.send_ir("8iOQERoC")
+    dp_id, dp_type, _ = _decode_dp_write(device.dp_writes[0])
+    assert dp_id == 7
+    assert dp_type == DPType.RAW
+
+
+async def test_learn_enters_waits_reports_and_exits(linked):
+    device, session = linked
+    await session.handshake()
+    blaster = IRBlaster(session)
+
+    async def press_remote():
+        await asyncio.sleep(0.05)
+        device.push_dp(202, DPType.RAW, b"\xf2\x23\x90\x11\x1a\x02")
+
+    learned, _ = await asyncio.gather(
+        blaster.learn(timeout=1.0, poll_interval=0.01),
+        press_remote(),
+    )
+    assert learned == "8iOQERoC"  # RAW bytes -> base64
+
+    first = _decode_dp_write(device.dp_writes[0])
+    last = _decode_dp_write(device.dp_writes[-1])
+    assert first == (202, DPType.ENUM, b"\x01")  # STUDY_ON
+    assert last == (202, DPType.ENUM, b"\x00")  # STUDY_OFF
+
+
+async def test_learn_times_out_but_still_exits_study(linked):
+    device, session = linked
+    await session.handshake()
+    blaster = IRBlaster(session)
+    with pytest.raises(TimeoutError, match="no IR code learned"):
+        await blaster.learn(timeout=0.1, poll_interval=0.01)
+    last = _decode_dp_write(device.dp_writes[-1])
+    assert last == (202, DPType.ENUM, b"\x00")  # STUDY_OFF

tests/test_ir_codec.py

@@ -0,0 +1,53 @@
+"""tests/test_ir_codec.py"""
+
+import pytest
+
+from tuya_re.ir import base64_to_pulses, pulses_to_base64
+
+# Golden vector, hand-computed:
+#   9202 -> f2 23 | 4496 -> 90 11 | 538 -> 1a 02  (little-endian u16)
+#   -> base64 "8iOQERoC"
+GOLDEN_PULSES = [9202, 4496, 538]
+GOLDEN_B64 = "8iOQERoC"
+
+# Real ir_study_code captured from a JMIR05 blaster in study mode (DP 202).
+HARDWARE_B64 = (
+    "vALnA0gGwgdIBucDKAPnAygD5wMoAxESvALnAygDwgcoA+cDKAPnAygDGgUaB"
+    "RoF6wHRCBoF5wMoA+cDvAJaLOsB5wNIBtEIGgUaBW8BGgUoAxoF6wERErwCR"
+    "w68AhoF6wEhC7wCQgJvAecDKAPCB+sBbwFCAkgGbwEaBfMA0Ps="
+)
+
+
+def test_pulses_to_base64_golden():
+    assert pulses_to_base64(GOLDEN_PULSES) == GOLDEN_B64
+
+
+def test_base64_to_pulses_golden():
+    assert base64_to_pulses(GOLDEN_B64) == GOLDEN_PULSES
+
+
+def test_hardware_code_decodes_to_sane_pulses():
+    pulses = base64_to_pulses(HARDWARE_B64)
+    assert len(pulses) == 64
+    assert pulses[0] == 700
+    assert all(0 < p <= 0xFFFF for p in pulses)
+    # round-trips back to the same base64
+    assert pulses_to_base64(pulses) == HARDWARE_B64
+
+
+def test_round_trip():
+    pulses = [9000, 4500, 560, 560, 560, 1690, 39000]
+    assert base64_to_pulses(pulses_to_base64(pulses)) == pulses
+
+
+def test_value_too_large_raises():
+    with pytest.raises(ValueError, match="out of u16 range"):
+        pulses_to_base64([70000])
+
+
+def test_odd_length_payload_raises():
+    import base64
+
+    bad = base64.b64encode(b"\x01\x02\x03").decode()
+    with pytest.raises(ValueError, match="not a whole number"):
+        base64_to_pulses(bad)

tests/test_lan_discovery.py

@@ -0,0 +1,37 @@
+import hashlib
+import json
+
+from tuya_re import crypto, lan_discovery as disc, lan_protocol as lp
+from tuya_re.const import LanCommand, UDP_KEY_SEED
+
+UDP_KEY = hashlib.md5(UDP_KEY_SEED).digest()
+
+
+def test_decode_broadcast_encrypted_55aa():
+    info = {
+        "gwId": "dev123",
+        "ip": "192.168.1.50",
+        "version": "3.3",
+        "productKey": "pk",
+    }
+    body = crypto.aes_ecb_encrypt(UDP_KEY, json.dumps(info).encode())
+    frame = lp.pack_frame(0, LanCommand.UDP, body, retcode=0)
+    assert disc.decode_broadcast(frame) == info
+
+
+def test_decode_broadcast_plain_json_payload():
+    info = {"gwId": "d", "ip": "10.0.0.9", "version": "3.3"}
+    # some devices' payloads are already plaintext JSON inside the frame
+    frame = lp.pack_frame(0, LanCommand.UDP, json.dumps(info).encode(), retcode=0)
+    assert disc.decode_broadcast(frame) == info
+
+
+def test_decode_broadcast_payload_raw_json():
+    info = {"gwId": "x", "ip": "10.0.0.1"}
+    assert disc.decode_broadcast_payload(json.dumps(info).encode()) == info
+
+
+def test_decode_broadcast_payload_encrypted():
+    info = {"gwId": "y", "ip": "10.0.0.2"}
+    enc = crypto.aes_ecb_encrypt(UDP_KEY, json.dumps(info).encode())
+    assert disc.decode_broadcast_payload(enc) == info

tests/test_lan_protocol.py

@@ -0,0 +1,162 @@
+import pytest
+
+from tuya_re import lan_protocol as lp
+from tuya_re.const import LanCommand
+
+KEY = b"0123456789abcdef"
+
+
+def test_pack_control_matches_golden():
+    body = lp.encode_v33_command(
+        KEY,
+        LanCommand.CONTROL,
+        {
+            "devId": "synthdev0001",
+            "uid": "synthdev0001",
+            "t": "100",
+            "dps": {"1": True},
+        },
+    )
+    frame = lp.pack_frame(seqno=1, command=LanCommand.CONTROL, body=body)
+    assert frame.hex() == (
+        "000055aa0000000100000007000000673"
+        "32e3300000000000000000000000051027acc8d66f9d991bb545def2c54f98f2a1d63"
+        "ed129ea6a1e08abe6427fed33fbd18005b18ec06894ddff50046fbee433c1a9df3e72"
+        "0960094b19b5c30d031a603e43b8f00ae44bada4be6f66160ddd4de28550000aa55"
+    )
+
+
+def test_pack_dpquery_matches_golden():
+    body = lp.encode_v33_command(
+        KEY,
+        LanCommand.DP_QUERY,
+        {
+            "gwId": "synthdev0001",
+            "devId": "synthdev0001",
+            "uid": "synthdev0001",
+            "t": "100",
+        },
+    )
+    frame = lp.pack_frame(seqno=2, command=LanCommand.DP_QUERY, body=body)
+    assert frame.hex() == (
+        "000055aa000000020000000a00000058d958003254c7c411ddff3f18fc25cad7982598"
+        "d6c3e06d7668511179ee665bec29ec20bf47d8217234c0b4cab174f9f1c8cca11f4740"
+        "beecff7c92d5d3c308fdc23cef0c529f97348f21b887ff7ae67c3956bdca0000aa55"
+    )
+
+
+def test_unpack_roundtrip_and_crc():
+    body = lp.encode_v33_command(
+        KEY, LanCommand.CONTROL, {"devId": "d", "dps": {"1": False}}
+    )
+    frame = lp.pack_frame(3, LanCommand.CONTROL, body)
+    msg = lp.unpack_frame(frame)
+    assert msg.command == LanCommand.CONTROL and msg.seqno == 3
+    assert lp.decode_v33_payload(KEY, msg.payload) == {
+        "devId": "d",
+        "dps": {"1": False},
+    }
+
+
+def test_unpack_bad_crc_raises():
+    body = lp.encode_v33_command(KEY, LanCommand.CONTROL, {"a": 1})
+    frame = bytearray(lp.pack_frame(1, LanCommand.CONTROL, body))
+    frame[20] ^= 0xFF
+    with pytest.raises(lp.LanFrameError):
+        lp.unpack_frame(bytes(frame))
+
+
+def test_decode_reply_with_retcode():
+    body = lp.encode_v33_command(KEY, LanCommand.DP_QUERY, {"dps": {"1": True}})
+    reply = lp.pack_frame(2, LanCommand.DP_QUERY, body, retcode=0)
+    msg = lp.unpack_frame(reply)
+    assert lp.decode_v33_payload(KEY, msg.payload) == {"dps": {"1": True}}
+
+
+def test_decode_empty_payload_is_empty_dict():
+    assert lp.decode_v33_payload(KEY, b"") == {}
+
+
+def test_derive_session_key_v34():
+    assert (
+        lp.derive_session_key_v34(
+            b"0123456789abcdef", b"0123456789abcdef", b"abcdef0123456789"
+        ).hex()
+        == "465ad66115cf0cb58482681d57f0133b"
+    )
+
+
+def test_pack_hmac_frame_start_golden():
+    REAL = b"0123456789abcdef"
+    from tuya_re import crypto
+
+    body = crypto.aes_ecb_encrypt(REAL, REAL)  # ECB(real, local_nonce)
+    frame = lp.pack_frame(1, LanCommand.SESS_KEY_NEG_START, body, hmac_key=REAL)
+    assert frame.hex() == (
+        "000055aa0000000100000003000000447272"
+        "7e881edcfd0100a718687909b565377222e061a924c591cd9c27ea163ed4d7dd1f9e"
+        "b60b8cb5b90748aa228534c62460d05b84665c9e692efc896dd77d680000aa55"
+    )
+
+
+def test_unpack_hmac_frame_verifies():
+    REAL = b"0123456789abcdef"
+    resp_hex = (
+        "000055aa0000000200000004000000640f9be99491cb21d2e042af13e00ce19"
+        "734a8706148aba7b9e47b4fd03c3428475216353fe75fa1cb7918233866ab9feb377222"
+        "e061a924c591cd9c27ea163ed416389ab8912c499dc37aa85108337e419fb2469e93c62"
+        "d807367617653a450a40000aa55"
+    )
+    msg = lp.unpack_frame(bytes.fromhex(resp_hex), hmac_key=REAL)
+    assert msg.command == LanCommand.SESS_KEY_NEG_RESP
+    # decrypt body with REAL, recover remote_nonce + hmac
+    from tuya_re import crypto
+
+    dec = crypto.aes_ecb_decrypt(REAL, msg.payload)
+    assert dec[:16] == b"abcdef0123456789"
+
+
+def test_unpack_hmac_bad_mac_raises():
+    REAL = b"0123456789abcdef"
+    from tuya_re import crypto
+
+    frame = bytearray(
+        lp.pack_frame(
+            1, LanCommand.CONTROL, crypto.aes_ecb_encrypt(REAL, b"x"), hmac_key=REAL
+        )
+    )
+    frame[-6] ^= 0xFF  # corrupt inside the hmac
+    with pytest.raises(lp.LanFrameError):
+        lp.unpack_frame(bytes(frame), hmac_key=REAL)
+
+
+def test_encode_v34_control_frame_golden():
+    SESSION = bytes.fromhex("465ad66115cf0cb58482681d57f0133b")
+    body = lp.encode_command(
+        SESSION,
+        LanCommand.CONTROL,
+        {
+            "devId": "synthdev0001",
+            "uid": "synthdev0001",
+            "t": "100",
+            "dps": {"1": True},
+        },
+        version="3.4",
+    )
+    frame = lp.pack_frame(4, LanCommand.CONTROL, body, hmac_key=SESSION)
+    assert frame.hex() == (
+        "000055aa00000004000000070000008464"
+        "5421669e0a4da19c83e1c3bdc0368d7828489e443086f21b978782f671cb651a270cc3"
+        "01b9635c773070fb8985b8006bebceb8c013a303b61c9729da66a9132643ca448149ef"
+        "67b0ada24a728d4365132dee5659b3f58f65ded80ac7caeded60fe7b6d665c26d815ff"
+        "f0ba45c252a69a6276f7f9dae56475cd0f3a59de324f0000aa55"
+    )
+
+
+def test_decode_v34_payload_strips_header():
+    SESSION = bytes.fromhex("465ad66115cf0cb58482681d57f0133b")
+
+    body = lp.encode_command(
+        SESSION, LanCommand.CONTROL, {"dps": {"1": False}}, version="3.4"
+    )
+    assert lp.decode_payload(SESSION, body, version="3.4") == {"dps": {"1": False}}

tests/test_lan_session.py

@@ -0,0 +1,188 @@
+import asyncio
+import hashlib
+import hmac as _hmac
+import struct
+
+import pytest
+
+from tuya_re import crypto, lan_protocol as lp
+from tuya_re.const import LanCommand
+from tuya_re.lan_session import LanSwitch
+
+KEY = b"0123456789abcdef"
+KEY_STR = KEY.decode()  # "0123456789abcdef" is ascii
+
+
+async def _read_frame(reader):
+    header = await reader.readexactly(16)
+    length = struct.unpack(">4I", header)[3]
+    return header + await reader.readexactly(length)
+
+
+class FakePlug:
+    def __init__(self, state):
+        self.state = state
+        self.server = None
+        self.host = self.port = None
+
+    async def start(self):
+        self.server = await asyncio.start_server(self._handle, "127.0.0.1", 0)
+        sock = self.server.sockets[0].getsockname()
+        self.host, self.port = sock[0], sock[1]
+
+    async def _handle(self, reader, writer):
+        try:
+            while True:
+                frame = await _read_frame(reader)
+                msg = lp.unpack_frame(frame)
+                req = lp.decode_v33_payload(KEY, msg.payload)
+                if msg.command == LanCommand.DP_QUERY:
+                    body = lp.encode_v33_command(
+                        KEY, LanCommand.DP_QUERY, {"dps": {"1": self.state}}
+                    )
+                    writer.write(
+                        lp.pack_frame(msg.seqno, LanCommand.DP_QUERY, body, retcode=0)
+                    )
+                elif msg.command == LanCommand.CONTROL:
+                    self.state = bool(req["dps"]["1"])
+                    body = lp.encode_v33_command(KEY, LanCommand.CONTROL, {})
+                    writer.write(
+                        lp.pack_frame(msg.seqno, LanCommand.CONTROL, body, retcode=0)
+                    )
+                await writer.drain()
+        except (asyncio.IncompleteReadError, ConnectionResetError):
+            pass
+
+
+@pytest.fixture
+async def plug():
+    p = FakePlug(state=False)
+    await p.start()
+    yield p
+    p.server.close()
+
+
+async def test_status_reads_dp1(plug):
+    plug.state = True
+    s = LanSwitch(
+        device_id="d", local_key=KEY_STR, version="3.3", host=plug.host, port=plug.port
+    )
+    assert await s.status() is True
+
+
+async def test_on_off_toggle(plug):
+    s = LanSwitch("d", KEY_STR, "3.3", plug.host, plug.port)
+    await s.turn_on()
+    assert plug.state is True
+    await s.turn_off()
+    assert plug.state is False
+    await s.toggle()  # was off -> on
+    assert plug.state is True
+
+
+async def test_wrong_key_raises(plug):
+    s = LanSwitch("d", "ffffffffffffffff", "3.3", plug.host, plug.port)
+    with pytest.raises(lp.LanFrameError):
+        await s.status()
+
+
+async def test_unsupported_version_raises(plug):
+    s = LanSwitch("d", KEY_STR, "3.5", plug.host, plug.port)
+    with pytest.raises(NotImplementedError):
+        await s.status()
+
+
+# ---------------------------------------------------------------------------
+# v3.4 fake server and tests
+# ---------------------------------------------------------------------------
+
+REMOTE_NONCE = b"abcdef0123456789"
+
+
+class FakePlugV34:
+    def __init__(self, state):
+        self.state = state
+        self.server = None
+        self.host = self.port = None
+
+    async def start(self):
+        self.server = await asyncio.start_server(self._handle, "127.0.0.1", 0)
+        s = self.server.sockets[0].getsockname()
+        self.host, self.port = s[0], s[1]
+
+    async def _handle(self, reader, writer):
+        try:
+            # negotiation
+            start = lp.unpack_frame(await _read_frame(reader), hmac_key=KEY)
+            local_nonce = crypto.aes_ecb_decrypt(KEY, start.payload)[:16]
+            resp_plain = (
+                REMOTE_NONCE + _hmac.new(KEY, local_nonce, hashlib.sha256).digest()
+            )
+            writer.write(
+                lp.pack_frame(
+                    2,
+                    LanCommand.SESS_KEY_NEG_RESP,
+                    crypto.aes_ecb_encrypt(KEY, resp_plain),
+                    hmac_key=KEY,
+                )
+            )
+            await writer.drain()
+            _finish = lp.unpack_frame(await _read_frame(reader), hmac_key=KEY)
+            session = lp.derive_session_key_v34(KEY, local_nonce, REMOTE_NONCE)
+            # commands
+            while True:
+                msg = lp.unpack_frame(await _read_frame(reader), hmac_key=session)
+                req = lp.decode_payload(session, msg.payload, version="3.4")
+                if msg.command == LanCommand.DP_QUERY:
+                    body = lp.encode_command(
+                        session,
+                        LanCommand.DP_QUERY,
+                        {"dps": {"1": self.state}},
+                        version="3.4",
+                    )
+                    writer.write(
+                        lp.pack_frame(
+                            msg.seqno,
+                            LanCommand.DP_QUERY,
+                            body,
+                            retcode=0,
+                            hmac_key=session,
+                        )
+                    )
+                elif msg.command == LanCommand.CONTROL_NEW:
+                    self.state = bool(req["data"]["dps"]["1"])
+                    body = lp.encode_command(
+                        session, LanCommand.CONTROL_NEW, {}, version="3.4"
+                    )
+                    writer.write(
+                        lp.pack_frame(
+                            msg.seqno,
+                            LanCommand.CONTROL_NEW,
+                            body,
+                            retcode=0,
+                            hmac_key=session,
+                        )
+                    )
+                await writer.drain()
+        except (asyncio.IncompleteReadError, ConnectionResetError, lp.LanFrameError):
+            pass
+
+
+@pytest.fixture
+async def plug34():
+    p = FakePlugV34(state=False)
+    await p.start()
+    yield p
+    p.server.close()
+
+
+async def test_v34_status_and_toggle(plug34):
+    s = LanSwitch("d", KEY_STR, "3.4", plug34.host, plug34.port)
+    plug34.state = True
+    assert await s.status() is True
+    await s.turn_off()
+    assert plug34.state is False
+    await s.turn_on()
+    assert plug34.state is True
+    await s.toggle()
+    assert plug34.state is False

tests/test_packet.py

@@ -0,0 +1,83 @@
+"""tests/test_packet.py"""
+
+import pytest
+
+from tuya_re import packet
+from tuya_re.const import Code, SECURITY_FLAG_LOGIN
+
+
+def test_varint_roundtrip():
+    for value in (0, 1, 0x7F, 0x80, 300, 0xFFFF, 2**28 - 1):
+        encoded = packet.pack_varint(value)
+        decoded, pos = packet.unpack_varint(encoded, 0)
+        assert decoded == value
+        assert pos == len(encoded)
+
+
+def test_varint_single_byte_under_128():
+    assert packet.pack_varint(5) == b"\x05"
+    assert packet.pack_varint(300) == bytes([0xAC, 0x02])  # 300 = 0b10_0101100
+
+
+def test_build_frame_layout():
+    frame = packet.build_frame(
+        seq_num=1, response_to=0, code=Code.SENDER_DEVICE_INFO, payload=b""
+    )
+    # header(12) + crc(2) = 14, zero-padded to 16
+    assert len(frame) == 16
+    assert frame[:12] == bytes([0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0])
+
+
+def test_parse_frame_roundtrip():
+    frame = packet.build_frame(3, 2, Code.SENDER_DPS, b"\x01\x01\x01\x01")
+    seq, resp_to, code, payload = packet.parse_frame(frame)
+    assert (seq, resp_to, code, payload) == (
+        3,
+        2,
+        Code.SENDER_DPS.value,
+        b"\x01\x01\x01\x01",
+    )
+
+
+def test_parse_frame_bad_crc_raises():
+    frame = bytearray(packet.build_frame(1, 0, Code.SENDER_DPS, b"\x05"))
+    frame[12] ^= 0xFF  # corrupt payload byte
+    with pytest.raises(packet.FrameError):
+        packet.parse_frame(bytes(frame))
+
+
+def test_encrypt_decrypt_frame_roundtrip():
+    key = bytes(range(16))
+    frame = packet.build_frame(1, 0, Code.SENDER_DEVICE_INFO, b"")
+    blob = packet.encrypt_frame(frame, key, SECURITY_FLAG_LOGIN, iv=bytes(16))
+    assert blob[0] == SECURITY_FLAG_LOGIN
+    assert blob[1:17] == bytes(16)
+    out = packet.decrypt_frame(blob, lambda flag: key)
+    assert out == frame
+
+
+def test_split_chunks_fit_mtu_and_roundtrip():
+    blob = bytes(range(256)) * 2  # 512 bytes, forces many chunks
+    chunks = packet.split_packets(blob, protocol_version=3)
+    assert all(len(c) <= 20 for c in chunks)
+    # chunk 0 carries total length and version byte
+    _, pos = packet.unpack_varint(chunks[0], 0)
+    total, pos = packet.unpack_varint(chunks[0], pos)
+    assert total == len(blob)
+    assert chunks[0][pos] == 3 << 4
+
+    ras = packet.Reassembler()
+    results = [ras.feed(c) for c in chunks]
+    assert results[:-1] == [None] * (len(chunks) - 1)
+    assert results[-1] == blob
+
+
+def test_reassembler_resets_on_packet_zero():
+    blob = bytes(range(40))  # 40 bytes -> 3 chunks (17 + 19 + 4 payload)
+    chunks = packet.split_packets(blob)
+    assert len(chunks) == 3
+    ras = packet.Reassembler()
+    ras.feed(chunks[0])  # start once
+    assert ras.feed(chunks[0]) is None  # restart mid-stream is tolerated
+    assert ras.feed(chunks[1]) is None
+    assert ras.feed(chunks[2]) == blob

tests/test_protocol.py

@@ -0,0 +1,130 @@
+"""tests/test_protocol.py"""
+
+import asyncio
+
+import pytest
+
+from tuya_re import crypto, packet
+from tuya_re.config import Credentials
+from tuya_re.const import Code, DPType, SECURITY_FLAG_LOGIN, SECURITY_FLAG_SESSION
+from tuya_re.protocol import Session
+
+CREDS = Credentials(
+    device_id="testdevice000000000001",
+    uuid="uuidTESTtest0000",
+    local_key="abcdef0123456789",
+    product_id="mknd4lci",
+)
+SRAND = b"\x01\x02\x03\x04\x05\x06"
+LOGIN_KEY = crypto.login_key(CREDS.local_key)
+SESSION_KEY = crypto.session_key(CREDS.local_key, SRAND)
+
+
+class FakeDevice:
+    """Collects chunks Session writes; lets tests answer as the device."""
+
+    def __init__(self):
+        self.reassembler = packet.Reassembler()
+        self.frames: list[tuple[int, int, int, bytes]] = []
+        self.session: Session | None = None
+        self._device_seq = 100
+
+    async def send(self, chunk: bytes) -> None:
+        blob = self.reassembler.feed(chunk)
+        if blob is None:
+            return
+        key = LOGIN_KEY if blob[0] == SECURITY_FLAG_LOGIN else SESSION_KEY
+        frame = crypto.aes_cbc_decrypt(key, blob[1:17], blob[17:])
+        parsed = packet.parse_frame(frame)
+        self.frames.append(parsed)
+        self.reply(parsed)
+
+    def reply(self, parsed) -> None:
+        seq, _, code, _ = parsed
+        if code == Code.SENDER_DEVICE_INFO:
+            payload = bytes([1, 0, 3, 0, 0, 1]) + SRAND + bytes(2) + bytes(32)
+            self.respond(
+                seq, Code.SENDER_DEVICE_INFO, payload, LOGIN_KEY, SECURITY_FLAG_LOGIN
+            )
+        elif code == Code.SENDER_PAIR:
+            self.respond(
+                seq, Code.SENDER_PAIR, b"\x00", SESSION_KEY, SECURITY_FLAG_SESSION
+            )
+        elif code == Code.SENDER_DPS:
+            self.respond(
+                seq, Code.SENDER_DPS, b"\x00", SESSION_KEY, SECURITY_FLAG_SESSION
+            )
+
+    def respond(self, response_to, code, payload, key, flag) -> None:
+        self._device_seq += 1
+        frame = packet.build_frame(self._device_seq, response_to, code, payload)
+        blob = packet.encrypt_frame(frame, key, flag)
+        for chunk in packet.split_packets(blob):
+            self.session.handle_notification(chunk)
+
+    def push(self, code, payload, key=None, flag=SECURITY_FLAG_SESSION):
+        """Device-initiated frame (response_to=0)."""
+        self._device_seq += 1
+        frame = packet.build_frame(self._device_seq, 0, code, payload)
+        blob = packet.encrypt_frame(frame, key or SESSION_KEY, flag)
+        for chunk in packet.split_packets(blob):
+            self.session.handle_notification(chunk)
+
+
+@pytest.fixture
+def linked():
+    device = FakeDevice()
+    session = Session(CREDS, device.send, response_timeout=1.0)
+    device.session = session
+    return device, session
+
+
+async def test_handshake_derives_session_key_and_pairs(linked):
+    device, session = linked
+    await session.handshake()
+    assert session.paired
+    codes = [f[2] for f in device.frames]
+    assert codes == [Code.SENDER_DEVICE_INFO, Code.SENDER_PAIR]
+    # pair payload: uuid + key6 + device_id zero-padded to 44
+    pair_payload = device.frames[1][3]
+    assert pair_payload[:16] == CREDS.uuid.encode()
+    assert pair_payload[16:22] == CREDS.local_key[:6].encode()
+    assert pair_payload[22:44] == CREDS.device_id.encode()
+    assert len(pair_payload) == 44
+
+
+async def test_set_dp_bool_sends_dps_frame(linked):
+    device, session = linked
+    await session.handshake()
+    await session.set_dp(108, DPType.BOOL, True)
+    code, payload = device.frames[-1][2], device.frames[-1][3]
+    assert code == Code.SENDER_DPS
+    assert payload == bytes([108, DPType.BOOL, 1, 1])
+
+
+async def test_received_dps_are_recorded_and_acked(linked):
+    device, session = linked
+    await session.handshake()
+    # device pushes dp 108 = False (bool)
+    device.push(Code.RECEIVE_DP, bytes([108, DPType.BOOL, 1, 0]))
+    await asyncio.sleep(0)  # let ack task run
+    assert session.dps[108] is False
+    assert device.frames[-1][2] == Code.RECEIVE_DP  # our ack
+    assert device.frames[-1][1] != 0  # it is a response
+
+
+async def test_time1_request_is_answered(linked):
+    device, session = linked
+    await session.handshake()
+    device.push(Code.RECEIVE_TIME1_REQ, b"")
+    await asyncio.sleep(0)
+    frame = device.frames[-1]
+    assert frame[2] == Code.RECEIVE_TIME1_REQ
+    assert len(frame[3]) == 13 + 2  # ascii ms timestamp + tz
+
+
+async def test_handshake_timeout_raises(linked):
+    device, session = linked
+    device.reply = lambda parsed: None  # device goes silent
+    with pytest.raises(TimeoutError):
+        await session.handshake()

uv.lock

@@ -0,0 +1,957 @@
+version = 1
+revision = 3
+requires-python = ">=3.11"
+
+[[package]]
+name = "bleak"
+version = "3.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "dbus-fast", marker = "sys_platform == 'linux'" },
+    { name = "pyobjc-core", marker = "sys_platform == 'darwin'" },
+    { name = "pyobjc-framework-corebluetooth", marker = "sys_platform == 'darwin'" },
+    { name = "pyobjc-framework-libdispatch", marker = "sys_platform == 'darwin'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.12'" },
+    { name = "winrt-runtime", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-devices-bluetooth", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-devices-bluetooth-advertisement", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-devices-bluetooth-genericattributeprofile", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-devices-enumeration", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-devices-radios", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-foundation", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-foundation-collections", marker = "sys_platform == 'win32'" },
+    { name = "winrt-windows-storage-streams", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/16/df/05a3f80ca8e3f7f5b0dba68a9e618147c909ccdba1468f07487dc8d72a9d/bleak-3.0.2.tar.gz", hash = "sha256:c2229cb8238d5876b4bd05c74bf7a1aea1f88da39d2e51ac9dfd5cc319d5265f", size = 125293, upload-time = "2026-05-02T23:01:04.066Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/54/05aceb9cd80073805b3ed8522e3196e8cb22f70e741873fa51406c31f4e7/bleak-3.0.2-py3-none-any.whl", hash = "sha256:39092feb9e83f1df5ad2f88e837723c7211c982ce9e9cda6235104bc2ebe0d0d", size = 146490, upload-time = "2026-05-02T23:01:02.592Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.6.17"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c9/c7/424b75da314c1045981bd9777432fad05a9e0c69daa4ed7e308bbaffe405/certifi-2026.6.17.tar.gz", hash = "sha256:024c88eeec92ca068db80f02b8b07c9cef7b9fe261d1d535abfd5abd6f6af432", size = 134594, upload-time = "2026-06-17T10:31:07.894Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/2f/c5464532e965badff2f4c4c1a3a83f5697f0d7c407ed0cda44aaa99bb451/certifi-2026.6.17-py3-none-any.whl", hash = "sha256:2227dcbaafe0d2f59279d1762ddddc37783ed4354594f194ffc31d20f41fc3db", size = 133289, upload-time = "2026-06-17T10:31:06.348Z" },
+]
+
+[[package]]
+name = "cffi"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "implementation_name != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" },
+    { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" },
+    { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" },
+    { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" },
+    { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" },
+    { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" },
+    { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" },
+    { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" },
+    { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" },
+    { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" },
+    { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" },
+    { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" },
+    { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" },
+]
+
+[[package]]
+name = "charset-normalizer"
+version = "3.4.7"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/a1/67fe25fac3c7642725500a3f6cfe5821ad557c3abb11c9d20d12c7008d3e/charset_normalizer-3.4.7.tar.gz", hash = "sha256:ae89db9e5f98a11a4bf50407d4363e7b09b31e55bc117b4f7d80aab97ba009e5", size = 144271, upload-time = "2026-04-02T09:28:39.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/d7/b5b7020a0565c2e9fa8c09f4b5fa6232feb326b8c20081ccded47ea368fd/charset_normalizer-3.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7641bb8895e77f921102f72833904dcd9901df5d6d72a2ab8f31d04b7e51e4e7", size = 309705, upload-time = "2026-04-02T09:26:02.191Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/53/58c29116c340e5456724ecd2fff4196d236b98f3da97b404bc5e51ac3493/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:202389074300232baeb53ae2569a60901f7efadd4245cf3a3bf0617d60b439d7", size = 206419, upload-time = "2026-04-02T09:26:03.583Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/02/e8146dc6591a37a00e5144c63f29fb7c97a734ea8a111190783c0e60ab63/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:30b8d1d8c52a48c2c5690e152c169b673487a2a58de1ec7393196753063fcd5e", size = 227901, upload-time = "2026-04-02T09:26:04.738Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/73/77486c4cd58f1267bf17db420e930c9afa1b3be3fe8c8b8ebbebc9624359/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:532bc9bf33a68613fd7d65e4b1c71a6a38d7d42604ecf239c77392e9b4e8998c", size = 222742, upload-time = "2026-04-02T09:26:06.36Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fa/f74eb381a7d94ded44739e9d94de18dc5edc9c17fb8c11f0a6890696c0a9/charset_normalizer-3.4.7-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2fe249cb4651fd12605b7288b24751d8bfd46d35f12a20b1ba33dea122e690df", size = 214061, upload-time = "2026-04-02T09:26:08.347Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/92/42bd3cefcf7687253fb86694b45f37b733c97f59af3724f356fa92b8c344/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_armv7l.whl", hash = "sha256:65bcd23054beab4d166035cabbc868a09c1a49d1efe458fe8e4361215df40265", size = 199239, upload-time = "2026-04-02T09:26:09.823Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/3d/069e7184e2aa3b3cddc700e3dd267413dc259854adc3380421c805c6a17d/charset_normalizer-3.4.7-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:08e721811161356f97b4059a9ba7bafb23ea5ee2255402c42881c214e173c6b4", size = 210173, upload-time = "2026-04-02T09:26:10.953Z" },
+    { url = "https://files.pythonhosted.org/packages/62/51/9d56feb5f2e7074c46f93e0ebdbe61f0848ee246e2f0d89f8e20b89ebb8f/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e060d01aec0a910bdccb8be71faf34e7799ce36950f8294c8bf612cba65a2c9e", size = 209841, upload-time = "2026-04-02T09:26:12.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/59/893d8f99cc4c837dda1fe2f1139079703deb9f321aabcb032355de13b6c7/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:38c0109396c4cfc574d502df99742a45c72c08eff0a36158b6f04000043dbf38", size = 200304, upload-time = "2026-04-02T09:26:13.711Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/1d/ee6f3be3464247578d1ed5c46de545ccc3d3ff933695395c402c21fa6b77/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:1c2a768fdd44ee4a9339a9b0b130049139b8ce3c01d2ce09f67f5a68048d477c", size = 229455, upload-time = "2026-04-02T09:26:14.941Z" },
+    { url = "https://files.pythonhosted.org/packages/54/bb/8fb0a946296ea96a488928bdce8ef99023998c48e4713af533e9bb98ef07/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:1a87ca9d5df6fe460483d9a5bbf2b18f620cbed41b432e2bddb686228282d10b", size = 210036, upload-time = "2026-04-02T09:26:16.478Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/bc/015b2387f913749f82afd4fcba07846d05b6d784dd16123cb66860e0237d/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d635aab80466bc95771bb78d5370e74d36d1fe31467b6b29b8b57b2a3cd7d22c", size = 224739, upload-time = "2026-04-02T09:26:17.751Z" },
+    { url = "https://files.pythonhosted.org/packages/17/ab/63133691f56baae417493cba6b7c641571a2130eb7bceba6773367ab9ec5/charset_normalizer-3.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ae196f021b5e7c78e918242d217db021ed2a6ace2bc6ae94c0fc596221c7f58d", size = 216277, upload-time = "2026-04-02T09:26:18.981Z" },
+    { url = "https://files.pythonhosted.org/packages/06/6d/3be70e827977f20db77c12a97e6a9f973631a45b8d186c084527e53e77a4/charset_normalizer-3.4.7-cp311-cp311-win32.whl", hash = "sha256:adb2597b428735679446b46c8badf467b4ca5f5056aae4d51a19f9570301b1ad", size = 147819, upload-time = "2026-04-02T09:26:20.295Z" },
+    { url = "https://files.pythonhosted.org/packages/20/d9/5f67790f06b735d7c7637171bbfd89882ad67201891b7275e51116ed8207/charset_normalizer-3.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:8e385e4267ab76874ae30db04c627faaaf0b509e1ccc11a95b3fc3e83f855c00", size = 159281, upload-time = "2026-04-02T09:26:21.74Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/83/6413f36c5a34afead88ce6f66684d943d91f233d76dd083798f9602b75ae/charset_normalizer-3.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:d4a48e5b3c2a489fae013b7589308a40146ee081f6f509e047e0e096084ceca1", size = 147843, upload-time = "2026-04-02T09:26:22.901Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/eb/4fc8d0a7110eb5fc9cc161723a34a8a6c200ce3b4fbf681bc86feee22308/charset_normalizer-3.4.7-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:eca9705049ad3c7345d574e3510665cb2cf844c2f2dcfe675332677f081cbd46", size = 311328, upload-time = "2026-04-02T09:26:24.331Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e3/0fadc706008ac9d7b9b5be6dc767c05f9d3e5df51744ce4cc9605de7b9f4/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6178f72c5508bfc5fd446a5905e698c6212932f25bcdd4b47a757a50605a90e2", size = 208061, upload-time = "2026-04-02T09:26:25.568Z" },
+    { url = "https://files.pythonhosted.org/packages/42/f0/3dd1045c47f4a4604df85ec18ad093912ae1344ac706993aff91d38773a2/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e1421b502d83040e6d7fb2fb18dff63957f720da3d77b2fbd3187ceb63755d7b", size = 229031, upload-time = "2026-04-02T09:26:26.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/67/675a46eb016118a2fbde5a277a5d15f4f69d5f3f5f338e5ee2f8948fcf43/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:edac0f1ab77644605be2cbba52e6b7f630731fc42b34cb0f634be1a6eface56a", size = 225239, upload-time = "2026-04-02T09:26:28.044Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f8/d0118a2f5f23b02cd166fa385c60f9b0d4f9194f574e2b31cef350ad7223/charset_normalizer-3.4.7-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5649fd1c7bade02f320a462fdefd0b4bd3ce036065836d4f42e0de958038e116", size = 216589, upload-time = "2026-04-02T09:26:29.239Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/f1/6d2b0b261b6c4ceef0fcb0d17a01cc5bc53586c2d4796fa04b5c540bc13d/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_armv7l.whl", hash = "sha256:203104ed3e428044fd943bc4bf45fa73c0730391f9621e37fe39ecf477b128cb", size = 202733, upload-time = "2026-04-02T09:26:30.5Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/c0/7b1f943f7e87cc3db9626ba17807d042c38645f0a1d4415c7a14afb5591f/charset_normalizer-3.4.7-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:298930cec56029e05497a76988377cbd7457ba864beeea92ad7e844fe74cd1f1", size = 212652, upload-time = "2026-04-02T09:26:31.709Z" },
+    { url = "https://files.pythonhosted.org/packages/38/dd/5a9ab159fe45c6e72079398f277b7d2b523e7f716acc489726115a910097/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:708838739abf24b2ceb208d0e22403dd018faeef86ddac04319a62ae884c4f15", size = 211229, upload-time = "2026-04-02T09:26:33.282Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/ff/531a1cad5ca855d1c1a8b69cb71abfd6d85c0291580146fda7c82857caa1/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:0f7eb884681e3938906ed0434f20c63046eacd0111c4ba96f27b76084cd679f5", size = 203552, upload-time = "2026-04-02T09:26:34.845Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/4c/a5fb52d528a8ca41f7598cb619409ece30a169fbdf9cdce592e53b46c3a6/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4dc1e73c36828f982bfe79fadf5919923f8a6f4df2860804db9a98c48824ce8d", size = 230806, upload-time = "2026-04-02T09:26:36.152Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7a/071feed8124111a32b316b33ae4de83d36923039ef8cf48120266844285b/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:aed52fea0513bac0ccde438c188c8a471c4e0f457c2dd20cdbf6ea7a450046c7", size = 212316, upload-time = "2026-04-02T09:26:37.672Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/35/f7dba3994312d7ba508e041eaac39a36b120f32d4c8662b8814dab876431/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:fea24543955a6a729c45a73fe90e08c743f0b3334bbf3201e6c4bc1b0c7fa464", size = 227274, upload-time = "2026-04-02T09:26:38.93Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/2d/a572df5c9204ab7688ec1edc895a73ebded3b023bb07364710b05dd1c9be/charset_normalizer-3.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb6d88045545b26da47aa879dd4a89a71d1dce0f0e549b1abcb31dfe4a8eac49", size = 218468, upload-time = "2026-04-02T09:26:40.17Z" },
+    { url = "https://files.pythonhosted.org/packages/86/eb/890922a8b03a568ca2f336c36585a4713c55d4d67bf0f0c78924be6315ca/charset_normalizer-3.4.7-cp312-cp312-win32.whl", hash = "sha256:2257141f39fe65a3fdf38aeccae4b953e5f3b3324f4ff0daf9f15b8518666a2c", size = 148460, upload-time = "2026-04-02T09:26:41.416Z" },
+    { url = "https://files.pythonhosted.org/packages/35/d9/0e7dffa06c5ab081f75b1b786f0aefc88365825dfcd0ac544bdb7b2b6853/charset_normalizer-3.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:5ed6ab538499c8644b8a3e18debabcd7ce684f3fa91cf867521a7a0279cab2d6", size = 159330, upload-time = "2026-04-02T09:26:42.554Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/5d/481bcc2a7c88ea6b0878c299547843b2521ccbc40980cb406267088bc701/charset_normalizer-3.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:56be790f86bfb2c98fb742ce566dfb4816e5a83384616ab59c49e0604d49c51d", size = 147828, upload-time = "2026-04-02T09:26:44.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/3b/66777e39d3ae1ddc77ee606be4ec6d8cbd4c801f65e5a1b6f2b11b8346dd/charset_normalizer-3.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f496c9c3cc02230093d8330875c4c3cdfc3b73612a5fd921c65d39cbcef08063", size = 309627, upload-time = "2026-04-02T09:26:45.198Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/4e/b7f84e617b4854ade48a1b7915c8ccfadeba444d2a18c291f696e37f0d3b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea948db76d31190bf08bd371623927ee1339d5f2a0b4b1b4a4439a65298703c", size = 207008, upload-time = "2026-04-02T09:26:46.824Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/bb/ec73c0257c9e11b268f018f068f5d00aa0ef8c8b09f7753ebd5f2880e248/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a277ab8928b9f299723bc1a2dabb1265911b1a76341f90a510368ca44ad9ab66", size = 228303, upload-time = "2026-04-02T09:26:48.397Z" },
+    { url = "https://files.pythonhosted.org/packages/85/fb/32d1f5033484494619f701e719429c69b766bfc4dbc61aa9e9c8c166528b/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3bec022aec2c514d9cf199522a802bd007cd588ab17ab2525f20f9c34d067c18", size = 224282, upload-time = "2026-04-02T09:26:49.684Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/07/330e3a0dda4c404d6da83b327270906e9654a24f6c546dc886a0eb0ffb23/charset_normalizer-3.4.7-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e044c39e41b92c845bc815e5ae4230804e8e7bc29e399b0437d64222d92809dd", size = 215595, upload-time = "2026-04-02T09:26:50.915Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/7c/fc890655786e423f02556e0216d4b8c6bcb6bdfa890160dc66bf52dee468/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_armv7l.whl", hash = "sha256:f495a1652cf3fbab2eb0639776dad966c2fb874d79d87ca07f9d5f059b8bd215", size = 201986, upload-time = "2026-04-02T09:26:52.197Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/97/bfb18b3db2aed3b90cf54dc292ad79fdd5ad65c4eae454099475cbeadd0d/charset_normalizer-3.4.7-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e712b419df8ba5e42b226c510472b37bd57b38e897d3eca5e8cfd410a29fa859", size = 211711, upload-time = "2026-04-02T09:26:53.49Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/a5/a581c13798546a7fd557c82614a5c65a13df2157e9ad6373166d2a3e645d/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7804338df6fcc08105c7745f1502ba68d900f45fd770d5bdd5288ddccb8a42d8", size = 210036, upload-time = "2026-04-02T09:26:54.975Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bf/b3ab5bcb478e4193d517644b0fb2bf5497fbceeaa7a1bc0f4d5b50953861/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:481551899c856c704d58119b5025793fa6730adda3571971af568f66d2424bb5", size = 202998, upload-time = "2026-04-02T09:26:56.303Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/4e/23efd79b65d314fa320ec6017b4b5834d5c12a58ba4610aa353af2e2f577/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f59099f9b66f0d7145115e6f80dd8b1d847176df89b234a5a6b3f00437aa0832", size = 230056, upload-time = "2026-04-02T09:26:57.554Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/9f/1e1941bc3f0e01df116e68dc37a55c4d249df5e6fa77f008841aef68264f/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:f59ad4c0e8f6bba240a9bb85504faa1ab438237199d4cce5f622761507b8f6a6", size = 211537, upload-time = "2026-04-02T09:26:58.843Z" },
+    { url = "https://files.pythonhosted.org/packages/80/0f/088cbb3020d44428964a6c97fe1edfb1b9550396bf6d278330281e8b709c/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:3dedcc22d73ec993f42055eff4fcfed9318d1eeb9a6606c55892a26964964e48", size = 226176, upload-time = "2026-04-02T09:27:00.437Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/9f/130394f9bbe06f4f63e22641d32fc9b202b7e251c9aef4db044324dac493/charset_normalizer-3.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:64f02c6841d7d83f832cd97ccf8eb8a906d06eb95d5276069175c696b024b60a", size = 217723, upload-time = "2026-04-02T09:27:02.021Z" },
+    { url = "https://files.pythonhosted.org/packages/73/55/c469897448a06e49f8fa03f6caae97074fde823f432a98f979cc42b90e69/charset_normalizer-3.4.7-cp313-cp313-win32.whl", hash = "sha256:4042d5c8f957e15221d423ba781e85d553722fc4113f523f2feb7b188cc34c5e", size = 148085, upload-time = "2026-04-02T09:27:03.192Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/78/1b74c5bbb3f99b77a1715c91b3e0b5bdb6fe302d95ace4f5b1bec37b0167/charset_normalizer-3.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:3946fa46a0cf3e4c8cb1cc52f56bb536310d34f25f01ca9b6c16afa767dab110", size = 158819, upload-time = "2026-04-02T09:27:04.454Z" },
+    { url = "https://files.pythonhosted.org/packages/68/86/46bd42279d323deb8687c4a5a811fd548cb7d1de10cf6535d099877a9a9f/charset_normalizer-3.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:80d04837f55fc81da168b98de4f4b797ef007fc8a79ab71c6ec9bc4dd662b15b", size = 147915, upload-time = "2026-04-02T09:27:05.971Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c8/c67cb8c70e19ef1960b97b22ed2a1567711de46c4ddf19799923adc836c2/charset_normalizer-3.4.7-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:c36c333c39be2dbca264d7803333c896ab8fa7d4d6f0ab7edb7dfd7aea6e98c0", size = 309234, upload-time = "2026-04-02T09:27:07.194Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/c091fdee33f20de70d6c8b522743b6f831a2f1cd3ff86de4c6a827c48a76/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2aed2e5e41f24ea8ef1590b8e848a79b56f3a5564a65ceec43c9d692dc7d8a", size = 208042, upload-time = "2026-04-02T09:27:08.749Z" },
+    { url = "https://files.pythonhosted.org/packages/87/1c/ab2ce611b984d2fd5d86a5a8a19c1ae26acac6bad967da4967562c75114d/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:54523e136b8948060c0fa0bc7b1b50c32c186f2fceee897a495406bb6e311d2b", size = 228706, upload-time = "2026-04-02T09:27:09.951Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/29/2b1d2cb00bf085f59d29eb773ce58ec2d325430f8c216804a0a5cd83cbca/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:715479b9a2802ecac752a3b0efa2b0b60285cf962ee38414211abdfccc233b41", size = 224727, upload-time = "2026-04-02T09:27:11.175Z" },
+    { url = "https://files.pythonhosted.org/packages/47/5c/032c2d5a07fe4d4855fea851209cca2b6f03ebeb6d4e3afdb3358386a684/charset_normalizer-3.4.7-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bd6c2a1c7573c64738d716488d2cdd3c00e340e4835707d8fdb8dc1a66ef164e", size = 215882, upload-time = "2026-04-02T09:27:12.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/c2/356065d5a8b78ed04499cae5f339f091946a6a74f91e03476c33f0ab7100/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_armv7l.whl", hash = "sha256:c45e9440fb78f8ddabcf714b68f936737a121355bf59f3907f4e17721b9d1aae", size = 200860, upload-time = "2026-04-02T09:27:13.721Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/cd/a32a84217ced5039f53b29f460962abb2d4420def55afabe45b1c3c7483d/charset_normalizer-3.4.7-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3534e7dcbdcf757da6b85a0bbf5b6868786d5982dd959b065e65481644817a18", size = 211564, upload-time = "2026-04-02T09:27:15.272Z" },
+    { url = "https://files.pythonhosted.org/packages/44/86/58e6f13ce26cc3b8f4a36b94a0f22ae2f00a72534520f4ae6857c4b81f89/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e8ac484bf18ce6975760921bb6148041faa8fef0547200386ea0b52b5d27bf7b", size = 211276, upload-time = "2026-04-02T09:27:16.834Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/fe/d17c32dc72e17e155e06883efa84514ca375f8a528ba2546bee73fc4df81/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:a5fe03b42827c13cdccd08e6c0247b6a6d4b5e3cdc53fd1749f5896adcdc2356", size = 201238, upload-time = "2026-04-02T09:27:18.229Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/29/f33daa50b06525a237451cdb6c69da366c381a3dadcd833fa5676bc468b3/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2d6eb928e13016cea4f1f21d1e10c1cebd5a421bc57ddf5b1142ae3f86824fab", size = 230189, upload-time = "2026-04-02T09:27:19.445Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/6e/52c84015394a6a0bdcd435210a7e944c5f94ea1055f5cc5d56c5fe368e7b/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e74327fb75de8986940def6e8dee4f127cc9752bee7355bb323cc5b2659b6d46", size = 211352, upload-time = "2026-04-02T09:27:20.79Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/d7/4353be581b373033fb9198bf1da3cf8f09c1082561e8e922aa7b39bf9fe8/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d6038d37043bced98a66e68d3aa2b6a35505dc01328cd65217cefe82f25def44", size = 227024, upload-time = "2026-04-02T09:27:22.063Z" },
+    { url = "https://files.pythonhosted.org/packages/30/45/99d18aa925bd1740098ccd3060e238e21115fffbfdcb8f3ece837d0ace6c/charset_normalizer-3.4.7-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7579e913a5339fb8fa133f6bbcfd8e6749696206cf05acdbdca71a1b436d8e72", size = 217869, upload-time = "2026-04-02T09:27:23.486Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/5ee478aa53f4bb7996482153d4bfe1b89e0f087f0ab6b294fcf92d595873/charset_normalizer-3.4.7-cp314-cp314-win32.whl", hash = "sha256:5b77459df20e08151cd6f8b9ef8ef1f961ef73d85c21a555c7eed5b79410ec10", size = 148541, upload-time = "2026-04-02T09:27:25.146Z" },
+    { url = "https://files.pythonhosted.org/packages/48/77/72dcb0921b2ce86420b2d79d454c7022bf5be40202a2a07906b9f2a35c97/charset_normalizer-3.4.7-cp314-cp314-win_amd64.whl", hash = "sha256:92a0a01ead5e668468e952e4238cccd7c537364eb7d851ab144ab6627dbbe12f", size = 159634, upload-time = "2026-04-02T09:27:26.642Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/a3/c2369911cd72f02386e4e340770f6e158c7980267da16af8f668217abaa0/charset_normalizer-3.4.7-cp314-cp314-win_arm64.whl", hash = "sha256:67f6279d125ca0046a7fd386d01b311c6363844deac3e5b069b514ba3e63c246", size = 148384, upload-time = "2026-04-02T09:27:28.271Z" },
+    { url = "https://files.pythonhosted.org/packages/94/09/7e8a7f73d24dba1f0035fbbf014d2c36828fc1bf9c88f84093e57d315935/charset_normalizer-3.4.7-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:effc3f449787117233702311a1b7d8f59cba9ced946ba727bdc329ec69028e24", size = 330133, upload-time = "2026-04-02T09:27:29.474Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/da/96975ddb11f8e977f706f45cddd8540fd8242f71ecdb5d18a80723dcf62c/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fbccdc05410c9ee21bbf16a35f4c1d16123dcdeb8a1d38f33654fa21d0234f79", size = 216257, upload-time = "2026-04-02T09:27:30.793Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/e8/1d63bf8ef2d388e95c64b2098f45f84758f6d102a087552da1485912637b/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:733784b6d6def852c814bce5f318d25da2ee65dd4839a0718641c696e09a2960", size = 234851, upload-time = "2026-04-02T09:27:32.44Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/40/e5ff04233e70da2681fa43969ad6f66ca5611d7e669be0246c4c7aaf6dc8/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a89c23ef8d2c6b27fd200a42aa4ac72786e7c60d40efdc76e6011260b6e949c4", size = 233393, upload-time = "2026-04-02T09:27:34.03Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c1/06c6c49d5a5450f76899992f1ee40b41d076aee9279b49cf9974d2f313d5/charset_normalizer-3.4.7-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6c114670c45346afedc0d947faf3c7f701051d2518b943679c8ff88befe14f8e", size = 223251, upload-time = "2026-04-02T09:27:35.369Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9f/f2ff16fb050946169e3e1f82134d107e5d4ae72647ec8a1b1446c148480f/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:a180c5e59792af262bf263b21a3c49353f25945d8d9f70628e73de370d55e1e1", size = 206609, upload-time = "2026-04-02T09:27:36.661Z" },
+    { url = "https://files.pythonhosted.org/packages/69/d5/a527c0cd8d64d2eab7459784fb4169a0ac76e5a6fc5237337982fd61347e/charset_normalizer-3.4.7-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3c9a494bc5ec77d43cea229c4f6db1e4d8fe7e1bbffa8b6f0f0032430ff8ab44", size = 220014, upload-time = "2026-04-02T09:27:38.019Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/80/8a7b8104a3e203074dc9aa2c613d4b726c0e136bad1cc734594b02867972/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8d828b6667a32a728a1ad1d93957cdf37489c57b97ae6c4de2860fa749b8fc1e", size = 218979, upload-time = "2026-04-02T09:27:39.37Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9a/b759b503d507f375b2b5c153e4d2ee0a75aa215b7f2489cf314f4541f2c0/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf1493cd8607bec4d8a7b9b004e699fcf8f9103a9284cc94962cb73d20f9d4a3", size = 209238, upload-time = "2026-04-02T09:27:40.722Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/0f3f5d47b86bdb79256e7290b26ac847a2832d9a4033f7eb2cd4bcf4bb5b/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0c96c3b819b5c3e9e165495db84d41914d6894d55181d2d108cc1a69bfc9cce0", size = 236110, upload-time = "2026-04-02T09:27:42.33Z" },
+    { url = "https://files.pythonhosted.org/packages/96/23/bce28734eb3ed2c91dcf93abeb8a5cf393a7b2749725030bb630e554fdd8/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:752a45dc4a6934060b3b0dab47e04edc3326575f82be64bc4fc293914566503e", size = 219824, upload-time = "2026-04-02T09:27:43.924Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/6f/6e897c6984cc4d41af319b077f2f600fc8214eb2fe2d6bcb79141b882400/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:8778f0c7a52e56f75d12dae53ae320fae900a8b9b4164b981b9c5ce059cd1fcb", size = 233103, upload-time = "2026-04-02T09:27:45.348Z" },
+    { url = "https://files.pythonhosted.org/packages/76/22/ef7bd0fe480a0ae9b656189ec00744b60933f68b4f42a7bb06589f6f576a/charset_normalizer-3.4.7-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ce3412fbe1e31eb81ea42f4169ed94861c56e643189e1e75f0041f3fe7020abe", size = 225194, upload-time = "2026-04-02T09:27:46.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/a7/0e0ab3e0b5bc1219bd80a6a0d4d72ca74d9250cb2382b7c699c147e06017/charset_normalizer-3.4.7-cp314-cp314t-win32.whl", hash = "sha256:c03a41a8784091e67a39648f70c5f97b5b6a37f216896d44d2cdcb82615339a0", size = 159827, upload-time = "2026-04-02T09:27:48.053Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1d/29d32e0fb40864b1f878c7f5a0b343ae676c6e2b271a2d55cc3a152391da/charset_normalizer-3.4.7-cp314-cp314t-win_amd64.whl", hash = "sha256:03853ed82eeebbce3c2abfdbc98c96dc205f32a79627688ac9a27370ea61a49c", size = 174168, upload-time = "2026-04-02T09:27:49.795Z" },
+    { url = "https://files.pythonhosted.org/packages/de/32/d92444ad05c7a6e41fb2036749777c163baf7a0301a040cb672d6b2b1ae9/charset_normalizer-3.4.7-cp314-cp314t-win_arm64.whl", hash = "sha256:c35abb8bfff0185efac5878da64c45dafd2b37fb0383add1be155a763c1f083d", size = 153018, upload-time = "2026-04-02T09:27:51.116Z" },
+    { url = "https://files.pythonhosted.org/packages/db/8f/61959034484a4a7c527811f4721e75d02d653a35afb0b6054474d8185d4c/charset_normalizer-3.4.7-py3-none-any.whl", hash = "sha256:3dce51d0f5e7951f8bb4900c257dad282f49190fdbebecd4ba99bcc41fef404d", size = 61958, upload-time = "2026-04-02T09:28:37.794Z" },
+]
+
+[[package]]
+name = "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 = "coverage"
+version = "7.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cc/8b/adeb62ea8951f13c4c7fef2e7a85e1a06b499c8d8237ea589d496029e53f/coverage-7.15.0.tar.gz", hash = "sha256:9ac3fe7a1435986463eaa8ee253ae2f2a268709ba4ae5c7dd1f52a05391ad78f", size = 925362, upload-time = "2026-07-02T13:10:50.535Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ae/23/82e910835ef4b8391047025e1d53aa48d66029f444eb8b25373c849bf503/coverage-7.15.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:003fff99412ea848c0aaebcc78ed2b6ce7d8a1227ed17e68470672770b78a02a", size = 220662, upload-time = "2026-07-02T13:08:39.205Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/0d/c7b213dde2f1579de5231062b386d8413f79c11667eb58c39319b25991da/coverage-7.15.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5cbd804bf2784ce7b45114516050f346ecd50f960c4bb630a7ee9e1d78fa2118", size = 221168, upload-time = "2026-07-02T13:08:40.471Z" },
+    { url = "https://files.pythonhosted.org/packages/33/77/d000aeedfac085088337b3c7becdad328474b1f8a9e4c9368a0c99605d68/coverage-7.15.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8773e15c23305b58882a4611fb9b2755977eae0dc2e515366a1b6c98866cc4c2", size = 251587, upload-time = "2026-07-02T13:08:42.033Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/e0/86787c56b9df17afd370d5e293515dd4d9a107a561d13054873eefad8ecc/coverage-7.15.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:f50e40081494c1dc4239ebb202014cbcc3306ea96fb6302a34c8cc0967fc5ae8", size = 253497, upload-time = "2026-07-02T13:08:43.387Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/02/181bc917359299c07dead6270f94e411151c8b60cec905c33499da69afe6/coverage-7.15.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daf96f37f5fc3a7b6c6da862eb4aee61c426bd63da236ed4a73ef0e503b4bca5", size = 255607, upload-time = "2026-07-02T13:08:44.897Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/35/ca5e7427699913da6788c4f910e73ab16c5f4b59ec5d3a999dce2a45112f/coverage-7.15.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:51aa20f6ae2788fd197747766edf4cd8234fd9423309b934257fa6b21a592723", size = 257563, upload-time = "2026-07-02T13:08:46.334Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/4d/b8220bacc2fc3c4e9078e27c32e99fb411479a4718a72bdd00036a9891c8/coverage-7.15.0-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:03d1f922757662eb7af586e77834792274cff776bc7b1d1a0b66a49ea9d84735", size = 251726, upload-time = "2026-07-02T13:08:47.941Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/e4/2e145da1991d72189b9c3cf7eca05c716ee7080d099aaea6757cfc7df008/coverage-7.15.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a6d6acc9a7666245e6133dd15144ca038a85a9cd5026bb06d6bbae9e77440dc9", size = 253301, upload-time = "2026-07-02T13:08:49.5Z" },
+    { url = "https://files.pythonhosted.org/packages/72/28/d2c841d698bf762e481f08bd4839d370246b6d9b61dab085a7b20b201a08/coverage-7.15.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1ac2c4c27c7df851dc9a017c2d7de00b69147e84ba3d96f37a530b0b6fb51035", size = 251361, upload-time = "2026-07-02T13:08:51.304Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/ed/55d9ffde994fba3897c0c783f77a7d053b0c18787f6892ed5b0aed73f469/coverage-7.15.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b761a1d504fd4bd1f20f418753964dca9f5862a511fc854dac58296b3b223671", size = 255129, upload-time = "2026-07-02T13:08:52.661Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/c0/ecbf33b8c460ea2718aeb813e2df8140d0370e5f67261c31524ceb0a2a8d/coverage-7.15.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:e43b045e11c16e897895758ae90e4a90cf99e93d58549e2f90c0e2272e155695", size = 251081, upload-time = "2026-07-02T13:08:54.188Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/de/fb87b4261f54448dd2b9504ef19a58be42cef0d9520595fbfe1219b15234/coverage-7.15.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:589b54513e901739f4b4582c705ce96b80c96f57641b1464607e2367a270e540", size = 251988, upload-time = "2026-07-02T13:08:55.726Z" },
+    { url = "https://files.pythonhosted.org/packages/df/27/3494d5f291b9a4cb868f73c11221a8bd2d5bd761a8f9acea61ff57128dd1/coverage-7.15.0-cp311-cp311-win32.whl", hash = "sha256:106781b8482749162d0b47056937ba0933508e5d9447f65a5e7d5c422f0d6bb4", size = 222754, upload-time = "2026-07-02T13:08:57.091Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/ee/cd4847ebc9be6a9c0123d763645a6f1f3be6b8c58c962706368b79cbac07/coverage-7.15.0-cp311-cp311-win_amd64.whl", hash = "sha256:821e92b3631d762a339695824cadbbc73020354eba2a23a551a99ad34938fbe6", size = 223225, upload-time = "2026-07-02T13:08:58.594Z" },
+    { url = "https://files.pythonhosted.org/packages/57/37/5011581aa7f2be498b97dcc7c9902192442a42f4f9a748aeadb3d6506b42/coverage-7.15.0-cp311-cp311-win_arm64.whl", hash = "sha256:309990eb5fb8014b9f67cb211f7fd41876ec8a88a88d3ae76de0ed1d611e3640", size = 222774, upload-time = "2026-07-02T13:09:00.074Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/74/fd4c0901137c4f8d81a76ada99e43c65163b4c94a02ece107a4ec0c6b615/coverage-7.15.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b75ee5e8cb7575636ac598719b4307ac529ec8fcd79608a35c3cd4d4dada812d", size = 220838, upload-time = "2026-07-02T13:09:02.084Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/2e/2347583467bd7f0402635101a916961915cc68fce652cd0db5f173ea04fc/coverage-7.15.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ffb31267816b93b075302248cc1737506081b4f163df4401e9df1a6424aafabe", size = 221197, upload-time = "2026-07-02T13:09:03.617Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/17/99fa688541ae1d6e84543a0e544f83de0c944815b63e9e7b1ed411d15036/coverage-7.15.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e4d0bb73455bf97ab243a8f12c37c686ccf1c13bb614b7b85f1d062f06f42b2c", size = 252705, upload-time = "2026-07-02T13:09:05.059Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/02/6a95a5cd83b74839017ef9cf48d2d8c9ae60af919e17a3f336e6f9f1b7bd/coverage-7.15.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:20d9ccc4ebd0edc434d86dfd2a1dd2a8efa6b6b3073d0485a394fee86459ebb4", size = 255441, upload-time = "2026-07-02T13:09:06.559Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f2/406f6c57d600f68185942422c4c00f1a3255d60aee6e5fd961425cd9987e/coverage-7.15.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:20c8a976c365c8cb12f0cbd099508772ea41fb5fa80657a8506df0e11bd278c5", size = 256556, upload-time = "2026-07-02T13:09:08.197Z" },
+    { url = "https://files.pythonhosted.org/packages/74/8e/d3fa48489c15ecdec1ba48fd61f68798555dddd2f6716f9ad42adeb1a2a9/coverage-7.15.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f948fd5ba1b9cbca91f0ae08b4c1ce2b139509149a435e2585d056d57d70bf01", size = 258815, upload-time = "2026-07-02T13:09:09.691Z" },
+    { url = "https://files.pythonhosted.org/packages/47/2e/2d40ddd110462c6a2769677cf7f1c119a52b45f568978fc6c98e4cc0dd0f/coverage-7.15.0-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f58185f06edf6ad68ec9fb155d63ef650c82f3fbd7e1770e2867751fb13158f4", size = 253117, upload-time = "2026-07-02T13:09:11.212Z" },
+    { url = "https://files.pythonhosted.org/packages/51/c0/310782f0d7c3cb2b5ac05ba8d205fe91f24a36f6bf3256098f1782181c38/coverage-7.15.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02adc79a920c73c647c5d117f55747df7f2de94571884758ce8bc58e04f0a796", size = 254475, upload-time = "2026-07-02T13:09:13.029Z" },
+    { url = "https://files.pythonhosted.org/packages/86/f7/702da6c275f8ae6ade423d2877243122932c9b27f5403003b9ef8c927d12/coverage-7.15.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6eb7c300fbed667fd6e3588eba71c1904cdb06110ca6fdf908c26bdd88b8e382", size = 252619, upload-time = "2026-07-02T13:09:14.699Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/84/c5b15a7e5ecba4e56218d772d99fe80a63e63f8d11f12783723a6005ab45/coverage-7.15.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b5fb23fa2de9dce1f5c36c09066d8fcda16cd96e8e26686caa2d7cb9b567d65c", size = 256689, upload-time = "2026-07-02T13:09:16.103Z" },
+    { url = "https://files.pythonhosted.org/packages/95/2f/c8b07559b57701230c61b23a953858c052890c12ef568d81780c6c46e92e/coverage-7.15.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:cec79341dbe6281484024979976d0c7f22beae08b4a254655decd25d42cbe766", size = 252189, upload-time = "2026-07-02T13:09:17.828Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/80/6d2f049dd3fd3dbfd60b62ba6b2162a04009e2c002ce70b24cf3878dec7a/coverage-7.15.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:6c664c5444b1d970b1b2a450e21fb19ee5c9cfdf151ded2dda37260031cca0da", size = 254059, upload-time = "2026-07-02T13:09:19.304Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/92/b0287a2c42031d25c628f815f89a3cd9f8268ee78bb1252c9356cda1c689/coverage-7.15.0-cp312-cp312-win32.whl", hash = "sha256:5f764a3fa339bde6b3aa97657f5a6a3a9451e4a5b4ea98a2892c773a43525f77", size = 222893, upload-time = "2026-07-02T13:09:20.812Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/69/e34c481915fecb499b3146975061dac528752e37706edc1804f32c822469/coverage-7.15.0-cp312-cp312-win_amd64.whl", hash = "sha256:52f9a4d2c4c56c8848bc2f524916698354b0211488b38c49ad9ae54f6cafbff6", size = 223429, upload-time = "2026-07-02T13:09:22.315Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/98/6e878f0b571d32684ef3f38d7c03db241ca5b82a5da8a5391596a8f209c4/coverage-7.15.0-cp312-cp312-win_arm64.whl", hash = "sha256:31e5c3e70c85307ea35a12964e2e40f56ca2ee4b1c8c721ccf4609d17071080b", size = 222810, upload-time = "2026-07-02T13:09:23.812Z" },
+    { url = "https://files.pythonhosted.org/packages/76/04/145a3748098bcc86b631a85408d2c3dc5c104e0bd86d605468239b25b6c4/coverage-7.15.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5be4caf3b28836f078abe700f8944dac4a65d78f16d6c600c89cb624e5535782", size = 220863, upload-time = "2026-07-02T13:09:25.371Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/5c/4ed55708fed2c64b63c9bc5715daef670872202101938869b7fe5d5fbb8f/coverage-7.15.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dd58ad1404704303ca8d4f4b8a1095e7cbc7040ef17a66df1e6619aa10176430", size = 221230, upload-time = "2026-07-02T13:09:26.897Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/19/3a80b97d3b2a5c77a01ae359c6bed20c13738fe3d9380f08616d4fec0281/coverage-7.15.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bbcbb317c2e5ded5b21104af81c29f391be2af98d065693ffbe8d23949b948e5", size = 252227, upload-time = "2026-07-02T13:09:28.543Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/fa/b70062750686bd7da454da27927622f48bbac6990ac7a4c4a4653e7b0036/coverage-7.15.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:27f31ecb458da3f859aab3f15ada871eb7a7768807d88df4a9f186bb17737970", size = 254823, upload-time = "2026-07-02T13:09:30.177Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/09/dad6a75a2e561b9dc5086a8c5257a7591d584246f67e23e70d2995b89ab6/coverage-7.15.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:13fb759be317fdc62e0f56bffdf61cfcb45c7761ad6b71e3e583e71a67ae753c", size = 256059, upload-time = "2026-07-02T13:09:31.979Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/e7/b5d2941fa9564573d44b693a871ff3156f0c42cbefe977a09fa7fdc59971/coverage-7.15.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:d5cf007add5ab4bb8fa9f4c77e3732127c9e6cad501d7db43355fbfafca0be84", size = 258190, upload-time = "2026-07-02T13:09:34.035Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/1d/8e895bcde3c57ccd46d896dda5f2b3d5df761a1b0c6c9d450d175dedc632/coverage-7.15.0-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cc78d9843bd576fbe2118248258d485e968dc535f95ed504a7b0867ba9b51389", size = 252456, upload-time = "2026-07-02T13:09:35.765Z" },
+    { url = "https://files.pythonhosted.org/packages/14/4c/f6997da343ddeb959be82c3b05322793f92c071ad45f7cb8a96336e2dd5f/coverage-7.15.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a263060f1de0b4b74b4e089c2a70b8003b3781c733329a9c8fd54995328f9950", size = 254192, upload-time = "2026-07-02T13:09:37.445Z" },
+    { url = "https://files.pythonhosted.org/packages/17/27/a0bc09d032267b9da89d95a2d874cfbef2a5aebbf0e87cf7aba221d79a99/coverage-7.15.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c48decf16e0dfd5b049c7d5e82200c23c08126719142998d4f172444e3d0529e", size = 252153, upload-time = "2026-07-02T13:09:39.422Z" },
+    { url = "https://files.pythonhosted.org/packages/54/c0/77fc233d9fba07b244c40948c53fe27308b8f21732fb3417f87fbd6fd992/coverage-7.15.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:08fb028000ed0aaa0a4cbdfbb98be7cb42f370db973fbbb469733505ab20e13e", size = 256310, upload-time = "2026-07-02T13:09:41.006Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/24/601cecfb5825becacb8d45219a018a3b55b9dbaec624efdb0ea249d08be2/coverage-7.15.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:fb7dc0c3b7d8a1077abea0b8546ebc5e26d6ef6ecefc2f0f5ad2b8a53bdad837", size = 251974, upload-time = "2026-07-02T13:09:42.733Z" },
+    { url = "https://files.pythonhosted.org/packages/47/1e/6f45e5a5b3d5484318d368702af6716b5ab8913b0428bec981a562fcf296/coverage-7.15.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6cb3602054ccbe9f0d8c2dc04bbeba90d5719236e2cd06e042ddd6d3fc7b6e37", size = 253745, upload-time = "2026-07-02T13:09:44.376Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/db/4df027a77bd11d0e527f44c53557c76e54ad027413d0304252ea3a78d67e/coverage-7.15.0-cp313-cp313-win32.whl", hash = "sha256:0bf781da64326b677be344df505171435b6f58716108606621d5d27d964fff8b", size = 222902, upload-time = "2026-07-02T13:09:46.122Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/10/0355894d34e231f2c5449e71287e81a50793a325df2e2b027b7bcd9dfd19/coverage-7.15.0-cp313-cp313-win_amd64.whl", hash = "sha256:2c57a275078ee3fa185f83e400f765bc764a549de66d99b47881645cbd4ea629", size = 223444, upload-time = "2026-07-02T13:09:47.687Z" },
+    { url = "https://files.pythonhosted.org/packages/06/ef/bb725f263befaaff851203ab338e68af15e195d7f7b5f323162532d9b6a8/coverage-7.15.0-cp313-cp313-win_arm64.whl", hash = "sha256:3812c61afc6685c7999b39320779ab8f43b7a3081fdb0def39976e56fbdb9a21", size = 222839, upload-time = "2026-07-02T13:09:49.717Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/9c/1e3ca54f72a3185ece06c58d871099898c48f0ed6430d17b6ab75f0d180a/coverage-7.15.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:41cb79af843222e11da87127ad0ecbfa878abadd0f770a4a99391a27d3887324", size = 220906, upload-time = "2026-07-02T13:09:51.339Z" },
+    { url = "https://files.pythonhosted.org/packages/09/37/f718613d83b274880382f6b67e78f3802549ae39b0b3e65ae5b5974df56e/coverage-7.15.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7d2008989ef8fe54188d3f3bfa2e3099b025af11e90a6a1b9e7dc433d04263d8", size = 221239, upload-time = "2026-07-02T13:09:53.138Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/ce/22bae91e0b75445f68d365c7643ed0aa4880bbf77450ee74ca65bdae53a7/coverage-7.15.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:769e8ece11a596315ebf5aa7ec383aeeed016c091d2bf6363ffb996d41529092", size = 252286, upload-time = "2026-07-02T13:09:54.996Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/1e/bec5e32aa508615d9d7a2790effb25fb4dc28606e995816afe400b25ece3/coverage-7.15.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:65a6b6164ee5c39e2f3803f314292d6c61a607ba7fee253d1e03c42dc3903502", size = 254789, upload-time = "2026-07-02T13:09:56.678Z" },
+    { url = "https://files.pythonhosted.org/packages/17/29/0e865435b4354e4a7c03b1b7920046d31d0a273d55decefea27e011cb9bf/coverage-7.15.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75128817f95a5c45bb01d65fd2d8b9cb54bbe03d81608fb70e3e14b437ad56c2", size = 256135, upload-time = "2026-07-02T13:09:58.343Z" },
+    { url = "https://files.pythonhosted.org/packages/84/ff/33a870b58a13325d62fc0a6c8f01fa0ff667cef60c7498e2382a147dfa18/coverage-7.15.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9887bb428fe2d4cd4bee89bac1a6c9932f484afd5b36fbd4ff6ea5f825bb1f5e", size = 258449, upload-time = "2026-07-02T13:10:00.057Z" },
+    { url = "https://files.pythonhosted.org/packages/18/7b/6fffe596bf3ddba8462758d02c5dad730fd91055a6634aa2e4226229181a/coverage-7.15.0-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0bfc0be1f702042207a93a00523b1065ee1fe951e96edf311581c0bbc2e34888", size = 252313, upload-time = "2026-07-02T13:10:01.946Z" },
+    { url = "https://files.pythonhosted.org/packages/58/1b/11468dd6c1676ab831a70cb9a8d4e198e8607fa0b7220ab918b73fe9bfbd/coverage-7.15.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f64627d55def5a43282d70e08396672692f77e4da610a5bb8bb4060b432b6859", size = 254142, upload-time = "2026-07-02T13:10:04.065Z" },
+    { url = "https://files.pythonhosted.org/packages/79/41/29328e21d16b1b95092c30dd700e08cf915bd3734f836df8f3bdb0e8fa9f/coverage-7.15.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:2c6f0fa473003905c6d5bac328ee4eba9fbea654f15bc24b8a3274b23363fa99", size = 252108, upload-time = "2026-07-02T13:10:06.11Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/de/05ccfb990439655b35afbfd8e0d13fe66677565a7d4eb38c3f5ef2635e1c/coverage-7.15.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:2bcf9afaf064172c6ec3c58a325a9957ad1178c05dd934e25f253321776e0676", size = 256385, upload-time = "2026-07-02T13:10:08.141Z" },
+    { url = "https://files.pythonhosted.org/packages/51/0e/486828a3d2695ea7a2609f17ff572f6b01905e608379440a11da4b8dffbe/coverage-7.15.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:baf06bc987115d6fb938d403f7eab684a057766c490367999a2b71a6883110c6", size = 251923, upload-time = "2026-07-02T13:10:10.179Z" },
+    { url = "https://files.pythonhosted.org/packages/18/c7/03582b6715f078e5e558354c87616d945b9894cda2dace8e4009b17035e4/coverage-7.15.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f0405f2ff97b1c4c0e782cb32e02f32369bcf2e6b618b591d67e1ea754575dfe", size = 253580, upload-time = "2026-07-02T13:10:12.052Z" },
+    { url = "https://files.pythonhosted.org/packages/db/dc/9e578bbaf2ecb4959a81b7e7601ad8cca772cba2892e8d144cb749b4a71a/coverage-7.15.0-cp314-cp314-win32.whl", hash = "sha256:ab282853ed5fbd64bbb162f19cb8fcb7087187508a6374b4f9c34ec1577c4e8f", size = 223107, upload-time = "2026-07-02T13:10:13.994Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/3e/c8c3b75d8dbe0e35f7b0cc3ff5e949fc59500f70b21d0398813f66740664/coverage-7.15.0-cp314-cp314-win_amd64.whl", hash = "sha256:3bb3040e9f4bbe26fcb0cd7cc85ac63e630d3f3a9c74f027abf4caa27e706663", size = 223597, upload-time = "2026-07-02T13:10:15.906Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/bc/3cbc9fb036eb388519bccd521f783499c39b64256013fbc362782f196fe1/coverage-7.15.0-cp314-cp314-win_arm64.whl", hash = "sha256:346771144d34f7fa84ec28386f78e0f31653f33cf35e19d253d5b35f9e8201da", size = 223020, upload-time = "2026-07-02T13:10:17.844Z" },
+    { url = "https://files.pythonhosted.org/packages/28/00/199c4a8d656dff63102577a056c0fce2ff6a79e40adac092fc986c49cbf1/coverage-7.15.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d34a010905fb6401324ba016b5da03d574967f7b21ce48ea41e66f0f1f95f641", size = 221638, upload-time = "2026-07-02T13:10:19.703Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8e/9d0092c96a3d3a26951ecc7020826aa57bcb1b119ca81acbba996884ab13/coverage-7.15.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:bb25d825d885ca8036795dacfc3924d33091fc76d71ebc99420c6b79e77d96fa", size = 221903, upload-time = "2026-07-02T13:10:21.514Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/b4/c0ca3028f42c9a08e51feb4561ef1192e5de99797cd1db5b04590c215bda/coverage-7.15.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:94c9686bfe8a9a6810297aecbd99beaa3445f9e8dc2f80b1382cca0d86b64461", size = 263267, upload-time = "2026-07-02T13:10:23.261Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/aa/a375e3846e5d3c013dc600b2a3231089055c73d77f5393dd2192a8d64da6/coverage-7.15.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9bd671c25f9d85f09d7ec481d0e43d5139f486c06a37139847a7ce569788af72", size = 265390, upload-time = "2026-07-02T13:10:25.152Z" },
+    { url = "https://files.pythonhosted.org/packages/92/e1/5783cdabb797305e1c9e4809fea496d31834c51fa772514f73dc148bcfc9/coverage-7.15.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:110cbdf8d2e216577312cf06ccf85539c0e5a5420ef747e4a4719b5e483c88cd", size = 267811, upload-time = "2026-07-02T13:10:27.249Z" },
+    { url = "https://files.pythonhosted.org/packages/85/31/96d8bbf58b8e9193bc8389574a91a0db48355ee98feb66aa6bf8d1b32eea/coverage-7.15.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2c5d4619214f1d9993e7b00a8600d14614b7e9d84e89507460b126aa5e6559e5", size = 268928, upload-time = "2026-07-02T13:10:29.242Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/7a/5294567e811a1cb7eda93140c628fa050d66189da28da320f93d1d815c73/coverage-7.15.0-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:781a704516e2d8346fbbd5be6c6f3412dd824785146528b3a01816f26c081007", size = 262378, upload-time = "2026-07-02T13:10:31.107Z" },
+    { url = "https://files.pythonhosted.org/packages/69/3f/3f48538421f899f28946f90a3d272136a4686e1abf461cc9249a783ee0f3/coverage-7.15.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd4a1b44bcb65ee29e947ac92bbee04956df3a6bfc6143641bb6cae7ede00fc9", size = 265263, upload-time = "2026-07-02T13:10:32.942Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/d3/092df15efcab8a9c1467ee960eb8019bbad3f9300d115d89ea6195f369ff/coverage-7.15.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:0e4950c9d6d3e39c64c991814ff315e2d0b9cb8152363594212c9e55208c0a8f", size = 262866, upload-time = "2026-07-02T13:10:35.104Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/ab/0254d2b88665efb2c57ad368cc77ab5de3435bd8d5add4729c1b0e79431e/coverage-7.15.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:fe9c87ff42e5472d80d21704972e1f96e104a0a599d77c5e35db5a3c562e2571", size = 266599, upload-time = "2026-07-02T13:10:37.05Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/79/1cfa4023e489ce6fbc7be4a5d442dbc375edb4f4fda39a352cedb53263c2/coverage-7.15.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f00d5ae1dd2fe13fb8186e3e7d37bcbd8b25c0d764ff7d1b32cef9be058510a8", size = 261714, upload-time = "2026-07-02T13:10:38.966Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/eb/fee5c8665656be63f497418d410484637c438172568688e8ac92e06574e7/coverage-7.15.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:363ab38cc78b615f11c9cac3cf1d7eef950c18b9fdedfb9066f59461dcf84d68", size = 264025, upload-time = "2026-07-02T13:10:40.789Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/99/63005db722f91edc81abc16302f9cc2f6228c1679e46e15be9ae144b14d0/coverage-7.15.0-cp314-cp314t-win32.whl", hash = "sha256:54fd9c53a5fafff509195f1b6a3f9be615d8e8362a3629ff1de23d270c03c86b", size = 223413, upload-time = "2026-07-02T13:10:42.597Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/e8/2bc6181c4fb06f1a6b981eb85330cc57bfad7e3f710fc9c9d350013ba228/coverage-7.15.0-cp314-cp314t-win_amd64.whl", hash = "sha256:87b47553097ba185ed964866078e7e63adea9f5f51b5f39691c34f30afd21080", size = 224245, upload-time = "2026-07-02T13:10:44.47Z" },
+    { url = "https://files.pythonhosted.org/packages/79/b8/4d959bf9cc45d0cfed2f4d35cafcab978cdb6ea02eb5100009cd740632a3/coverage-7.15.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aeefb2dd178fe7eee79f0ad25d75855cb35ee9ed472db2c5ea06f5b4fd00cec5", size = 223558, upload-time = "2026-07-02T13:10:46.368Z" },
+    { url = "https://files.pythonhosted.org/packages/52/30/21b2ad45959cd50e909e02ebac1e30b4ceb7162e91c11d4c570223a458b7/coverage-7.15.0-py3-none-any.whl", hash = "sha256:56da6a4cbe8f7e9e80bd072ca9cefe67d7106a440a7ec06519ec6507ac94ad19", size = 212632, upload-time = "2026-07-02T13:10:48.641Z" },
+]
+
+[package.optional-dependencies]
+toml = [
+    { name = "tomli", marker = "python_full_version <= '3.11'" },
+]
+
+[[package]]
+name = "cryptography"
+version = "49.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "platform_python_implementation != 'PyPy'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/99/d1c90d6041656cc6ee229dc99cd67fd0cd5aec3c5f7d72fffc27cc750054/cryptography-49.0.0.tar.gz", hash = "sha256:f89660a348f4f78a92366240a61404e337586ef7f5909a2fef59ca88ef505493", size = 854345, upload-time = "2026-06-12T20:02:30.512Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/22/adf66990e63584a68dfb50c24f48a125c07b1699899381c8151e63ed458c/cryptography-49.0.0-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:966fe0e9c67490071f14c0d2b1cb2dfb3023c5ce39457343931415f08382f2db", size = 4032100, upload-time = "2026-06-12T20:02:32.143Z" },
+    { url = "https://files.pythonhosted.org/packages/09/41/3797cfaf69cae04a13ee78ebd83f0678d9c02b4779d21ce24445326f1a69/cryptography-49.0.0-cp311-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:36d1709f992593689b45bda411498d62c6e365f2ca00b84657d4dadd24de16db", size = 4692978, upload-time = "2026-06-12T20:01:21.305Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/8b/43011f7ebe515a8aa20d61f290a326cd890c2e738e16e59eaff8d9c3a412/cryptography-49.0.0-cp311-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0e959b578856a3924bc0cbb710fc12c387b9412a951389f3ca61704a9e25f325", size = 4716422, upload-time = "2026-06-12T20:01:48.566Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/91/01ce7303a4579e6d3a6abef01bd322848e9ea7a219adcabc5048b9033571/cryptography-49.0.0-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:53ecee2e23f7169b6117e99fc8a944e5e50f79e69758a83b52a00cb98ab2b2d2", size = 4700503, upload-time = "2026-06-12T20:02:47.091Z" },
+    { url = "https://files.pythonhosted.org/packages/62/99/a2c95cf8293f07491e9e27c20cc4dcd18176d944e674679adeb1d0173fd6/cryptography-49.0.0-cp311-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:2eda353d8a27bcbcaa4cbed18994a74ab4d19a2ca897db188ea269ab9b71419b", size = 5309779, upload-time = "2026-06-12T20:02:08.987Z" },
+    { url = "https://files.pythonhosted.org/packages/20/2c/0622f20ff02b2ef32558733443805dc82fd4c275be01b2d19d14676f3a1b/cryptography-49.0.0-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:2afe9051da7ae7bd5905da5a949280c7d2bb75682e188f650a9d0f2756b834c6", size = 4749683, upload-time = "2026-06-12T20:02:03.335Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/5b/c5246635d5fd3b64e0d45ae10e99fd32fe9676a79915ccfe5a61ba9af1a5/cryptography-49.0.0-cp311-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:0b82e28ee398a386f0807bba7884d30f25218855690f45115831bcce5d90822c", size = 4337874, upload-time = "2026-06-12T20:02:54.323Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/88/05563c7fe2e914e87d1a536d06fe83e66b4e1d95cb593e05aea375531da8/cryptography-49.0.0-cp311-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:ccac2bfebc306b862133e3bb71f3f6ee8bb525240089b2d952e4144b3a6d5da7", size = 4700283, upload-time = "2026-06-12T20:01:34.822Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/b6/d7696e4e890d6ae1469935164c9e5215c557671cb78d6e3f458ccceaa632/cryptography-49.0.0-cp311-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:d0527ce944105f257f605a827d6ebead966c752038b6e8656abb9c5edee6fc68", size = 5265844, upload-time = "2026-06-12T20:01:24.09Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/3c/f3ad17eecc1a57b0ba236dc01f90e783c51f4a2f35f64777cc4f47a184b2/cryptography-49.0.0-cp311-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:cbc77da8c523d5abd028635ba850a6966fcee2c82e2bf65a41d1d8afe0f98be9", size = 4749290, upload-time = "2026-06-12T20:01:30.848Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/01/339573cf1023163a400b0b5d16f6d507de413b9f60be6fd1b77feeaf6737/cryptography-49.0.0-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:b87e65d263b3e5d3bb92a57e2a6638e2f31110fa7aa890c7b2dbba42248d0a3f", size = 4834612, upload-time = "2026-06-12T20:01:29.246Z" },
+    { url = "https://files.pythonhosted.org/packages/71/fd/577302e213a1be9468f92d1afef66fcf1ef83d516819d9992ca547f592bd/cryptography-49.0.0-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:66ec79c3904820572d7e987abdf304281f141d37ad9a489b8e97066e7b9b6459", size = 4980804, upload-time = "2026-06-12T20:01:42.853Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/09/f42b1d190c5ba75f72062a387f8030d1d75f6ab035788f1d9c4b01de6525/cryptography-49.0.0-cp311-abi3-win_amd64.whl", hash = "sha256:e5dfc1e64de5677cec922ffa8da89c546d0415bf6efdf081842e5d44c84e1f0e", size = 3810026, upload-time = "2026-06-12T20:02:39.262Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/9e/db72b3ae7fc9cfad53e630e56c6ae83b9b6ff0bf3718ffb8012d20b3aabf/cryptography-49.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:73a205dce83953d131a4aa1e0fd917a2fd1c5b1eef251e9d7152efefcbf5caf7", size = 4013892, upload-time = "2026-06-12T20:02:10.735Z" },
+    { url = "https://files.pythonhosted.org/packages/86/12/c48a424f38db03027be9f7ed5c7dc5de9933dbee992865f98b13727a009d/cryptography-49.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:196ecd6a36e4e9aa10270393bb98d8df88fccee0bf1e5128b91ae4eb4375896d", size = 4678835, upload-time = "2026-06-12T20:02:48.743Z" },
+    { url = "https://files.pythonhosted.org/packages/68/28/8a3ad4653662c93fc44dc4e5d8fd374c25c42e07b34bbfbadf49cf57a5a8/cryptography-49.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7abcee80084cda3f7691f3eb1ce480d8df49cec637b429aa35986c1de71738aa", size = 4697239, upload-time = "2026-06-12T20:02:56.03Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/b2/2193fc74f81aee4f9b62733133b73b5176718932ed8f2e4b03fa040480a6/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:4ae387c9cb68ea569ca17e490d66d8142b81c3cc814bf179974b7d146e490bbb", size = 4685593, upload-time = "2026-06-12T20:02:50.666Z" },
+    { url = "https://files.pythonhosted.org/packages/47/f1/1d3eaa243bfc5de4a187b22aa8c048b3e4980bfbe830ac46e6bac2e66947/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_ppc64le.whl", hash = "sha256:f37d847238971164fdbc68ade6f6574aecc9c0af714190e2083429ff68f4ce9d", size = 5289961, upload-time = "2026-06-12T20:01:46.468Z" },
+    { url = "https://files.pythonhosted.org/packages/58/39/2d51306721330c486495853eda1c567880ff036de15a14c4b74f399934af/cryptography-49.0.0-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:c2bc30226390d60ea19d9f82b19db005fe0452154a23c1c410c12ea801e43561", size = 4731145, upload-time = "2026-06-12T20:02:16.832Z" },
+    { url = "https://files.pythonhosted.org/packages/17/50/983e838c7fd0d87fd8c969bcdd328edaf5f756e38df5281637424c155873/cryptography-49.0.0-cp314-cp314t-manylinux_2_31_armv7l.whl", hash = "sha256:07cab27cc7b7e0fd28e5e26bb9eeedde5c135c868b46de4a27845abe94af6122", size = 4321719, upload-time = "2026-06-12T20:02:52.611Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/f5/8f571d7e27c55bce9f76f026143bcb1e040a4233149ecca0bea5fa5dd5f7/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_aarch64.whl", hash = "sha256:b20133d204d2bb56ba047642199603876c872026ca53e79c35b83772ab2cc505", size = 4685209, upload-time = "2026-06-12T20:02:07.282Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/84/0e27016a6fc5a0886f797018b26aa42f40c09a82332bff77822a451deaaa/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_ppc64le.whl", hash = "sha256:b970c6da94d5bb18629db453d14f2a1300f6bf59b61e9b82377931ef95504866", size = 5246285, upload-time = "2026-06-12T20:01:32.439Z" },
+    { url = "https://files.pythonhosted.org/packages/11/2d/5e1fb307cb5931881516b464c98774b3f2c36b5d4bb9a2830253cf553cad/cryptography-49.0.0-cp314-cp314t-manylinux_2_34_x86_64.whl", hash = "sha256:d8ecde755e2e91bf773fc94e8c9d730cd7f2007004cb492263a794ec3899a1c8", size = 4730441, upload-time = "2026-06-12T20:02:01.469Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/c0/bff5a02ee731d207d6a1ed51732549d8c53d2bc8da1d10ec6f2844201d68/cryptography-49.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e3fb64c420688e5319ae25113a354015abbd8dffbfbc41781a1ea66fc7622ac3", size = 4815869, upload-time = "2026-06-12T20:01:36.574Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/26/814681d14248d95d73d5c3eea0c39a94eb8302df966f670a2c60de90974b/cryptography-49.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32703d93296f5c1f4b53349ad3a250c2cae0fdecd3a3dd5d47e616d8d616af27", size = 4960948, upload-time = "2026-06-12T20:02:18.688Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/fe/93ecac273d3738939d023612ad12cca9a3740a5345d69fda04134c43fd96/cryptography-49.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:33cd0565932807baddb67b96dbee92f2c374b5c89dee09fd74079aeb8c8dba61", size = 3799153, upload-time = "2026-06-12T20:01:39.059Z" },
+    { url = "https://files.pythonhosted.org/packages/19/2a/5bb823f5bedcf80718cea7fbc95ec5515cca3769633c4b01a32be7f30e7c/cryptography-49.0.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:ec5e529fb80935c94fe7b729f9972b50e351a0e6b50aa294fd5cabb109fcc29a", size = 4025947, upload-time = "2026-06-12T20:01:25.745Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/df/40577043ca124e17012f408ddddaeb213b856336ac82ddb3bc915f39e29f/cryptography-49.0.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f78ff2c9ed8dc2d036b0f4d640e22522213d047c1b14e61205a7e55c80a494d4", size = 4692429, upload-time = "2026-06-12T20:01:53.628Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/99/2d13299eb3dd27b02dcfaafcc91d6b5cb3329f7cbd6d8f51921acd566c1a/cryptography-49.0.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:35b151772baff2c74cba7fa290ceaff4c3b11c0c881eb93eb5dbc05a7cfbba18", size = 4700968, upload-time = "2026-06-12T20:02:45.383Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/4d/9c0cd02f95e2602dd5e563da149ee0830abef3537be8b34dc56281ebe27a/cryptography-49.0.0-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:0f21641cf4b30fca7aee061ced0ec7ad7b073518088b7c9969a297c0ae796c69", size = 4697758, upload-time = "2026-06-12T20:01:41.13Z" },
+    { url = "https://files.pythonhosted.org/packages/24/01/186c825898477d77e2324d5360fefe622ff1d8d1963ec0554e2cada8ec77/cryptography-49.0.0-cp39-abi3-manylinux_2_28_ppc64le.whl", hash = "sha256:9e82dcc8e56052715fb18b2429e3bca4823b1629136a2084fc45a9a5cecb9b64", size = 5298863, upload-time = "2026-06-12T20:02:24.579Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/7b/62cbbab75d0659865bf0273790031544a0b16c8072d258f9428dcd8190dc/cryptography-49.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6f2debedf9ca60cf1d5bd466475638af5130f89965605cd818484d19987d3a21", size = 4735983, upload-time = "2026-06-12T20:01:50.14Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/72/3e798c064bc39e471008075d0f9bc9daf77a80879c092e4a8e170c585ed4/cryptography-49.0.0-cp39-abi3-manylinux_2_31_armv7l.whl", hash = "sha256:8c25ceb16df5b9435f3f6a9829204985b0e0cbee3b48aacd432c7d2c850b44d9", size = 4334173, upload-time = "2026-06-12T20:01:44.743Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/ee/6fca21d1ac73e06f8bef71940abfd4d2f6472b4bca284d770f32bd4086f6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:28d8b15e6275f12c8a207dc309dfa957903c927d08d0cc937ee3f63f200693cc", size = 4697298, upload-time = "2026-06-12T20:02:20.918Z" },
+    { url = "https://files.pythonhosted.org/packages/67/d0/a5fcd3515f0bae49a7b6d0413cc1bdccdcc1fc0047037a0d480642cdc5d6/cryptography-49.0.0-cp39-abi3-manylinux_2_34_ppc64le.whl", hash = "sha256:6fc361c34fb6aac015ce19435876635e5c6d21db31998b0920f675f131e043b8", size = 5254338, upload-time = "2026-06-12T20:02:22.737Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/84/84fe36f19caf857d61cb7fc9c63035a47ffabd84ea12d1d393148efa3615/cryptography-49.0.0-cp39-abi3-manylinux_2_34_x86_64.whl", hash = "sha256:2400ef9c9e2299a25614eb1dea3db54a69b1349efd043bfac9c67630d136df36", size = 4735650, upload-time = "2026-06-12T20:02:41.389Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/a0/db537264e234f7273a73ec020873d6d6b39dfd8a53db78b550ca8320440e/cryptography-49.0.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:67e1d20ad9ef3a563c59ef22e7a8a0b8210bd26604369ea4a30a7c66aefe504e", size = 4834820, upload-time = "2026-06-12T20:01:51.847Z" },
+    { url = "https://files.pythonhosted.org/packages/93/77/8df9eb486495979bccecd1062e2eaf435250e84437040295b57d09048b0b/cryptography-49.0.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:42b0684e0e40cf26122427802486f6d93aea593612603a94fbf260c7eb1e9c1b", size = 4967968, upload-time = "2026-06-12T20:02:12.524Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/e6/f60198ea8d9dfa15fff9ed4ca02ce362f6eadd9ba757dcc50634c4257b63/cryptography-49.0.0-cp39-abi3-win_amd64.whl", hash = "sha256:026ac7423e6fa66872d3bf889be5974507da3944f866f704fa200eadacd00001", size = 3785547, upload-time = "2026-06-12T20:02:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/63/d3/4a83af35d65e3fad632c926fad684c193ea4398569ccb0bbbc7fe8f5dc9a/cryptography-49.0.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:fc1e275c2f1d97b1a6450b8b0ea3ebfa6e087a611c2b26cb2404d48588abab7b", size = 3993685, upload-time = "2026-06-12T20:02:14.883Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a7/f9dac0ab7f80368c56993a7bf638ef9935f825c91902798481fac0898138/cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83782480a4a9da4d0feb51950131ba32e12e70813848b3343f6e18c28a66838", size = 4676239, upload-time = "2026-06-12T20:02:28.793Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/70/2ba3769dd0ae167e2f33dfa9592d45db6ff9a61d62ca1a5b3d1bdd09068f/cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:b39efa323140595abd3ecca8529d321ae50f55f3aa3ba9cc81ea56a6011953d5", size = 4715584, upload-time = "2026-06-12T20:01:27.495Z" },
+    { url = "https://files.pythonhosted.org/packages/94/64/2923570ac1c0bd3a737aa366ac3abbbbde273042308b8cde95e2364a6e6a/cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_34_aarch64.whl", hash = "sha256:b47db11c2c3525083296069b98ac5221907455e989ae0c2e3008bde851921615", size = 4675885, upload-time = "2026-06-12T20:01:55.49Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/f8/614dc7e051418cfe53d55173c1e24c6b0085e89996fe90508c2fdf769aef/cryptography-49.0.0-pp311-pypy311_pp73-manylinux_2_34_x86_64.whl", hash = "sha256:084ef1af862eb07ec46d25f68689f2102a9fc0e05ce7b80f14f5fe51e4eef0f6", size = 4715449, upload-time = "2026-06-12T20:02:05.469Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/50/a9caea39ad19c431c1a3f8a31114df65b260cdfe67786b6c7e7c040c4c44/cryptography-49.0.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:be9fcb48a55f023493482827d4f459bd263cc20efde64f204b97c123201850c6", size = 3783731, upload-time = "2026-06-12T20:02:43.319Z" },
+]
+
+[[package]]
+name = "dbus-fast"
+version = "5.0.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/db/b621610e50b1bc46ff63534d75239553c1bf33256de6096b58214fd9808a/dbus_fast-5.0.22.tar.gz", hash = "sha256:34dc67d7d21a12399828dd13e63b352750580beea54ea7c729e708f2d2905fef", size = 83224, upload-time = "2026-06-05T18:47:59.171Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/84/dfb014de75a3a854dccaae1cce8f840e4312e3efc781768eedd60d25d9ef/dbus_fast-5.0.22-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:846f9a6602b4383f989201f7851459fb225a8912cd24b38e63894748545c3040", size = 838836, upload-time = "2026-06-05T18:55:51.51Z" },
+    { url = "https://files.pythonhosted.org/packages/70/c2/be41bcc678e97092d44ba22d09ce687f76c955b3367a7e6863377b1cfea5/dbus_fast-5.0.22-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:886b43446b6fdc3986befbbb88db1365b14e49dd0a7edf84c2c67ac66c7160a4", size = 883163, upload-time = "2026-06-05T18:55:53Z" },
+    { url = "https://files.pythonhosted.org/packages/17/cf/336c08f88fdd813a39fc1603a10a15aec67115e08a895e7c9840df54d4d7/dbus_fast-5.0.22-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:3a699fca957acc845ddb12b47f741dba23ce147fdb93583e0c7e7bad3e9b2355", size = 886852, upload-time = "2026-06-05T18:55:54.434Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f1/7c1aa53f25252a2317f21ad6e8eaa125246d2585ea4611f3f10a6feaeeb1/dbus_fast-5.0.22-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:9a5b05fd4973862042e5bee2c5e8c5a15297e0b33a975bf25b44becf7bcb3618", size = 846497, upload-time = "2026-06-05T18:55:56.193Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/32/a981ef2305f1bf41e538e02fa0cd69614f9043fd00ca965bf3044416c79b/dbus_fast-5.0.22-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:6c4dae5292a7924ec062815c34b49043d8386cd22e165f9fb4012de00997cdf1", size = 882275, upload-time = "2026-06-05T18:55:57.653Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/a0/78800a172f4ca32e19a70a36e175f54831f33a497c9644f3a3fa4dce01ea/dbus_fast-5.0.22-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b7d90a52be79acbaef257f3a81d5b9b9dec40f1bad29429ac5c7802684fb9b84", size = 890566, upload-time = "2026-06-05T18:55:59.407Z" },
+    { url = "https://files.pythonhosted.org/packages/24/06/233b0bc13919474f70320bf389cb81ce02811956d6cf86c45e84679b63c3/dbus_fast-5.0.22-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8f0bcad7f71d2304a68a5b0bc0d24c3fcc14710a2ffcf5f2a27521e3aece71ca", size = 799464, upload-time = "2026-06-05T18:56:02.617Z" },
+    { url = "https://files.pythonhosted.org/packages/68/e9/77bc23a6f5aebfb8f2c34489795e8517aed7eca31738438e1a4c4a4891d3/dbus_fast-5.0.22-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4ffcf16034f71a801bd2108aeffb6337d104c9459e8b1a218d16a917c8a2d2e9", size = 852687, upload-time = "2026-06-05T18:56:04.433Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/04/56769d0936d1273d1801ef574ec426ccb3f61f4b0a7a0eeb9eb2b8ccafa5/dbus_fast-5.0.22-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:98de6d2c200d8182e1fd0bdde3206fa556b8fa14ebb752a044cd8daa87b4658c", size = 833814, upload-time = "2026-06-05T18:56:05.87Z" },
+    { url = "https://files.pythonhosted.org/packages/06/ca/964f0d39a3be03b12a98f39519d34ad95b74360c7e3adf4cd4907dc25fd6/dbus_fast-5.0.22-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b013437b66dc22b8d9aca5e0b0d46bf1980208a143409469fe482d9684a2a717", size = 806891, upload-time = "2026-06-05T18:56:07.623Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/25/57fe6ab509ad9da2e190498fa9c37f868e38ac521d940a9edb9ba6b6c657/dbus_fast-5.0.22-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:855f15b7f7805171da2b82de1c317d01cfbb9fb8ac61fcc1e8dec54d8c69fab7", size = 830867, upload-time = "2026-06-05T18:56:09.473Z" },
+    { url = "https://files.pythonhosted.org/packages/be/2b/da036e9f4aeb776833139575fe0774544aa6cd13ba997eea7fbc4ab99852/dbus_fast-5.0.22-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7d1c42963235cfc015a2d2b8c5fe42b65387493b4ad4ce0ec122601c805e6742", size = 860651, upload-time = "2026-06-05T18:56:10.952Z" },
+    { url = "https://files.pythonhosted.org/packages/76/5a/fa81a6685c763ea488ad93228cb6e036adc9af6a560f4c31643691f4cfd8/dbus_fast-5.0.22-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de10ff3b3cb2acb1c09fe17158a470519000d37bb5ee5fd69c4075e81ce8dcf5", size = 798472, upload-time = "2026-06-05T18:56:14.141Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/34/6b272e6df60be1aa4d575aa30220175a52c002a649c951d9950bfa3a72d6/dbus_fast-5.0.22-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:979761985fe343c701f2b7575285d6e370123f7231d4656209ef7824bb686bbb", size = 850312, upload-time = "2026-06-05T18:56:16.36Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/5c/9045c3595ddcd4069e6b5d051df06bf11a2b022592f721c9acea1e0e4d22/dbus_fast-5.0.22-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fb73f1d8374253b7c17d69e902cf2ded1bfb089cb6ae67c10b4e0bdfe1b8fe08", size = 828366, upload-time = "2026-06-05T18:56:17.786Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/78/ca6881442b8fa29edbe6d99bec4b535b0b2e2f423075d015ff5b719c4e2c/dbus_fast-5.0.22-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b67a02037eb58bcf9e445df60ea0d9d7346fd334abde3aa62e03c75823b53979", size = 806036, upload-time = "2026-06-05T18:56:19.501Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c6/458728eb1caa26171e6a8ae1d0d99bd29aaeac67ad7824bbd95d7f854a41/dbus_fast-5.0.22-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:83940ea00d7ee2f0c5bcb5d19d7d05e7949e52d467616a0b735d72e7285402ec", size = 828353, upload-time = "2026-06-05T18:56:21.346Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/1d/830b1569264780210d44898e5b0d95cffe2830b952c2ee21ea481274cd81/dbus_fast-5.0.22-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:279d212e9fb262d595af2e4b5b9e951bc00c73a5c8eeb50f158caa13705b9c84", size = 857743, upload-time = "2026-06-05T18:56:22.9Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8c/4eefaabdf538882528164060ae83d9a34f1172b019c32c3254436834e9b1/dbus_fast-5.0.22-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:703e0f8f9af52e8e053394ee2b578042be0c3d8ea2b1488f9db8cb14393cc13f", size = 810835, upload-time = "2026-06-05T18:56:26.356Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/cf/fd327dbb40ee67a9331fb587bf78aff2ab1500b35979978a5cacb10d7f8c/dbus_fast-5.0.22-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eb1d7e8e65561d0fd438004fd9e0f981c8a862912fed58dd4e29db1936c39d73", size = 855498, upload-time = "2026-06-05T18:56:28.009Z" },
+    { url = "https://files.pythonhosted.org/packages/56/33/1709ebc16a4d353ddc4fcd29252e2b9d93bded6422a45fd6df170e0911c1/dbus_fast-5.0.22-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:959fab6420897ab99410e67d6f9f9a7f6f4cedb6014700768f5e2d71dbff5dc6", size = 833510, upload-time = "2026-06-05T18:56:29.806Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/fd/89d7c34152900d986b9c78e39cc62aa73eefc22b57b3a8c946d945a85540/dbus_fast-5.0.22-cp314-cp314-manylinux_2_41_x86_64.whl", hash = "sha256:eb31c5ff339a7071b914617a69d5b7c6ba7d411da4b01a5f9b5b2fe51e9d1301", size = 853669, upload-time = "2026-06-05T18:47:56.747Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/a1/031cc4a89d947f1fe110f663f93dcce9230213b7accaf719790d813def04/dbus_fast-5.0.22-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:856f0543c593f3480e93e67bcd1aa4ddc1d94a6076cfd3ad4e0f5e2b01b33dc3", size = 818486, upload-time = "2026-06-05T18:56:31.72Z" },
+    { url = "https://files.pythonhosted.org/packages/36/e2/de8b764fdb947314fb8c2e079b556510194fd100983776845e234a107cc9/dbus_fast-5.0.22-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:96d231d128c1f46f263790335897195dde9dac2f38571782db8ae1d8647bd548", size = 833582, upload-time = "2026-06-05T18:56:33.325Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/1f/e5f0dd28d07c4b3f7bafd3357bfa424c8dace355a3dad921fec05db4634b/dbus_fast-5.0.22-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:595bd3ccfd8318cbafff79f33a15709fee3728724fd61d5fa220080d73b574cb", size = 862291, upload-time = "2026-06-05T18:56:35.102Z" },
+    { url = "https://files.pythonhosted.org/packages/26/69/5b54654f598ef98e8f94fd5a40929668b1f8fcd76e7fb50de0db73d329da/dbus_fast-5.0.22-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:04bac97d0cb754a4d13037d0132517f1df28192d6e0568a0bf6df06623062285", size = 1534804, upload-time = "2026-06-05T18:56:38.804Z" },
+    { url = "https://files.pythonhosted.org/packages/24/b7/c00d01699dc87ffc35f143226d3b296372840e2e2bc15101d35df7c74949/dbus_fast-5.0.22-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3eb57d592d84b0bb90e0c077db7ecb61562f49cc9b86a3ef08cbe17243e9cc4f", size = 1613316, upload-time = "2026-06-05T18:56:40.461Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/94/ea0db4c1aa6409cb16551b50aa8573e72f64407ca5281b042919ef81ca1c/dbus_fast-5.0.22-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:de4d235d1282ebb3ab65b6cddab84e914c045d92ceb381ddcbdbaf66bf1fb132", size = 822053, upload-time = "2026-06-05T18:56:42.519Z" },
+    { url = "https://files.pythonhosted.org/packages/40/e4/a3bb52185b8a8c76bd8aaba3ff4fa8395eea19fbc142122b43dc377b275c/dbus_fast-5.0.22-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:048f34299fbe82d7b87c56f47e8bd83f62339a4517685abc6671d603a55d2c89", size = 1549996, upload-time = "2026-06-05T18:56:44.307Z" },
+    { url = "https://files.pythonhosted.org/packages/37/2b/6e405ba92e87d78a689a387809d975f97f8c8748b98efccfacd2b4e1d9f5/dbus_fast-5.0.22-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:92df9fb6d8adeb17b534621c2ee730295bbe1d0c2584d5c82b1db478e3f04e8f", size = 823004, upload-time = "2026-06-05T18:56:46.023Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/8f/77135ab8d690030cdb0ebeca879640b5945c4cbf5344ecbc507b4628da24/dbus_fast-5.0.22-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7be4271e38251f1ad726962dec60da887c8ed352d157352e4fc27f56aece5c5d", size = 1629160, upload-time = "2026-06-05T18:56:47.688Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.18"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/cd/63/9496c57188a2ee585e0f1db071d75089a11e98aa86eb99d9d7618fc1edce/idna-3.18.tar.gz", hash = "sha256:ffb385a7e039654cef1ab9ef32c6fafe283c0c0467bba1d9029738ce4a14a848", size = 196711, upload-time = "2026-06-02T14:34:07.794Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/5e/d4e9f1a599fb8e573b7b87160658329fbf28d19eac2718f51fc3def3aa5a/idna-3.18-py3-none-any.whl", hash = "sha256:7f952cbe720b688055e3f87de14f5c3e5fdaa8bc3928985c4077ca689de849a2", size = 65455, upload-time = "2026-06-02T14:34:06.319Z" },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "26.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
+]
+
+[[package]]
+name = "pycparser"
+version = "3.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
+]
+
+[[package]]
+name = "pycryptodome"
+version = "3.23.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/a6/8452177684d5e906854776276ddd34eca30d1b1e15aa1ee9cefc289a33f5/pycryptodome-3.23.0.tar.gz", hash = "sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef", size = 4921276, upload-time = "2025-05-17T17:21:45.242Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/5d/bdb09489b63cd34a976cc9e2a8d938114f7a53a74d3dd4f125ffa49dce82/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4", size = 2495152, upload-time = "2025-05-17T17:20:20.833Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/ce/7840250ed4cc0039c433cd41715536f926d6e86ce84e904068eb3244b6a6/pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae", size = 1639348, upload-time = "2025-05-17T17:20:23.171Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/f0/991da24c55c1f688d6a3b5a11940567353f74590734ee4a64294834ae472/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477", size = 2184033, upload-time = "2025-05-17T17:20:25.424Z" },
+    { url = "https://files.pythonhosted.org/packages/54/16/0e11882deddf00f68b68dd4e8e442ddc30641f31afeb2bc25588124ac8de/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7", size = 2270142, upload-time = "2025-05-17T17:20:27.808Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/fc/4347fea23a3f95ffb931f383ff28b3f7b1fe868739182cb76718c0da86a1/pycryptodome-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446", size = 2309384, upload-time = "2025-05-17T17:20:30.765Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/d9/c5261780b69ce66d8cfab25d2797bd6e82ba0241804694cd48be41add5eb/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265", size = 2183237, upload-time = "2025-05-17T17:20:33.736Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/6f/3af2ffedd5cfa08c631f89452c6648c4d779e7772dfc388c77c920ca6bbf/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b", size = 2343898, upload-time = "2025-05-17T17:20:36.086Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/dc/9060d807039ee5de6e2f260f72f3d70ac213993a804f5e67e0a73a56dd2f/pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d", size = 2269197, upload-time = "2025-05-17T17:20:38.414Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/34/e6c8ca177cb29dcc4967fef73f5de445912f93bd0343c9c33c8e5bf8cde8/pycryptodome-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a", size = 1768600, upload-time = "2025-05-17T17:20:40.688Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/1d/89756b8d7ff623ad0160f4539da571d1f594d21ee6d68be130a6eccb39a4/pycryptodome-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625", size = 1799740, upload-time = "2025-05-17T17:20:42.413Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/61/35a64f0feaea9fd07f0d91209e7be91726eb48c0f1bfc6720647194071e4/pycryptodome-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39", size = 1703685, upload-time = "2025-05-17T17:20:44.388Z" },
+    { url = "https://files.pythonhosted.org/packages/db/6c/a1f71542c969912bb0e106f64f60a56cc1f0fabecf9396f45accbe63fa68/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27", size = 2495627, upload-time = "2025-05-17T17:20:47.139Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/4e/a066527e079fc5002390c8acdd3aca431e6ea0a50ffd7201551175b47323/pycryptodome-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843", size = 1640362, upload-time = "2025-05-17T17:20:50.392Z" },
+    { url = "https://files.pythonhosted.org/packages/50/52/adaf4c8c100a8c49d2bd058e5b551f73dfd8cb89eb4911e25a0c469b6b4e/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490", size = 2182625, upload-time = "2025-05-17T17:20:52.866Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e9/a09476d436d0ff1402ac3867d933c61805ec2326c6ea557aeeac3825604e/pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575", size = 2268954, upload-time = "2025-05-17T17:20:55.027Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c5/ffe6474e0c551d54cab931918127c46d70cab8f114e0c2b5a3c071c2f484/pycryptodome-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b", size = 2308534, upload-time = "2025-05-17T17:20:57.279Z" },
+    { url = "https://files.pythonhosted.org/packages/18/28/e199677fc15ecf43010f2463fde4c1a53015d1fe95fb03bca2890836603a/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a", size = 2181853, upload-time = "2025-05-17T17:20:59.322Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/ea/4fdb09f2165ce1365c9eaefef36625583371ee514db58dc9b65d3a255c4c/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f", size = 2342465, upload-time = "2025-05-17T17:21:03.83Z" },
+    { url = "https://files.pythonhosted.org/packages/22/82/6edc3fc42fe9284aead511394bac167693fb2b0e0395b28b8bedaa07ef04/pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa", size = 2267414, upload-time = "2025-05-17T17:21:06.72Z" },
+    { url = "https://files.pythonhosted.org/packages/59/fe/aae679b64363eb78326c7fdc9d06ec3de18bac68be4b612fc1fe8902693c/pycryptodome-3.23.0-cp37-abi3-win32.whl", hash = "sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886", size = 1768484, upload-time = "2025-05-17T17:21:08.535Z" },
+    { url = "https://files.pythonhosted.org/packages/54/2f/e97a1b8294db0daaa87012c24a7bb714147c7ade7656973fd6c736b484ff/pycryptodome-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2", size = 1799636, upload-time = "2025-05-17T17:21:10.393Z" },
+    { url = "https://files.pythonhosted.org/packages/18/3d/f9441a0d798bf2b1e645adc3265e55706aead1255ccdad3856dbdcffec14/pycryptodome-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c", size = 1703675, upload-time = "2025-05-17T17:21:13.146Z" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.20.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+]
+
+[[package]]
+name = "pyobjc-core"
+version = "12.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b4/b1/729f7458a63758bd21716648a8abcd9a0c8f2d2e9897763c8a1a1c7fd31b/pyobjc_core-12.2.1.tar.gz", hash = "sha256:7a7b9b018402342cf32bf1956366896350fbe5c0478cb3ef59778f77abed7f07", size = 1063383, upload-time = "2026-06-19T16:19:39.357Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/87/16564ef5e4568ee0edd9e712d8111dc8b67621d6bb6ff430646ee2d637dd/pyobjc_core-12.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:24b76a63caf0b5369d4a377c7c0438cd70df81539057af3db839bfaa3579e04a", size = 6484662, upload-time = "2026-06-19T16:04:44.979Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/88/300ad283bed0c971c52dcac6f70113e138169d4ce6d856ddd03d16081e51/pyobjc_core-12.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a64232bb27ed101d4adc7d42b0e64a6d3331aac7bee7861c037a6777a163f10b", size = 6433347, upload-time = "2026-06-19T16:04:49.341Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/1e/b9b0ddffae66996b8779f1f7958adc9f21c13a0448cd3be8d7fe589b5b0f/pyobjc_core-12.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:af101222762665a4125157906cb4b23f5d5a63d3851d5e0504f72a1eaaa2cfd2", size = 6436004, upload-time = "2026-06-19T16:04:53.257Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/26/bd309ede07784c6e5fac4b440c90a5f72a66da7859ed303a9392fe8a5f3f/pyobjc_core-12.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:efe465e3ecc6fc73f7c7622620345d134a8d34564ab1c29d8247e45f4ed55071", size = 6687044, upload-time = "2026-06-19T16:04:57.42Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/8a/cfa4f56939d554dbb342ec6e5226a441e2f552bc2002a0ddf7705bb11bef/pyobjc_core-12.2.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:2b8fc0531c27277325e113ac00b8a72a82e6145f0a88175b9425d8de814ff69a", size = 6429289, upload-time = "2026-06-19T16:05:02.191Z" },
+    { url = "https://files.pythonhosted.org/packages/42/74/446c89bc18103aaa4a00d1fb85ff8acace9a0dc3f362d9678ebf7571e275/pyobjc_core-12.2.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:9bef500f979e22d54f9da3aaebf6a48f873234b324858bd69256055a318955c7", size = 6690181, upload-time = "2026-06-19T16:05:06.201Z" },
+    { url = "https://files.pythonhosted.org/packages/99/c7/0121ee4c616af07ad2de8cd1a286f6978dc9a227eb58b7c2e875cb68a1df/pyobjc_core-12.2.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:047c226eeb58a2993ace5e8904e71cc9426ee20d064c617f8fbf32717d37093e", size = 6487078, upload-time = "2026-06-19T16:05:10.093Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/a8/cb9fcc150f97d0bf22a2028f88b24cc35949beb1bcc7b8bc5c17d4401677/pyobjc_core-12.2.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:1188613805336270279570467e4455b74cb6c0f60913ac74c917ee1c37cfaecb", size = 6733064, upload-time = "2026-06-19T16:05:14.313Z" },
+]
+
+[[package]]
+name = "pyobjc-framework-cocoa"
+version = "12.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyobjc-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/51/34/fbe38a204643aa4e1b91391cdce07a34da565a69171ebcad08de7438a556/pyobjc_framework_cocoa-12.2.1.tar.gz", hash = "sha256:b94b37fe5730e5ae1fb0052912cd174e6ec329b0bfba4a012ae5db1014b5864b", size = 3125751, upload-time = "2026-06-19T16:20:05.159Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/d6/dc66ea8519a0475efbccf73f82cc28066339bb300a27f5e1bf91ab1d7002/pyobjc_framework_cocoa-12.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:dc6da84f4fc62cc25463bbb85e77a57b8d5ac6caf9a60702daf2edb601332f15", size = 387298, upload-time = "2026-06-19T16:07:37.412Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/cf/1b3b32b2f28f66cc053c3438ef4e6df36a1591945bf05e7399da18d74553/pyobjc_framework_cocoa-12.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:28b9b8bab1c36efb94744786918752d0c1842f5fbb67e7d5ca97b5f736512080", size = 388113, upload-time = "2026-06-19T16:07:38.9Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/46/68e8e4d926a2f70fed0437047bc3f9fe08af8fe620d94d80656ebc3cfa9b/pyobjc_framework_cocoa-12.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:3b74a78fa7803e547b32e5e8ec1b49987b52fe318383e793bc6cd49b80efbd9f", size = 388183, upload-time = "2026-06-19T16:07:40.483Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/f3/dfc9af4c9eb2e5389c860ad5ef252be9fe456db09f39d537555dc5057aa1/pyobjc_framework_cocoa-12.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:dc2eaca2f13c7bcd8e41e51a372e47825dea9dd3126108760eed7ba883d2945c", size = 392275, upload-time = "2026-06-19T16:07:42.078Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/c8/b90baa8f3592eded79b4be98fb59d2b8dc16b62361e34292bd95806ebd9f/pyobjc_framework_cocoa-12.2.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b386c324d64ae565c1f6b7dfb77be68f640a1c7c23caa6966ab661131f519561", size = 388357, upload-time = "2026-06-19T16:07:43.364Z" },
+    { url = "https://files.pythonhosted.org/packages/98/d8/64a94651b9294702d55e748d94de30e25bc59d0784526be7643f4467eccd/pyobjc_framework_cocoa-12.2.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a6c584e2af0813cb2f6103b184e632665a26f58c1bd5b08ffd6e95a19c617f7b", size = 392404, upload-time = "2026-06-19T16:07:44.955Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/cc/26e8a7bf1f5e8caa38b7f80d486296f9fd3c97e71ad7e5444ef22e802758/pyobjc_framework_cocoa-12.2.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:b6023657b8d6cc049a21bd6b4752425f2f53c42f9f0b02d64c7608cc484bf103", size = 388589, upload-time = "2026-06-19T16:07:46.276Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/f3/eedf743a303ea742b8e082afe3613fb4d6618bc1a48cf2568b004ce906f7/pyobjc_framework_cocoa-12.2.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:c685ccd8e266a07cf912a2c5a13b1f2eff2a868a1aff163b4801b4687bd425e1", size = 392691, upload-time = "2026-06-19T16:07:47.477Z" },
+]
+
+[[package]]
+name = "pyobjc-framework-corebluetooth"
+version = "12.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyobjc-core" },
+    { name = "pyobjc-framework-cocoa" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d4/91/c76f3c5e8e80c7047e43c4c05b3e6fda9a7cefad5aae85487007674c966c/pyobjc_framework_corebluetooth-12.2.1.tar.gz", hash = "sha256:7dbb285295097205bebbcb11f55161e5faa02111108fb7b17536176e31971eb0", size = 37568, upload-time = "2026-06-19T16:20:12.191Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/ad/de57d9060e4c5e9ca1a9bdd5b6bd1bdb73b198c0c53953cac445d9b3a84b/pyobjc_framework_corebluetooth-12.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f11df7052fa2d0524a9dadbc9c578fd3b8f3a350431edfa4ffa9e0a74b6faa32", size = 13195, upload-time = "2026-06-19T16:08:26.961Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/c4/7938016860850e28c001dc9b7c653352c43f7aebfffc6d3c5fd087281f22/pyobjc_framework_corebluetooth-12.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:2f8d2ed65c0e98ba044b6a7fc2f9a290a5c579a28d33a57c642f8617ccbcca0f", size = 13217, upload-time = "2026-06-19T16:08:27.802Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/79/890a53ed45c1006eedcf60627b7d661c8696e5367723ceb25cc6a0216b30/pyobjc_framework_corebluetooth-12.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:30a26eef36c250fc14e73335641e24f764b32b7e42bae945a5d8a1c2347040b5", size = 13235, upload-time = "2026-06-19T16:08:28.727Z" },
+    { url = "https://files.pythonhosted.org/packages/22/7a/40ffc3be8e31b1eb1f8f5eb2a58ef832287fb1ea6b3c452dc8b25b9e064b/pyobjc_framework_corebluetooth-12.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:756933b9ce6160a986c8877ab667659fa2d8e15aff28d0981b5284fbdd1ea735", size = 13416, upload-time = "2026-06-19T16:08:29.643Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ff/6f3b0bb3110ec82dbedaea47de151bd688980f5aadc634ef0cd236fdbd16/pyobjc_framework_corebluetooth-12.2.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:2a2e6d56f51e4ca3e3b9766ef34150a9a7ce5f0cf4f9ee879ec10923af58e97e", size = 13223, upload-time = "2026-06-19T16:08:30.672Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/4c/4e12660569219e4a68186ae9709b85278d3ebaf8d2f8e1c826a7337f4f7a/pyobjc_framework_corebluetooth-12.2.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:50d7e4245dbdc8789dcc1f11fca2e633aa126a298b09db62f8216531fe107ee2", size = 13414, upload-time = "2026-06-19T16:08:31.679Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/4c/976ae9bcce3615af806e3c314ea9caa3faacf11ec44f00b1a149559c6cb3/pyobjc_framework_corebluetooth-12.2.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:c8d126c56b71c25218be186930a1b41739f83e931726a52e3298beeb170c5e5b", size = 13222, upload-time = "2026-06-19T16:08:32.481Z" },
+    { url = "https://files.pythonhosted.org/packages/99/be/44bb648a6b5c8aec79138bf562dab9eef414016ee31f37066bf81d809ae9/pyobjc_framework_corebluetooth-12.2.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:81023518feb75e9b2b676b28198955c51ae00548cf23c73c524c7101263b68db", size = 13424, upload-time = "2026-06-19T16:08:33.336Z" },
+]
+
+[[package]]
+name = "pyobjc-framework-libdispatch"
+version = "12.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pyobjc-core" },
+    { name = "pyobjc-framework-cocoa" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/3f/561653aff3f19873457c95c053f0298da517be89fdfc0ec35115ed5b7030/pyobjc_framework_libdispatch-12.2.1.tar.gz", hash = "sha256:0d24eda41c6c258135077f60d410e704bc7b5a67adcb2ca463918896c7363795", size = 40336, upload-time = "2026-06-19T16:20:56.371Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1d/b0/dc263ed1cee54badccaf60f061de1e25bea95504984401a22bee274b5f59/pyobjc_framework_libdispatch-12.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:0e295775c76eace23f60e53ef74b0f79429c665f91a870e4665c4b9887466efa", size = 20488, upload-time = "2026-06-19T16:12:49.441Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/8f/42cfa987c07a2b5ce8c236a42b0fb388b8807dac72c25e004cd4905ea9a3/pyobjc_framework_libdispatch-12.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8f41b5021ff70bc51220a79b41ebd1eacb55fe3ceb67448594f30e491a2c42a5", size = 15656, upload-time = "2026-06-19T16:12:50.361Z" },
+    { url = "https://files.pythonhosted.org/packages/22/c6/cfe97f1beb13f5b7ca5c4348158c2de886d58ffba5be09a9376557f7d6f6/pyobjc_framework_libdispatch-12.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:9c0ebf99520083bf17c007a544c100056a0d4ae5c346fb89e1bdfe6d041f16f2", size = 15679, upload-time = "2026-06-19T16:12:51.28Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/de/ef6b51bc72fe5ac1df80c34b1b13a97d0922ddd6bc5d3ecf5ead1557bf34/pyobjc_framework_libdispatch-12.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3f56fd71b963a0b6e440ed2f0ea2fb635221758b7eb908ba38f96f5144b83ca3", size = 15946, upload-time = "2026-06-19T16:12:52.098Z" },
+    { url = "https://files.pythonhosted.org/packages/42/87/5b4a6c8580f2a486daf4b0d14a2356c47abfda401b329e71e46ac9b5460c/pyobjc_framework_libdispatch-12.2.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:999bad9a2c9198c837ba8f57a3ca9f05b4fc4bf7b69318baaa266dd2ab2fc8f7", size = 15699, upload-time = "2026-06-19T16:12:52.917Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/44/68cff50cb37a6ea311b7e805105ea13c33043762772714bc25d269c0730d/pyobjc_framework_libdispatch-12.2.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:3fc93971f40d9757995c1e4b995a1614a468a5178be27e3d81e9bdc0b5e3cf75", size = 15981, upload-time = "2026-06-19T16:12:53.845Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/5d/1f48e023555817f1271e86849ebd092743fc8bd292b6f82e87aba5df6122/pyobjc_framework_libdispatch-12.2.1-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:26a096c81c8cf272f4f1bb8f6c4b7565e005d273d218b53b83d925da5292633f", size = 15719, upload-time = "2026-06-19T16:12:54.64Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/44/b45c32851a3bcd367c62804c23aa55ea7918af6e16fddf1df23f5d7ca750/pyobjc_framework_libdispatch-12.2.1-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:82c6512fb4985f3bcd6b60b0cff79a4b483b44d1d2e5405010e34dd4b60aa01b", size = 16009, upload-time = "2026-06-19T16:12:55.513Z" },
+]
+
+[[package]]
+name = "pytest"
+version = "9.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "pygments" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e4/47/b9efed96c114afcfa3c9d3fe98a76a1d14c74a9e266d397cf6eb64be5e01/pytest-9.1.1.tar.gz", hash = "sha256:1088fbde8f2b49d95a549a195707afa7a76a3ce9bcadc26b6d71f0ffda5fe313", size = 1636369, upload-time = "2026-06-19T10:58:32.857Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/24/25/1de2678b631f5a49215c6c96fff41ba892b0a34df68d6d80292b1b48aa7f/pytest-9.1.1-py3-none-any.whl", hash = "sha256:37a86b45efb9a47a61a36449063e8e18d0cab3161329fc099eb21783169c4f0c", size = 386536, upload-time = "2026-06-19T10:58:31.347Z" },
+]
+
+[[package]]
+name = "pytest-asyncio"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" },
+]
+
+[[package]]
+name = "pytest-cov"
+version = "7.1.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "coverage", extra = ["toml"] },
+    { 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 = "requests"
+version = "2.34.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "charset-normalizer" },
+    { name = "idna" },
+    { name = "urllib3" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.15.20"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/dc/35b341fc554ba02f217fc10da57d1a75168cfbcf75b0ef2202176d4c4f2d/ruff-0.15.20.tar.gz", hash = "sha256:1416eb04349192646b54de98f146c4f59afe37d0decfc02c3cbbf396f3a28566", size = 4755489, upload-time = "2026-06-25T17:20:37.578Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/94/d9/2d5014f0253ba541d2061d9fa7193f48e941c8b21bb88a7ff9bbe0bd0596/ruff-0.15.20-py3-none-linux_armv6l.whl", hash = "sha256:00e188c53e499c3c1637f73c91dcf2fb56d576cab76ce1be50a27c4e80e37078", size = 10839665, upload-time = "2026-06-25T17:19:44.702Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d3/ac1798ba64f670698867fcfc591d50e7e421bef137db564858f619a30fcf/ruff-0.15.20-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9ebd1fd9b9c95fc0bd7b2761aebec1f030013d2e193a2901b224af68fe47251b", size = 11208649, upload-time = "2026-06-25T17:19:48.787Z" },
+    { url = "https://files.pythonhosted.org/packages/47/47/d3ac899991202095dfcf3d5176be4272642be3cf981a2f1a30f72a2afb95/ruff-0.15.20-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c5b16cdd67ca108185cd36dce98c576350c03b1660a751de725fb049193a0632", size = 10622638, upload-time = "2026-06-25T17:19:51.354Z" },
+    { url = "https://files.pythonhosted.org/packages/33/13/4e043fe30aa94d4ff5213a9881fc296d12960f5971b234a5263fdc225312/ruff-0.15.20-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3413bb3c3d2ca6a8208f1f4809cd2dca3c6de6d0b491c0e70847672bde6e6efd", size = 10984227, upload-time = "2026-06-25T17:19:54.044Z" },
+    { url = "https://files.pythonhosted.org/packages/76/e6/92e7bf40388bc5800073b96564f56264f7e48bfd1a498f5ced6ae6d5a769/ruff-0.15.20-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bd7ec42b3bb3da066488db093308a69c4ac5ee6d2af333a86ba6e2eb2e7dd44b", size = 10622882, upload-time = "2026-06-25T17:19:57.037Z" },
+    { url = "https://files.pythonhosted.org/packages/13/7a/43460be3f24495a3aa46d4b16873e2c4941b3b5f0b00cf88c03b7b94b339/ruff-0.15.20-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e1a36ad0eb77fba9aabfb69ede54de6f376d04ac18ebea022847046d340a8267", size = 11474808, upload-time = "2026-06-25T17:20:00.357Z" },
+    { url = "https://files.pythonhosted.org/packages/27/a0/f37077884873221c6b33b4ab49eb18f9f88e54a16a25a5bca59bef46dd66/ruff-0.15.20-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b6df3b1e4610432f0386dba04d853b5f08cbbc903410c6fcc02f620f05aff53c", size = 12293094, upload-time = "2026-06-25T17:20:03.446Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/74/165545b60256a9704c21ac0ec4a0d07933b320812f9584836c9f4aca4292/ruff-0.15.20-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e89f198a1ea6ef0d727c1cf16088bc91a6cb0ab947dedc966715691647186eae", size = 11526176, upload-time = "2026-06-25T17:20:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/86/b1/a976a136d40ade83ce743578399865f57001003a409acadc0ecbb3051082/ruff-0.15.20-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:309809086c2acb67624950a3c8133e80f32d0d3e27106c0cd60ff26657c9f24b", size = 11520767, upload-time = "2026-06-25T17:20:09.191Z" },
+    { url = "https://files.pythonhosted.org/packages/19/0f/f032696cb01c9b54c0263fa393474d7758f1cdc021a01b04e3cbc2500999/ruff-0.15.20-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:2d2374caa2f2c2f9e2b7da0a50802cfb8b79f55a9b5e49379f564544fbf56487", size = 11500132, upload-time = "2026-06-25T17:20:13.602Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/f4/51b1a14bc69e8c224b15dab9cce8e99b425e0455d462caa2b3c9be2b6a8e/ruff-0.15.20-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a1ed17b65293e0c2f22fc387bc13198a5de94bf4429589b0ff6946b0feaf21a3", size = 10943828, upload-time = "2026-06-25T17:20:16.635Z" },
+    { url = "https://files.pythonhosted.org/packages/71/4b/fe267640783cd02bf6c5cc290b1df1051be2ec294c678b5c15fe19e52343/ruff-0.15.20-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:f701305e66b38ea6c91882490eb73459796808e4c6362a1b765255e0cdcd4053", size = 10645418, upload-time = "2026-06-25T17:20:19.4Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/c0/a65aa4ec2f5e87a1df32dc3ec1fede434fe3dfd5cbcf3b503cafc676ab54/ruff-0.15.20-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5b9c0c367ad8e5d0d5b5b8537864c469a0a0e55417aadfbeca41fa61333be9f4", size = 11211770, upload-time = "2026-06-25T17:20:22.033Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/a4/0caa331d954ae2723d729d351c989cb4ca8b6077d5c6c2cb6de75e98c041/ruff-0.15.20-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:01cc00dd58f0df339d0e902219dd53990ea99996a0344e5d9cc8d45d5307e460", size = 11618698, upload-time = "2026-06-25T17:20:25.259Z" },
+    { url = "https://files.pythonhosted.org/packages/10/9b/5f14927848d2fd4aa891fd88d883788c5a7baba561c7874732364045708c/ruff-0.15.20-py3-none-win32.whl", hash = "sha256:ed65ef510e43a137207e0f01cfcf998aeddb1aeeda5c9d35023e910284d7cf21", size = 10857322, upload-time = "2026-06-25T17:20:28.612Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f0/fe47c501f9dea92a26d788ff98bb5d92ed4cb4c88792c5c88af6b697dc8e/ruff-0.15.20-py3-none-win_amd64.whl", hash = "sha256:a525c81c70fb0380344dd1d8745d8cc1c890b7fc94a58d5a07bd8eb9557b8415", size = 11993274, upload-time = "2026-06-25T17:20:31.871Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/2b/9555445e1201d92b3195f45cdb153a0b68f24e0a4273f6e3d5ab46e212bb/ruff-0.15.20-py3-none-win_arm64.whl", hash = "sha256:2f5b2a6d614e8700388806a14996c40fab2c47b819ef57d790a34878858ed9ca", size = 11343498, upload-time = "2026-06-25T17:20:35.03Z" },
+]
+
+[[package]]
+name = "tinytuya"
+version = "1.19.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama" },
+    { name = "cryptography" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/6f/2d/7931178ad866617d3e5119ed8eba1fa3953137ccbcda8771756d6d155359/tinytuya-1.19.0.tar.gz", hash = "sha256:ff943874e00c73bcaf0e85e32fe1463b463afa5b8211fda0ce6db7ac9733e2cc", size = 187480, upload-time = "2026-06-29T05:59:03.075Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/48/a4/dcfa272ce41be5df4103ad144b0cfea24b389bb40c9f81445560ec1a7060/tinytuya-1.19.0-py3-none-any.whl", hash = "sha256:b8b525a8396ac201b7892f84584a53ac3de65171d8d3d2737c2cfca628c74030", size = 167515, upload-time = "2026-06-29T05:59:01.557Z" },
+]
+
+[[package]]
+name = "tomli"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" },
+    { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" },
+    { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" },
+    { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" },
+    { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" },
+    { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" },
+    { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" },
+    { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" },
+    { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" },
+    { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" },
+    { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" },
+    { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" },
+    { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" },
+    { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" },
+    { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" },
+    { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" },
+    { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" },
+    { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" },
+    { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" },
+    { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" },
+    { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" },
+    { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" },
+    { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" },
+    { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" },
+]
+
+[[package]]
+name = "tuya-re"
+version = "0.1.0"
+source = { editable = "." }
+dependencies = [
+    { name = "bleak" },
+    { name = "pycryptodome" },
+    { name = "tinytuya" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "pytest" },
+    { name = "pytest-asyncio" },
+    { name = "pytest-cov" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "bleak", specifier = ">=0.22" },
+    { name = "pycryptodome", specifier = ">=3.20" },
+    { name = "tinytuya", specifier = ">=1.18.0" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "pytest", specifier = ">=8" },
+    { name = "pytest-asyncio", specifier = ">=0.24" },
+    { name = "pytest-cov", specifier = ">=5" },
+    { name = "ruff", specifier = ">=0.9" },
+]
+
+[[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 = "urllib3"
+version = "2.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+]
+
+[[package]]
+name = "winrt-runtime"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/16/dd/acdd527c1d890c8f852cc2af644aa6c160974e66631289420aa871b05e65/winrt_runtime-3.2.1.tar.gz", hash = "sha256:c8dca19e12b234ae6c3dadf1a4d0761b51e708457492c13beb666556958801ea", size = 21721, upload-time = "2025-06-06T14:40:27.593Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/8d/d7ae0e07cd85c7768de76e8578261854f2af72bd3a8a527bb675e8ae0eda/winrt_runtime-3.2.1-cp311-cp311-win32.whl", hash = "sha256:9e9b64f1ba631cc4b9fe60b8ff16fef3f32c7ce2fcc84735a63129ff8b15c022", size = 210798, upload-time = "2025-06-06T06:44:04.775Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/66/d05f6e6c0517654734e7f87fa1f0fbc965add9f27cc36b524d96331ab3d8/winrt_runtime-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:c0a9046ae416808420a358c51705af8ae100acd40bc578be57ddfdd51cbb0f9c", size = 242032, upload-time = "2025-06-06T06:44:06.103Z" },
+    { url = "https://files.pythonhosted.org/packages/39/a5/760c8396110f6d3e4c417752da1a2bf3b89e0998329c2f10afc717ef6291/winrt_runtime-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:e94f3cb40ea2d723c44c82c16d715c03c6b3bd977d135b49535fdd5415fd9130", size = 415659, upload-time = "2025-06-06T06:44:07.007Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/54/3dd06f2341fab6abb06588a16b30e0b213b0125be7b79dafc3bdba3b334a/winrt_runtime-3.2.1-cp312-cp312-win32.whl", hash = "sha256:762b3d972a2f7037f7db3acbaf379dd6d8f6cda505f71f66c6b425d1a1eae2f1", size = 210090, upload-time = "2025-06-06T06:44:08.151Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/a1/1d7248d5c62ccbea5f3e0da64ca4529ce99c639c3be2485b6ed709f5c740/winrt_runtime-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:06510db215d4f0dc45c00fbb1251c6544e91742a0ad928011db33b30677e1576", size = 241391, upload-time = "2025-06-06T06:44:09.442Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/ae/6a205d8dafc79f7c242be7f940b1e0c1971fd64ab3079bda4b514aa3d714/winrt_runtime-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:14562c29a087ccad38e379e585fef333e5c94166c807bdde67b508a6261aa195", size = 415242, upload-time = "2025-06-06T06:44:10.407Z" },
+    { url = "https://files.pythonhosted.org/packages/79/d4/1a555d8bdcb8b920f8e896232c82901cc0cda6d3e4f92842199ae7dff70a/winrt_runtime-3.2.1-cp313-cp313-win32.whl", hash = "sha256:44e2733bc709b76c554aee6c7fe079443b8306b2e661e82eecfebe8b9d71e4d1", size = 210022, upload-time = "2025-06-06T06:44:11.767Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/24/2b6e536ca7745d788dfd17a2ec376fa03a8c7116dc638bb39b035635484f/winrt_runtime-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:3c1fdcaeedeb2920dc3b9039db64089a6093cad2be56a3e64acc938849245a6d", size = 241349, upload-time = "2025-06-06T06:44:12.661Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/7f/6d72973279e2929b2a71ed94198ad4a5d63ee2936e91a11860bf7b431410/winrt_runtime-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:28f3dab083412625ff4d2b46e81246932e6bebddf67bea7f05e01712f54e6159", size = 415126, upload-time = "2025-06-06T06:44:13.702Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/87/88bd98419a9da77a68e030593fee41702925a7ad8a8aec366945258cbb31/winrt_runtime-3.2.1-cp314-cp314-win32.whl", hash = "sha256:9b6298375468ac2f6815d0c008a059fc16508c8f587e824c7936ed9216480dad", size = 210257, upload-time = "2025-09-20T07:06:41.054Z" },
+    { url = "https://files.pythonhosted.org/packages/87/85/e5c2a10d287edd9d3ee8dc24bf7d7f335636b92bf47119768b7dd2fd1669/winrt_runtime-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:e36e587ab5fd681ee472cd9a5995743f75107a1a84d749c64f7e490bc86bc814", size = 241873, upload-time = "2025-09-20T07:06:42.059Z" },
+    { url = "https://files.pythonhosted.org/packages/52/2a/eb9e78397132175f70dd51dfa4f93e489c17d6b313ae9dce60369b8d84a7/winrt_runtime-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:35d6241a2ebd5598e4788e69768b8890ee1eee401a819865767a1fbdd3e9a650", size = 416222, upload-time = "2025-09-20T07:06:43.376Z" },
+]
+
+[[package]]
+name = "winrt-windows-devices-bluetooth"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b2/a0/1c8a0c469abba7112265c6cb52f0090d08a67c103639aee71fc690e614b8/winrt_windows_devices_bluetooth-3.2.1.tar.gz", hash = "sha256:db496d2d92742006d5a052468fc355bf7bb49e795341d695c374746113d74505", size = 23732, upload-time = "2025-06-06T14:41:20.489Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3b/cf/671bf29337323cc08f9969cb32312f217d2927d29dbf2964f0dbb378cb90/winrt_windows_devices_bluetooth-3.2.1-cp311-cp311-win32.whl", hash = "sha256:f4082a00b834c1e34b961e0612f3e581356bdb38c5798bd6842f88ec02e5152b", size = 105535, upload-time = "2025-06-06T07:00:08.146Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/d5/5761a8b6dcc56957018970dd443059c8ee8a79de7b07f0b4d143f8e7dc15/winrt_windows_devices_bluetooth-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:44277a3f2cc5ac32ce9b4b2d96c5c5f601d394ac5f02cc71bcd551f738660e2d", size = 114612, upload-time = "2025-06-06T07:00:08.984Z" },
+    { url = "https://files.pythonhosted.org/packages/24/0b/7819bb102286752d3572a75d03e6a8000ffe3c6cb7aee3eb136dca383fe2/winrt_windows_devices_bluetooth-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:0803a417403a7d225316b9b0c4fe3f8446579d6a22f2f729a2c21f4befc74a80", size = 105017, upload-time = "2025-06-06T07:00:09.813Z" },
+    { url = "https://files.pythonhosted.org/packages/54/ff/c4a3de909a875b46fad5e9f4fd412bba48571405bfa802b878954abf128c/winrt_windows_devices_bluetooth-3.2.1-cp312-cp312-win32.whl", hash = "sha256:18c833ec49e7076127463679e85efc59f61785ade0dc185c852586b21be1f31c", size = 105752, upload-time = "2025-06-06T07:00:10.684Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/78/bfee1f0c8d188c561c5b946ab21f6a0037e60dea110e80b1d6a1d529639f/winrt_windows_devices_bluetooth-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:9b6702c462b216c91e32388023a74d0f87210cef6fd5d93b7191e9427ce2faca", size = 113356, upload-time = "2025-06-06T07:00:11.541Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/1b/d9da9c29d36cabadef4e19c3e9ba6d2692f6a28224c81fcff757132ea0da/winrt_windows_devices_bluetooth-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:419fd1078c7749119f6b4bbf6be4e586e03a0ed544c03b83178f1d85f1b3d148", size = 104724, upload-time = "2025-06-06T07:00:12.406Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/cc/797516c5c0f8d7f5b680862e0ed7c1087c58aec0bcf57a417fa90f7eb983/winrt_windows_devices_bluetooth-3.2.1-cp313-cp313-win32.whl", hash = "sha256:12b0a16fb36ce0b42243ca81f22a6b53fbb344ed7ea07a6eeec294604f0505e4", size = 105757, upload-time = "2025-06-06T07:00:13.269Z" },
+    { url = "https://files.pythonhosted.org/packages/05/6d/f60588846a065e69a2ec5e67c5f85eb45cb7edef2ee8974cd52fa8504de6/winrt_windows_devices_bluetooth-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:6703dfbe444ee22426738830fb305c96a728ea9ccce905acfdf811d81045fdb3", size = 113363, upload-time = "2025-06-06T07:00:14.135Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/13/2d3c4762018b26a9f66879676ea15d7551cdbf339c8e8e0c56ea05ea31ef/winrt_windows_devices_bluetooth-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:2cf8a0bfc9103e32dc7237af15f84be06c791f37711984abdca761f6318bbdb2", size = 104722, upload-time = "2025-06-06T07:00:14.999Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/95/91cfdf941a1ba791708ab3477fc4e46793c8fe9117fc3e0a8c5ac5d7a09c/winrt_windows_devices_bluetooth-3.2.1-cp314-cp314-win32.whl", hash = "sha256:de36ded53ca3ba12fc6dd4deb14b779acc391447726543815df4800348aad63a", size = 109015, upload-time = "2025-09-20T07:09:51.067Z" },
+    { url = "https://files.pythonhosted.org/packages/61/fa/7460655628d0f340a93524f5236bb9f8514eb0e1d334b38cba8a89f6c1a6/winrt_windows_devices_bluetooth-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:3295d932cc93259d5ccb23a41e3a3af4c78ce5d6a6223b2b7638985f604fa34c", size = 115931, upload-time = "2025-09-20T07:09:51.922Z" },
+    { url = "https://files.pythonhosted.org/packages/de/70/e1248dea2ab881eb76b61ff1ad6cb9c07ac005faf99349e4af0b29bc3f1b/winrt_windows_devices_bluetooth-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:1f61c178766a1bbce0669f44790c6161ff4669404c477b4aedaa576348f9e102", size = 109561, upload-time = "2025-09-20T07:09:52.733Z" },
+]
+
+[[package]]
+name = "winrt-windows-devices-bluetooth-advertisement"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/fc/7ffe66ca4109b9e994b27c00f3d2d506e6e549e268791f755287ad9106d8/winrt_windows_devices_bluetooth_advertisement-3.2.1.tar.gz", hash = "sha256:0223852a7b7fa5c8dea3c6a93473bd783df4439b1ed938d9871f947933e574cc", size = 16906, upload-time = "2025-06-06T14:41:21.448Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ad/5e/c628719e877a89f00cac7ce53f9666acbc5ed6f074130729d5d6768b63ff/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp311-cp311-win32.whl", hash = "sha256:fe17c2cf63284646622e8b2742b064bf7970bbf53cfab02062136c67fa6b06c9", size = 89614, upload-time = "2025-06-06T07:00:20.952Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/1a/d172d6f1c2fae53535e7f23835025cf39e3002749a0304f18a38e8ed490d/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:78e99dd48b4d89b71b7778c5085fdba64e754dd3ebc54fd09c200fe5222c6e09", size = 95783, upload-time = "2025-06-06T07:00:21.764Z" },
+    { url = "https://files.pythonhosted.org/packages/67/c1/568dfdaea62ca3b13bb70162cb292e5cd0be5bbb98b738961ddcc2edd374/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:6d5d2295474deab444fc4311580c725a2ca8a814b0f3344d0779828891d75401", size = 89253, upload-time = "2025-06-06T07:00:22.603Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/15/ad05c28e049208c97011728e2debdb45439175f75efe357b6faa4c9ba099/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp312-cp312-win32.whl", hash = "sha256:901933cc40de5eb7e5f4188897c899dd0b0f577cb2c13eab1a63c7dfe89b08c4", size = 90033, upload-time = "2025-06-06T07:00:23.421Z" },
+    { url = "https://files.pythonhosted.org/packages/26/48/074779081841f6eba4987930c4e7adcec38a5985b7dffd9fecc41f39a89c/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:e6c66e7d4f4ca86d2c801d30efd2b9673247b59a2b4c365d9e11650303d68d89", size = 95824, upload-time = "2025-06-06T07:00:24.238Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/25/e01966033a02b2d0718710bb47ef4f6b9b5a619ca2c857e06eb5c8e3ed13/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:447d19defd8982d39944642eb7ebe89e4e20259ec9734116cf88879fb2c514ff", size = 89311, upload-time = "2025-06-06T07:00:25.029Z" },
+    { url = "https://files.pythonhosted.org/packages/34/01/8fc8e57605ea08dd0723c035ed0c2d0435dace2bc80a66d33aecfea49a56/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp313-cp313-win32.whl", hash = "sha256:4122348ea525a914e85615647a0b54ae8b2f42f92cdbf89c5a12eea53ef6ed90", size = 90037, upload-time = "2025-06-06T07:00:25.818Z" },
+    { url = "https://files.pythonhosted.org/packages/86/83/503cf815d84c5ba8c8bc61480f32e55579ebf76630163405f7df39aa297b/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:b66410c04b8dae634a7e4b615c3b7f8adda9c7d4d6902bcad5b253da1a684943", size = 95822, upload-time = "2025-06-06T07:00:26.666Z" },
+    { url = "https://files.pythonhosted.org/packages/32/13/052be8b6642e6f509b30c194312b37bfee8b6b60ac3bd5ca2968c3ea5b80/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:07af19b1d252ddb9dd3eb2965118bc2b7cabff4dda6e499341b765e5038ca61d", size = 89326, upload-time = "2025-06-06T07:00:27.477Z" },
+    { url = "https://files.pythonhosted.org/packages/27/3d/421d04a20037370baf13de929bc1dc5438b306a76fe17275ec5d893aae6c/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp314-cp314-win32.whl", hash = "sha256:2985565c265b3f9eab625361b0e40e88c94b03d89f5171f36146f2e88b3ee214", size = 92264, upload-time = "2025-09-20T07:09:53.563Z" },
+    { url = "https://files.pythonhosted.org/packages/07/c7/43601ab82fe42bcff430b8466d84d92b31be06cc45c7fd64e9aac40f7851/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:d102f3fac64fde32332e370969dfbc6f37b405d8cc055d9da30d14d07449a3c2", size = 97517, upload-time = "2025-09-20T07:09:54.411Z" },
+    { url = "https://files.pythonhosted.org/packages/91/17/e3303f6a25a2d98e424b06580fc85bbfd068f383424c67fa47cb1b357a46/winrt_windows_devices_bluetooth_advertisement-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:ffeb5e946cd42c32c6999a62e240d6730c653cdfb7b49c7839afba375e20a62a", size = 94122, upload-time = "2025-09-20T07:09:55.187Z" },
+]
+
+[[package]]
+name = "winrt-windows-devices-bluetooth-genericattributeprofile"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/44/21/aeeddc0eccdfbd25e543360b5cc093233e2eab3cdfb53ad3cabae1b5d04d/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1.tar.gz", hash = "sha256:cdf6ddc375e9150d040aca67f5a17c41ceaf13a63f3668f96608bc1d045dde71", size = 38896, upload-time = "2025-06-06T14:41:22.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/5e/349a5d958be8c0570f0a49bbb746088bcfaa81555accb57503ba01185359/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp311-cp311-win32.whl", hash = "sha256:832cf65d035a11e6dbfef4fd66abdcc46be7e911ec96e2e72e98e12d8d5b9d3c", size = 182312, upload-time = "2025-06-06T07:00:49.974Z" },
+    { url = "https://files.pythonhosted.org/packages/90/db/929ab0085ec89e46bd3a58c74b451dd770c3285dfa0cbd4f4aa4730da004/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:8179638a6c721b0bbf04ba251ef98d5e02d9a17f0cce377398e42c4fbb441415", size = 187768, upload-time = "2025-06-06T07:00:50.853Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/53/f316e2224c384178204430439f04f9b72017fe8237e341a9aebb20da8191/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:70b7edfca3190b89ae38bf60972b11978311b6d933d3142ae45560c955dbf5c7", size = 184189, upload-time = "2025-06-06T07:00:51.791Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/a1/75ac783a5faee9b455fef2f53b7fef97b21ed60d52401b44c690202141e4/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp312-cp312-win32.whl", hash = "sha256:ef894d21e0a805f3e114940254636a8045335fa9de766c7022af5d127dfad557", size = 183326, upload-time = "2025-06-06T07:00:52.662Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/d9/a9dcc15322d2f5c7dfd491bd7ab121e36437caf78ebfa92bc0dd0546e2ca/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:db05de95cd1b24a51abb69cb936a8b17e9214e015757d0b37e3a5e207ddceb3d", size = 187810, upload-time = "2025-06-06T07:00:53.594Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/fc/47d00af076f558267097af3050910beda6bf8a21ceaa5830bbd26fcaf85e/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:8d4e131cf3d15fc5ad81c1bcde3509ac171298217381abed6bdf687f29871984", size = 184516, upload-time = "2025-06-06T07:00:55.24Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/93/30b45ce473d1a604908221a1fa035fe8d5e4bb9008e820ae671a21dab94c/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp313-cp313-win32.whl", hash = "sha256:b1879c8dcf46bd2110b9ad4b0b185f4e2a5f95170d014539203a5fee2b2115f0", size = 183342, upload-time = "2025-06-06T07:00:56.16Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/3b/eb9d99b82a36002d7885206d00ea34f4a23db69c16c94816434ded728fa3/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d8d89f01e9b6931fb48217847caac3227a0aeb38a5b7782af71c2e7b262ec30", size = 187844, upload-time = "2025-06-06T07:00:57.134Z" },
+    { url = "https://files.pythonhosted.org/packages/84/9b/ebbbe9be9a3e640dcfc5f166eb48f2f9d8ce42553f83aa9f4c5dcd9eb5f5/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:4e71207bb89798016b1795bb15daf78afe45529f2939b3b9e78894cfe650b383", size = 184540, upload-time = "2025-06-06T07:00:58.081Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/32/cb447ca7730a1e05730272309b074da6a04af29a8c0f5121014db8a2fc02/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp314-cp314-win32.whl", hash = "sha256:d5f83739ca370f0baf52b0400aebd6240ab80150081fbfba60fd6e7b2e7b4c5f", size = 185249, upload-time = "2025-09-20T07:09:58.639Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/fa/f465d5d44dda166bf7ec64b7a950f57eca61f165bfe18345e9a5ea542def/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:13786a5853a933de140d456cd818696e1121c7c296ae7b7af262fc5d2cffb851", size = 193739, upload-time = "2025-09-20T07:09:59.893Z" },
+    { url = "https://files.pythonhosted.org/packages/78/08/51c53ac3c704cd92da5ed7e7b9b57159052f6e46744e4f7e447ed708aa22/winrt_windows_devices_bluetooth_genericattributeprofile-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:5140682da2860f6a55eb6faf9e980724dc457c2e4b4b35a10e1cebd8fc97d892", size = 194836, upload-time = "2025-09-20T07:10:00.87Z" },
+]
+
+[[package]]
+name = "winrt-windows-devices-enumeration"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/dd/75835bfbd063dffa152109727dedbd80f6e92ea284855f7855d48cdf31c9/winrt_windows_devices_enumeration-3.2.1.tar.gz", hash = "sha256:df316899e39bfc0ffc1f3cb0f5ee54d04e1d167fbbcc1484d2d5121449a935cf", size = 23538, upload-time = "2025-06-06T14:41:26.787Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/92/ca1fd311d96fce15fba25543a2ae3cb829744a8af548a11d74233d0e4f64/winrt_windows_devices_enumeration-3.2.1-cp311-cp311-win32.whl", hash = "sha256:9f29465a6c6b0456e4330d4ad09eccdd53a17e1e97695c2e57db0d4666cc0011", size = 129898, upload-time = "2025-06-06T07:01:59.687Z" },
+    { url = "https://files.pythonhosted.org/packages/03/fd/5bd5da5d7997725ba3f1995c16aa1c3362937f8ff68ad4cadfd3415eebcb/winrt_windows_devices_enumeration-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2a725d04b4cb43aa0e2af035f73a60d16a6c0ff165fcb6b763383e4e33a975fd", size = 142361, upload-time = "2025-06-06T07:02:00.546Z" },
+    { url = "https://files.pythonhosted.org/packages/df/be/d423b63e740600e0617ddb85fba3ef99e7bbff02299fe46323bfe624a382/winrt_windows_devices_enumeration-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:6365ef5978d4add26678827286034acf474b6b133aa4054e76567d12194e6817", size = 135808, upload-time = "2025-06-06T07:02:01.4Z" },
+    { url = "https://files.pythonhosted.org/packages/31/3e/81642208ecd6c6c936f35a39a433c54e3f68e09d316546b8f953581ae334/winrt_windows_devices_enumeration-3.2.1-cp312-cp312-win32.whl", hash = "sha256:1db22b0292b93b0688d11ad932ad1f3629d4f471310281a2fbfe187530c2c1f3", size = 130249, upload-time = "2025-06-06T07:02:02.237Z" },
+    { url = "https://files.pythonhosted.org/packages/00/f4/a9ede5f3f0d86abfc7590726cf711133d97419b49ced372fca532e4f0696/winrt_windows_devices_enumeration-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:a73bc88d7f510af454f2b392985501c96f39b89fd987140708ccaec1588ceebc", size = 141512, upload-time = "2025-06-06T07:02:03.424Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ef/4fad07c03124bdc3acd64f80f3bd3cc4417ea641e07bb16a9503afd3e554/winrt_windows_devices_enumeration-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:2853d687803f0dd76ae1afe3648abc0453e09dff0e7eddbb84b792eddb0473ca", size = 135383, upload-time = "2025-06-06T07:02:04.312Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/7d/ebd712ab8ccd599c593796fbcd606abe22b5a8e20db134aa87987d67ac0e/winrt_windows_devices_enumeration-3.2.1-cp313-cp313-win32.whl", hash = "sha256:14a71cdcc84f624c209cbb846ed6bd9767a9a9437b2bf26b48ac9a91599da6e9", size = 130276, upload-time = "2025-06-06T07:02:05.178Z" },
+    { url = "https://files.pythonhosted.org/packages/70/de/f30daaaa0e6f4edb6bd7ddb3e058bd453c9ad90c032a4545c4d4639338aa/winrt_windows_devices_enumeration-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:6ca40d334734829e178ad46375275c4f7b5d6d2d4fc2e8879690452cbfb36015", size = 141536, upload-time = "2025-06-06T07:02:06.067Z" },
+    { url = "https://files.pythonhosted.org/packages/75/4b/9a6aafdc74a085c550641a325be463bf4b811f6f605766c9cd4f4b5c19d2/winrt_windows_devices_enumeration-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:2d14d187f43e4409c7814b7d1693c03a270e77489b710d92fcbbaeca5de260d4", size = 135362, upload-time = "2025-06-06T07:02:06.997Z" },
+    { url = "https://files.pythonhosted.org/packages/41/31/5785cd1ec54dc0f0e6f3e6a466d07a62b8014a6e2b782e80444ef87e83ab/winrt_windows_devices_enumeration-3.2.1-cp314-cp314-win32.whl", hash = "sha256:e087364273ed7c717cd0191fed4be9def6fdf229fe9b536a4b8d0228f7814106", size = 134252, upload-time = "2025-09-20T07:10:12.935Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/f6/68d91068048410f49794c0b19c45759c63ca559607068cfe5affba2f211b/winrt_windows_devices_enumeration-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:0da1ddb8285d97a6775c36265d7157acf1bbcb88bcc9a7ce9a4549906c822472", size = 145509, upload-time = "2025-09-20T07:10:13.797Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/a4/898951d5bfc474aa9c7d133fe30870f0f2184f4ba3027eafb779d30eb7bc/winrt_windows_devices_enumeration-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:09bf07e74e897e97a49a9275d0a647819254ddb74142806bbbcf4777ed240a22", size = 141334, upload-time = "2025-09-20T07:10:14.637Z" },
+]
+
+[[package]]
+name = "winrt-windows-devices-radios"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5e/02/9704ea359ad8b0d6faa1011f98fb477e8fb6eac5201f39d19e73c2407e7b/winrt_windows_devices_radios-3.2.1.tar.gz", hash = "sha256:4dc9b9d1501846049eb79428d64ec698d6476c27a357999b78a8331072e18a0b", size = 5908, upload-time = "2025-06-06T14:41:44.868Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/a0/4a8b51da15de218cec04bcc1cd85b4b93bcfd8ebe50a5f0a7eee28836dc6/winrt_windows_devices_radios-3.2.1-cp311-cp311-win32.whl", hash = "sha256:7c02790472414b6cda00d24a8cd23bca18e4b7474ddad4f9264f4484b891807e", size = 38505, upload-time = "2025-06-06T07:07:59.204Z" },
+    { url = "https://files.pythonhosted.org/packages/de/49/ba69e3180585dbc6f3336a09fef7cba4558a6a1e7d500500f62c1478418e/winrt_windows_devices_radios-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:f87745486d313ba1e7562ca97f25ad436ec01ad4b3b9ea349fb6b6f25cb41104", size = 40157, upload-time = "2025-06-06T07:07:59.948Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/92/64817f71a20ecf842da36dc3848f42614217688137a69c93fda8a6103155/winrt_windows_devices_radios-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:6cee6f946ff3a3571850d1ca745edaee7c331d06ca321873e650779654effc4a", size = 36976, upload-time = "2025-06-06T07:08:00.719Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/e0/4731a3c412318b2c5e74a8803a32e2fb9afc2c98368c6b61a422eb359e7e/winrt_windows_devices_radios-3.2.1-cp312-cp312-win32.whl", hash = "sha256:c3e683ce682338a5a5ed465f735e223ba7a22f16d0bbea2d070962bc7657edbb", size = 38606, upload-time = "2025-06-06T07:08:01.477Z" },
+    { url = "https://files.pythonhosted.org/packages/37/8e/91464854dfc9e0be9ce8dcbe2bd6a67c19b68ab91584fc5de0f4f13e78f8/winrt_windows_devices_radios-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:a116e552a3f38607b9be558fb2e7de9b4450d1f9080069944d74d80cdda1873e", size = 40172, upload-time = "2025-06-06T07:08:02.214Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/0d/1bd62f606b6c4dfa936fccc4712be5506a40fc5d1b7177c3d3cbcaf30972/winrt_windows_devices_radios-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:4c28822f9251c9d547324f596b5c2581f050254ded05e5b786c650a3502744c1", size = 36989, upload-time = "2025-06-06T07:08:03.295Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/94/c22a14fd424632f3f3c0b25672218db9e8f4ae9e1355e0b148f2fe6015b5/winrt_windows_devices_radios-3.2.1-cp313-cp313-win32.whl", hash = "sha256:ae4a0065927fcd2d10215223f8a46be6fb89bad71cb4edd25dae3d01c137b3a8", size = 38613, upload-time = "2025-06-06T07:08:04.077Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c1/24cec0cc228642554b48d436a7617d7162fb952919c55fc26e2d99c310bd/winrt_windows_devices_radios-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:bf1a975f46a2aa271ffea1340be0c7e64985050d07433e701343dddc22a72290", size = 40180, upload-time = "2025-06-06T07:08:04.849Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/d3/776453af26e78c0d0c0e1bfa89f86fd81322872f31a3e5dafb344dd47bf2/winrt_windows_devices_radios-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:10b298ed154c5824cea2de174afce1694ed2aabfb58826de814074027ffef96f", size = 36989, upload-time = "2025-06-06T07:08:05.576Z" },
+    { url = "https://files.pythonhosted.org/packages/76/79/4627afae6b389ddd1e5f1d691663c6b14d6c8f98959082aed1217cc57ef9/winrt_windows_devices_radios-3.2.1-cp314-cp314-win32.whl", hash = "sha256:21452e1cae50e44cd1d5e78159e1b9986ac3389b66458ad89caa196ce5eca2d6", size = 39521, upload-time = "2025-09-20T07:11:17.992Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/7c/c6aea91908ee7279ed51d12157bc8aeecb8850af2441073c3c91b261ad31/winrt_windows_devices_radios-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:6a8413e586fe597c6849607885cca7e0549da33ae5699165d11f7911534c6eaf", size = 41121, upload-time = "2025-09-20T07:11:18.747Z" },
+    { url = "https://files.pythonhosted.org/packages/86/c5/652f14e3c501452ad8e0723518d9bbd729219b47f4a4dbe2966c2f82dca8/winrt_windows_devices_radios-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:39129fd9d09103adb003575f59881c1a5a70a43310547850150b46c6f4020312", size = 38114, upload-time = "2025-09-20T07:11:19.599Z" },
+]
+
+[[package]]
+name = "winrt-windows-foundation"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/0c/55/098ce7ea0679efcc1298b269c48768f010b6c68f90c588f654ec874c8a74/winrt_windows_foundation-3.2.1.tar.gz", hash = "sha256:ad2f1fcaa6c34672df45527d7c533731fdf65b67c4638c2b4aca949f6eec0656", size = 30485, upload-time = "2025-06-06T14:41:53.344Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c0/36/09b9757f7cbf269e67008ea2ad188a44f974c94c9b49ebf0b52d1a8c4069/winrt_windows_foundation-3.2.1-cp311-cp311-win32.whl", hash = "sha256:d1b5970241ccd61428f7330d099be75f4f52f25e510d82c84dbbdaadd625e437", size = 111944, upload-time = "2025-06-06T07:10:58.496Z" },
+    { url = "https://files.pythonhosted.org/packages/05/a5/216d66df6bdcee58eb3877fabc1544337e23f850bf9f93838db7f5698371/winrt_windows_foundation-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:f3762be2f6e0f2aedf83a0742fd727290b397ffe3463d963d29211e4ebb53a7e", size = 118465, upload-time = "2025-06-06T07:10:59.678Z" },
+    { url = "https://files.pythonhosted.org/packages/be/ca/48ca8b5bc5be5c7a5516c9e1d9a21861b4217e1b4ee57923aab6f13fa411/winrt_windows_foundation-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:806c77818217b3476e6c617293b3d5b0ff8a9901549dc3417586f6799938d671", size = 109609, upload-time = "2025-06-06T07:11:00.54Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/f8/495e304ddedd5ff2f196efbde906265cb75ade4d79e2937837f72ef654a0/winrt_windows_foundation-3.2.1-cp312-cp312-win32.whl", hash = "sha256:867642ccf629611733db482c4288e17b7919f743a5873450efb6d69ae09fdc2b", size = 112169, upload-time = "2025-06-06T07:11:01.438Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/5e/b5059e4ece095351c496c9499783130c302d25e353c18031d5231b1b3b3c/winrt_windows_foundation-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:45550c5b6c2125cde495c409633e6b1ea5aa1677724e3b95eb8140bfccbe30c9", size = 118668, upload-time = "2025-06-06T07:11:02.475Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/70/acbcb3ef07b1b67e2de4afab9176a5282cfd775afd073efe6828dfc65ace/winrt_windows_foundation-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:94f4661d71cb35ebc52be7af112f2eeabdfa02cb05e0243bf9d6bd2cafaa6f37", size = 109671, upload-time = "2025-06-06T07:11:03.538Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/71/5e87131e4aecc8546c76b9e190bfe4e1292d028bda3f9dd03b005d19c76c/winrt_windows_foundation-3.2.1-cp313-cp313-win32.whl", hash = "sha256:3998dc58ed50ecbdbabace1cdef3a12920b725e32a5806d648ad3f4829d5ba46", size = 112184, upload-time = "2025-06-06T07:11:04.459Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7f/8d5108461351d4f6017f550af8874e90c14007f9122fa2eab9f9e0e9b4e1/winrt_windows_foundation-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:6e98617c1e46665c7a56ce3f5d28e252798416d1ebfee3201267a644a4e3c479", size = 118672, upload-time = "2025-06-06T07:11:05.55Z" },
+    { url = "https://files.pythonhosted.org/packages/44/f5/2edf70922a3d03500dab17121b90d368979bd30016f6dbca0d043f0c71f1/winrt_windows_foundation-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:2a8c1204db5c352f6a563130a5a41d25b887aff7897bb677d4ff0b660315aad4", size = 109673, upload-time = "2025-06-06T07:11:06.398Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/0a/d77346e39fe0c81f718cde49f83fe77c368c0e14c6418f72dfa1e7ef22d0/winrt_windows_foundation-3.2.1-cp314-cp314-win32.whl", hash = "sha256:35e973ab3c77c2a943e139302256c040e017fd6ff1a75911c102964603bba1da", size = 114590, upload-time = "2025-09-20T07:11:49.97Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/56/4d2b545bea0f34f68df6d4d4ca22950ff8a935497811dccdc0ca58737a05/winrt_windows_foundation-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:a22a7ebcec0d262e60119cff728f32962a02df60471ded8b2735a655eccc0ef5", size = 122148, upload-time = "2025-09-20T07:11:50.826Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ed/b9d3a11cac73444c0a3703200161cd7267dab5ab85fd00e1f965526e74a8/winrt_windows_foundation-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:3be7fbae829b98a6a946db4fbaf356b11db1fbcbb5d4f37e7a73ac6b25de8b87", size = 114360, upload-time = "2025-09-20T07:11:51.626Z" },
+]
+
+[[package]]
+name = "winrt-windows-foundation-collections"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ef/62/d21e3f1eeb8d47077887bbf0c3882c49277a84d8f98f7c12bda64d498a07/winrt_windows_foundation_collections-3.2.1.tar.gz", hash = "sha256:0eff1ad0d8d763ad17e9e7bbd0c26a62b27215016393c05b09b046d6503ae6d5", size = 16043, upload-time = "2025-06-06T14:41:53.983Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/87/b3/7e4a75c62e86bedf9458b7ec8dfed74cff3236e0b4b2288f95967d5cc4d2/winrt_windows_foundation_collections-3.2.1-cp311-cp311-win32.whl", hash = "sha256:9b272d9936e7db4840881c5dcf921eb26789ae4ef23fb6ec15e13e19a16254e7", size = 59693, upload-time = "2025-06-06T07:11:13.388Z" },
+    { url = "https://files.pythonhosted.org/packages/32/58/049db1d95fdfc0c8451dc6db17442ed4e6b2aba361c425c0bb8dc8c98c4a/winrt_windows_foundation_collections-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:c646a5d442dd6540ade50890081ca118b41f073356e19032d0a5d7d0d38fbc89", size = 70828, upload-time = "2025-06-06T07:11:14.54Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/6b/a04974f5555c86452e54c19d063d9fd45f0fe9f2a6858e7fe12c639043fb/winrt_windows_foundation_collections-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:2c4630027c93cdd518b0cf4cc726b8fbdbc3388e36d02aa1de190a0fc18ca523", size = 59051, upload-time = "2025-06-06T07:11:15.379Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/0b/7802349391466d3f7e8f62f588f36a1a0b6560abfcdbdaa426fe21d322b4/winrt_windows_foundation_collections-3.2.1-cp312-cp312-win32.whl", hash = "sha256:15704eef3125788f846f269cf54a3d89656fa09a1dc8428b70871f717d595ad6", size = 60060, upload-time = "2025-06-06T07:11:16.173Z" },
+    { url = "https://files.pythonhosted.org/packages/37/94/5b888713e472746635a382e523513ab1b8200af55c5b56bc70e1e4369115/winrt_windows_foundation_collections-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:550dfb8c82fe74d9e0728a2a16a9175cc9e34ca2b8ef758d69b2a398894b698b", size = 69058, upload-time = "2025-06-06T07:11:17.009Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/3c/829273622c9b37c67b97f187b92be318404f7d33db045e31d72b7d50f54c/winrt_windows_foundation_collections-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:810ad4bd11ab4a74fdbcd3ed33b597ef7c0b03af73fc9d7986c22bcf3bd24f84", size = 58793, upload-time = "2025-06-06T07:11:17.837Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/cd/99ef050d80bea2922fa1ded93e5c250732634095d8bd3595dd808083e5ca/winrt_windows_foundation_collections-3.2.1-cp313-cp313-win32.whl", hash = "sha256:4267a711b63476d36d39227883aeb3fb19ac92b88a9fc9973e66fbce1fd4aed9", size = 60063, upload-time = "2025-06-06T07:11:18.65Z" },
+    { url = "https://files.pythonhosted.org/packages/94/93/4f75fd6a4c96f1e9bee198c5dc9a9b57e87a9c38117e1b5e423401886353/winrt_windows_foundation_collections-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:5e12a6e75036ee90484c33e204b85fb6785fcc9e7c8066ad65097301f48cdd10", size = 69057, upload-time = "2025-06-06T07:11:19.446Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/de47ccc390017ec5575e7e7fd9f659ee3747c52049cdb2969b1b538ce947/winrt_windows_foundation_collections-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:34b556255562f1b36d07fba933c2bcd9f0db167fa96727a6cbb4717b152ad7a2", size = 58792, upload-time = "2025-06-06T07:11:20.24Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/47/b3301d964422d4611c181348149a7c5956a2a76e6339de451a000d4ae8e7/winrt_windows_foundation_collections-3.2.1-cp314-cp314-win32.whl", hash = "sha256:33188ed2d63e844c8adfbb82d1d3d461d64aaf78d225ce9c5930421b413c45ab", size = 62211, upload-time = "2025-09-20T07:11:52.411Z" },
+    { url = "https://files.pythonhosted.org/packages/20/59/5f2c940ff606297129e93ebd6030c813e6a43a786de7fc33ccb268e0b06b/winrt_windows_foundation_collections-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:d4cfece7e9c0ead2941e55a1da82f20d2b9c8003bb7a8853bb7f999b539f80a4", size = 70399, upload-time = "2025-09-20T07:11:53.254Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/2d/2c8eb89062c71d4be73d618457ed68e7e2ba29a660ac26349d44fc121cbf/winrt_windows_foundation_collections-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:3884146fea13727510458f6a14040b7632d5d90127028b9bfd503c6c655d0c01", size = 61392, upload-time = "2025-09-20T07:11:53.993Z" },
+]
+
+[[package]]
+name = "winrt-windows-storage-streams"
+version = "3.2.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "winrt-runtime" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/00/50/f4488b07281566e3850fcae1021f0285c9653992f60a915e15567047db63/winrt_windows_storage_streams-3.2.1.tar.gz", hash = "sha256:476f522722751eb0b571bc7802d85a82a3cae8b1cce66061e6e758f525e7b80f", size = 34335, upload-time = "2025-06-06T14:43:23.905Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/60/a9e0dc03434aa29e6b5c83067e988cd5934adf830cd9f87cbbc06569ca32/winrt_windows_storage_streams-3.2.1-cp311-cp311-win32.whl", hash = "sha256:7dace2f9e364422255d0e2f335f741bfe7abb1f4d4f6003622b2450b87c91e69", size = 127509, upload-time = "2025-06-06T14:01:58.971Z" },
+    { url = "https://files.pythonhosted.org/packages/23/98/6c9c21b5e75ff5927a130da9eaf5ab628dfa1f93b64c181f0193706cbd6c/winrt_windows_storage_streams-3.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:b02fa251a7eef6081eca1a5f64ecf349cfd1ac0ac0c5a5a30be52897d060bed5", size = 132491, upload-time = "2025-06-06T14:01:59.788Z" },
+    { url = "https://files.pythonhosted.org/packages/38/ca/d0a02045d445cbf1029d65f01b487fdded5b333c0367a8bae0565b3def00/winrt_windows_storage_streams-3.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:efdf250140340a75647e8e8ad002782d91308e9fdd1e19470a5b9cc969ae4780", size = 128577, upload-time = "2025-06-06T14:02:00.623Z" },
+    { url = "https://files.pythonhosted.org/packages/87/e7/7d3f2a4a442f264e05cab2bdf20ed1b95cb3f753bd1b0f277f2b49fb8335/winrt_windows_storage_streams-3.2.1-cp312-cp312-win32.whl", hash = "sha256:77c1f0e004b84347b5bd705e8f0fc63be8cd29a6093be13f1d0869d0d97b7d78", size = 127787, upload-time = "2025-06-06T14:02:02.277Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/2f/cc36f475f8af293f40e2c2a5d6c2e75a189c2c2d4d01ecb3551578518c79/winrt_windows_storage_streams-3.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:e4508ee135af53e4fc142876abbf4bc7c2a95edfc7d19f52b291a8499cacd6dc", size = 131849, upload-time = "2025-06-06T14:02:03.09Z" },
+    { url = "https://files.pythonhosted.org/packages/94/84/896fb734f7456910ec412f3f3adfdc3f0dc3134864a496d5b120592f3bfd/winrt_windows_storage_streams-3.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:040cb94e6fb26b0d00a00e8b88b06fadf29dfe18cf24ed6cb3e69709c3613307", size = 128144, upload-time = "2025-06-06T14:02:03.946Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/d2/24d9f59bdc05e741261d5bec3bcea9a848d57714126a263df840e2b515a8/winrt_windows_storage_streams-3.2.1-cp313-cp313-win32.whl", hash = "sha256:401bb44371720dc43bd1e78662615a2124372e7d5d9d65dfa8f77877bbcb8163", size = 127774, upload-time = "2025-06-06T14:02:04.752Z" },
+    { url = "https://files.pythonhosted.org/packages/15/59/601724453b885265c7779d5f8025b043a68447cbc64ceb9149d674d5b724/winrt_windows_storage_streams-3.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:202c5875606398b8bfaa2a290831458bb55f2196a39c1d4e5fa88a03d65ef915", size = 131827, upload-time = "2025-06-06T14:02:05.601Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/c2/a419675a6087c9ea496968c9b7805ef234afa585b7483e2269608a12b044/winrt_windows_storage_streams-3.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:ca3c5ec0aab60895006bf61053a1aca6418bc7f9a27a34791ba3443b789d230d", size = 128180, upload-time = "2025-06-06T14:02:06.759Z" },
+    { url = "https://files.pythonhosted.org/packages/55/70/2869ea2112c565caace73c9301afd1d7afcc49bdd37fac058f0178ba95d4/winrt_windows_storage_streams-3.2.1-cp314-cp314-win32.whl", hash = "sha256:5cd0dbad86fcc860366f6515fce97177b7eaa7069da261057be4813819ba37ee", size = 131701, upload-time = "2025-09-20T07:17:16.849Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/3d/aae50b1d0e37b5a61055759aedd42c6c99d7c17ab8c3e568ab33c0288938/winrt_windows_storage_streams-3.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:3c5bf41d725369b9986e6d64bad7079372b95c329897d684f955d7028c7f27a0", size = 135566, upload-time = "2025-09-20T07:17:17.69Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/c3/6d3ce7a58e6c828e0795c9db8790d0593dd7fdf296e513c999150deb98d4/winrt_windows_storage_streams-3.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:293e09825559d0929bbe5de01e1e115f7a6283d8996ab55652e5af365f032987", size = 134393, upload-time = "2025-09-20T07:17:18.802Z" },
+]