diff --git a/.dockerignore b/.dockerignore index 1f6292b..9512f3e 100644 --- a/.dockerignore +++ b/.dockerignore @@ -9,4 +9,10 @@ uv.lock dist/ scripts/ -*__pycache__/ \ No newline at end of file +*__pycache__/ +.venv/ +.pytest_cache/ +.ruff_cache/ +.github/ +benchmarks/ +tests/ diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml new file mode 100644 index 0000000..6dc2f87 --- /dev/null +++ b/.github/workflows/ci.yml @@ -0,0 +1,72 @@ +name: CI + +on: + push: + branches: [main, develop] + pull_request: + workflow_dispatch: + +permissions: + contents: read + +jobs: + lint: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: astral-sh/setup-uv@v8.3.0 + with: + enable-cache: true + - run: uv sync --locked --all-extras + - run: uv run ruff check . + + test: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + python-version: ["3.11", "3.12", "3.13", "3.14"] + steps: + - uses: actions/checkout@v7 + - uses: astral-sh/setup-uv@v8.3.0 + with: + enable-cache: true + python-version: ${{ matrix.python-version }} + - run: uv sync --locked --all-extras + - run: uv run pytest -q + + build: + needs: [lint, test] + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + - uses: astral-sh/setup-uv@v8.3.0 + with: + enable-cache: true + - run: uv build + + # Bumps the version (via python-semantic-release, reading conventional + # commits since the last tag), pushes the version/changelog commit and + # tag, and creates a GitHub release with the built wheel and sdist. + # main produces releases; develop produces -rc.N prereleases. Runs after + # lint+test+build so nothing broken gets tagged. Not published to PyPI. + release: + needs: [lint, test, build] + if: github.event_name == 'push' || github.event_name == 'workflow_dispatch' + runs-on: ubuntu-latest + concurrency: release + permissions: + contents: write + steps: + - uses: actions/checkout@v7 + with: + fetch-depth: 0 + ref: ${{ github.ref_name }} + - uses: astral-sh/setup-uv@v8.3.0 + with: + enable-cache: true + + - name: Release + run: uv run --group release semantic-release version + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/.gitignore b/.gitignore index 9a5b45b..8924d97 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ poetry.lock -uv.lock dist/ -*__pycache__/ \ No newline at end of file +*__pycache__/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..d88f97c --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,14 @@ +exclude: ^(tests/lcmtypes/|lcm_websocket_server/lib/lcm_utils/channel_stats(_list)?\.py$) +repos: + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.17.6 + hooks: + - id: ruff-check + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v5.0.0 + hooks: + - id: check-added-large-files + - id: check-toml + - id: check-yaml + - id: end-of-file-fixer + - id: trailing-whitespace diff --git a/README.md b/README.md index 9ab8002..aba334c 100644 --- a/README.md +++ b/README.md @@ -18,12 +18,15 @@ pip install lcm-websocket-server pip install . ``` -Or with the `image` extension: +Or with optional extras: ```bash -pip install ".[image]" +pip install ".[image]" # Dial proxy (OpenCV) +pip install ".[orjson,uvloop]" # faster JSON encoding and event loop ``` +See [Development](#wrench-development) for working on the project itself. + ## :rocket: Usage > [!TIP] @@ -33,7 +36,7 @@ pip install ".[image]" #### JSON Proxy -The `lcm-websocket-json-proxy` command can be used to run a server that republishes LCM messages as JSON over a WebSocket connection. +The `lcm-websocket-json-proxy` command can be used to run a server that republishes LCM messages as JSON over a WebSocket connection. > [!NOTE] > The `lcm-websocket-server` command has been renamed to `lcm-websocket-json-proxy`. The old name is still available for backwards compatibility, but it is recommended to use the new name. @@ -47,15 +50,32 @@ The `lcm_packages` argument is the name of the package (or comma-separated list #### Tuning Options -Both proxy commands accept optional tuning flags: +Both proxy commands accept these options: | Flag | Default | Description | |------|---------|-------------| | `--queue-size N` | 64 | Max messages buffered per connection before the oldest are dropped | -| `--poll-interval S` | 0.1 | Sleep duration (seconds) when the message queue is empty | | `--spy-interval S` | 1.0 | LCM spy stats emission interval (seconds) | +| `--compression {deflate,none}` | `deflate` (JSON), `none` (Dial) | WebSocket permessage-deflate. Saves bandwidth for JSON on slow links at a CPU cost per client; useless for JPEG | +| `--uvloop` | off | Use the uvloop event loop (requires the `uvloop` extra) | +| `--processes N` | 1 | Run N server processes on the same port (`SO_REUSEPORT`) to use more than one core | +| `--ping-interval S` | 20 | Seconds between WebSocket keepalive pings (0 disables) | +| `--ping-timeout S` | 20 | Seconds to wait for a pong before closing (0 disables) | + +The Dial proxy also accepts: + +| Flag | Default | Description | +|------|---------|-------------| +| `--max-fps F` | no cap | Max transcoded frames per second per image channel | +| `--image-workers N` | min(8, cores) | Threads for image transcoding | + +Delivery is event-driven; `--poll-interval` is accepted for compatibility but ignored. -Increase `--queue-size` if you see drop warnings in the logs and your consumer can tolerate a larger backlog. Decrease `--poll-interval` for lower latency at the cost of slightly higher CPU use. +If drop warnings appear in the logs, the client is not keeping up. Options: connect with `?conflate=1` (see below), increase `--queue-size`, or subscribe to fewer channels. + +Each message is encoded once and shared by all clients. Encoding runs in worker threads: JSON on a small pool and images on a separate pool, so image bursts do not delay JSON. One process is bound to roughly one core for JSON work; with `--processes N` each process has its own LCM subscription, encode cache and spy statistics. + +For faster JSON encoding, install the `orjson` extra (about 2x faster than the standard library path). **Example: `compas_lcmtypes`** @@ -91,7 +111,7 @@ To run the server locally on port 8765 and republish messages on all channels (J lcm-websocket-dial-proxy --host localhost --port 8765 --channel '.*' --quality 75 --scale 1.0 ``` -The Dial proxy depends on the `molars-lcmtypes` Python package to be installed. This package is not available on PyPI, so it must be built and installed manually; see the [MolaRS repository](https://github.com/CoMPASLab/molars/) for more info. +The Dial proxy depends on the `molars-lcmtypes` Python package to be installed. This package is not available on PyPI, so it must be built and installed manually; see the [MolaRS repository](https://github.com/CoMPASLab/molars/) for more info. The `Dockerfile.dial` file can be used to build the image with the `molars-lcmtypes` package installed. For this, the Python wheel `molars_lcmtypes-0.0.0-py3-none-any.whl` must be placed at the repository root before building the image. @@ -114,18 +134,31 @@ Clients can specify an optional `update_interval_ms` query parameter in the WebS const ws = new WebSocket('ws://localhost:8765/.*?update_interval_ms=500'); ``` -This will cause the latest message for each subscribed channel to be sent to the client every 500 milliseconds. +This will cause the latest message for each subscribed channel to be sent to the client every 500 milliseconds. Between ticks only the latest message per channel is kept, so low-rate channels are never crowded out by high-rate ones. + +#### Conflation + +By default each connection buffers up to `--queue-size` messages and drops the oldest when full, regardless of channel. A client that cannot keep up with every message can instead request only the latest message per channel: +```javascript +const ws = new WebSocket('ws://localhost:8765/.*?conflate=1'); +``` + +Messages are still delivered as soon as possible, but a busy channel can no longer evict a quiet one. + +#### Invalid Requests + +A connection with an invalid channel regex (or one longer than 1024 characters) or an invalid `update_interval_ms` is closed with code 1008 (policy violation) and a reason describing the problem. ## :bar_chart: LCM Spy Virtual Channel -The server provides a **virtual channel** called `LWS_LCM_SPY` that publishes per-channel statistics at 1 Hz on a per-connection basis. Each WebSocket client gets its own stats stream, computed from live traffic observed during that connection. +The server provides a **virtual channel** called `LWS_LCM_SPY` that publishes per-channel statistics at 1 Hz (`--spy-interval`) to every client whose channel regex matches it. Statistics are counted once per message for all traffic the server receives, independent of any client's queue. Each client's view starts when it connects: message counts are since connect, and channels appear once they have received a message since then. ### Channel Statistics The virtual channel publishes a `channel_stats_list` message containing statistics for each active channel: - **Hz**: Message frequency - **Bandwidth**: Bytes per second -- **Jitter**: Variation in message intervals +- **Jitter**: Spread (max - min) of inter-arrival intervals over the last spy interval - **Message count**: Total messages received - **Undecodable count**: Messages that couldn't be decoded @@ -138,7 +171,7 @@ Connect to the spy channel using the channel name in the WebSocket path: const ws = new WebSocket('ws://localhost:8765/LWS_LCM_SPY'); ws.onmessage = (ev) => { - const stats = JSON.parse(ev.event); + const stats = JSON.parse(ev.data).event; console.log('Channel stats:', stats.channels); }; ``` @@ -158,6 +191,41 @@ A Python example client is provided in `examples/spy_client.py`: python examples/spy_client.py --host localhost --port 8765 ``` +## :satellite: Deployment + +### Monitoring + +Plain HTTP requests to the server port answer two endpoints (WebSocket connections on any path are unaffected): + +- `GET /healthz` returns `ok`. +- `GET /metrics` returns Prometheus text: connected clients, LCM messages received, frames and bytes sent, messages dropped from full client queues, encode counts, errors and time, and worst event-loop lag since the last scrape. + +A rising `lws_dropped_total` means clients are not keeping up. A sustained `lws_event_loop_lag_max_seconds` above roughly 50 ms means the process is saturated; use `--processes` or reduce load. + +### LCM receive buffers + +LCM messages dropped by the kernel never reach the server, so they appear in neither the logs, `/metrics`, nor the spy channel. Large or bursty traffic (especially images) needs larger UDP receive buffers than Linux defaults: + +```bash +sudo sysctl -w net.core.rmem_max=16777216 net.core.rmem_default=16777216 +export LCM_DEFAULT_URL="udpm://239.255.76.67:7667?ttl=0&recv_buf_size=16777216" +``` + +Persist the `sysctl` settings in `/etc/sysctl.d/`. Check for drops with `netstat -su` (`RcvbufErrors`). + +### Matching the link + +- **Local network**: compression off for best CPU efficiency. +- **Constrained links (e.g. ship to shore)**: keep `--compression deflate` for JSON; for Dial use `--scale`, `--quality` and `--max-fps` to cut image bandwidth, and raise `--ping-timeout` if large frames can take longer than 20 s to send. Clients that do not need every message should connect with `?conflate=1` or `?update_interval_ms=`. + +### Scaling + +One process handles about 100 JSON clients at 1.2 k msg/s (see [benchmarks](benchmarks/README.md)). Beyond that, `--processes N` adds cores. Each process has its own LCM subscription and encode cache, so image transcoding is repeated per process: keep the Dial proxy at one process and run a separate JSON proxy for large numbers of JSON clients. + +### Security + +The server has no authentication or encryption. When it is reachable beyond a trusted vehicle network, put it behind a reverse proxy that terminates TLS (`wss://`) and enforces access control. + ## :whale: Docker ### Build @@ -190,6 +258,25 @@ docker run \ Note that the `HOST`, `PORT`, and `CHANNEL` environment variables specified above are the defaults for the `mbari/lcm-websocket-server` image. These can be omitted if the defaults are acceptable. +Extra command-line flags can be passed with the `ARGS` environment variable, e.g. `-e ARGS="--uvloop --processes 4 -vv"`. The image includes the `orjson` and `uvloop` extras and a `HEALTHCHECK` that polls `/healthz`; if `HOST` is set to an address other than `0.0.0.0` or `127.0.0.1`, the health check cannot reach it. + The `LCM_PACKAGES` environment variable should be set to the name of the package (or comma-separated list of packages) that contains the LCM Python message definitions. The `/app` directory is included in the `PYTHONPATH` so that any packages mounted there (as shown with `-v` above) can be imported. It's recommended to run with `--network=host` to avoid issues with LCM over UDP. This will allow the container to use the host's network stack. + +## :wrench: Development + +```bash +uv sync --all-extras +uv run pre-commit install # ruff and file hygiene hooks on commit +uv run pytest +uv run ruff check . +``` + +The tests are self-contained: they use LCM types vendored in `tests/lcmtypes` and the in-process `memq://` LCM provider, so no LCM network or MolaRS install is needed. CI runs lint and tests on Python 3.11 to 3.14. + +Before a release, run the load benchmarks and compare against [benchmarks/README.md](benchmarks/README.md) to catch performance regressions. They need the full CoMPAS LCM types on `PYTHONPATH`: + +```bash +uv run python benchmarks/load.py all +``` diff --git a/benchmarks/README.md b/benchmarks/README.md new file mode 100644 index 0000000..329c309 --- /dev/null +++ b/benchmarks/README.md @@ -0,0 +1,47 @@ +# Benchmarks + +Load and microbenchmarks used to characterize the server under load. + +Both scripts need the CoMPAS LCM Python types (`stdlcm`, `senlcm`, `navlcm`, `geolcm`) on `PYTHONPATH`. + +```bash +export PYTHONPATH=/path/to/lcmtypes/python +uv run python benchmarks/load.py all # or: latency, json-scale, json-rate, dial, slow, periodic +uv run python benchmarks/encode.py +``` + +## `load.py` + +Runs the real `LCMWebSocketServer` in one process. Threads stand in for the LCM thread by calling `LCMRepublisher.inject()` at fixed rates, so UDP and the LCM C library are not exercised. Clients run in 8 worker processes over loopback. + +Default workload: 10 `odometry_t` channels at 100 Hz plus a 512-beam `multibeam_euclidean_t` at 20 Hz (1.22 k msg/s). Dial scenarios add a 2048x1536 Bayer `image_t` at 10 Hz. + +Reported per scenario: + +| Field | Meaning | +|---|---| +| `srvCPU` | Server process CPU over the window (100% = one core) | +| `deliv` | Non-image messages received per client as % of published | +| `lat` | Publish-to-receive latency from the `header_t` timestamp | +| `loopLag` | Worst event-loop stall seen by a 10 ms probe | +| `injLate` | Times the simulated LCM thread fell behind schedule | +| `dropWarn` | Queue-overflow warnings logged | +| `encodes/frame` | JPEG encodes per published image (1.00 = fully shared) | +| `spy-reported Hz` | Rates from `LWS_LCM_SPY`, to check against the source | + +## Results + +Deucalion (24 cores), Python 3.13, websockets 17.4, orjson installed. Baseline is v0.8.0 with default flags. + +| Scenario | v0.8.0 | Now | +|---|---|---| +| JSON, 1 client | 66% delivered, p50 32 ms | 100%, p50 0.5 ms | +| JSON, 50 clients | 36%, CPU 112% | 99.9%, CPU 76% | +| JSON, 100 clients, compression on | 9% | 92% | +| JSON, 100 clients, compression off | 12% | 100%, p50 4.4 ms | +| JSON, 10 clients at 10 k msg/s | 2.8% | 38% (one core saturated) | +| Dial, 10 clients, image encodes per frame | 9.3 | 1.00 | +| Dial, 10 clients, CPU (compression off) | 162% | 42% | +| Spy Hz for a 100 Hz channel (streaming / periodic) | 64 / 12 | 100 / 100 | + +Beyond about 100 JSON clients or 10 k msg/s, one process is GIL-bound; use `--processes N`. diff --git a/benchmarks/encode.py b/benchmarks/encode.py new file mode 100644 index 0000000..0dd454f --- /dev/null +++ b/benchmarks/encode.py @@ -0,0 +1,38 @@ +""" +Microbenchmark of JSONHandler.handle (decode + JSON encode) on the stdlib +and orjson paths. + +Usage (requires stdlcm/senlcm/navlcm/geolcm on PYTHONPATH): + uv run python benchmarks/encode.py +""" +import time + +from geolcm import point_t +from lcmutils import LCMTypeRegistry +from navlcm import odometry_t +from senlcm import multibeam_euclidean_t +from stdlcm import header_t + +from lcm_websocket_server.apps.json_proxy import JSONHandler +from lcm_websocket_server.lib.lcm_utils import types as T + +reg = LCMTypeRegistry() +for p in ("stdlcm", "senlcm", "navlcm", "geolcm"): reg.discover(p) +hdr = header_t(); hdr.frame_id = "base" +odo = odometry_t(); odo.header = hdr +mb = multibeam_euclidean_t(); mb.header = hdr; mb.n_beams = 512 +mb.flags = [0]*512; mb.range = [point_t() for _ in range(512)]; mb.intensity = [float(i) for i in range(512)] +h = JSONHandler(reg) +def bench(fn, n): + fn(); t = time.perf_counter() + for _ in range(n): fn() + return (time.perf_counter() - t) / n * 1e6 +orj = T.orjson +if orj is None: + print("orjson not installed; orjson column repeats stdlib") +for name, data, n in (("odometry_t", odo.encode(), 20000), ("multibeam n=512", mb.encode(), 1000)): + T.orjson = None + a = bench(lambda data=data: h.handle("C", data), n) + T.orjson = orj + b = bench(lambda data=data: h.handle("C", data), n) + print(f"{name:<18} stdlib {a:8.1f} us orjson {b:8.1f} us") diff --git a/benchmarks/load.py b/benchmarks/load.py new file mode 100644 index 0000000..0c4bc5c --- /dev/null +++ b/benchmarks/load.py @@ -0,0 +1,366 @@ +""" +End-to-end load harness for lcm-websocket-server. + +The server runs in its own process with the real LCMWebSocketServer and +handlers. Threads stand in for the LCM thread by calling +LCMRepublisher.inject() at fixed rates (serialised through a lock, as the +single LCM thread would be); UDP and the LCM C library are bypassed. +Clients run in separate worker processes and report delivered frames, +end-to-end latency (from the header_t timestamp stamped at publish) and the +spy channel's reported rates. + +Usage (requires stdlcm/senlcm/navlcm/geolcm on PYTHONPATH): + uv run python benchmarks/load.py SUITE [--duration S] + +Suites: latency, json-scale, json-rate, dial, slow, periodic, all +""" + +import argparse +import json +import multiprocessing as mp +import os +import re +import struct +import threading +import time + +TS_RE = re.compile(rb'"timestamp": ?(\d+)') +CHANNEL_RE = re.compile(r'"channel": ?"([^"]+)"') +SPY = "LWS_LCM_SPY" + + +# ----------------------------------------------------------------- server +def _cpu_seconds() -> float: + t = os.times() + return t.user + t.system + + +def _message_builders(): + import numpy as np + from geolcm import point_t + from navlcm import odometry_t + from senlcm import image_t, multibeam_euclidean_t + from stdlcm import header_t + + from lcm_websocket_server.lib.image import PixelFormat + + def header(ts): + h = header_t() + h.timestamp = ts + h.frame_id = "base" + return h + + def odo(ts): + m = odometry_t() + m.header = header(ts) + return m.encode() + + mb_msg = multibeam_euclidean_t() + mb_msg.n_beams = 512 + mb_msg.flags = [0] * 512 + mb_msg.range = [point_t() for _ in range(512)] + mb_msg.intensity = [float(i) for i in range(512)] + + def mb(ts): + mb_msg.header = header(ts) + return mb_msg.encode() + + # Semi-realistic Bayer frame: smooth gradient plus mild noise. + h, w = 1536, 2048 + yy, xx = np.mgrid[0:h, 0:w] + base = ((xx // 8 + yy // 8) % 256).astype(np.uint8) + rng = np.random.default_rng(0) + frames = [(base + rng.integers(0, 12, (h, w), dtype=np.uint8)).tobytes() for _ in range(4)] + counter = [0] + + def img(ts): + m = image_t() + m.header = header(ts) + m.width, m.height = w, h + m.pixelformat = PixelFormat.BAYER_RGGB.value + m.nmetadata, m.metadata = 0, [] + m.data = frames[counter[0] % 4] + m.size = len(m.data) + counter[0] += 1 + return m.encode() + + return {"odo": odo, "mb": mb, "img": img} + + +def run_server(port, mode, server_kwargs, streams, ready, go, window_end, stop, out_q): + import asyncio + import logging + + import cv2 + + from lcm_websocket_server.apps.dial_proxy import ( + DialHandler, + DownsamplingMJPEGEncoder, + ImageMessageToJPEGHandler, + ) + from lcm_websocket_server.apps.json_proxy import JSONHandler + from lcm_websocket_server.lib.cli import build_registry + from lcm_websocket_server.lib.lcm_utils import pubsub + from lcm_websocket_server.lib.log import set_stream_handler_verbosity + from lcm_websocket_server.lib.server import LCMWebSocketServer + + set_stream_handler_verbosity(0) + drops = {"n": 0} + + class DropCounter(logging.Handler): + def emit(self, record): + drops["n"] += 1 + + pubsub._logger.addHandler(DropCounter()) + + registry = build_registry(["stdlcm", "senlcm", "navlcm", "geolcm"], logging.getLogger("bench")) + json_handler = JSONHandler(registry) + if mode == "dial": + encoder = DownsamplingMJPEGEncoder(scale=1.0, params=[cv2.IMWRITE_JPEG_QUALITY, 75]) + inner = DialHandler(ImageMessageToJPEGHandler(encoder), json_handler) + else: + inner = json_handler + + encodes = {"image": 0, "other": 0} + + class CountingHandler(type(inner)): + def __init__(self): + self.__dict__.update(inner.__dict__) + + def handle(self, channel, data): + encodes["image" if self.is_heavy(channel, data) else "other"] += 1 + return super().handle(channel, data) + + republisher = pubsub.LCMRepublisher(".*") # never started; fed by inject() + lcm_lock = threading.Lock() + builders = _message_builders() + injected = {"n": 0, "late": 0, "image": 0} + + def injector(kind, channel, hz): + period = 1.0 / hz + nxt = time.perf_counter() + while not stop.is_set(): + data = builders[kind](time.time_ns() // 1000) + with lcm_lock: + republisher.inject(channel, data) + injected["n"] += 1 + injected["image"] += kind == "img" + nxt += period + delay = nxt - time.perf_counter() + if delay > 0: + time.sleep(delay) + else: + injected["late"] += 1 + nxt = time.perf_counter() + + server = LCMWebSocketServer( + "127.0.0.1", port, CountingHandler(), republisher, spy_registry=registry, **server_kwargs + ) + + async def main(): + lag = {"max": 0.0} + + async def lag_probe(): + while True: + t0 = time.perf_counter() + await asyncio.sleep(0.01) + lag["max"] = max(lag["max"], time.perf_counter() - t0 - 0.01) + + serve_task = asyncio.create_task(server.serve()) + probe = asyncio.create_task(lag_probe()) + await asyncio.sleep(0.3) + ready.set() + while not go.is_set(): + await asyncio.sleep(0.01) + for s in streams: + threading.Thread(target=injector, args=s, daemon=True).start() + c0, t0 = _cpu_seconds(), time.perf_counter() + lag["max"] = 0.0 + while not window_end.is_set(): + await asyncio.sleep(0.01) + c1, t1 = _cpu_seconds(), time.perf_counter() + out_q.put({ + "cpu_pct": 100 * (c1 - c0) / (t1 - t0), + "injected": injected["n"], + "injected_images": injected["image"], + "late": injected["late"], + "encodes": dict(encodes), + "drop_warnings": drops["n"], + "loop_lag_max_ms": 1000 * lag["max"], + }) + out_q.close() + out_q.join_thread() + while not stop.is_set(): + await asyncio.sleep(0.05) + server.close() + probe.cancel() + serve_task.cancel() + os._exit(0) # skip interpreter teardown of daemon threads + + asyncio.run(main()) + + +# ----------------------------------------------------------------- clients +def run_clients(port, n, path, duration, out_q, barrier, stall_first, compression): + import asyncio + + import websockets + + async def one(i, start): + stall = stall_first and i == 0 + st = {"frames": 0, "bytes": 0, "lat": [], "img": 0, "imglat": [], "chan": {}, "spyhz": {}, "stalled": stall} + kwargs = {} if compression else {"compression": None} + async with websockets.connect(f"ws://127.0.0.1:{port}/{path}", max_size=None, **kwargs) as ws: + await start.wait() + end = time.perf_counter() + duration + while (remaining := end - time.perf_counter()) > 0: + try: + m = await asyncio.wait_for(ws.recv(), remaining) + except TimeoutError: + break + now = time.time_ns() // 1000 + if stall: + await asyncio.sleep(1.0) # pathological slow consumer + st["frames"] += 1 + st["bytes"] += len(m) + if isinstance(m, bytes): + st["img"] += 1 + st["imglat"].append(now - struct.unpack(">q", m[12:20])[0]) + continue + channel = CHANNEL_RE.search(m[:64]).group(1) + if channel == SPY: + if i == 1: + for c in json.loads(m)["event"]["channels"]: + st["spyhz"].setdefault(c["channel"], []).append(c["hz"]) + continue + st["chan"][channel] = st["chan"].get(channel, 0) + 1 + ts = TS_RE.search(m[:400].encode()) + if ts: + st["lat"].append(now - int(ts.group(1))) + return st + + async def main(): + start = asyncio.Event() + tasks = [asyncio.create_task(one(i, start)) for i in range(n)] + await asyncio.sleep(1.0) # let all connect + await asyncio.get_running_loop().run_in_executor(None, barrier.wait) + start.set() + out_q.put(await asyncio.gather(*tasks)) + + asyncio.run(main()) + + +# ----------------------------------------------------------------- driver +def pct(values, p): + if not values: + return float("nan") + values = sorted(values) + return values[min(len(values) - 1, int(p / 100 * len(values)))] + + +def scenario(name, mode, streams, clients, path=".*", duration=6.0, compression=True, stall_first=False, procs=8): + port = 20000 + (os.getpid() + int(time.time())) % 20000 + ready, go, window_end, stop = mp.Event(), mp.Event(), mp.Event(), mp.Event() + server_q, client_q = mp.Queue(), mp.Queue() + server_kwargs = {"compression": "deflate" if compression else None} + sp = mp.Process(target=run_server, args=(port, mode, server_kwargs, streams, ready, go, window_end, stop, server_q)) + sp.start() + ready.wait(60) + + procs = max(1, min(procs, clients)) + per_proc = [clients // procs + (1 if i < clients % procs else 0) for i in range(procs)] + barrier = mp.Barrier(procs + 1) + cps = [ + mp.Process(target=run_clients, args=(port, k, path, duration, client_q, barrier, stall_first and j == 0, compression)) + for j, k in enumerate(per_proc) + ] + for c in cps: + c.start() + barrier.wait(60) + go.set() + time.sleep(duration) + window_end.set() + srv = server_q.get(timeout=30) + res = [] + for _ in cps: + res.extend(client_q.get(timeout=duration + 60)) + stop.set() + for c in cps: + c.join() + sp.join(10) + + healthy = [r for r in res if not r["stalled"]] + non_image_hz = sum(h for kind, _, h in streams if kind != "img") + expected = non_image_hz * duration + deliv = [sum(r["chan"].values()) / expected * 100 for r in healthy] + lat = [x for r in healthy for x in r["lat"]] + print( + f"{name:<40} clients={clients:<4} cmp={'on ' if compression else 'off'} " + f"srvCPU={srv['cpu_pct']:5.0f}% deliv avg={sum(deliv)/len(deliv):5.1f}% min={min(deliv):5.1f}% " + f"lat p50={pct(lat, 50)/1000:6.1f}ms p99={pct(lat, 99)/1000:6.1f}ms " + f"MB/s={sum(r['bytes'] for r in res)/duration/1e6:6.1f} loopLag={srv['loop_lag_max_ms']:4.0f}ms " + f"injLate={srv['late']} dropWarn={srv['drop_warnings']}", + flush=True, + ) + if srv["injected_images"]: + il = [x for r in healthy for x in r["imglat"]] + src_fps = sum(h for kind, _, h in streams if kind == "img") + print( + f" image: fps/client={sum(r['img'] for r in healthy)/len(healthy)/duration:.1f} (src {src_fps}) " + f"lat p50={pct(il, 50)/1000:.1f}ms p99={pct(il, 99)/1000:.1f}ms " + f"encodes/frame={srv['encodes']['image']/srv['injected_images']:.2f}", + flush=True, + ) + sources = {c: h for _, c, h in streams} + chans = {} + for r in healthy: + for k, v in r["chan"].items(): + chans.setdefault(k, []).append(v / duration) + shown = [k for k in ("NAV_0", "MULTIBEAM") if k in chans] + if shown: + print(" rcv Hz/client (source): " + ", ".join( + f"{k}={sum(chans[k])/len(chans[k]):.1f} ({sources[k]})" for k in shown), flush=True) + spy = next((r["spyhz"] for r in healthy if r["spyhz"]), {}) + if spy: + print(" spy-reported Hz (last 3): " + ", ".join( + f"{k}={[round(x) for x in spy[k][-3:]]}" for k in ("NAV_0", "MULTIBEAM", "CAM") if k in spy), flush=True) + if stall_first: + stalled = next(r for r in res if r["stalled"]) + print(f" stalled client frames={stalled['frames']}", flush=True) + + +NAV = [("odo", f"NAV_{i}", 100) for i in range(10)] + [("mb", "MULTIBEAM", 20)] +CAM = [("img", "CAM", 10)] + +SUITES = { + "latency": lambda d: scenario("json 1 client, nav 1.2k msg/s", "json", NAV, 1, duration=d), + "json-scale": lambda d: [ + scenario("json nav 10x100Hz + multibeam 20Hz", "json", NAV, n, duration=d) for n in (1, 10, 50, 100) + ] + [scenario("json nav 10x100Hz + multibeam 20Hz", "json", NAV, n, duration=d, compression=False) for n in (50, 100)], + "json-rate": lambda d: [ + scenario(f"json odo 10x{hz}Hz", "json", [("odo", f"NAV_{i}", hz) for i in range(10)], 10, duration=d, compression=False) + for hz in (200, 500, 1000) + ], + "dial": lambda d: [ + scenario("dial cam 3MP 10Hz + nav", "dial", CAM + NAV, n, duration=d, compression=False) for n in (1, 3, 10) + ] + [scenario("dial cam 3MP 10Hz + nav", "dial", CAM + NAV, 10, duration=d, compression=True)], + "slow": lambda d: [ + scenario("json, 1 stalled client among 20", "json", NAV, 20, duration=d, stall_first=True), + scenario("dial, 1 stalled client among 5", "dial", CAM + NAV, 5, duration=d, stall_first=True, compression=False), + ], + "periodic": lambda d: scenario("json periodic 500ms", "json", NAV, 10, path=".*?update_interval_ms=500", duration=d), +} + + +def main(): + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) + parser.add_argument("suite", choices=[*SUITES, "all"]) + parser.add_argument("--duration", type=float, default=6.0, help="Measurement window per scenario (s)") + args = parser.parse_args() + mp.set_start_method("fork") + for name in SUITES if args.suite == "all" else [args.suite]: + SUITES[name](args.duration) + + +if __name__ == "__main__": + main() diff --git a/channel_stats.lcm b/channel_stats.lcm index f43f837..e54cd52 100644 --- a/channel_stats.lcm +++ b/channel_stats.lcm @@ -13,4 +13,4 @@ struct channel_stats { struct channel_stats_list { int32_t num_channels; channel_stats channels[num_channels]; -} \ No newline at end of file +} diff --git a/docker/Dockerfile b/docker/Dockerfile index aeebc21..321e0dd 100644 --- a/docker/Dockerfile +++ b/docker/Dockerfile @@ -12,20 +12,25 @@ COPY . /app WORKDIR /app # Build lcm_websocket_server*.whl -RUN uv build +RUN uv build --wheel FROM ghcr.io/astral-sh/uv:python3.13-bookworm-slim # Copy glib-2.0 shared libraries COPY --from=builder /usr/lib/x86_64-linux-gnu/libglib-2.0.so.0 /usr/lib/x86_64-linux-gnu/libglib-2.0.so.0 -# Install lcm-websocket-server: +# Install lcm-websocket-server with the performance extras COPY --from=builder /app/dist/*.whl /tmp/ -RUN pip install --no-cache-dir /tmp/*.whl +RUN uv pip install --system --no-cache "$(ls /tmp/lcm_websocket_server-*.whl)[orjson,uvloop]" ENV HOST=0.0.0.0 ENV PORT=8765 ENV CHANNEL=.* ENV LCM_PACKAGES= +# Extra command-line flags, e.g. "--uvloop --processes 4 -vv" +ENV ARGS= -CMD ["sh", "-c", "PYTHONPATH=$PYTHONPATH:/app lcm-websocket-server --host \"$HOST\" --port \"$PORT\" --channel \"$CHANNEL\" \"$LCM_PACKAGES\""] +HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \ + CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/healthz' % os.environ['PORT'], timeout=3)"] + +CMD ["sh", "-c", "PYTHONPATH=$PYTHONPATH:/app lcm-websocket-json-proxy --host \"$HOST\" --port \"$PORT\" --channel \"$CHANNEL\" $ARGS \"$LCM_PACKAGES\""] diff --git a/docker/Dockerfile.dial b/docker/Dockerfile.dial index 5c0caed..e397228 100644 --- a/docker/Dockerfile.dial +++ b/docker/Dockerfile.dial @@ -2,14 +2,14 @@ ARG VERSION=latest FROM mbari/lcm-websocket-server:$VERSION # Install lcm-websocket-server with the image extra -RUN pip install --no-cache-dir $(ls /tmp/*.whl | head -n 1)[image] +RUN uv pip install --system --no-cache "$(ls /tmp/lcm_websocket_server-*.whl | head -n 1)[image,orjson,uvloop]" # Install the molars-lcmtypes wheel from the host COPY molars_lcmtypes-0.0.0-py3-none-any.whl /tmp/molars_lcmtypes-0.0.0-py3-none-any.whl -RUN pip install --no-cache-dir /tmp/molars_lcmtypes-0.0.0-py3-none-any.whl +RUN uv pip install --system --no-cache /tmp/molars_lcmtypes-0.0.0-py3-none-any.whl ENV JPEG_QUALITY=75 ENV JPEG_SCALE=1.0 -# Run lcm-websocket-dial-proxy -CMD ["sh", "-c", "lcm-websocket-dial-proxy -vv --host \"$HOST\" --port \"$PORT\" --channel \"$CHANNEL\" --quality \"$JPEG_QUALITY\" --scale \"$JPEG_SCALE\""] +# Run lcm-websocket-dial-proxy (HEALTHCHECK is inherited from the base image) +CMD ["sh", "-c", "lcm-websocket-dial-proxy -vv --host \"$HOST\" --port \"$PORT\" --channel \"$CHANNEL\" --quality \"$JPEG_QUALITY\" --scale \"$JPEG_SCALE\" $ARGS"] diff --git a/docs/image_transcoding/README.md b/docs/image_transcoding/README.md index 8b41cdc..bbd90c4 100644 --- a/docs/image_transcoding/README.md +++ b/docs/image_transcoding/README.md @@ -47,4 +47,4 @@ This service will be implemented in Python using the following libraries: - `navlcm` - `geolcm` -Messages will be [received](https://lcm-proj.github.io/lcm/python/index.html#lcm.LCM) via LCM and decoded according to the [`image_t` definition](https://github.com/CoMPASLab/compas_lcmtypes/blob/main/senlcm_image_t.lcm). The contained image data will be decoded according to the specified pixel format then [encoded](https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga5a0acefe5cbe0a81e904e452ec7ca733) into JPEG using OpenCV. The JPEG byte data will be [sent](https://websockets.readthedocs.io/en/stable/reference/asyncio/server.html#websockets.server.WebSocketServerProtocol.send) over WebSocket connections as a [Binary frame](https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6). \ No newline at end of file +Messages will be [received](https://lcm-proj.github.io/lcm/python/index.html#lcm.LCM) via LCM and decoded according to the [`image_t` definition](https://github.com/CoMPASLab/compas_lcmtypes/blob/main/senlcm_image_t.lcm). The contained image data will be decoded according to the specified pixel format then [encoded](https://docs.opencv.org/4.x/d4/da8/group__imgcodecs.html#ga5a0acefe5cbe0a81e904e452ec7ca733) into JPEG using OpenCV. The JPEG byte data will be [sent](https://websockets.readthedocs.io/en/stable/reference/asyncio/server.html#websockets.server.WebSocketServerProtocol.send) over WebSocket connections as a [Binary frame](https://www.rfc-editor.org/rfc/rfc6455.html#section-5.6). diff --git a/examples/dial_web_viewer_server.py b/examples/dial_web_viewer_server.py old mode 100644 new mode 100755 index 7670811..7a2eb27 --- a/examples/dial_web_viewer_server.py +++ b/examples/dial_web_viewer_server.py @@ -18,7 +18,6 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer from urllib.parse import urlsplit - HTML_TEMPLATE = """ @@ -312,10 +311,10 @@ function queueRender() { if (renderQueued) return; - + const now = performance.now(); const timeSinceLastRender = now - lastRenderTime; - + if (timeSinceLastRender < RENDER_THROTTLE_MS) { // Schedule render for later renderQueued = true; @@ -599,7 +598,7 @@ class ViewerHandler(BaseHTTPRequestHandler): ws_url = "" - def do_GET(self): # noqa: N802 (http.server naming convention) + def do_GET(self): parsed = urlsplit(self.path) if parsed.path != "/": self.send_response(404) @@ -669,4 +668,4 @@ def main() -> None: if __name__ == "__main__": - main() \ No newline at end of file + main() diff --git a/examples/spy_client.py b/examples/spy_client.py old mode 100644 new mode 100755 index 9cb8b8b..0c7ca44 --- a/examples/spy_client.py +++ b/examples/spy_client.py @@ -12,13 +12,14 @@ import argparse import asyncio import json + import websockets async def subscribe_to_spy(host: str, port: int): """ Subscribe to the LWS_LCM_SPY virtual channel and print stats. - + Args: host: WebSocket server host port: WebSocket server port @@ -26,27 +27,27 @@ async def subscribe_to_spy(host: str, port: int): # Connect to the spy channel uri = f"ws://{host}:{port}/LWS_LCM_SPY" print(f"Connecting to {uri}...") - + async with websockets.connect(uri) as websocket: print("Connected! Receiving channel stats...\n") - + while True: try: # Receive a message message = await websocket.recv() - + # Parse JSON data = json.loads(message) - + # Extract stats channel_list = data.get("event", {}) num_channels = channel_list.get("num_channels", 0) channels = channel_list.get("channels", []) - + print(f"=== Channel Statistics ({num_channels} channels) ===") print(f"{'Channel':<30} {'Type':<20} {'Hz':>8} {'Msgs':>8} {'BW (KB/s)':>12} {'Jitter':>10}") print("-" * 100) - + for channel in channels: ch_name = channel.get("channel", "") ch_type = channel.get("type", "") @@ -55,14 +56,14 @@ async def subscribe_to_spy(host: str, port: int): bandwidth = channel.get("bandwidth", 0.0) / 1024 # Convert to KB/s jitter = channel.get("jitter", 0.0) undecodable = channel.get("undecodable", 0) - + # Truncate long names ch_name_short = ch_name[:28] + ".." if len(ch_name) > 30 else ch_name ch_type_short = ch_type[:18] + ".." if len(ch_type) > 20 else ch_type - + marker = " ⚠" if undecodable > 0 else "" print(f"{ch_name_short:<30} {ch_type_short:<20} {hz:8.2f} {num_msgs:8d} {bandwidth:12.2f} {jitter:10.6f}{marker}") - + print() except json.JSONDecodeError as e: print(f"Failed to parse JSON: {e}") @@ -76,14 +77,14 @@ async def subscribe_to_spy(host: str, port: int): def main(): """Entry point.""" - parser = argparse.ArgumentParser(description=__doc__, + parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) - parser.add_argument("--host", type=str, default="localhost", + parser.add_argument("--host", type=str, default="localhost", help="WebSocket server host (default: localhost)") parser.add_argument("--port", type=int, default=8765, help="WebSocket server port (default: 8765)") args = parser.parse_args() - + try: asyncio.run(subscribe_to_spy(args.host, args.port)) except KeyboardInterrupt: diff --git a/lcm_websocket_server/apps/dial_proxy.py b/lcm_websocket_server/apps/dial_proxy.py index c542246..b3eda7e 100644 --- a/lcm_websocket_server/apps/dial_proxy.py +++ b/lcm_websocket_server/apps/dial_proxy.py @@ -3,27 +3,36 @@ """ import argparse -import asyncio +import threading from io import BytesIO -from typing import Optional, Union +from time import monotonic_ns import cv2 -from numpy import ndarray from lcmlog.event import Header -from lcmutils import LCMTypeRegistry +from numpy import ndarray from senlcm import image_t from stdlcm import header_t -from lcm_websocket_server.lib.lcm_utils.pubsub import LCMRepublisher, OBSERVER_QUEUE_MAXSIZE -from lcm_websocket_server.lib.lcm_utils.channel_stats import channel_stats -from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list -from lcm_websocket_server.lib.handler import EncodeCache, LCMWebSocketHandler -from lcm_websocket_server.lib.image import MJPEGEncoder, PixelFormat, UnsupportedPixelFormatError, get_decoder -from lcm_websocket_server.lib.log import LogMixin -from lcm_websocket_server.lib.server import LCMWebSocketServer from lcm_websocket_server.apps.json_proxy import JSONHandler -from lcm_websocket_server.lib.log import get_logger, set_stream_handler_verbosity - +from lcm_websocket_server.lib.cli import ( + ServerOptions, + add_server_args, + app_factory, + build_registry, + parse_server_options, + run_app, + serve_until_stopped, +) +from lcm_websocket_server.lib.handler import LCMWebSocketHandler +from lcm_websocket_server.lib.image import ( + MJPEGEncoder, + PixelFormat, + UnsupportedPixelFormatError, + get_decoder, +) +from lcm_websocket_server.lib.lcm_utils.pubsub import LCMRepublisher +from lcm_websocket_server.lib.log import LogMixin, get_logger +from lcm_websocket_server.lib.server import DEFAULT_HEAVY_WORKERS, LCMWebSocketServer logger = get_logger("lcm-websocket-dial-proxy") @@ -50,14 +59,17 @@ def _get_decoder(self, pixelformat: int, width: int, height: int): self._decoder_cache[key] = decoder return decoder - def handle(self, channel: str, data: Union[bytes, image_t]) -> Optional[bytes]: + def is_heavy(self, channel: str, data: bytes) -> bool: + return True + + def handle(self, channel: str, data: bytes | image_t) -> bytes | None: # Accept either raw bytes or a pre-decoded image_t object. if isinstance(data, image_t): image_event = data else: try: image_event = image_t.decode(data) - except Exception as e: + except Exception as e: # noqa: BLE001 - malformed input must not propagate self.logger.warning(f"Failed to decode image_t event from channel {channel}: {e}") return None @@ -71,14 +83,14 @@ def handle(self, channel: str, data: Union[bytes, image_t]) -> Optional[bytes]: # Decode the contained image. try: image = decoder.decode(image_event.data) - except Exception as e: + except Exception as e: # noqa: BLE001 - malformed input must not propagate self.logger.warning(f"Failed to decode image from channel {channel}: {e}") return None # Convert the image to JPEG. try: jpeg = self._encoder.encode(image) - except Exception as e: + except Exception as e: # noqa: BLE001 - malformed input must not propagate self.logger.warning(f"Failed to encode image as JPEG: {e}") return None @@ -89,19 +101,20 @@ class DownsamplingMJPEGEncoder(MJPEGEncoder): """ MJPEG encoder that downsamples the image before encoding it. """ - def __init__(self, scale: float, params: Optional[list] = None): + def __init__(self, scale: float, params: list | None = None): super().__init__(params) self._scale = scale def encode(self, image: ndarray) -> bytes: - # Downsample the image - image = cv2.resize(image, (0, 0), fx=self._scale, fy=self._scale, interpolation=cv2.INTER_AREA) + # Downsample the image (skipped at scale 1.0, where resize is a full-frame copy) + if self._scale != 1.0: + image = cv2.resize(image, (0, 0), fx=self._scale, fy=self._scale, interpolation=cv2.INTER_AREA) # Encode the image return super().encode(image) -class DialHandler(LogMixin): +class DialHandler(LCMWebSocketHandler, LogMixin): """ Handler for messages as preferred by Dial. @@ -109,20 +122,50 @@ class DialHandler(LogMixin): The image handler is invoked for `image_t` messages, and the JSON handler is invoked for all other messages. The image handler generates a JPEG image from the `image_t` message, prepends the original LCM message header and channel name, and sends the result as a binary frame over the WebSocket. - The JSON handler generates a JSON string from the LCM message, and sends the result as a text frame over the WebSocket. - - Results are cached per channel keyed by data object identity so that when - multiple clients subscribe to the same channel the encode work is done once. + The JSON handler generates UTF-8 JSON from the LCM message, and sends the result as a text frame over the WebSocket. """ IMAGE_T_FINGERPRINT = image_t._get_packed_fingerprint() - def __init__(self, image_handler: ImageMessageToJPEGHandler, json_handler: JSONHandler): + def __init__( + self, + image_handler: ImageMessageToJPEGHandler, + json_handler: JSONHandler, + max_image_fps: float | None = None, + ): + """ + Args: + image_handler: Converts image_t to JPEG. + json_handler: Converts all other messages to JSON. + max_image_fps: Optional per-channel cap on transcoded image frames. + Frames over the cap are skipped for all clients. + """ + if max_image_fps is not None and max_image_fps <= 0: + raise ValueError("max_image_fps must be positive") self._image_handler = image_handler self._json_handler = json_handler - self._cache = EncodeCache() + self._image_interval_ns = int(1e9 / max_image_fps) if max_image_fps else 0 + self._next_image_ns: dict[str, int] = {} + self._rate_lock = threading.Lock() - def _encode_image_t(self, channel: str, data: bytes) -> Optional[bytes]: + def _image_due(self, channel: str, now_ns: int) -> bool: + """ + Deadline-based rate limit per channel. Tolerates 10% early arrival so + source jitter does not halve the rate when the cap matches the source. + """ + interval = self._image_interval_ns + if not interval: + return True + with self._rate_lock: + deadline = self._next_image_ns.get(channel) + if deadline is not None and now_ns < deadline - interval // 10: + return False + # Resume from now after a long gap rather than bursting to catch up. + base = now_ns if deadline is None or now_ns - deadline > interval else deadline + self._next_image_ns[channel] = base + interval + return True + + def _encode_image_t(self, channel: str, data: bytes) -> bytes | None: """ Encode an image_t message as a binary frame. @@ -157,107 +200,66 @@ def _encode_image_t(self, channel: str, data: bytes) -> Optional[bytes]: return header_bytes + channel_name_utf8 + jpeg_bytes - def handle(self, channel: str, data: bytes) -> Optional[Union[bytes, str]]: - cached = self._cache.get(channel, data) - if cached is not None: - return cached + def is_heavy(self, channel: str, data: bytes) -> bool: + return data[:8] == DialHandler.IMAGE_T_FINGERPRINT - fingerprint = data[:8] - if fingerprint == DialHandler.IMAGE_T_FINGERPRINT: - response = self._encode_image_t(channel, data) - else: - response = self._json_handler.handle(channel, data) + def handle(self, channel: str, data: bytes) -> bytes | str | None: + if data[:8] == DialHandler.IMAGE_T_FINGERPRINT: + if not self._image_due(channel, monotonic_ns()): + return None + return self._encode_image_t(channel, data) + return self._json_handler.handle(channel, data) - if response is not None: - self._cache.put(channel, data, response) - return response +DIAL_LCM_PACKAGES = ( + "stdlcm", + "senlcm", + "navlcm", + "geolcm", + "lcm_action_server", + "mission_server", + "nav_server", + "control_server", +) async def run( - host: str, - port: int, - channel: str, + options: ServerOptions, scale: float = 1.0, quality: int = 75, - empty_wait_seconds: float = 0.1, - observer_queue_maxsize: int = OBSERVER_QUEUE_MAXSIZE, - spy_emit_interval_ns: int = 1_000_000_000, -): + image_workers: int = DEFAULT_HEAVY_WORKERS, + max_fps: float | None = None, +) -> None: """ Run the LCM WebSocket Dial proxy server. Args: - host: Host to bind to - port: Port to bind to - channel: LCM channel to subscribe to + options: Common server options scale: The scale factor to resize the image by. quality: The JPEG quality level. Clamped to the range [0, 100]. - empty_wait_seconds: Poll sleep when the message queue is empty (seconds) - observer_queue_maxsize: Max messages buffered per connection - spy_emit_interval_ns: LCM spy stats emission interval (nanoseconds) + image_workers: Threads for image transcoding. + max_fps: Optional per-channel cap on transcoded image frames per second. """ - # Create an LCM republisher - logger.debug(f"Creating LCM republisher for channel '{channel}'") - lcm_republisher = LCMRepublisher(channel) - lcm_republisher.start() - - # Initialize the LCM type registry - registry = LCMTypeRegistry() - package_names = [ - "stdlcm", - "senlcm", - "navlcm", - "geolcm", - "lcm_action_server", - "mission_server", - "nav_server", - "control_server", - ] - logger.info(f"Discovering LCM types in packages: {', '.join(package_names)}") - for package_name in package_names: - try: - registry.discover(package_name) - except ModuleNotFoundError: - logger.error(f"Could not discover types in MolaRS package '{package_name}'") - - # Register the channel_stats LCM types for the virtual spy channel - registry.register(channel_stats) - registry.register(channel_stats_list) - logger.info(f"Registered virtual channel stats types: {channel_stats.__name__}, {channel_stats_list.__name__}") - - if not registry.types: - logger.critical("No LCM types discovered, exiting.") + registry = build_registry(DIAL_LCM_PACKAGES, logger) + if registry is None: return - logger.info(f"Discovered LCM types: {', '.join([t.__name__ for t in registry.types])}") - # Create an image encoder quality = round(max(0, min(quality, 100))) jpeg_encoder = DownsamplingMJPEGEncoder(scale=scale, params=[cv2.IMWRITE_JPEG_QUALITY, quality]) + handler = DialHandler(ImageMessageToJPEGHandler(jpeg_encoder), JSONHandler(registry), max_image_fps=max_fps) - # Create the sub-handlers - image_handler = ImageMessageToJPEGHandler(jpeg_encoder) - json_handler = JSONHandler(registry) - - # Create an LCM WebSocket server - handler = DialHandler(image_handler, json_handler) + logger.debug(f"Creating LCM republisher for channel '{options.channel}'") + republisher = LCMRepublisher(options.channel) server = LCMWebSocketServer( - host, - port, + options.host, + options.port, handler, - lcm_republisher, - empty_wait_seconds=empty_wait_seconds, + republisher, spy_registry=registry, - observer_queue_maxsize=observer_queue_maxsize, - spy_emit_interval_ns=spy_emit_interval_ns, + heavy_workers=image_workers, + **options.server_kwargs(), ) - - # Start the server - logger.debug("Starting LCM WebSocket server") - await server.serve() - - # Stop the LCM republisher - lcm_republisher.stop() + await serve_until_stopped(server, republisher) def main(): @@ -265,46 +267,27 @@ def main(): Entry point for the LCM WebSocket Dial proxy server. """ parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--host", type=str, default="localhost", help="The host to listen on. Default: %(default)s") - parser.add_argument("--port", type=int, default=8765, help="The port to listen on. Default: %(default)s") - parser.add_argument("--channel", type=str, default=".*", help="The LCM channel to subscribe to. Use '.*' to subscribe to all channels.") + add_server_args(parser, compression_default="none") parser.add_argument("--scale", type=float, default=1.0, help="The scale factor to resize the image by. Default: %(default)s") parser.add_argument("--quality", type=int, default=75, help="The JPEG quality level, 0-100. Default: %(default)s") - parser.add_argument("--queue-size", type=int, default=OBSERVER_QUEUE_MAXSIZE, help="Max messages buffered per connection before oldest are dropped. Default: %(default)s") - parser.add_argument("--poll-interval", type=float, default=0.1, help="Sleep duration (seconds) when the message queue is empty. Default: %(default)s") - parser.add_argument("--spy-interval", type=float, default=1.0, help="LCM spy stats emission interval (seconds). Default: %(default)s") - parser.add_argument("-v", "--verbose", action="count", default=0, help="Increase verbosity level. 0=ERROR, 1=WARNING, 2=INFO, 3=DEBUG. Default: %(default)s") + parser.add_argument("--max-fps", type=float, default=None, help="Cap on transcoded frames per second per image channel. Default: no cap") + parser.add_argument("--image-workers", type=int, default=DEFAULT_HEAVY_WORKERS, help="Threads for image transcoding. Default: %(default)s") args = parser.parse_args() - host = args.host - port = args.port - channel = args.channel - scale = args.scale - quality = args.quality - verbosity = args.verbose - empty_wait_seconds = args.poll_interval - observer_queue_maxsize = args.queue_size - spy_emit_interval_ns = int(args.spy_interval * 1_000_000_000) - - # Set the verbosity level - set_stream_handler_verbosity(verbosity) - - # Run the server coroutine - logger.info(f"Starting LCM WebSocket Dial proxy at ws://{host}:{port}") - try: - asyncio.run(run( - host, - port, - channel, - scale=scale, - quality=quality, - empty_wait_seconds=empty_wait_seconds, - observer_queue_maxsize=observer_queue_maxsize, - spy_emit_interval_ns=spy_emit_interval_ns, - )) - except KeyboardInterrupt: - logger.info("Stopped") + options = parse_server_options(args, logger) + run_app( + app_factory( + run, + options, + scale=args.scale, + quality=args.quality, + image_workers=args.image_workers, + max_fps=args.max_fps, + ), + options, + logger, + ) if __name__ == "__main__": - asyncio.run(main()) + main() diff --git a/lcm_websocket_server/apps/json_proxy.py b/lcm_websocket_server/apps/json_proxy.py index e2dd474..59fb8bf 100644 --- a/lcm_websocket_server/apps/json_proxy.py +++ b/lcm_websocket_server/apps/json_proxy.py @@ -2,36 +2,36 @@ LCM WebSocket JSON proxy server. """ import argparse -import asyncio -from typing import List, Optional from lcmutils import LCMType, LCMTypeRegistry +from lcm_websocket_server.lib.cli import ( + ServerOptions, + add_server_args, + app_factory, + build_registry, + parse_server_options, + run_app, + serve_until_stopped, +) +from lcm_websocket_server.lib.handler import LCMWebSocketHandler, TextPayload +from lcm_websocket_server.lib.lcm_utils.pubsub import LCMRepublisher +from lcm_websocket_server.lib.lcm_utils.types import encode_event_json_bytes +from lcm_websocket_server.lib.log import LogMixin, get_logger from lcm_websocket_server.lib.server import LCMWebSocketServer -from lcm_websocket_server.lib.handler import EncodeCache, LCMWebSocketHandler -from lcm_websocket_server.lib.lcm_utils.pubsub import LCMRepublisher, OBSERVER_QUEUE_MAXSIZE -from lcm_websocket_server.lib.lcm_utils.channel_stats import channel_stats -from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list -from lcm_websocket_server.lib.lcm_utils.types import encode_event_json -from lcm_websocket_server.lib.log import LogMixin, get_logger, set_stream_handler_verbosity - logger = get_logger("lcm-websocket-json-proxy") class JSONHandler(LCMWebSocketHandler, LogMixin): """ - Handler that converts LCM messages to JSON. - - Results are cached per channel keyed by data object identity so that when - multiple clients subscribe to the same channel the encode work is done once. + Handler that converts LCM messages to JSON. Stateless and thread-safe. """ def __init__(self, lcm_type_registry: LCMTypeRegistry): self._lcm_type_registry = lcm_type_registry - self._cache = EncodeCache() - def _decode(self, data: bytes) -> Optional[LCMType]: + def _decode(self, data: bytes) -> LCMType | None: """ Decode an LCM message. @@ -52,15 +52,11 @@ def _decode(self, data: bytes) -> Optional[LCMType]: if nested_message is not None: setattr(message, slot, nested_message) return message - except Exception as e: + except Exception as e: # noqa: BLE001 - malformed input must not propagate self.logger.debug(f"Failed to decode LCM data: {e}") return None - def handle(self, channel: str, data: bytes) -> Optional[str]: - cached = self._cache.get(channel, data) - if cached is not None: - return cached - + def handle(self, channel: str, data: bytes) -> TextPayload | None: # Decode the LCM message event = self._decode(data) if event is None: @@ -70,74 +66,32 @@ def handle(self, channel: str, data: bytes) -> Optional[str]: fingerprint_hex = data[:8].hex() # Encode the event as JSON - result = encode_event_json(channel, fingerprint_hex, event) - self._cache.put(channel, data, result) - return result - - -async def run( - host: str, - port: int, - channel: str, - lcm_packages: List[str], - empty_wait_seconds: float = 0.1, - observer_queue_maxsize: int = OBSERVER_QUEUE_MAXSIZE, - spy_emit_interval_ns: int = 1_000_000_000, -): + return TextPayload(encode_event_json_bytes(channel, fingerprint_hex, event)) + + +async def run(options: ServerOptions, lcm_packages: list[str]) -> None: """ Run the LCM WebSocket JSON proxy server. Args: - host: Host to bind to - port: Port to bind to - channel: LCM channel to subscribe to + options: Common server options lcm_packages: LCM packages to discover types from - empty_wait_seconds: Poll sleep when the queue is empty (seconds) - observer_queue_maxsize: Max messages buffered per connection - spy_emit_interval_ns: LCM spy stats emission interval (nanoseconds) """ - # Create an LCM republisher - logger.debug(f"Creating LCM republisher for channel '{channel}'") - lcm_republisher = LCMRepublisher(channel) - lcm_republisher.start() - - # Initialize the LCM type registry - registry = LCMTypeRegistry() - for package in lcm_packages: - try: - registry.discover(package) - except ModuleNotFoundError: - logger.error(f"Failed to discover LCM types in package '{package}'") - - # Register the channel_stats LCM types for the virtual spy channel - registry.register(channel_stats) - registry.register(channel_stats_list) - logger.info(f"Registered virtual channel stats types: {channel_stats.__name__}, {channel_stats_list.__name__}") - - if not registry.types: - logger.critical("No LCM types discovered, exiting.") + registry = build_registry(lcm_packages, logger) + if registry is None: return - logger.info(f"Discovered LCM types: {', '.join([t.__name__ for t in registry.types])}") - # Create an LCM WebSocket server - handler = JSONHandler(registry) + logger.debug(f"Creating LCM republisher for channel '{options.channel}'") + republisher = LCMRepublisher(options.channel) server = LCMWebSocketServer( - host, - port, - handler, - lcm_republisher, - empty_wait_seconds=empty_wait_seconds, + options.host, + options.port, + JSONHandler(registry), + republisher, spy_registry=registry, - observer_queue_maxsize=observer_queue_maxsize, - spy_emit_interval_ns=spy_emit_interval_ns, + **options.server_kwargs(), ) - - # Start the server - logger.debug("Starting LCM WebSocket server") - await server.serve() - - # Stop the LCM republisher - lcm_republisher.stop() + await serve_until_stopped(server, republisher) def main(): @@ -145,43 +99,13 @@ def main(): Entry point for the LCM WebSocket JSON proxy server. """ parser = argparse.ArgumentParser(description=__doc__) - parser.add_argument("--host", type=str, default="localhost", help="The host to listen on. Default: %(default)s") - parser.add_argument("--port", type=int, default=8765, help="The port to listen on. Default: %(default)s") - parser.add_argument("--channel", type=str, default=".*", help="The LCM channel to subscribe to. Use '.*' to subscribe to all channels.") - parser.add_argument("--queue-size", type=int, default=OBSERVER_QUEUE_MAXSIZE, help="Max messages buffered per connection before oldest are dropped. Default: %(default)s") - parser.add_argument("--poll-interval", type=float, default=0.1, help="Sleep duration (seconds) when the message queue is empty. Default: %(default)s") - parser.add_argument("--spy-interval", type=float, default=1.0, help="LCM spy stats emission interval (seconds). Default: %(default)s") - parser.add_argument("-v", "--verbose", action="count", default=0, help="Increase verbosity level. 0=ERROR, 1=WARNING, 2=INFO, 3=DEBUG. Default: %(default)s") + add_server_args(parser, compression_default="deflate") parser.add_argument("lcm_packages", type=str, help="The LCM packages to discover LCM types from. Separate multiple packages with a comma.") args = parser.parse_args() - host = args.host - port = args.port - channel = args.channel - verbosity = args.verbose - lcm_packages = args.lcm_packages.split(",") - empty_wait_seconds = args.poll_interval - observer_queue_maxsize = args.queue_size - spy_emit_interval_ns = int(args.spy_interval * 1_000_000_000) - - # Set the verbosity level - set_stream_handler_verbosity(verbosity) - - # Run the server coroutine - logger.info(f"Starting LCM WebSocket JSON proxy at ws://{host}:{port}") - try: - asyncio.run(run( - host, - port, - channel, - lcm_packages, - empty_wait_seconds=empty_wait_seconds, - observer_queue_maxsize=observer_queue_maxsize, - spy_emit_interval_ns=spy_emit_interval_ns, - )) - except KeyboardInterrupt: - logger.info("Stopped") + options = parse_server_options(args, logger) + run_app(app_factory(run, options, args.lcm_packages.split(",")), options, logger) if __name__ == "__main__": - asyncio.run(main()) + main() diff --git a/lcm_websocket_server/lib/cli.py b/lcm_websocket_server/lib/cli.py new file mode 100644 index 0000000..2d19e2c --- /dev/null +++ b/lcm_websocket_server/lib/cli.py @@ -0,0 +1,200 @@ +""" +Shared command-line and process plumbing for the proxy apps. +""" + +import argparse +import asyncio +import functools +import logging +import multiprocessing +import signal +from collections.abc import Callable, Coroutine, Iterable +from dataclasses import dataclass +from typing import Any + +from lcmutils import LCMTypeRegistry + +from lcm_websocket_server.lib.lcm_utils.channel_stats import channel_stats +from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list +from lcm_websocket_server.lib.lcm_utils.pubsub import ( + OBSERVER_QUEUE_MAXSIZE, + LCMRepublisher, +) +from lcm_websocket_server.lib.log import set_stream_handler_verbosity +from lcm_websocket_server.lib.server import LCMWebSocketServer + +COMPRESSION_CHOICES = ("deflate", "none") + + +@dataclass(frozen=True) +class ServerOptions: + """Options common to all proxy apps.""" + + host: str = "localhost" + port: int = 8765 + channel: str = ".*" + queue_size: int = OBSERVER_QUEUE_MAXSIZE + spy_interval_ns: int = 1_000_000_000 + compression: str | None = "deflate" + uvloop: bool = False + processes: int = 1 + verbosity: int = 0 + ping_interval: float | None = 20.0 + ping_timeout: float | None = 20.0 + + def server_kwargs(self) -> dict[str, Any]: + """Keyword arguments for LCMWebSocketServer derived from these options.""" + return { + "observer_queue_maxsize": self.queue_size, + "spy_emit_interval_ns": self.spy_interval_ns, + "compression": self.compression, + "reuse_port": self.processes > 1, + "ping_interval": self.ping_interval, + "ping_timeout": self.ping_timeout, + } + + +def add_server_args(parser: argparse.ArgumentParser, compression_default: str) -> None: + """Add the common server arguments to a parser.""" + parser.add_argument("--host", type=str, default="localhost", help="The host to listen on. Default: %(default)s") + parser.add_argument("--port", type=int, default=8765, help="The port to listen on. Default: %(default)s") + parser.add_argument("--channel", type=str, default=".*", help="The LCM channel to subscribe to. Use '.*' to subscribe to all channels.") + parser.add_argument("--queue-size", type=int, default=OBSERVER_QUEUE_MAXSIZE, help="Max messages buffered per connection before oldest are dropped. Default: %(default)s") + parser.add_argument("--poll-interval", type=float, default=None, help=argparse.SUPPRESS) # deprecated no-op + parser.add_argument("--spy-interval", type=float, default=1.0, help="LCM spy stats emission interval (seconds). Default: %(default)s") + parser.add_argument("--compression", choices=COMPRESSION_CHOICES, default=compression_default, help="WebSocket permessage-deflate compression. Saves bandwidth for JSON at a CPU cost per client; useless for JPEG. Default: %(default)s") + parser.add_argument("--uvloop", action="store_true", help="Use the uvloop event loop (requires the 'uvloop' extra).") + parser.add_argument("--processes", type=int, default=1, help="Number of server processes sharing the port (SO_REUSEPORT). Each has its own LCM subscription, encode cache and spy stats. Default: %(default)s") + parser.add_argument("--ping-interval", type=float, default=20.0, help="Seconds between keepalive pings; 0 disables. Default: %(default)s") + parser.add_argument("--ping-timeout", type=float, default=20.0, help="Seconds to wait for a pong before closing; 0 disables. Raise for slow links carrying large frames. Default: %(default)s") + parser.add_argument("-v", "--verbose", action="count", default=0, help="Increase verbosity level. 0=ERROR, 1=WARNING, 2=INFO, 3=DEBUG. Default: %(default)s") + + +def parse_server_options(args: argparse.Namespace, logger: logging.Logger) -> ServerOptions: + """Build ServerOptions from parsed arguments and apply logging verbosity.""" + set_stream_handler_verbosity(args.verbose) + if args.poll_interval is not None: + logger.warning("--poll-interval is deprecated and ignored; delivery is now event-driven") + if args.processes < 1: + raise SystemExit("--processes must be >= 1") + return ServerOptions( + host=args.host, + port=args.port, + channel=args.channel, + queue_size=args.queue_size, + spy_interval_ns=int(args.spy_interval * 1_000_000_000), + compression=None if args.compression == "none" else args.compression, + uvloop=args.uvloop, + processes=args.processes, + verbosity=args.verbose, + ping_interval=args.ping_interval or None, + ping_timeout=args.ping_timeout or None, + ) + + +def build_registry(packages: Iterable[str], logger: logging.Logger) -> LCMTypeRegistry | None: + """ + Discover LCM types from packages and register the spy types. + + Returns: + The registry, or None if no types were discovered from the packages. + """ + registry = LCMTypeRegistry() + for package in packages: + try: + registry.discover(package) + except ModuleNotFoundError: + logger.error(f"Failed to discover LCM types in package '{package}'") + + if not registry.types: + logger.critical("No LCM types discovered, exiting.") + return None + + registry.register(channel_stats) + registry.register(channel_stats_list) + logger.info(f"Discovered LCM types: {', '.join(t.__name__ for t in registry.types)}") + return registry + + +async def serve_until_stopped(server: LCMWebSocketServer, republisher: LCMRepublisher) -> None: + """Start the republisher, serve until closed or SIGTERM, then stop the republisher.""" + loop = asyncio.get_running_loop() + try: + loop.add_signal_handler(signal.SIGTERM, server.close) + except (NotImplementedError, RuntimeError): + pass # unsupported platform or not on the main thread + republisher.start() + try: + await server.serve() + finally: + republisher.stop() + + +AppFactory = Callable[[], Coroutine[Any, Any, None]] + + +def _run_one(app: AppFactory, use_uvloop: bool) -> None: + try: + if use_uvloop: + import uvloop + + uvloop.run(app()) + else: + asyncio.run(app()) + except KeyboardInterrupt: + pass + + +def run_app(app: AppFactory, options: ServerOptions, logger: logging.Logger) -> None: + """ + Run an app coroutine factory in one or more processes. + + `app` must be picklable (e.g. functools.partial of a module-level coroutine + function) when options.processes > 1. + """ + if options.uvloop: + try: + import uvloop # noqa: F401 + except ImportError: + raise SystemExit("--uvloop requires the 'uvloop' extra: uv add 'lcm-websocket-server[uvloop]'") + + logger.info(f"Starting at ws://{options.host}:{options.port} ({options.processes} process(es))") + if options.processes == 1: + _run_one(app, options.uvloop) + logger.info("Stopped") + return + + ctx = multiprocessing.get_context("spawn") + procs = [ + ctx.Process(target=_run_worker, args=(app, options.uvloop, options.verbosity), name=f"lws-worker-{i}") + for i in range(options.processes) + ] + for p in procs: + p.start() + + def terminate(*_): + for p in procs: + if p.is_alive(): + p.terminate() + + signal.signal(signal.SIGTERM, terminate) + try: + for p in procs: + p.join() + except KeyboardInterrupt: + pass # workers receive SIGINT from the terminal too + finally: + terminate() + for p in procs: + p.join(timeout=5) + logger.info("Stopped") + + +def _run_worker(app: AppFactory, use_uvloop: bool, verbosity: int) -> None: + set_stream_handler_verbosity(verbosity) # spawned processes start with default logging + _run_one(app, use_uvloop) + + +def app_factory(fn: Callable[..., Coroutine[Any, Any, None]], *args, **kwargs) -> AppFactory: + """Picklable zero-argument coroutine factory.""" + return functools.partial(fn, *args, **kwargs) diff --git a/lcm_websocket_server/lib/handler.py b/lcm_websocket_server/lib/handler.py index 0b21d34..52d5315 100644 --- a/lcm_websocket_server/lib/handler.py +++ b/lcm_websocket_server/lib/handler.py @@ -1,55 +1,84 @@ -import threading +import asyncio from abc import ABC, abstractmethod -from typing import Optional, Union +from collections import OrderedDict +from collections.abc import Awaitable, Callable +from typing import Any + + +class TextPayload(bytes): + """ + UTF-8 encoded payload sent as a WebSocket text frame. + + Lets handlers encode text once and have the server send it to every + client without re-encoding a str per connection. + """ + + __slots__ = () + + +Payload = str | bytes | bytearray | memoryview + +DEFAULT_CACHE_DEPTH = 4 class EncodeCache: """ - Per-channel single-entry cache keyed by data object identity. + Single-flight cache of encoded payloads, confined to one event loop. - Shared across all connections on the same handler instance so that when N - clients subscribe to the same channel, the encode work is done once and the - result is reused for the remaining N-1 clients. + Keyed by channel and by the identity of the raw data object: the + republisher hands the same bytes object to every subscriber, so identity + identifies "this exact message". The first request for a message starts + the encode; concurrent requests await the same future, so each message is + encoded at most once regardless of the number of clients. - Thread-safe: handle() may be called concurrently from multiple asyncio - to_thread workers. + Keeps the `depth` most recent messages per channel so clients that lag a + few messages behind still hit the cache. """ - def __init__(self): - self._lock = threading.Lock() - # channel -> (original data object, encoded result) - self._cache: dict[str, tuple[bytes, object]] = {} + def __init__(self, depth: int = DEFAULT_CACHE_DEPTH): + if depth < 1: + raise ValueError("depth must be >= 1") + self._depth = depth + # channel -> id(data) -> (data, future) + self._entries: dict[str, OrderedDict[int, tuple[bytes, asyncio.Future]]] = {} - def get(self, channel: str, data: bytes) -> Optional[object]: + async def get_or_encode(self, channel: str, data: bytes, encode: Callable[[], Awaitable[Any]]) -> Any: """ - Return the cached result for (channel, data) if available, else None. + Return the encoded result for (channel, data), starting `encode()` only + if no request for this message is cached or in flight. - Identity comparison (`is`) is used intentionally: the same raw bytes - object is placed into every subscriber queue by LCMRepublisher._handle, - so object identity reliably identifies "this exact message". + Cancelling one caller does not cancel the shared encode. """ - with self._lock: - entry = self._cache.get(channel) - if entry is not None and entry[0] is data: - return entry[1] - return None + per_channel = self._entries.get(channel) + if per_channel is None: + per_channel = self._entries[channel] = OrderedDict() + + key = id(data) + entry = per_channel.get(key) + if entry is not None and entry[0] is data: + future = entry[1] + else: + future = asyncio.ensure_future(encode()) + per_channel[key] = (data, future) + while len(per_channel) > self._depth: + per_channel.popitem(last=False) - def put(self, channel: str, data: bytes, result: object) -> None: - """Store an encoded result for (channel, data).""" - with self._lock: - self._cache[channel] = (data, result) + if future.done(): + return future.result() + return await asyncio.shield(future) class LCMWebSocketHandler(ABC): """ LCM WebSocket handler interface. - Implementations must be synchronous. The server calls handle() via - asyncio.to_thread() to keep CPU-intensive work off the event loop. + Implementations must be synchronous and thread-safe: the server runs + handle() in worker threads, possibly concurrently for different messages. + The server caches results, so handle() is called at most once per message. """ @abstractmethod - def handle(self, channel: str, data: bytes) -> Optional[Union[str, bytes, bytearray, memoryview]]: + def handle(self, channel: str, data: bytes) -> Payload | None: """ Handle an LCM message. @@ -59,5 +88,13 @@ def handle(self, channel: str, data: bytes) -> Optional[Union[str, bytes, bytear Returns: Response to be sent to the WebSocket client, or None to not send a response. + str and TextPayload are sent as text frames, other bytes-like as binary frames. """ raise NotImplementedError + + def is_heavy(self, channel: str, data: bytes) -> bool: + """ + Whether handling this message is CPU-heavy native work (e.g. image + encoding) that should run on the separate heavy worker pool. + """ + return False diff --git a/lcm_websocket_server/lib/image.py b/lcm_websocket_server/lib/image.py index 5638e26..00ae1f3 100644 --- a/lcm_websocket_server/lib/image.py +++ b/lcm_websocket_server/lib/image.py @@ -4,8 +4,9 @@ from abc import ABC, abstractmethod +from collections.abc import Sequence from enum import Enum -from typing import Optional, Sequence, Type, TypeVar +from typing import TypeVar import cv2 import numpy as np @@ -106,10 +107,9 @@ class PixelFormat(Enum): def _register( format: PixelFormat, *, - decoder: Type[ImageDecoderClass], - encoder: Optional[Type[ImageEncoderClass]] = None, + decoder: type[ImageDecoderClass], + encoder: type[ImageEncoderClass] | None = None, ): - global _ENCODER_MAP, _DECODER_MAP _ENCODER_MAP[format] = encoder _DECODER_MAP[format] = decoder @@ -123,7 +123,7 @@ def __init__(self, format: PixelFormat): super().__init__(f"Unsupported pixel format: {format} ({format.name})") -def get_encoder(format: PixelFormat) -> Type[ImageEncoderClass]: +def get_encoder(format: PixelFormat) -> type[ImageEncoderClass]: """ Get the image encoder class for the given pixel format. @@ -139,7 +139,7 @@ def get_encoder(format: PixelFormat) -> Type[ImageEncoderClass]: raise UnsupportedPixelFormatError(format) -def get_decoder(format: PixelFormat) -> Type[ImageDecoderClass]: +def get_decoder(format: PixelFormat) -> type[ImageDecoderClass]: """ Get the image decoder class for the given pixel format. @@ -226,7 +226,7 @@ def decode(self, data: bytes) -> np.ndarray: class MJPEGEncoder(ImageEncoder): - def __init__(self, params: Optional[Sequence[int]] = None): + def __init__(self, params: Sequence[int] | None = None): super().__init__() self.params = params or [cv2.IMWRITE_JPEG_QUALITY, 90] diff --git a/lcm_websocket_server/lib/lcm_utils/pubsub.py b/lcm_websocket_server/lib/lcm_utils/pubsub.py index 4ef8227..03c452f 100644 --- a/lcm_websocket_server/lib/lcm_utils/pubsub.py +++ b/lcm_websocket_server/lib/lcm_utils/pubsub.py @@ -1,35 +1,102 @@ """ LCM pub/sub utilities. + +Threading model: LCMRepublisher._handle runs on the LCM thread (single +producer). Each LCMObserver has a single consumer, which is either an asyncio +task (await get()) or synchronous code (get_nowait()/drain()). """ -import logging +import asyncio import queue import re import threading +from collections import deque +from collections.abc import Callable from time import monotonic_ns from lcmutils import LCMDaemon -from lcm_websocket_server.lib.log import LogMixin +from lcm_websocket_server.lib.log import LogMixin, get_logger -_logger = logging.getLogger(__name__) +_logger = get_logger(__name__) OBSERVER_QUEUE_MAXSIZE = 64 +# LCM handle timeout so the daemon thread can observe stop() on a quiet bus. +DAEMON_TIMEOUT_MS = 100 + +# Client-supplied regexes are capped to bound matching cost. +MAX_CHANNEL_REGEX_LENGTH = 1024 + +# Upper bound on cached channel -> observers routes (guards against channel-name churn). +MAX_ROUTE_CACHE_SIZE = 4096 + +Event = tuple[str, bytes] +# Tap signature: (channel, data, arrival monotonic_ns) +Tap = Callable[[str, bytes, int], None] + + +class InvalidChannelRegex(ValueError): + """Raised when a channel regex is too long or does not compile.""" + + +def compile_channel_regex(pattern: str) -> re.Pattern: + """ + Validate and compile a channel regex. + + Raises: + InvalidChannelRegex: If the pattern is too long or invalid. + """ + if len(pattern) > MAX_CHANNEL_REGEX_LENGTH: + raise InvalidChannelRegex(f"Channel regex exceeds {MAX_CHANNEL_REGEX_LENGTH} characters") + try: + return re.compile(pattern) + except re.error as e: + raise InvalidChannelRegex(f"Invalid channel regex {pattern!r}: {e}") from e + class LCMObserver: """ - Observer for an LCMObservable. Puts received events in a thread-safe queue. + Observer for an LCMRepublisher. + + Two buffering modes: + - FIFO (default): bounded deque; when full the oldest event is dropped. + - Conflate: only the latest event per channel is kept, so a busy channel + can never evict a quiet one. Channels are served in insertion order. - The internal queue is bounded (default: OBSERVER_QUEUE_MAXSIZE). When the - queue is full the oldest entry is dropped so the consumer always sees the - most recent data rather than accumulating unbounded backlog. + An asyncio consumer awaits get(); the producer wakes it via + call_soon_threadsafe only when the consumer is actually waiting, so the + per-message cost on the LCM thread stays small. """ - def __init__(self, channel_regex: str = ".*", queue_maxsize: int = OBSERVER_QUEUE_MAXSIZE): - self._queue = queue.Queue(maxsize=queue_maxsize) + + def __init__( + self, + channel_regex: str = ".*", + queue_maxsize: int = OBSERVER_QUEUE_MAXSIZE, + conflate: bool = False, + ): self._channel_regex = channel_regex + self._pattern = compile_channel_regex(channel_regex) + self._maxsize = queue_maxsize + self._conflate = conflate + self._fifo: deque = deque(maxlen=queue_maxsize) + self._latest: dict[str, bytes] = {} + self._latest_lock = threading.Lock() self._drop_count: int = 0 + # Async wakeup state (bound lazily to the consumer's loop) + self._loop: asyncio.AbstractEventLoop | None = None + self._event: asyncio.Event | None = None + self._waiting = False + + @property + def conflate(self) -> bool: + return self._conflate + + @property + def drop_count(self) -> int: + return self._drop_count + def match(self, channel: str) -> bool: """ Check if the observer matches a given channel. @@ -40,90 +107,119 @@ def match(self, channel: str) -> bool: Returns: bool: True if the observer matches the channel, False otherwise. """ - try: - return re.fullmatch(self._channel_regex, channel) is not None - except re.error: - return False - - def _put(self, event) -> None: - """ - Put an event into the queue, dropping the oldest entry if the queue is full. + return self._pattern.fullmatch(channel) is not None - Called from the LCM thread (single producer), so the get/put pair here - is safe: no other producer can race between the two calls. + # ------------------------------------------------------------- producer + def handle(self, event: Event) -> None: """ - try: - self._queue.put_nowait(event) - except queue.Full: - try: - self._queue.get_nowait() - # Keep the unfinished-task count balanced so queue.join() works - # if anyone ever uses it. - self._queue.task_done() - except queue.Empty: - pass - try: - self._queue.put_nowait(event) - except queue.Full: - pass # extremely unlikely second race; skip the message - - self._drop_count += 1 - # Log on the first drop and then at each power-of-ten threshold so - # the operator is alerted immediately but not spammed on a fast stream. - if self._drop_count == 1 or self._drop_count % 10 ** len(str(self._drop_count - 1)) == 0: - channel = event[0] if event else "unknown" - _logger.warning( - "Observer (channel regex %r) dropped oldest message on channel %r " - "(queue full at maxsize=%d, total dropped: %d). " - "Consider increasing --queue-size or reducing the publish rate.", - self._channel_regex, - channel, - self._queue.maxsize, - self._drop_count, - ) - - def handle(self, event: tuple[str, bytes]) -> None: - """ - Handle an LCM event. + Handle an LCM event (called from the producer thread). Args: event (tuple[str, bytes]): The LCM event (channel, data) """ - self._put(event) - - def get(self, *args, **kwargs) -> tuple[str, bytes]: - """ - Get the next event from the queue. + if self._conflate: + with self._latest_lock: + self._latest[event[0]] = event[1] + else: + fifo = self._fifo + if len(fifo) == self._maxsize: + self._record_drop(event[0]) + fifo.append(event) # deque(maxlen) drops the oldest atomically + self._notify() + + def _notify(self) -> None: + if self._waiting: + self._waiting = False + try: + self._loop.call_soon_threadsafe(self._event.set) + except RuntimeError: + pass # consumer loop already closed + + def _record_drop(self, channel: str) -> None: + self._drop_count += 1 + # Log on the first drop and then at each power-of-ten threshold so + # the operator is alerted immediately but not spammed on a fast stream. + if self._drop_count == 1 or self._drop_count % 10 ** len(str(self._drop_count - 1)) == 0: + _logger.warning( + "Observer (channel regex %r) dropped oldest message on channel %r " + "(queue full at maxsize=%d, total dropped: %d). " + "Consider increasing --queue-size, using ?conflate=1, or reducing the publish rate.", + self._channel_regex, + channel, + self._maxsize, + self._drop_count, + ) + + # ------------------------------------------------------------- consumer + def _try_get(self): + if self._conflate: + with self._latest_lock: + if not self._latest: + return None + channel = next(iter(self._latest)) + return channel, self._latest.pop(channel) + try: + return self._fifo.popleft() + except IndexError: + return None - Returns: - tuple[str, bytes]: The next event (channel, data) + def get_nowait(self): """ - return self._queue.get(*args, **kwargs) + Get the next event without blocking. - def task_done(self) -> None: + Raises: + queue.Empty: If no event is available. """ - Indicate that a formerly enqueued event (i.e., the last call to `LCMObserver.get`) is complete. - """ - self._queue.task_done() - - -class LCMTimedObserver(LCMObserver): - """ - Observer variant that captures an arrival timestamp for each event. - """ - - def handle(self, event: tuple[str, bytes]) -> None: - channel, data = event - self._put((channel, data, monotonic_ns())) - - def get(self, *args, **kwargs) -> tuple[str, bytes, int]: - return self._queue.get(*args, **kwargs) + event = self._try_get() + if event is None: + raise queue.Empty + return event + + def drain(self) -> list: + """Remove and return all buffered events (latest per channel in conflate mode).""" + if self._conflate: + with self._latest_lock: + latest, self._latest = self._latest, {} + return list(latest.items()) + events = [] + popleft = self._fifo.popleft + while True: + try: + events.append(popleft()) + except IndexError: + return events + + async def get(self): + """Wait for and return the next event. Must always be awaited from the same loop.""" + while True: + event = self._try_get() + if event is not None: + return event + if self._event is None: + self._loop = asyncio.get_running_loop() + self._event = asyncio.Event() + self._event.clear() + self._waiting = True + # Re-check after publishing the waiting flag to avoid a lost wakeup. + event = self._try_get() + if event is not None: + self._waiting = False + return event + await self._event.wait() + + def __len__(self) -> int: + return len(self._latest) if self._conflate else len(self._fifo) class LCMRepublisher(LogMixin): """ Subscribes to an LCM channel in a background thread and republishes events to subscribers. + + Routing is cached per channel name, so per-message cost is proportional to + the number of matching observers rather than the number of subscribers, and + each (possibly client-supplied) regex runs once per distinct channel. """ + def __init__(self, channel: str): """ Args: @@ -131,13 +227,14 @@ def __init__(self, channel: str): """ self._channel = channel - self._daemon = LCMDaemon() + self._daemon = LCMDaemon(timeout_millis=DAEMON_TIMEOUT_MS) self._daemon.subscribe(self._channel)(self._handle) - self._subscribers: list[LCMObserver] = [] - # Protects _subscribers against concurrent mutation (asyncio thread) - # vs iteration (_handle, LCM thread). - self._subscribers_lock = threading.Lock() + # Copy-on-write state read lock-free by the LCM thread: + # (subscribers, channel -> matching subscribers) + self._state: tuple[tuple[LCMObserver, ...], dict[str, tuple[LCMObserver, ...]]] = ((), {}) + self._taps: tuple[Tap, ...] = () + self._write_lock = threading.Lock() def subscribe(self, subscriber: LCMObserver) -> None: """ @@ -146,8 +243,8 @@ def subscribe(self, subscriber: LCMObserver) -> None: Args: subscriber (LCMObserver): The subscriber to subscribe. """ - with self._subscribers_lock: - self._subscribers.append(subscriber) + with self._write_lock: + self._state = (self._state[0] + (subscriber,), {}) def unsubscribe(self, subscriber: LCMObserver) -> None: """ @@ -156,8 +253,21 @@ def unsubscribe(self, subscriber: LCMObserver) -> None: Args: subscriber (LCMObserver): The subscriber to unsubscribe. """ - with self._subscribers_lock: - self._subscribers.remove(subscriber) + with self._write_lock: + subscribers = list(self._state[0]) + subscribers.remove(subscriber) + self._state = (tuple(subscribers), {}) + + def add_tap(self, tap: Tap) -> None: + """Register a callable invoked on the LCM thread for every event, before dispatch.""" + with self._write_lock: + self._taps = self._taps + (tap,) + + def remove_tap(self, tap: Tap) -> None: + with self._write_lock: + taps = list(self._taps) + taps.remove(tap) + self._taps = tuple(taps) def start(self) -> None: """ @@ -173,8 +283,7 @@ def stop(self) -> None: @property def subscriber_count(self) -> int: - with self._subscribers_lock: - return len(self._subscribers) + return len(self._state[0]) def inject(self, channel: str, data: bytes) -> None: """ @@ -189,18 +298,33 @@ def inject(self, channel: str, data: bytes) -> None: """ self._handle(channel, data) + def _route(self, channel: str) -> tuple[LCMObserver, ...]: + subscribers, routes = self._state + targets = routes.get(channel) + if targets is None: + targets = tuple(s for s in subscribers if s.match(channel)) + if len(routes) >= MAX_ROUTE_CACHE_SIZE: + routes.clear() + routes[channel] = targets + return targets + def _handle(self, channel: str, data: bytes): """ - Handle an LCM event. + Handle an LCM event. Exceptions are logged rather than propagated so + they cannot kill the LCM thread. Args: channel (str): The LCM channel data (bytes): The LCM data """ - # Take a snapshot under the lock so we don't hold the lock during - # per-subscriber dispatch (which calls queue.put). - with self._subscribers_lock: - subscribers = list(self._subscribers) - for subscriber in subscribers: - if subscriber.match(channel): - subscriber.handle((channel, data)) + try: + taps = self._taps + if taps: + ts = monotonic_ns() + for tap in taps: + tap(channel, data, ts) + event = (channel, data) + for subscriber in self._route(channel): + subscriber.handle(event) + except Exception: + self.logger.exception(f"Error dispatching message on channel {channel!r}") diff --git a/lcm_websocket_server/lib/lcm_utils/spy.py b/lcm_websocket_server/lib/lcm_utils/spy.py index 2bc5117..a84ab6f 100644 --- a/lcm_websocket_server/lib/lcm_utils/spy.py +++ b/lcm_websocket_server/lib/lcm_utils/spy.py @@ -1,4 +1,14 @@ -from typing import Optional +""" +lcm-spy style channel statistics. + +SpyAccumulator keeps cumulative per-channel counters and is fed once per +message from the LCM thread (as an LCMRepublisher tap), so its counts reflect +all traffic regardless of any client's queue. LCMSpy is a cheap +per-connection view that reports statistics since that connection started. +""" + +import threading +from dataclasses import dataclass from time import monotonic_ns, time_ns from lcmutils import LCMTypeRegistry @@ -6,177 +16,172 @@ from lcm_websocket_server.lib.lcm_utils.channel_stats import channel_stats from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list +VIRTUAL_CHANNEL = "LWS_LCM_SPY" + + +class _ChannelCounters: + """Mutable cumulative counters for one channel. Guarded by SpyAccumulator's lock.""" + + __slots__ = ( + "jitter_s", + "last_arrival_ns", + "latest_wall_ns", + "num_bytes", + "num_msgs", + "type_name", + "undecodable", + "window_max_ns", + "window_min_ns", + "window_start_ns", + ) + + def __init__(self, now_ns: int): + self.type_name = "" + self.num_msgs = 0 + self.num_bytes = 0 + self.undecodable = 0 + self.latest_wall_ns = 0 + self.last_arrival_ns: int | None = None + self.window_start_ns = now_ns + self.window_min_ns: int | None = None + self.window_max_ns: int | None = None + self.jitter_s = 0.0 + + def roll_window(self, now_ns: int, window_ns: int) -> None: + """Close the jitter window if it has elapsed: jitter = max - min inter-arrival interval.""" + if now_ns - self.window_start_ns < window_ns: + return + if self.window_min_ns is not None: + self.jitter_s = (self.window_max_ns - self.window_min_ns) / 1e9 + else: + self.jitter_s = 0.0 + self.window_min_ns = None + self.window_max_ns = None + self.window_start_ns = now_ns + +@dataclass(frozen=True) +class ChannelSnapshot: + """Immutable view of a channel's cumulative counters.""" -class ChannelData: + type_name: str + num_msgs: int + num_bytes: int + undecodable: int + latest_wall_ns: int + jitter_s: float + + +class SpyAccumulator: """ - Maintains metrics for a specific LCM channel. + Shared, thread-safe cumulative statistics for every observed channel. + + record() matches the LCMRepublisher tap signature. """ - def __init__(self): - self._last_type: Optional[str] = None - self._num_msgs: int = 0 - self._min_interval: Optional[float] = None - self._max_interval: Optional[float] = None - self._bandwidth: float = 0.0 - self._undecodable: int = 0 - - self._hz = 0.0 - self._hz_min_interval: float = float("inf") - self._hz_max_interval: float = 0.0 - self._hz_bytes: int = 0 - self._hz_last_update_timestamp: int = monotonic_ns() - self._last_msg_timestamp: Optional[int] = None - self._latest_msg_timestamp_ns: int = 0 - self._hz_last_nreceived: int = 0 - - def message_received(self, lcm_type: str, len_data: int, decoded: bool, timestamp_ns: Optional[int] = None) -> None: + def __init__(self, registry: LCMTypeRegistry, window_ns: int = 1_000_000_000): """ - Handle a received message of a given type. - Args: - lcm_type (str): The string representation of the LCM type. - len_data (int): The length of the data in bytes. - decoded (bool): Whether the message was decoded successfully. - timestamp_ns (Optional[int]): Arrival timestamp in nanoseconds. - """ - self._num_msgs += 1 - self._last_type = lcm_type - timestamp = timestamp_ns if timestamp_ns is not None else monotonic_ns() - self._latest_msg_timestamp_ns = time_ns() - if not decoded: - self._undecodable += 1 - - # Track inter-message timing for jitter using consecutive message deltas. - if self._last_msg_timestamp is not None: - interval = timestamp - self._last_msg_timestamp - self._hz_min_interval = min(self._hz_min_interval, interval) - self._hz_max_interval = max(self._hz_max_interval, interval) - self._last_msg_timestamp = timestamp - - self._hz_bytes += len_data - - def update_hz_data(self, timestamp: int) -> None: + registry: Registry used to identify message types. + window_ns: Window over which inter-arrival jitter is measured. """ - Update the Hz data based on the last received message. - - Args: - timestamp (int): The current timestamp in nanoseconds. - """ - diff_recv = self._num_msgs - self._hz_last_nreceived - self._hz_last_nreceived = self._num_msgs - dt = timestamp - self._hz_last_update_timestamp - self._hz_last_update_timestamp = timestamp - self._hz = diff_recv / (dt / 1e9) if dt > 0 else 0.0 - - # Store interval stats (convert from nanoseconds to seconds) - if self._hz_min_interval != float("inf") and self._hz_max_interval > 0.0: - self._min_interval = self._hz_min_interval / 1e9 - self._max_interval = self._hz_max_interval / 1e9 - else: - self._min_interval = None - self._max_interval = None - - # Reset for next period - self._hz_min_interval = float("inf") - self._hz_max_interval = 0.0 - - self._bandwidth = self._hz_bytes / (dt / 1e9) if dt > 0 else 0.0 - self._hz_bytes = 0 - - def report(self, channel: str) -> channel_stats: - """ - Generate a report of the channel's stats. - - Returns: - channel_stats: A channel_stats object containing the stats for this channel. - """ - stats = channel_stats() - stats.channel = channel - stats.type = self._last_type or "" - stats.num_msgs = self._num_msgs - stats.latest_msg_timestamp_ns = self._latest_msg_timestamp_ns - stats.hz = self._hz - stats.inv_hz = 1.0 / self._hz if self._hz > 0 else 9999.0 - # Jitter is already in seconds (converted in update_hz_data) - if self._min_interval is not None and self._max_interval is not None: - stats.jitter = self._max_interval - self._min_interval - else: - stats.jitter = 0.0 - stats.bandwidth = self._bandwidth - stats.undecodable = self._undecodable - return stats + self._registry = registry + self._window_ns = window_ns + self._lock = threading.Lock() + self._channels: dict[str, _ChannelCounters] = {} + + def record(self, channel: str, data: bytes, timestamp_ns: int) -> None: + """Account for one message. Called on the LCM thread.""" + if channel == VIRTUAL_CHANNEL: + return + lcm_type = self._registry.detect(data) + type_name = lcm_type.__name__ if lcm_type is not None else data[:8].hex() + wall_ns = time_ns() + + with self._lock: + c = self._channels.get(channel) + if c is None: + c = self._channels[channel] = _ChannelCounters(timestamp_ns) + c.roll_window(timestamp_ns, self._window_ns) + c.type_name = type_name + c.num_msgs += 1 + c.num_bytes += len(data) + if lcm_type is None: + c.undecodable += 1 + c.latest_wall_ns = wall_ns + if c.last_arrival_ns is not None: + interval = timestamp_ns - c.last_arrival_ns + if c.window_min_ns is None or interval < c.window_min_ns: + c.window_min_ns = interval + if c.window_max_ns is None or interval > c.window_max_ns: + c.window_max_ns = interval + c.last_arrival_ns = timestamp_ns + + def snapshot(self, now_ns: int | None = None) -> dict[str, ChannelSnapshot]: + """Return a consistent snapshot of all channels.""" + now_ns = monotonic_ns() if now_ns is None else now_ns + with self._lock: + result = {} + for channel, c in self._channels.items(): + c.roll_window(now_ns, self._window_ns) + result[channel] = ChannelSnapshot( + c.type_name, c.num_msgs, c.num_bytes, c.undecodable, c.latest_wall_ns, c.jitter_s + ) + return result class LCMSpy: """ - Per-connection lcm-spy stats accumulator. + Per-connection lcm-spy view over a shared SpyAccumulator. - Call `handle()` for each observed LCM event and `maybe_get_stats_bytes()` - periodically to emit the virtual `LWS_LCM_SPY` payload at a fixed cadence. + Message and undecodable counts are relative to when the view was created; + rates (Hz, bandwidth) cover the period since the previous get_stats() call. """ - VIRTUAL_CHANNEL = "LWS_LCM_SPY" + VIRTUAL_CHANNEL = VIRTUAL_CHANNEL - def __init__(self, registry: LCMTypeRegistry): - """ - Args: - registry (LCMTypeRegistry): Registry for detecting LCM types - """ - self._registry = registry - self._channel_data: dict[str, ChannelData] = {} - self._last_emit_ts_ns = monotonic_ns() + def __init__(self, accumulator: SpyAccumulator, now_ns: int | None = None): + self._accumulator = accumulator + now_ns = monotonic_ns() if now_ns is None else now_ns + snap = accumulator.snapshot(now_ns) + self._baseline = {ch: (s.num_msgs, s.undecodable) for ch, s in snap.items()} + self._prev = {ch: (s.num_msgs, s.num_bytes) for ch, s in snap.items()} + self._prev_ns = now_ns - def handle(self, channel: str, data: bytes, timestamp_ns: Optional[int] = None) -> None: + def get_stats(self, now_ns: int | None = None) -> channel_stats_list: """ - Handle an LCM event and maintain per-channel lcm-spy stats. - """ - if channel == self.VIRTUAL_CHANNEL: - return - - if channel not in self._channel_data: - self._channel_data[channel] = ChannelData() - - lcm_type = self._registry.detect(data) - lcm_type_name = lcm_type.__name__ if lcm_type is not None else data[:8].hex() - self._channel_data[channel].message_received( - lcm_type_name, - len(data), - lcm_type is not None, - timestamp_ns=timestamp_ns, - ) - - def get_stats(self) -> channel_stats_list: + Compute stats for channels that received messages since this view was created. """ - Get the current stats for all channels. + now_ns = monotonic_ns() if now_ns is None else now_ns + snap = self._accumulator.snapshot(now_ns) + dt = (now_ns - self._prev_ns) / 1e9 - Returns: - channel_stats_list: A list of channel_stats objects for each channel. - """ stats_list = channel_stats_list() - for channel in sorted(self._channel_data): - data = self._channel_data[channel] - stats_list.channels.append(data.report(channel)) + for channel in sorted(snap): + s = snap[channel] + base_msgs, base_undecodable = self._baseline.get(channel, (0, 0)) + prev_msgs, prev_bytes = self._prev.get(channel, (0, 0)) + self._prev[channel] = (s.num_msgs, s.num_bytes) + if s.num_msgs <= base_msgs: + continue # nothing on this channel since the view was created + + hz = (s.num_msgs - prev_msgs) / dt if dt > 0 else 0.0 + stats = channel_stats() + stats.channel = channel + stats.type = s.type_name + stats.num_msgs = s.num_msgs - base_msgs + stats.latest_msg_timestamp_ns = s.latest_wall_ns + stats.hz = hz + stats.inv_hz = 1.0 / hz if hz > 0 else 9999.0 + stats.jitter = s.jitter_s + stats.bandwidth = (s.num_bytes - prev_bytes) / dt if dt > 0 else 0.0 + stats.undecodable = s.undecodable - base_undecodable + stats_list.channels.append(stats) + stats_list.num_channels = len(stats_list.channels) + self._prev_ns = now_ns return stats_list - def maybe_get_stats_bytes(self, interval_ns: int = 1_000_000_000) -> Optional[bytes]: - """ - Update internal rates and emit encoded stats if the interval has elapsed. - - Args: - interval_ns (int): Emission interval in nanoseconds. Default is 1 second. - - Returns: - Optional[bytes]: Encoded `channel_stats_list` payload when due, else None. - """ - timestamp = monotonic_ns() - if timestamp - self._last_emit_ts_ns < interval_ns: - return None - - self._last_emit_ts_ns = timestamp - for data in self._channel_data.values(): - data.update_hz_data(timestamp) - - stats_list = self.get_stats() - return stats_list.encode() + def get_stats_bytes(self, now_ns: int | None = None) -> bytes: + """Encoded `channel_stats_list` payload for the virtual channel.""" + return self.get_stats(now_ns).encode() diff --git a/lcm_websocket_server/lib/lcm_utils/types.py b/lcm_websocket_server/lib/lcm_utils/types.py index 8a11014..e588000 100644 --- a/lcm_websocket_server/lib/lcm_utils/types.py +++ b/lcm_websocket_server/lib/lcm_utils/types.py @@ -1,69 +1,100 @@ """ Utilities for working with LCM types and raw data. + +JSON conventions: LCM structs become objects keyed by field name, `bytes` +become hex strings, and non-finite floats (NaN, +/-inf) become null so the +output is always valid JSON. """ import json +import math from typing import Any -from lcmutils import LCMType +try: + import orjson +except ImportError: # optional extra + orjson = None + +# type -> tuple of field names for LCM types, or None for non-LCM types +_LCM_SLOTS: dict[type, tuple[str, ...] | None] = {} + + +def _lcm_slots(tp: type) -> tuple[str, ...] | None: + """Field names of an lcm-gen class, cached per type. Cheaper than a Protocol isinstance check.""" + try: + return _LCM_SLOTS[tp] + except KeyError: + slots = None + if hasattr(tp, "_get_packed_fingerprint") and hasattr(tp, "__slots__"): + slots = tuple(tp.__slots__) + _LCM_SLOTS[tp] = slots + return slots + + +def _encode_sequence(values) -> Any: + if not values: + return [] + first = type(values[0]) + # LCM arrays are homogeneous, so primitive arrays can skip per-element dispatch. + if first is float: + if all(map(math.isfinite, values)): + return values + return [v if math.isfinite(v) else None for v in values] + if first is int or first is str or first is bool: + return values + return [encode_value(v) for v in values] def encode_value(value: Any) -> Any: """ - Encode a value. - - If the value is an LCM event, encode it as a dictionary. If the value is a list, encode each element. Otherwise, return the value. - + Encode a value into JSON-serializable form. + Args: value: Value to encode. - + Returns: Encoded value. """ - if isinstance(value, LCMType): - return encode_event_dict(value) - elif isinstance(value, list): - return list(map(encode_value, value)) - elif isinstance(value, dict): - return {key: encode_value(value) for key, value in value.items()} - elif isinstance(value, bytes): + tp = type(value) + if tp is float: + return value if math.isfinite(value) else None + if tp is int or tp is str or tp is bool or value is None: + return value + if tp is list or tp is tuple: + return _encode_sequence(value) + if tp is bytes: return value.hex() - elif isinstance(value, float) and value != value: - return None + if tp is dict: + return {key: encode_value(v) for key, v in value.items()} + slots = _lcm_slots(tp) + if slots is not None: + return {slot: encode_value(getattr(value, slot)) for slot in slots} return value def encode_event_dict(event: object) -> dict: """ Encode an LCM event as a dictionary. - + Args: event: LCM event to encode. - + Returns: Dictionary representation of the event. """ - event_type = type(event) - event_dict = {} - - for slot in event_type.__slots__: - value = getattr(event, slot) - value = encode_value(value) - - event_dict[slot] = value - - return event_dict + slots = _lcm_slots(type(event)) or tuple(type(event).__slots__) + return {slot: encode_value(getattr(event, slot)) for slot in slots} def encode_event_json(channel: str, fingerprint: str, event: object, **kwargs) -> str: """ - Encode an LCM event as a JSON string. - + Encode an LCM event as a JSON string using the standard library. + Args: channel: Channel of the event. fingerprint: Fingerprint of the event. event: LCM event to encode. **kwargs: Keyword arguments to pass to json.dumps. - + Returns: JSON string representation of the event. """ @@ -72,3 +103,29 @@ def encode_event_json(channel: str, fingerprint: str, event: object, **kwargs) - "fingerprint": fingerprint, "event": encode_event_dict(event) if event is not None else {} }, **kwargs) + + +def _orjson_default(value: Any) -> Any: + """orjson fallback for types it does not serialize natively.""" + if type(value) is bytes: + return value.hex() + slots = _lcm_slots(type(value)) + if slots is not None: + return {slot: getattr(value, slot) for slot in slots} + raise TypeError(f"Type is not JSON serializable: {type(value).__name__}") + + +def encode_event_json_bytes(channel: str, fingerprint: str, event: object) -> bytes: + """ + Encode an LCM event as compact UTF-8 JSON. + + Uses orjson when installed (it walks arrays in C and maps non-finite + floats to null natively), otherwise the standard library. Both produce + equivalent JSON. + """ + if orjson is not None: + return orjson.dumps( + {"channel": channel, "fingerprint": fingerprint, "event": event if event is not None else {}}, + default=_orjson_default, + ) + return encode_event_json(channel, fingerprint, event, separators=(",", ":")).encode() diff --git a/lcm_websocket_server/lib/log.py b/lcm_websocket_server/lib/log.py index 27931b2..0f703d5 100644 --- a/lcm_websocket_server/lib/log.py +++ b/lcm_websocket_server/lib/log.py @@ -16,23 +16,25 @@ def get_logger(name: str, level: int = logging.DEBUG) -> logging.Logger: """ Get a logger. By default, the logger is attached to a StreamHandler with a predefined formatter for consistency. - + Args: name: Logger name. level: Logging level. - + Returns: Logger. """ - logger = logging.Logger(name, level) - logger.addHandler(STREAM_HANDLER) + logger = logging.getLogger(name) + logger.setLevel(level) + if STREAM_HANDLER not in logger.handlers: + logger.addHandler(STREAM_HANDLER) return logger def set_stream_handler_level(level: int): """ Set the logging level of the stream handler. - + Args: level: Logging level. """ @@ -42,12 +44,12 @@ def set_stream_handler_level(level: int): def set_stream_handler_verbosity(verbosity: int): """ Set the verbosity of the stream handler. - + - 0 = ERROR - 1 = WARNING - 2 = INFO - 3 = DEBUG - + Args: verbosity: Verbosity level. """ @@ -57,7 +59,7 @@ class LogMixin: """ Logging mixin. """ - + @property def logger(self) -> logging.Logger: """ @@ -65,5 +67,4 @@ def logger(self) -> logging.Logger: """ if not hasattr(self, "_logger"): self._logger = get_logger(self.__class__.__name__) - self._logger.addHandler(logging.NullHandler()) - return self._logger \ No newline at end of file + return self._logger diff --git a/lcm_websocket_server/lib/metrics.py b/lcm_websocket_server/lib/metrics.py new file mode 100644 index 0000000..92e9947 --- /dev/null +++ b/lcm_websocket_server/lib/metrics.py @@ -0,0 +1,103 @@ +""" +Server health metrics, exposed in the Prometheus text format. + +Counters are updated from the event loop, the LCM thread and encode workers. +Plain int increments are effectively atomic under the GIL; float +accumulation from worker threads takes a lock. +""" + +import asyncio +import threading +import time + +from lcm_websocket_server.lib.lcm_utils.pubsub import LCMObserver + +LOOP_PROBE_INTERVAL_S = 0.25 + + +class ServerMetrics: + """Counters and gauges describing server load and health.""" + + def __init__(self): + self.messages_received = 0 + self.frames_sent = 0 + self.bytes_sent = 0 + self.encode_requests = 0 + self.encodes = 0 + self.encode_errors = 0 + self.connections = 0 + self.rejected_connections = 0 + self._encode_seconds = 0.0 + self._encode_lock = threading.Lock() + self._active: set[LCMObserver] = set() + self._dropped_closed = 0 + self._loop_lag_max_s = 0.0 + + # ------------------------------------------------------------ updates + def record_message(self, channel: str, data: bytes, timestamp_ns: int) -> None: + """LCMRepublisher tap: count every received message.""" + self.messages_received += 1 + + def record_encode(self, seconds: float, error: bool) -> None: + with self._encode_lock: + self.encodes += 1 + self.encode_errors += error + self._encode_seconds += seconds + + def record_sent(self, num_bytes: int) -> None: + self.frames_sent += 1 + self.bytes_sent += num_bytes + + def client_connected(self, observer: LCMObserver) -> None: + self.connections += 1 + self._active.add(observer) + + def client_disconnected(self, observer: LCMObserver) -> None: + self._active.discard(observer) + self._dropped_closed += observer.drop_count + + async def probe_loop_lag(self) -> None: + """Track the worst event-loop scheduling delay; run as a task.""" + while True: + start = time.perf_counter() + await asyncio.sleep(LOOP_PROBE_INTERVAL_S) + lag = time.perf_counter() - start - LOOP_PROBE_INTERVAL_S + self._loop_lag_max_s = max(self._loop_lag_max_s, lag) + + # ------------------------------------------------------------ views + @property + def clients(self) -> int: + return len(self._active) + + @property + def dropped(self) -> int: + return self._dropped_closed + sum(o.drop_count for o in self._active) + + @property + def encode_seconds(self) -> float: + with self._encode_lock: + return self._encode_seconds + + def render(self) -> str: + """Prometheus text exposition. Resets the loop-lag maximum.""" + lag, self._loop_lag_max_s = self._loop_lag_max_s, 0.0 + rows = [ + ("lws_clients", "gauge", "Connected WebSocket clients", self.clients), + ("lws_connections_total", "counter", "Accepted WebSocket connections", self.connections), + ("lws_rejected_connections_total", "counter", "Connections closed for invalid requests", + self.rejected_connections), + ("lws_messages_received_total", "counter", "LCM messages received", self.messages_received), + ("lws_frames_sent_total", "counter", "WebSocket frames sent", self.frames_sent), + ("lws_bytes_sent_total", "counter", "Payload bytes sent (before compression)", self.bytes_sent), + ("lws_dropped_total", "counter", "Messages dropped from full client queues", self.dropped), + ("lws_encode_requests_total", "counter", "Encoded payload requests (hits + misses)", + self.encode_requests), + ("lws_encodes_total", "counter", "Handler encodes performed (cache misses)", self.encodes), + ("lws_encode_errors_total", "counter", "Handler encodes that raised", self.encode_errors), + ("lws_encode_seconds_total", "counter", "Time spent in handler encodes", self.encode_seconds), + ("lws_event_loop_lag_max_seconds", "gauge", "Worst event-loop delay since the last scrape", lag), + ] + lines = [] + for name, kind, help_text, value in rows: + lines += [f"# HELP {name} {help_text}", f"# TYPE {name} {kind}", f"{name} {value}"] + return "\n".join(lines) + "\n" diff --git a/lcm_websocket_server/lib/server.py b/lcm_websocket_server/lib/server.py index a21059a..3984ffb 100644 --- a/lcm_websocket_server/lib/server.py +++ b/lcm_websocket_server/lib/server.py @@ -1,21 +1,74 @@ import asyncio -import queue -from urllib.parse import unquote, urlparse, parse_qs -from typing import Optional +import os +import time +from concurrent.futures import ThreadPoolExecutor +from dataclasses import dataclass +from http import HTTPStatus +from urllib.parse import parse_qs, unquote, urlparse from lcmutils import LCMTypeRegistry from websockets.asyncio.server import ServerConnection, serve -from websockets.protocol import OPEN - -from lcm_websocket_server.lib.handler import LCMWebSocketHandler +from websockets.exceptions import ConnectionClosed +from websockets.extensions.permessage_deflate import ServerPerMessageDeflateFactory +from websockets.frames import CloseCode +from websockets.http11 import Request, Response + +from lcm_websocket_server.lib.handler import ( + DEFAULT_CACHE_DEPTH, + EncodeCache, + LCMWebSocketHandler, + TextPayload, +) from lcm_websocket_server.lib.lcm_utils.pubsub import ( + OBSERVER_QUEUE_MAXSIZE, + InvalidChannelRegex, LCMObserver, LCMRepublisher, - LCMTimedObserver, - OBSERVER_QUEUE_MAXSIZE, ) -from lcm_websocket_server.lib.lcm_utils.spy import LCMSpy +from lcm_websocket_server.lib.lcm_utils.spy import LCMSpy, SpyAccumulator from lcm_websocket_server.lib.log import LogMixin +from lcm_websocket_server.lib.metrics import ServerMetrics + +_TRUE_VALUES = {"1", "true", "yes", "on"} +# WebSocket close reasons are limited to 123 bytes. +_MAX_CLOSE_REASON = 120 + +# Light work (JSON) holds the GIL, so a few threads suffice to keep the loop free. +DEFAULT_LIGHT_WORKERS = 4 +# Heavy work (OpenCV) releases the GIL and parallelises across cores. +DEFAULT_HEAVY_WORKERS = min(8, os.cpu_count() or 1) + +# websockets keepalive defaults (seconds); None disables. +DEFAULT_PING_INTERVAL = 20.0 +DEFAULT_PING_TIMEOUT = 20.0 + + +@dataclass(frozen=True) +class ClientRequest: + """Subscription parameters parsed from the WebSocket request path.""" + + channel_regex: str + update_interval_ms: int | None = None + conflate: bool = False + + @classmethod + def parse(cls, path: str) -> "ClientRequest": + parsed = urlparse(path) + query = parse_qs(parsed.query) + + channel_regex = unquote(parsed.path.lstrip("/")) or ".*" + + update_interval_ms = None + if "update_interval_ms" in query: + try: + update_interval_ms = int(query["update_interval_ms"][0]) + except ValueError: + raise ValueError(f"Invalid update_interval_ms value: {query['update_interval_ms'][0]!r}") + if update_interval_ms <= 0: + raise ValueError("update_interval_ms must be positive") + + conflate = query.get("conflate", ["0"])[0].lower() in _TRUE_VALUES + return cls(channel_regex, update_interval_ms, conflate) class LCMWebSocketServer(LogMixin): @@ -31,19 +84,38 @@ def __init__( port: int, handler: LCMWebSocketHandler, lcm_republisher: LCMRepublisher, - empty_wait_seconds: float = 0.1, - spy_registry: Optional[LCMTypeRegistry] = None, + spy_registry: LCMTypeRegistry | None = None, observer_queue_maxsize: int = OBSERVER_QUEUE_MAXSIZE, spy_emit_interval_ns: int = 1_000_000_000, + light_workers: int = DEFAULT_LIGHT_WORKERS, + heavy_workers: int = DEFAULT_HEAVY_WORKERS, + encode_cache_depth: int = DEFAULT_CACHE_DEPTH, + compression: str | None = "deflate", + reuse_port: bool = False, + ping_interval: float | None = DEFAULT_PING_INTERVAL, + ping_timeout: float | None = DEFAULT_PING_TIMEOUT, ): self._host = host self._port = port self._handler = handler self._lcm_republisher = lcm_republisher - self._empty_wait_seconds = empty_wait_seconds self._spy_registry = spy_registry self._observer_queue_maxsize = observer_queue_maxsize self._spy_emit_interval_ns = spy_emit_interval_ns + self._spy_accumulator = ( + SpyAccumulator(spy_registry, window_ns=spy_emit_interval_ns) if spy_registry is not None else None + ) + + if compression not in ("deflate", None): + raise ValueError(f"Unsupported compression: {compression!r}") + self._compression = compression + self._reuse_port = reuse_port + self._ping_interval = ping_interval + self._ping_timeout = ping_timeout + self.metrics = ServerMetrics() + self._cache = EncodeCache(encode_cache_depth) + self._light_executor = ThreadPoolExecutor(light_workers, thread_name_prefix="lws-light") + self._heavy_executor = ThreadPoolExecutor(heavy_workers, thread_name_prefix="lws-heavy") self._server = None @@ -54,206 +126,196 @@ async def websocket_handler(self, websocket: ServerConnection): Args: websocket: The WebSocket connection """ - # Parse the path and query - parsed_url = urlparse(websocket.request.path) - query_params = parse_qs(parsed_url.query) - - # Parse the update interval in ms, if present in query params - update_interval_ms = None - if 'update_interval_ms' in query_params: - try: - update_interval_ms = int(query_params['update_interval_ms'][0]) - self.logger.info(f"Using update interval of {update_interval_ms} ms") - except ValueError: - self.logger.warning(f"Invalid update_interval_ms value: {query_params['update_interval_ms'][0]}") - client_host, client_port = websocket.remote_address[:2] - self.logger.info(f"Client {websocket.id} connected from {client_host}:{client_port} at {parsed_url.path}") + try: + request = ClientRequest.parse(websocket.request.path) + # Periodic mode only ever sends the latest message per channel, so it always conflates. + observer = LCMObserver( + channel_regex=request.channel_regex, + queue_maxsize=self._observer_queue_maxsize, + conflate=request.conflate or request.update_interval_ms is not None, + ) + except (ValueError, InvalidChannelRegex) as e: + self.logger.warning(f"Rejecting client {websocket.id} from {client_host}:{client_port}: {e}") + self.metrics.rejected_connections += 1 + await websocket.close(CloseCode.POLICY_VIOLATION, str(e)[:_MAX_CLOSE_REASON]) + return - channel_regex = unquote(parsed_url.path.lstrip('/')) - if not channel_regex: # empty path -> subscribe to all channels - channel_regex = '.*' + self.logger.info( + f"Client {websocket.id} connected from {client_host}:{client_port} at {websocket.request.path}" + ) - # Subscribe to the LCM republisher - observer = LCMObserver(channel_regex=channel_regex, queue_maxsize=self._observer_queue_maxsize) self._lcm_republisher.subscribe(observer) - - spy = None - spy_observer = None - if self._spy_registry is not None and observer.match(LCMSpy.VIRTUAL_CHANNEL): - spy = LCMSpy(self._spy_registry) - spy_observer = LCMTimedObserver(channel_regex=".*", queue_maxsize=self._observer_queue_maxsize) - self._lcm_republisher.subscribe(spy_observer) + self.metrics.client_connected(observer) + tasks = [] + if request.update_interval_ms is not None: + tasks.append(asyncio.create_task(self._periodic_loop(observer, websocket, request.update_interval_ms))) + else: + tasks.append(asyncio.create_task(self._stream_loop(observer, websocket))) + + if self._spy_accumulator is not None and observer.match(LCMSpy.VIRTUAL_CHANNEL): + tasks.append(asyncio.create_task(self._spy_loop(websocket, LCMSpy(self._spy_accumulator)))) self.logger.info(f"Enabled per-connection spy stats for client {websocket.id}") + closed = asyncio.create_task(websocket.wait_closed()) self.logger.debug(f"Active subscribers after connect: {self._lcm_republisher.subscriber_count}") try: - if update_interval_ms is not None: - await self._periodic_update_loop(observer, websocket, update_interval_ms, spy, spy_observer) - else: - await self._update_loop(observer, websocket, spy, spy_observer) - except Exception as e: - self.logger.error(f"Unexpected error in client {websocket.id}: {e}") + done, _ = await asyncio.wait([*tasks, closed], return_when=asyncio.FIRST_COMPLETED) + for task in done: + if task is closed or task.cancelled(): + continue + exc = task.exception() + if exc is not None and not isinstance(exc, ConnectionClosed): + self.logger.error(f"Unexpected error in client {websocket.id}: {exc!r}") finally: + for task in (*tasks, closed): + task.cancel() + await asyncio.gather(*tasks, closed, return_exceptions=True) self._lcm_republisher.unsubscribe(observer) - if spy_observer is not None: - self._lcm_republisher.unsubscribe(spy_observer) + self.metrics.client_disconnected(observer) self.logger.info( f"Client {websocket.id} disconnected; " f"active subscribers: {self._lcm_republisher.subscriber_count}" ) - async def _send_virtual_spy_if_due(self, websocket: ServerConnection, spy: Optional[LCMSpy]) -> None: - if spy is None: - return - - payload = spy.maybe_get_stats_bytes(self._spy_emit_interval_ns) - if payload is None: - return - - response = await asyncio.to_thread(self._handler.handle, LCMSpy.VIRTUAL_CHANNEL, payload) - if response is None: - return - - await websocket.send(response) - - def _drain_spy_observer(self, spy_observer: Optional[LCMTimedObserver], spy: Optional[LCMSpy]) -> None: - if spy_observer is None or spy is None: - return - - while True: - try: - channel, data, timestamp_ns = spy_observer.get(block=False) - except queue.Empty: - break - - spy.handle(channel, data, timestamp_ns=timestamp_ns) - spy_observer.task_done() + async def _encode(self, channel: str, data: bytes): + """ + Encode a message for sending, at most once per message across all clients. + Cache hits are served on the loop without a thread hop. + """ + self.metrics.encode_requests += 1 + return await self._cache.get_or_encode(channel, data, lambda: self._run_handler(channel, data)) - async def _update_loop( - self, - observer: LCMObserver, - websocket: ServerConnection, - spy: Optional[LCMSpy], - spy_observer: Optional[LCMTimedObserver], - ): + async def _run_handler(self, channel: str, data: bytes): """ - Update loop: dequeue and forward LCM messages as fast as the client can consume them. + Run handler.handle() on the appropriate worker pool so CPU-intensive work + does not block the event loop. Errors are logged and yield None. + """ + try: + executor = self._heavy_executor if self._handler.is_heavy(channel, data) else self._light_executor + return await asyncio.get_running_loop().run_in_executor(executor, self._timed_handle, channel, data) + except Exception as e: # noqa: BLE001 - a bad message must not end the stream + self.logger.error(f"Error during message handling on channel {channel!r}: {e!r}") + return None + + def _timed_handle(self, channel: str, data: bytes): + """handler.handle() with timing; runs in a worker thread.""" + start = time.perf_counter() + error = True + try: + result = self._handler.handle(channel, data) + error = False + return result + finally: + self.metrics.record_encode(time.perf_counter() - start, error) - handler.handle() is offloaded to a thread so CPU-intensive work (image - encoding, JSON serialisation) does not block the event loop. + async def _send(self, websocket: ServerConnection, payload) -> None: + if type(payload) is TextPayload: + await websocket.send(payload, text=True) + else: + await websocket.send(payload) + self.metrics.record_sent(len(payload)) - task_done() is guaranteed to be called for every successful get() via a - try/finally block, regardless of whether handle() or send() raises. + async def _stream_loop(self, observer: LCMObserver, websocket: ServerConnection): + """ + Forward messages as fast as the client can consume them. Waits on the + observer (no polling), so delivery latency is bounded by encode + send. """ while True: - self._drain_spy_observer(spy_observer, spy) + channel, data = await observer.get() + payload = await self._encode(channel, data) + if payload is not None: + await self._send(websocket, payload) - try: - channel, data = observer.get(block=False) - except queue.Empty: - if websocket.state is not OPEN: - break - try: - await self._send_virtual_spy_if_due(websocket, spy) - except Exception as e: - self.logger.debug(f"Error while sending spy response to client {websocket.id}: {e}") - if websocket.state is not OPEN: - break - await asyncio.sleep(self._empty_wait_seconds) - continue - - # task_done() is called in the finally so it is never skipped, - # even when handle() raises or send() fails. - try: - try: - response = await asyncio.to_thread(self._handler.handle, channel, data) - except Exception as e: - self.logger.error(f"Error during message handling: {e}") - continue # finally still runs - - if response is not None: - try: - await websocket.send(response) - except Exception as e: - self.logger.debug(f"Error while sending response to client {websocket.id}: {e}") - continue # finally still runs; skip spy on broken connection - finally: - observer.task_done() - - try: - await self._send_virtual_spy_if_due(websocket, spy) - except Exception as e: - self.logger.debug(f"Error while sending spy response to client {websocket.id}: {e}") - if websocket.state is not OPEN: - break - - async def _periodic_update_loop( - self, - observer: LCMObserver, - websocket: ServerConnection, - update_interval_ms: int, - spy: Optional[LCMSpy], - spy_observer: Optional[LCMTimedObserver], - ): + async def _periodic_loop(self, observer: LCMObserver, websocket: ServerConnection, update_interval_ms: int): """ - Periodic update loop: emit only the latest message per channel at a fixed interval. + Emit only the latest message per channel at a fixed interval. - handler.handle() is offloaded to a thread (same as _update_loop). + Deadlines are absolute so the period does not drift by the processing time. """ - interval_sec = update_interval_ms / 1000.0 - channel_latest_data: dict[str, bytes | None] = {} + loop = asyncio.get_running_loop() + interval = update_interval_ms / 1000.0 + deadline = loop.time() while True: - if websocket.state is not OPEN: - break - - await asyncio.sleep(interval_sec) - - self._drain_spy_observer(spy_observer, spy) - - # Drain the observer queue, keeping only the latest message per channel. - while True: - try: - channel, data = observer.get(block=False) - channel_latest_data[channel] = data - observer.task_done() - except queue.Empty: - break - - self._drain_spy_observer(spy_observer, spy) - - # Handle and send the latest message for each channel. - for channel, data in channel_latest_data.items(): - if data is None: - continue - - try: - response = await asyncio.to_thread(self._handler.handle, channel, data) - except Exception as e: - self.logger.error(f"Error during message handling: {e}") - continue - finally: - channel_latest_data[channel] = None - - if response is not None: - try: - await websocket.send(response) - except Exception as e: - self.logger.debug(f"Error while sending response to client {websocket.id}: {e}") - - try: - await self._send_virtual_spy_if_due(websocket, spy) - except Exception as e: - self.logger.debug(f"Error while sending spy response to client {websocket.id}: {e}") - if websocket.state is not OPEN: - break + deadline += interval + delay = deadline - loop.time() + if delay > 0: + await asyncio.sleep(delay) + else: + deadline = loop.time() # fell behind; do not burst to catch up + + for channel, data in observer.drain(): + payload = await self._encode(channel, data) + if payload is not None: + await self._send(websocket, payload) + + async def _spy_loop(self, websocket: ServerConnection, spy: LCMSpy): + """Emit the virtual spy channel at a fixed cadence.""" + loop = asyncio.get_running_loop() + interval = self._spy_emit_interval_ns / 1e9 + deadline = loop.time() + while True: + deadline += interval + await asyncio.sleep(max(0.0, deadline - loop.time())) + response = await self._encode(LCMSpy.VIRTUAL_CHANNEL, spy.get_stats_bytes()) + if response is not None: + await self._send(websocket, response) async def serve(self): """ Run the server. """ - async with serve(self.websocket_handler, self._host, self._port) as self._server: - await self._server.wait_closed() + self._lcm_republisher.add_tap(self.metrics.record_message) + if self._spy_accumulator is not None: + self._lcm_republisher.add_tap(self._spy_accumulator.record) + lag_probe = asyncio.create_task(self.metrics.probe_loop_lag()) + try: + async with serve( + self.websocket_handler, self._host, self._port, **self._serve_kwargs() + ) as self._server: + await self._server.wait_closed() + finally: + lag_probe.cancel() + self._lcm_republisher.remove_tap(self.metrics.record_message) + if self._spy_accumulator is not None: + self._lcm_republisher.remove_tap(self._spy_accumulator.record) + self._light_executor.shutdown(wait=False, cancel_futures=True) + self._heavy_executor.shutdown(wait=False, cancel_futures=True) + + def _process_request(self, connection: ServerConnection, request: Request) -> Response | None: + """ + Answer plain HTTP GETs for /healthz and /metrics on the WebSocket port. + WebSocket upgrade requests (any path) proceed to the handshake. + """ + if request.headers.get("Upgrade", "").lower() == "websocket": + return None + path = urlparse(request.path).path + if path == "/healthz": + return connection.respond(HTTPStatus.OK, "ok\n") + if path == "/metrics": + return connection.respond(HTTPStatus.OK, self.metrics.render()) + return None + + def _serve_kwargs(self) -> dict: + kwargs = { + "compression": None, + "process_request": self._process_request, + "ping_interval": self._ping_interval, + "ping_timeout": self._ping_timeout, + } + if self._compression == "deflate": + # websockets' default deflate settings with compression level 1: + # roughly half the CPU of the default level 6 for a similar ratio on JSON. + kwargs["extensions"] = [ + ServerPerMessageDeflateFactory( + server_max_window_bits=12, + client_max_window_bits=12, + compress_settings={"memLevel": 5, "level": 1}, + ) + ] + if self._reuse_port: + kwargs["reuse_port"] = True + return kwargs def close(self): """ diff --git a/pyproject.toml b/pyproject.toml index ceaa856..50ddc61 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,13 +1,13 @@ [project] name = "lcm-websocket-server" -version = "0.7.2" +version = "0.8.0" description = "WebSocket server for republishing LCM messages" authors = [ {name = "Kevin Barnard", email = "kbarnard@mbari.org"} ] license = {text = "MIT"} readme = "README.md" -requires-python = ">=3.9" +requires-python = ">=3.11" dependencies = [ "websockets>=16.0", "lcmlog-py>=0.1.0", @@ -20,6 +20,12 @@ image = [ "numpy>=1.26.4", "opencv-python-headless>=4.9.0.80", ] +orjson = [ + "orjson>=3.10", +] +uvloop = [ + "uvloop>=0.21", +] [project.scripts] lcm-websocket-server = "lcm_websocket_server.apps.json_proxy:main" @@ -38,8 +44,56 @@ dev = [ "pre-commit>=4.2.0", "pytest>=8.0", "pytest-asyncio>=0.23", + "ruff>=0.17,<0.18", +] +release = [ + "python-semantic-release>=10.7.0", ] [tool.pytest.ini_options] asyncio_mode = "auto" testpaths = ["tests"] +pythonpath = ["tests/lcmtypes", "."] +asyncio_default_fixture_loop_scope = "function" + +[tool.ruff] +target-version = "py311" +# lcm-gen output is not edited by hand +extend-exclude = [ + "lcm_websocket_server/lib/lcm_utils/channel_stats.py", + "lcm_websocket_server/lib/lcm_utils/channel_stats_list.py", + "tests/lcmtypes", +] + +[tool.semantic_release] +version_toml = ["pyproject.toml:project.version"] +tag_format = "v{version}" +commit_message = "chore(release): {version}\n\nAutomatically generated by python-semantic-release" +allow_zero_version = true +major_on_zero = false +# Keep uv.lock in sync with the bumped version and build the release assets +build_command = """ + uv lock --upgrade-package lcm-websocket-server + git add uv.lock + uv build +""" + +[tool.semantic_release.branches.main] +match = "main" +prerelease = false + +[tool.semantic_release.branches.develop] +match = "develop" +prerelease = true +prerelease_token = "rc" + +[tool.semantic_release.changelog] +mode = "update" +exclude_commit_patterns = ["^chore\\(release\\):"] + +[tool.semantic_release.changelog.default_templates] +changelog_file = "CHANGELOG.md" + +[tool.semantic_release.publish] +dist_glob_patterns = ["dist/*"] +upload_to_vcs_release = true diff --git a/scripts/docker_build.sh b/scripts/docker_build.sh index f79c551..95f4722 100755 --- a/scripts/docker_build.sh +++ b/scripts/docker_build.sh @@ -27,4 +27,4 @@ fi DOCKERIMAGE="mbari/lcm-websocket-server:$DOCKERTAG" echo "Building docker image $DOCKERIMAGE" -docker build -t $DOCKERIMAGE -f docker/$DOCKERFILE --build-arg VERSION=$VERSION . \ No newline at end of file +docker build -t $DOCKERIMAGE -f docker/$DOCKERFILE --build-arg VERSION=$VERSION . diff --git a/scripts/docker_build_all.sh b/scripts/docker_build_all.sh index 99c86c2..54a56fd 100755 --- a/scripts/docker_build_all.sh +++ b/scripts/docker_build_all.sh @@ -8,4 +8,4 @@ EXTS=( "dial" ) for ext in "${EXTS[@]}"; do ./scripts/docker_build.sh $ext -done \ No newline at end of file +done diff --git a/scripts/docker_push.sh b/scripts/docker_push.sh index 5b6ed5b..289d244 100755 --- a/scripts/docker_push.sh +++ b/scripts/docker_push.sh @@ -11,4 +11,4 @@ fi DOCKERIMAGE="mbari/lcm-websocket-server:$DOCKERTAG" echo "Pushing docker image $DOCKERIMAGE" -docker push $DOCKERIMAGE \ No newline at end of file +docker push $DOCKERIMAGE diff --git a/scripts/docker_push_all.sh b/scripts/docker_push_all.sh index 7bd9b66..5f3ad09 100755 --- a/scripts/docker_push_all.sh +++ b/scripts/docker_push_all.sh @@ -8,4 +8,4 @@ EXTS=( "dial" ) for ext in "${EXTS[@]}"; do ./scripts/docker_push.sh $ext -done \ No newline at end of file +done diff --git a/scripts/docker_update_latest_tags.sh b/scripts/docker_update_latest_tags.sh index 6d183e3..c79b29d 100755 --- a/scripts/docker_update_latest_tags.sh +++ b/scripts/docker_update_latest_tags.sh @@ -8,4 +8,4 @@ docker push mbari/lcm-websocket-server:latest for EXT in "${EXTS[@]}"; do docker tag mbari/lcm-websocket-server:$VERSION-$EXT mbari/lcm-websocket-server:latest-$EXT docker push mbari/lcm-websocket-server:latest-$EXT -done \ No newline at end of file +done diff --git a/tests/conftest.py b/tests/conftest.py index 0caec9d..16c192d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -3,34 +3,39 @@ All LCM interaction uses LCMRepublisher.inject() which bypasses the UDP multicast network entirely, so no LCM daemon or network is required. +LCM instances use the in-process memq provider so tests also work on hosts +without a multicast route (e.g. CI runners); subprocesses inherit it. """ +import os + +os.environ.setdefault("LCM_DEFAULT_URL", "memq://") + import asyncio import socket -from typing import AsyncIterator +from collections.abc import AsyncIterator import cv2 import numpy as np import pytest import pytest_asyncio +from lcmutils import LCMTypeRegistry from senlcm import image_t from stdlcm import header_t -from lcmutils import LCMTypeRegistry - from lcm_websocket_server.apps.dial_proxy import ( DialHandler, DownsamplingMJPEGEncoder, ImageMessageToJPEGHandler, ) from lcm_websocket_server.apps.json_proxy import JSONHandler +from lcm_websocket_server.lib.handler import LCMWebSocketHandler from lcm_websocket_server.lib.image import PixelFormat from lcm_websocket_server.lib.lcm_utils.channel_stats import channel_stats from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list from lcm_websocket_server.lib.lcm_utils.pubsub import LCMRepublisher from lcm_websocket_server.lib.server import LCMWebSocketServer - # --------------------------------------------------------------------------- # Port helpers # --------------------------------------------------------------------------- @@ -147,9 +152,6 @@ async def running_server( ) -> AsyncIterator[tuple[LCMWebSocketServer, int]]: """ Start a real LCMWebSocketServer on a free port and tear it down after each test. - - Uses empty_wait_seconds=0.001 so tests don't spend 100 ms waiting on each - empty-queue poll. """ port = free_port() server = LCMWebSocketServer( @@ -157,7 +159,6 @@ async def running_server( port, json_handler, republisher, - empty_wait_seconds=0.001, ) serve_task = asyncio.create_task(server.serve()) # Give the server time to bind and start accepting connections. @@ -168,6 +169,34 @@ async def running_server( server.close() try: await asyncio.wait_for(serve_task, timeout=2.0) - except (asyncio.TimeoutError, asyncio.CancelledError): + except (TimeoutError, asyncio.CancelledError): serve_task.cancel() await asyncio.gather(serve_task, return_exceptions=True) + + +@pytest_asyncio.fixture +async def server_factory(republisher: LCMRepublisher): + """ + Factory that starts a server with an arbitrary handler. + Returns an async callable: make(handler, **server_kwargs) -> (server, port). + Cleans up all started servers on teardown. + """ + started: list[tuple[LCMWebSocketServer, asyncio.Task]] = [] + + async def make(handler: LCMWebSocketHandler, **kwargs) -> tuple[LCMWebSocketServer, int]: + port = free_port() + server = LCMWebSocketServer("localhost", port, handler, republisher, **kwargs) + task = asyncio.create_task(server.serve()) + await asyncio.sleep(0.05) + started.append((server, task)) + return server, port + + yield make + + for server, task in started: + server.close() + try: + await asyncio.wait_for(task, timeout=2.0) + except (TimeoutError, asyncio.CancelledError): + task.cancel() + await asyncio.gather(task, return_exceptions=True) diff --git a/tests/lcmtypes/README.md b/tests/lcmtypes/README.md new file mode 100644 index 0000000..bcf7249 --- /dev/null +++ b/tests/lcmtypes/README.md @@ -0,0 +1,8 @@ +# Test LCM types + +Python LCM types used by the test suite, copied unmodified from the lcm-gen output of +[MolaRS](https://github.com/CoMPASLab/molars) (`stdlcm.header_t`, `senlcm.image_t`, +`senlcm.image_metadata_t`), so the tests run without MolaRS installed. + +pytest puts this directory first on `sys.path` (see `pythonpath` in `pyproject.toml`). +Regenerate from MolaRS if those message definitions change. diff --git a/tests/lcmtypes/senlcm/__init__.py b/tests/lcmtypes/senlcm/__init__.py new file mode 100644 index 0000000..464fbc7 --- /dev/null +++ b/tests/lcmtypes/senlcm/__init__.py @@ -0,0 +1,6 @@ +"""Subset of the MolaRS senlcm types used by the tests (generated by lcm-gen).""" + +from .image_metadata_t import image_metadata_t +from .image_t import image_t + +__all__ = ["image_metadata_t", "image_t"] diff --git a/tests/lcmtypes/senlcm/image_metadata_t.py b/tests/lcmtypes/senlcm/image_metadata_t.py new file mode 100644 index 0000000..6297e79 --- /dev/null +++ b/tests/lcmtypes/senlcm/image_metadata_t.py @@ -0,0 +1,74 @@ +"""LCM type definitions +This file automatically generated by lcm. +DO NOT MODIFY BY HAND!!!! +""" + +try: + import cStringIO.StringIO as BytesIO +except ImportError: + from io import BytesIO +import struct + +class image_metadata_t(object): + __slots__ = ["key", "n", "value"] + + __typenames__ = ["string", "int32_t", "byte"] + + __dimensions__ = [None, None, ["n"]] + + def __init__(self): + self.key = "" + self.n = 0 + self.value = b"" + + def encode(self): + buf = BytesIO() + buf.write(image_metadata_t._get_packed_fingerprint()) + self._encode_one(buf) + return buf.getvalue() + + def _encode_one(self, buf): + __key_encoded = self.key.encode('utf-8') + buf.write(struct.pack('>I', len(__key_encoded)+1)) + buf.write(__key_encoded) + buf.write(b"\0") + buf.write(struct.pack(">i", self.n)) + buf.write(bytearray(self.value[:self.n])) + + def decode(data): + if hasattr(data, 'read'): + buf = data + else: + buf = BytesIO(data) + if buf.read(8) != image_metadata_t._get_packed_fingerprint(): + raise ValueError("Decode error") + return image_metadata_t._decode_one(buf) + decode = staticmethod(decode) + + def _decode_one(buf): + self = image_metadata_t() + __key_len = struct.unpack('>I', buf.read(4))[0] + self.key = buf.read(__key_len)[:-1].decode('utf-8', 'replace') + self.n = struct.unpack(">i", buf.read(4))[0] + self.value = buf.read(self.n) + return self + _decode_one = staticmethod(_decode_one) + + def _get_hash_recursive(parents): + if image_metadata_t in parents: return 0 + tmphash = (0x4d25b1a682bbfdc7) & 0xffffffffffffffff + tmphash = (((tmphash<<1)&0xffffffffffffffff) + (tmphash>>63)) & 0xffffffffffffffff + return tmphash + _get_hash_recursive = staticmethod(_get_hash_recursive) + _packed_fingerprint = None + + def _get_packed_fingerprint(): + if image_metadata_t._packed_fingerprint is None: + image_metadata_t._packed_fingerprint = struct.pack(">Q", image_metadata_t._get_hash_recursive([])) + return image_metadata_t._packed_fingerprint + _get_packed_fingerprint = staticmethod(_get_packed_fingerprint) + + def get_hash(self): + """Get the LCM hash of the struct""" + return struct.unpack(">Q", image_metadata_t._get_packed_fingerprint())[0] + diff --git a/tests/lcmtypes/senlcm/image_t.py b/tests/lcmtypes/senlcm/image_t.py new file mode 100644 index 0000000..1ca795e --- /dev/null +++ b/tests/lcmtypes/senlcm/image_t.py @@ -0,0 +1,126 @@ +"""LCM type definitions +This file automatically generated by lcm. +DO NOT MODIFY BY HAND!!!! +""" + +try: + import cStringIO.StringIO as BytesIO +except ImportError: + from io import BytesIO +import struct + +import stdlcm.header_t + +import senlcm.image_metadata_t + +class image_t(object): + __slots__ = ["header", "width", "height", "row_stride", "pixelformat", "size", "data", "nmetadata", "metadata"] + + __typenames__ = ["stdlcm.header_t", "int32_t", "int32_t", "int32_t", "int32_t", "int32_t", "byte", "int32_t", "senlcm.image_metadata_t"] + + __dimensions__ = [None, None, None, None, None, None, ["size"], None, ["nmetadata"]] + + PIXEL_FORMAT_UYVY = 1498831189 + PIXEL_FORMAT_YUYV = 1448695129 + PIXEL_FORMAT_IYU1 = 827677001 + PIXEL_FORMAT_IYU2 = 844454217 + PIXEL_FORMAT_YUV420 = 842093913 + PIXEL_FORMAT_YUV411P = 1345401140 + PIXEL_FORMAT_I420 = 808596553 + PIXEL_FORMAT_NV12 = 842094158 + PIXEL_FORMAT_GRAY = 1497715271 + PIXEL_FORMAT_RGB = 859981650 + PIXEL_FORMAT_BGR = 861030210 + PIXEL_FORMAT_RGBA = 876758866 + PIXEL_FORMAT_BGRA = 877807426 + PIXEL_FORMAT_BAYER_BGGR = 825770306 + PIXEL_FORMAT_BAYER_GBRG = 844650584 + PIXEL_FORMAT_BAYER_GRBG = 861427800 + PIXEL_FORMAT_BAYER_RGGB = 878205016 + PIXEL_FORMAT_BE_BAYER16_BGGR = 826360386 + PIXEL_FORMAT_BE_BAYER16_GBRG = 843137602 + PIXEL_FORMAT_BE_BAYER16_GRBG = 859914818 + PIXEL_FORMAT_BE_BAYER16_RGGB = 876692034 + PIXEL_FORMAT_LE_BAYER16_BGGR = 826360396 + PIXEL_FORMAT_LE_BAYER16_GBRG = 843137612 + PIXEL_FORMAT_LE_BAYER16_GRBG = 859914828 + PIXEL_FORMAT_LE_BAYER16_RGGB = 876692044 + PIXEL_FORMAT_MJPEG = 1196444237 + PIXEL_FORMAT_BE_GRAY16 = 357 + PIXEL_FORMAT_LE_GRAY16 = 909199180 + PIXEL_FORMAT_BE_RGB16 = 358 + PIXEL_FORMAT_LE_RGB16 = 1279412050 + PIXEL_FORMAT_BE_SIGNED_GRAY16 = 359 + PIXEL_FORMAT_BE_SIGNED_RGB16 = 360 + PIXEL_FORMAT_FLOAT_GRAY32 = 842221382 + PIXEL_FORMAT_INVALID = -2 + PIXEL_FORMAT_ANY = -1 + + def __init__(self): + self.header = stdlcm.header_t() + self.width = 0 + self.height = 0 + self.row_stride = 0 + self.pixelformat = 0 + self.size = 0 + self.data = b"" + self.nmetadata = 0 + self.metadata = [] + + def encode(self): + buf = BytesIO() + buf.write(image_t._get_packed_fingerprint()) + self._encode_one(buf) + return buf.getvalue() + + def _encode_one(self, buf): + assert self.header._get_packed_fingerprint() == stdlcm.header_t._get_packed_fingerprint() + self.header._encode_one(buf) + buf.write(struct.pack(">iiiii", self.width, self.height, self.row_stride, self.pixelformat, self.size)) + buf.write(bytearray(self.data[:self.size])) + buf.write(struct.pack(">i", self.nmetadata)) + for i0 in range(self.nmetadata): + assert self.metadata[i0]._get_packed_fingerprint() == senlcm.image_metadata_t._get_packed_fingerprint() + self.metadata[i0]._encode_one(buf) + + def decode(data): + if hasattr(data, 'read'): + buf = data + else: + buf = BytesIO(data) + if buf.read(8) != image_t._get_packed_fingerprint(): + raise ValueError("Decode error") + return image_t._decode_one(buf) + decode = staticmethod(decode) + + def _decode_one(buf): + self = image_t() + self.header = stdlcm.header_t._decode_one(buf) + self.width, self.height, self.row_stride, self.pixelformat, self.size = struct.unpack(">iiiii", buf.read(20)) + self.data = buf.read(self.size) + self.nmetadata = struct.unpack(">i", buf.read(4))[0] + self.metadata = [] + for i0 in range(self.nmetadata): + self.metadata.append(senlcm.image_metadata_t._decode_one(buf)) + return self + _decode_one = staticmethod(_decode_one) + + def _get_hash_recursive(parents): + if image_t in parents: return 0 + newparents = parents + [image_t] + tmphash = (0x5f0325a1392627aa+ stdlcm.header_t._get_hash_recursive(newparents)+ senlcm.image_metadata_t._get_hash_recursive(newparents)) & 0xffffffffffffffff + tmphash = (((tmphash<<1)&0xffffffffffffffff) + (tmphash>>63)) & 0xffffffffffffffff + return tmphash + _get_hash_recursive = staticmethod(_get_hash_recursive) + _packed_fingerprint = None + + def _get_packed_fingerprint(): + if image_t._packed_fingerprint is None: + image_t._packed_fingerprint = struct.pack(">Q", image_t._get_hash_recursive([])) + return image_t._packed_fingerprint + _get_packed_fingerprint = staticmethod(_get_packed_fingerprint) + + def get_hash(self): + """Get the LCM hash of the struct""" + return struct.unpack(">Q", image_t._get_packed_fingerprint())[0] + diff --git a/tests/lcmtypes/stdlcm/__init__.py b/tests/lcmtypes/stdlcm/__init__.py new file mode 100644 index 0000000..d982849 --- /dev/null +++ b/tests/lcmtypes/stdlcm/__init__.py @@ -0,0 +1,5 @@ +"""Subset of the MolaRS stdlcm types used by the tests (generated by lcm-gen).""" + +from .header_t import header_t + +__all__ = ["header_t"] diff --git a/tests/lcmtypes/stdlcm/header_t.py b/tests/lcmtypes/stdlcm/header_t.py new file mode 100644 index 0000000..64996d6 --- /dev/null +++ b/tests/lcmtypes/stdlcm/header_t.py @@ -0,0 +1,72 @@ +"""LCM type definitions +This file automatically generated by lcm. +DO NOT MODIFY BY HAND!!!! +""" + +try: + import cStringIO.StringIO as BytesIO +except ImportError: + from io import BytesIO +import struct + +class header_t(object): + __slots__ = ["sequence", "timestamp", "frame_id"] + + __typenames__ = ["int32_t", "int64_t", "string"] + + __dimensions__ = [None, None, None] + + def __init__(self): + self.sequence = 0 + self.timestamp = 0 + self.frame_id = "" + + def encode(self): + buf = BytesIO() + buf.write(header_t._get_packed_fingerprint()) + self._encode_one(buf) + return buf.getvalue() + + def _encode_one(self, buf): + buf.write(struct.pack(">iq", self.sequence, self.timestamp)) + __frame_id_encoded = self.frame_id.encode('utf-8') + buf.write(struct.pack('>I', len(__frame_id_encoded)+1)) + buf.write(__frame_id_encoded) + buf.write(b"\0") + + def decode(data): + if hasattr(data, 'read'): + buf = data + else: + buf = BytesIO(data) + if buf.read(8) != header_t._get_packed_fingerprint(): + raise ValueError("Decode error") + return header_t._decode_one(buf) + decode = staticmethod(decode) + + def _decode_one(buf): + self = header_t() + self.sequence, self.timestamp = struct.unpack(">iq", buf.read(12)) + __frame_id_len = struct.unpack('>I', buf.read(4))[0] + self.frame_id = buf.read(__frame_id_len)[:-1].decode('utf-8', 'replace') + return self + _decode_one = staticmethod(_decode_one) + + def _get_hash_recursive(parents): + if header_t in parents: return 0 + tmphash = (0xa2111e7853888e66) & 0xffffffffffffffff + tmphash = (((tmphash<<1)&0xffffffffffffffff) + (tmphash>>63)) & 0xffffffffffffffff + return tmphash + _get_hash_recursive = staticmethod(_get_hash_recursive) + _packed_fingerprint = None + + def _get_packed_fingerprint(): + if header_t._packed_fingerprint is None: + header_t._packed_fingerprint = struct.pack(">Q", header_t._get_hash_recursive([])) + return header_t._packed_fingerprint + _get_packed_fingerprint = staticmethod(_get_packed_fingerprint) + + def get_hash(self): + """Get the LCM hash of the struct""" + return struct.unpack(">Q", header_t._get_packed_fingerprint())[0] + diff --git a/tests/test_cli.py b/tests/test_cli.py new file mode 100644 index 0000000..4043166 --- /dev/null +++ b/tests/test_cli.py @@ -0,0 +1,129 @@ +""" +Tests for shared CLI plumbing and server transport options. +""" + +import argparse +import asyncio +import json +import logging +import os +import sys + +import pytest +import websockets + +from lcm_websocket_server.lib.cli import ( + ServerOptions, + add_server_args, + build_registry, + parse_server_options, +) +from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list +from lcm_websocket_server.lib.server import LCMWebSocketServer +from tests.conftest import free_port, make_header_t + +logger = logging.getLogger("test-cli") + + +def parse(argv, compression_default="deflate"): + parser = argparse.ArgumentParser() + add_server_args(parser, compression_default) + return parse_server_options(parser.parse_args(argv), logger) + + +class TestServerOptions: + def test_defaults(self): + assert parse([]) == ServerOptions() + + def test_app_specific_compression_default(self): + assert parse([], compression_default="none").compression is None + + def test_flags(self): + opts = parse([ + "--host", "0.0.0.0", "--port", "1", "--channel", "NAV.*", "--queue-size", "8", + "--spy-interval", "0.5", "--compression", "none", "--processes", "3", "-vv", + ]) + assert opts == ServerOptions("0.0.0.0", 1, "NAV.*", 8, 500_000_000, None, False, 3, 2) + + def test_server_kwargs(self): + kwargs = ServerOptions(processes=2, compression=None, queue_size=8).server_kwargs() + assert kwargs == { + "observer_queue_maxsize": 8, + "spy_emit_interval_ns": 1_000_000_000, + "compression": None, + "reuse_port": True, + "ping_interval": 20.0, + "ping_timeout": 20.0, + } + + def test_zero_disables_keepalive(self): + opts = parse(["--ping-interval", "0", "--ping-timeout", "0"]) + assert opts.ping_interval is None and opts.ping_timeout is None + + def test_poll_interval_accepted_but_deprecated(self, caplog): + with caplog.at_level(logging.WARNING, logger="test-cli"): + parse(["--poll-interval", "0.1"]) + assert any("deprecated" in r.message for r in caplog.records) + + def test_invalid_processes(self): + with pytest.raises(SystemExit): + parse(["--processes", "0"]) + + +class TestBuildRegistry: + def test_registers_spy_types(self): + registry = build_registry(["stdlcm"], logger) + assert channel_stats_list in registry.types + + def test_returns_none_when_nothing_discovered(self): + assert build_registry(["no_such_package_xyz"], logger) is None + + +class TestCompression: + @pytest.mark.parametrize("compression, negotiated", [("deflate", True), (None, False)]) + async def test_permessage_deflate_negotiation(self, republisher, json_handler, compression, negotiated): + port = free_port() + server = LCMWebSocketServer("localhost", port, json_handler, republisher, compression=compression) + task = asyncio.create_task(server.serve()) + await asyncio.sleep(0.05) + try: + async with websockets.connect(f"ws://localhost:{port}/") as ws: + names = [ext.name for ext in ws.protocol.extensions] + assert ("permessage-deflate" in names) is negotiated + await asyncio.sleep(0.05) + republisher.inject("CH", make_header_t(sequence=4)) + assert json.loads(await asyncio.wait_for(ws.recv(), 3))["event"]["sequence"] == 4 + finally: + server.close() + await asyncio.wait_for(task, 3) + + def test_rejects_unknown_compression(self, republisher, json_handler): + with pytest.raises(ValueError): + LCMWebSocketServer("localhost", 0, json_handler, republisher, compression="brotli") + + +class TestMultiProcess: + async def test_json_proxy_serves_with_multiple_processes(self): + """End to end: the CLI starts 2 workers sharing a port; each serves the spy channel.""" + port = free_port() + env = {**os.environ, "PYTHONPATH": os.pathsep.join(sys.path)} + proc = await asyncio.create_subprocess_exec( + sys.executable, "-m", "lcm_websocket_server.apps.json_proxy", "--port", str(port), + "--processes", "2", "--spy-interval", "0.1", "--channel", "LWS_TEST_NO_TRAFFIC", "stdlcm", + env=env, + ) + try: + for _ in range(100): + try: + ws = await websockets.connect(f"ws://localhost:{port}/LWS_LCM_SPY") + break + except OSError: + await asyncio.sleep(0.1) + else: + pytest.fail("server did not start") + async with ws: + msg = json.loads(await asyncio.wait_for(ws.recv(), 5)) + assert msg["channel"] == "LWS_LCM_SPY" + finally: + proc.terminate() + await asyncio.wait_for(proc.wait(), 10) diff --git a/tests/test_dial_handler.py b/tests/test_dial_handler.py index 39e1f47..d6c443a 100644 --- a/tests/test_dial_handler.py +++ b/tests/test_dial_handler.py @@ -4,25 +4,21 @@ import inspect import json -import struct import cv2 import numpy as np import pytest from senlcm import image_t -from stdlcm import header_t from lcm_websocket_server.apps.dial_proxy import ( DialHandler, DownsamplingMJPEGEncoder, ImageMessageToJPEGHandler, ) -from lcm_websocket_server.lib.image import PixelFormat +from lcm_websocket_server.lib.handler import TextPayload from lcm_websocket_server.lib.lcm_utils.pubsub import LCMObserver, LCMRepublisher - from tests.conftest import make_bgr_image_t, make_header_t - # --------------------------------------------------------------------------- # Synchronous interface (Fix 2) # --------------------------------------------------------------------------- @@ -80,9 +76,9 @@ def test_image_t_produces_bytes_frame(self, dial_handler): result = dial_handler.handle("CAM", make_bgr_image_t()) assert isinstance(result, bytes) - def test_non_image_produces_str_json_frame(self, dial_handler): + def test_non_image_produces_text_json_frame(self, dial_handler): result = dial_handler.handle("STATE", make_header_t()) - assert isinstance(result, str) + assert isinstance(result, TextPayload) parsed = json.loads(result) assert parsed["channel"] == "STATE" @@ -121,36 +117,14 @@ def test_fingerprint_routing_matches_image_t(self, dial_handler): # --------------------------------------------------------------------------- -# Fix 3: EncodeCache on DialHandler +# Data identity (relied on by the server EncodeCache) # --------------------------------------------------------------------------- -class TestDialHandlerEncodeCache: - def _make_counting_handler(self, image_handler, json_handler): - encode_calls: list[str] = [] - - class CountingDialHandler(DialHandler): - def _encode_image_t(self_inner, channel, data): - encode_calls.append("image") - return super()._encode_image_t(channel, data) - - return CountingDialHandler(image_handler, json_handler), encode_calls - - def test_second_image_call_with_same_object_hits_cache( - self, image_handler, json_handler - ): - handler, calls = self._make_counting_handler(image_handler, json_handler) - data = make_bgr_image_t() - - r1 = handler.handle("CAM", data) - r2 = handler.handle("CAM", data) # same object → cache hit - - assert r1 == r2 - assert len(calls) == 1, f"Expected 1 encode, got {len(calls)}" - +class TestDataIdentity: def test_multiple_subscribers_share_same_data_object(self): """ When two connections subscribe to the same channel, inject() puts the - same data object into both queues, so the second call hits the cache. + same data object into both queues, so the server cache can share one encode. """ r = LCMRepublisher(".*") obs1, obs2 = LCMObserver(), LCMObserver() @@ -159,7 +133,63 @@ def test_multiple_subscribers_share_same_data_object(self): r.inject("CAM", make_bgr_image_t()) - _, data1 = obs1.get(block=False) - _, data2 = obs2.get(block=False) + _, data1 = obs1.get_nowait() + _, data2 = obs2.get_nowait() assert data1 is data2, "Both queues must hold the same bytes object" + + +class TestHeavyRouting: + def test_image_t_is_heavy(self, dial_handler): + assert dial_handler.is_heavy("CAM", make_bgr_image_t()) is True + + def test_other_types_are_light(self, dial_handler): + assert dial_handler.is_heavy("NAV", make_header_t()) is False + + +class TestImageRateLimit: + MS = 1_000_000 + + def _due_times(self, handler, arrivals_ms): + return [t for t in arrivals_ms if handler._image_due("CAM", t * self.MS)] + + def test_no_cap_passes_everything(self, image_handler, json_handler): + h = DialHandler(image_handler, json_handler) + assert self._due_times(h, range(0, 1000, 10)) == list(range(0, 1000, 10)) + + def test_cap_below_source_rate(self, image_handler, json_handler): + h = DialHandler(image_handler, json_handler, max_image_fps=5) # 10 Hz source + assert self._due_times(h, range(0, 1000, 100)) == [0, 200, 400, 600, 800] + + def test_fractional_ratio_averages_to_cap(self, image_handler, json_handler): + h = DialHandler(image_handler, json_handler, max_image_fps=7) # 10 Hz source + passed = self._due_times(h, range(0, 10_000, 100)) + assert 68 <= len(passed) <= 72 + + def test_cap_equal_to_jittery_source_passes_all(self, image_handler, json_handler): + h = DialHandler(image_handler, json_handler, max_image_fps=10) + arrivals = [i * 100 + (3 if i % 2 else -3) for i in range(1, 50)] + assert self._due_times(h, arrivals) == arrivals + + def test_channels_limited_independently(self, image_handler, json_handler): + h = DialHandler(image_handler, json_handler, max_image_fps=1) + assert h._image_due("A", 0) and h._image_due("B", 0) + assert not h._image_due("A", 10 * self.MS) + + def test_skipped_frame_returns_none(self, image_handler, json_handler): + h = DialHandler(image_handler, json_handler, max_image_fps=0.001) + assert h.handle("CAM", make_bgr_image_t()) is not None + assert h.handle("CAM", make_bgr_image_t()) is None + assert h.handle("NAV", make_header_t()) is not None # JSON unaffected + + def test_invalid_cap(self, image_handler, json_handler): + with pytest.raises(ValueError): + DialHandler(image_handler, json_handler, max_image_fps=0) + + +class TestNoOpResize: + def test_scale_one_does_not_resize(self, monkeypatch): + calls = [] + monkeypatch.setattr(cv2, "resize", lambda *a, **k: calls.append(1)) + DownsamplingMJPEGEncoder(scale=1.0).encode(np.zeros((4, 4, 3), np.uint8)) + assert calls == [] diff --git a/tests/test_encode_cache.py b/tests/test_encode_cache.py index de26225..615f0e7 100644 --- a/tests/test_encode_cache.py +++ b/tests/test_encode_cache.py @@ -1,114 +1,99 @@ """ -Tests for EncodeCache. +Tests for the loop-confined, single-flight EncodeCache. """ -import threading +import asyncio import pytest from lcm_websocket_server.lib.handler import EncodeCache -class TestEncodeCacheHitAndMiss: - def test_cache_miss_on_first_call(self): - cache = EncodeCache() - data = b"hello" - assert cache.get("CH", data) is None - - def test_cache_hit_after_put(self): - cache = EncodeCache() - data = b"hello" - result = b"encoded" - cache.put("CH", data, result) - assert cache.get("CH", data) is result # same object - - def test_cache_hit_uses_identity_not_equality(self): - """Two bytes objects with identical content but different identities are - different cache keys. - - LCM's encode() always allocates a new bytes object, making it a reliable - source of same-content, different-identity pairs. - """ - from stdlcm import header_t - - msg = header_t() - msg.sequence = 42 - data_a = msg.encode() - data_b = msg.encode() # same content, new allocation - assert data_a == data_b, "Sanity: content must be equal" - assert data_a is not data_b, "LCM encode() must return fresh bytes each call" - - result = b"encoded" - cache = EncodeCache() - cache.put("CH", data_a, result) - - # data_a → hit - assert cache.get("CH", data_a) is result - # data_b has equal content but a different identity → miss - assert cache.get("CH", data_b) is None - - def test_cache_is_per_channel(self): - cache = EncodeCache() - data = b"payload" - result_a = b"result_for_A" - result_b = b"result_for_B" - - cache.put("CHAN_A", data, result_a) - cache.put("CHAN_B", data, result_b) - - assert cache.get("CHAN_A", data) is result_a - assert cache.get("CHAN_B", data) is result_b - - def test_put_overwrites_previous_entry_for_channel(self): - cache = EncodeCache() - old_data = b"old" - new_data = b"new" - old_result = b"old_result" - new_result = b"new_result" - - cache.put("CH", old_data, old_result) - cache.put("CH", new_data, new_result) - - # The old entry is gone; only the new one remains. - assert cache.get("CH", old_data) is None - assert cache.get("CH", new_data) is new_result - - def test_unknown_channel_returns_none(self): - cache = EncodeCache() - assert cache.get("NONEXISTENT", b"data") is None - - -class TestEncodeCacheThreadSafety: - def test_concurrent_get_and_put_do_not_corrupt(self): - """ - Many threads doing get/put on the same cache should never raise or - return a result belonging to a different channel. - """ - cache = EncodeCache() - errors: list[Exception] = [] - iterations = 500 - - def worker(channel: str, data: bytes, result: bytes): - for _ in range(iterations): - try: - cache.put(channel, data, result) - got = cache.get(channel, data) - # If we get a hit it must be OUR result (not another channel's). - if got is not None and got is not result: - errors.append(ValueError( - f"Cache returned wrong result for {channel}: {got!r}" - )) - except Exception as exc: - errors.append(exc) - - threads = [ - threading.Thread(target=worker, args=(f"CH{i}", f"data{i}".encode(), f"res{i}".encode())) - for i in range(8) - ] - for t in threads: - t.start() - for t in threads: - t.join(timeout=10.0) - - assert not any(t.is_alive() for t in threads), "Worker thread hung" - assert not errors, f"Errors during concurrent cache access: {errors}" +class Encoder: + """Counts calls; optionally blocks until released to simulate a slow encode.""" + + def __init__(self, result="encoded", gate: asyncio.Event | None = None): + self.calls = 0 + self.result = result + self.gate = gate + + async def __call__(self): + self.calls += 1 + if self.gate is not None: + await self.gate.wait() + return self.result + + +class TestHitAndMiss: + async def test_second_request_for_same_object_is_cached(self): + cache, enc = EncodeCache(), Encoder() + data = b"x" + assert await cache.get_or_encode("CH", data, enc) == "encoded" + assert await cache.get_or_encode("CH", data, enc) == "encoded" + assert enc.calls == 1 + + async def test_identity_not_equality(self): + cache, enc = EncodeCache(), Encoder() + a, b = bytes(bytearray(b"same")), bytes(bytearray(b"same")) + assert a == b and a is not b + await cache.get_or_encode("CH", a, enc) + await cache.get_or_encode("CH", b, enc) + assert enc.calls == 2 + + async def test_per_channel(self): + cache, enc = EncodeCache(), Encoder() + data = b"x" + await cache.get_or_encode("A", data, enc) + await cache.get_or_encode("B", data, enc) + await cache.get_or_encode("A", data, enc) + assert enc.calls == 2 + + async def test_none_result_is_cached(self): + """Unencodable messages are not retried for every client.""" + cache, enc = EncodeCache(), Encoder(result=None) + data = b"x" + assert await cache.get_or_encode("CH", data, enc) is None + assert await cache.get_or_encode("CH", data, enc) is None + assert enc.calls == 1 + + +class TestDepth: + async def test_keeps_recent_messages_per_channel(self): + cache, enc = EncodeCache(depth=2), Encoder() + msgs = [bytes([i]) for i in range(3)] + for m in msgs: + await cache.get_or_encode("CH", m, enc) + assert enc.calls == 3 + await cache.get_or_encode("CH", msgs[1], enc) # still cached + await cache.get_or_encode("CH", msgs[2], enc) # still cached + assert enc.calls == 3 + await cache.get_or_encode("CH", msgs[0], enc) # evicted + assert enc.calls == 4 + + def test_invalid_depth(self): + with pytest.raises(ValueError): + EncodeCache(depth=0) + + +class TestSingleFlight: + async def test_concurrent_requests_share_one_encode(self): + gate = asyncio.Event() + cache, enc = EncodeCache(), Encoder(gate=gate) + data = b"x" + waiters = [asyncio.create_task(cache.get_or_encode("CH", data, enc)) for _ in range(10)] + await asyncio.sleep(0.01) + gate.set() + assert await asyncio.gather(*waiters) == ["encoded"] * 10 + assert enc.calls == 1 + + async def test_cancelling_one_waiter_does_not_cancel_the_encode(self): + gate = asyncio.Event() + cache, enc = EncodeCache(), Encoder(gate=gate) + data = b"x" + first = asyncio.create_task(cache.get_or_encode("CH", data, enc)) + second = asyncio.create_task(cache.get_or_encode("CH", data, enc)) + await asyncio.sleep(0.01) + first.cancel() + gate.set() + assert await second == "encoded" + assert enc.calls == 1 diff --git a/tests/test_image.py b/tests/test_image.py index c621d1f..c00e0d5 100644 --- a/tests/test_image.py +++ b/tests/test_image.py @@ -6,6 +6,9 @@ import numpy as np import pytest +from lcm_websocket_server.apps.dial_proxy import ( + DownsamplingMJPEGEncoder, +) from lcm_websocket_server.lib.image import ( BGRDecoder, GrayDecoder, @@ -15,11 +18,6 @@ RGBDecoder, UnsupportedPixelFormatError, get_decoder, - get_encoder, -) -from lcm_websocket_server.apps.dial_proxy import ( - DownsamplingMJPEGEncoder, - ImageMessageToJPEGHandler, ) W, H = 16, 12 # small enough to be fast; large enough to be non-trivial diff --git a/tests/test_json_handler.py b/tests/test_json_handler.py index 880a941..4bd08d4 100644 --- a/tests/test_json_handler.py +++ b/tests/test_json_handler.py @@ -4,19 +4,13 @@ import inspect import json -import queue -import pytest from stdlcm import header_t -from lcmutils import LCMTypeRegistry - -from lcm_websocket_server.apps.json_proxy import JSONHandler +from lcm_websocket_server.lib.handler import TextPayload from lcm_websocket_server.lib.lcm_utils.pubsub import LCMObserver, LCMRepublisher - from tests.conftest import make_header_t - # --------------------------------------------------------------------------- # Synchronous interface (Fix 2) # --------------------------------------------------------------------------- @@ -26,9 +20,9 @@ def test_handle_is_not_a_coroutine_function(self, json_handler): """handle() must be a plain def so asyncio.to_thread() can run it.""" assert not inspect.iscoroutinefunction(json_handler.handle) - def test_handle_returns_string_not_coroutine(self, json_handler): + def test_handle_returns_text_payload(self, json_handler): result = json_handler.handle("TEST", make_header_t()) - assert result is None or isinstance(result, str) + assert isinstance(result, TextPayload) def test_handle_returns_none_for_unknown_type(self, json_handler): garbage = b"\x00\x01\x02\x03\x04\x05\x06\x07" + b"not lcm data" @@ -79,66 +73,12 @@ def test_event_dict_contains_header_t_fields(self, json_handler): assert event["timestamp"] == 999 assert event["frame_id"] == "odom" - def test_nan_float_is_serialised_as_null(self, registry): - """NaN floats must not cause json.dumps to raise; they become JSON null.""" - from stdlcm import msg_t - msg = msg_t() - # msg_t has a 'data' bytes field; check for float fields in other types. - # Use encode_event_json directly to inject a NaN. - from lcm_websocket_server.lib.lcm_utils.types import encode_event_json - result = encode_event_json("CH", "ff" * 8, None) - parsed = json.loads(result) - assert parsed["event"] == {} - # --------------------------------------------------------------------------- -# Fix 3: Encode cache +# Data identity (relied on by the server EncodeCache) # --------------------------------------------------------------------------- -class TestJSONHandlerEncodeCache: - def _make_counting_handler(self, registry: LCMTypeRegistry) -> tuple[JSONHandler, list]: - """Return a JSONHandler subclass that records how many times _decode runs.""" - calls: list[int] = [] - - class CountingJSONHandler(JSONHandler): - def _decode(self_inner, data): - calls.append(1) - return super()._decode(data) - - return CountingJSONHandler(registry), calls - - def test_second_call_with_same_object_hits_cache(self, registry): - handler, calls = self._make_counting_handler(registry) - data = make_header_t(sequence=1) - - result1 = handler.handle("CH", data) - result2 = handler.handle("CH", data) # same object → cache hit - - assert result1 == result2 - assert len(calls) == 1, f"Expected 1 decode call, got {len(calls)}" - - def test_different_object_same_content_causes_re_encode(self, registry): - handler, calls = self._make_counting_handler(registry) - data_a = make_header_t(sequence=1) - data_b = make_header_t(sequence=1) # equal content, different object - assert data_a is not data_b - - handler.handle("CH", data_a) - handler.handle("CH", data_b) - - assert len(calls) == 2, "Different objects must each trigger a decode" - - def test_cache_is_per_channel(self, registry): - """Same data object on different channels should encode independently.""" - handler, calls = self._make_counting_handler(registry) - data = make_header_t() - - handler.handle("CHAN_A", data) - handler.handle("CHAN_B", data) - handler.handle("CHAN_A", data) # hit - - assert len(calls) == 2, "Expected 2 decodes (one per channel), got {len(calls)}" - +class TestDataIdentity: def test_republisher_puts_same_object_in_all_queues(self): """ LCMRepublisher must place the exact same bytes object into every @@ -151,7 +91,7 @@ def test_republisher_puts_same_object_in_all_queues(self): r.inject("CH", make_header_t()) - items = [obs.get(block=False) for obs in observers] + items = [obs.get_nowait() for obs in observers] data_objects = [item[1] for item in items] first = data_objects[0] diff --git a/tests/test_metrics.py b/tests/test_metrics.py new file mode 100644 index 0000000..53a7a8d --- /dev/null +++ b/tests/test_metrics.py @@ -0,0 +1,99 @@ +""" +Tests for ServerMetrics and the /healthz and /metrics HTTP endpoints. +""" + +import asyncio +import urllib.error +import urllib.request + +import pytest +import websockets + +from lcm_websocket_server.lib.handler import LCMWebSocketHandler +from lcm_websocket_server.lib.lcm_utils.pubsub import LCMObserver +from lcm_websocket_server.lib.metrics import ServerMetrics +from tests.conftest import make_header_t + + +def parse_metrics(text: str) -> dict[str, float]: + return { + line.split()[0]: float(line.split()[1]) + for line in text.splitlines() + if line and not line.startswith("#") + } + + +def http_get(port: int, path: str) -> tuple[int, str]: + try: + with urllib.request.urlopen(f"http://localhost:{port}{path}", timeout=3) as resp: + return resp.status, resp.read().decode() + except urllib.error.HTTPError as e: + return e.code, "" + + +class TestServerMetrics: + def test_render_is_prometheus_text(self): + m = ServerMetrics() + m.record_message("CH", b"x", 0) + m.record_encode(0.5, error=True) + m.record_sent(10) + values = parse_metrics(m.render()) + assert values["lws_messages_received_total"] == 1 + assert values["lws_encodes_total"] == 1 + assert values["lws_encode_errors_total"] == 1 + assert values["lws_encode_seconds_total"] == 0.5 + assert values["lws_frames_sent_total"] == 1 + assert values["lws_bytes_sent_total"] == 10 + + def test_drops_counted_for_active_and_closed_clients(self): + m = ServerMetrics() + a, b = LCMObserver(queue_maxsize=1), LCMObserver(queue_maxsize=1) + m.client_connected(a) + m.client_connected(b) + for obs in (a, b): + for _ in range(3): + obs.handle(("CH", b"x")) # 2 drops each + m.client_disconnected(a) + assert m.clients == 1 + assert m.dropped == 4 + + +class TestHttpEndpoints: + async def test_healthz(self, running_server): + _, port = running_server + assert await asyncio.to_thread(http_get, port, "/healthz") == (200, "ok\n") + + async def test_metrics_reflect_traffic(self, server_factory, republisher): + class Echo(LCMWebSocketHandler): + def handle(self, channel, data): + return data + + _, port = await server_factory(Echo()) + async with websockets.connect(f"ws://localhost:{port}/") as ws1, websockets.connect( + f"ws://localhost:{port}/" + ) as ws2: + await asyncio.sleep(0.05) + republisher.inject("CH", make_header_t()) + await asyncio.wait_for(asyncio.gather(ws1.recv(), ws2.recv()), 3) + status, body = await asyncio.to_thread(http_get, port, "/metrics") + assert status == 200 + values = parse_metrics(body) + assert values["lws_clients"] == 2 + assert values["lws_messages_received_total"] == 1 + assert values["lws_encode_requests_total"] == 2 + assert values["lws_encodes_total"] == 1 # shared across both clients + assert values["lws_frames_sent_total"] == 2 + + async def test_websocket_on_metrics_path_is_still_a_subscription(self, running_server, republisher): + """Only plain HTTP requests are intercepted; a WebSocket may subscribe to any channel regex.""" + _, port = running_server + async with websockets.connect(f"ws://localhost:{port}/metrics") as ws: + await asyncio.sleep(0.05) + republisher.inject("metrics", make_header_t(sequence=9)) + assert "metrics" in await asyncio.wait_for(ws.recv(), 3) + + @pytest.mark.parametrize("path", ["/", "/other"]) + async def test_other_plain_http_paths_rejected(self, running_server, path): + _, port = running_server + status, _ = await asyncio.to_thread(http_get, port, path) + assert status >= 400 diff --git a/tests/test_pubsub.py b/tests/test_pubsub.py index c2db035..9e7d378 100644 --- a/tests/test_pubsub.py +++ b/tests/test_pubsub.py @@ -1,7 +1,8 @@ """ -Tests for LCMObserver, LCMTimedObserver, and LCMRepublisher. +Tests for LCMObserver and LCMRepublisher. """ +import asyncio import queue import threading import time @@ -10,15 +11,14 @@ from stdlcm import header_t from lcm_websocket_server.lib.lcm_utils.pubsub import ( + MAX_CHANNEL_REGEX_LENGTH, OBSERVER_QUEUE_MAXSIZE, + InvalidChannelRegex, LCMObserver, LCMRepublisher, - LCMTimedObserver, ) - from tests.conftest import make_header_t - # --------------------------------------------------------------------------- # LCMObserver: queue bounds and drop-oldest # --------------------------------------------------------------------------- @@ -26,17 +26,17 @@ class TestLCMObserverBoundedQueue: def test_default_maxsize_is_observer_queue_maxsize(self): obs = LCMObserver() - assert obs._queue.maxsize == OBSERVER_QUEUE_MAXSIZE + assert obs._maxsize == OBSERVER_QUEUE_MAXSIZE def test_custom_maxsize_is_respected(self): obs = LCMObserver(queue_maxsize=4) - assert obs._queue.maxsize == 4 + assert obs._maxsize == 4 def test_queue_accepts_messages_up_to_maxsize(self): obs = LCMObserver(queue_maxsize=4) for i in range(4): obs.handle(("CH", make_header_t(sequence=i))) - assert obs._queue.qsize() == 4 + assert len(obs) == 4 def test_drop_oldest_when_full(self): """When the queue is full the oldest entry is evicted, not the newest.""" @@ -48,14 +48,13 @@ def test_drop_oldest_when_full(self): # Overflow with a new message: oldest (seq=0) should be dropped. obs.handle(("CH", make_header_t(sequence=99))) # queue: [1, 2, 99] - assert obs._queue.qsize() == 3 + assert len(obs) == 3 sequences = [] while True: try: - _, data = obs.get(block=False) + _, data = obs.get_nowait() sequences.append(header_t.decode(data).sequence) - obs.task_done() except queue.Empty: break @@ -71,14 +70,13 @@ def test_latest_message_always_present_after_many_overflows(self): obs.handle(("CH", make_header_t(sequence=i))) # The queue should hold exactly the last `maxsize` messages. - assert obs._queue.qsize() == maxsize + assert len(obs) == maxsize sequences = [] while True: try: - _, data = obs.get(block=False) + _, data = obs.get_nowait() sequences.append(header_t.decode(data).sequence) - obs.task_done() except queue.Empty: break @@ -111,27 +109,6 @@ def test_drop_warning_rate_limited_to_powers_of_ten(self, caplog): drop_warnings = [r for r in caplog.records if "dropped" in r.message] assert len(drop_warnings) == 3 - def test_task_done_count_balanced_after_drop(self): - """ - Each dropped item calls task_done() internally so queue.join() never - deadlocks when the caller calls task_done() for the item it consumed. - """ - obs = LCMObserver(queue_maxsize=2) - for i in range(4): # 2 overflow → 2 internal task_done() calls - obs.handle(("CH", make_header_t(sequence=i))) - - # Consume both surviving items and call task_done(). - for _ in range(2): - obs.get(block=False) - obs.task_done() - - # join() should return immediately (all tasks done). - done = threading.Event() - t = threading.Thread(target=lambda: (obs._queue.join(), done.set()), daemon=True) - t.start() - t.join(timeout=1.0) - assert done.is_set(), "queue.join() did not return — task_done() accounting is broken" - # --------------------------------------------------------------------------- # LCMObserver: channel regex matching @@ -157,49 +134,13 @@ def test_matches_regex_pattern(self): assert obs.match("CAM_REAR") is True assert obs.match("IMU") is False - def test_invalid_regex_returns_false(self): - obs = LCMObserver(channel_regex="[invalid") - assert obs.match("anything") is False + def test_invalid_regex_raises(self): + with pytest.raises(InvalidChannelRegex): + LCMObserver(channel_regex="[invalid") - -# --------------------------------------------------------------------------- -# LCMTimedObserver -# --------------------------------------------------------------------------- - -class TestLCMTimedObserver: - def test_includes_monotonic_timestamp(self): - obs = LCMTimedObserver() - before = time.monotonic_ns() - obs.handle(("CH", make_header_t())) - after = time.monotonic_ns() - - _, _, ts = obs.get(block=False) - obs.task_done() - - assert before <= ts <= after - - def test_drop_oldest_preserves_latest_timestamps(self): - obs = LCMTimedObserver(queue_maxsize=2) - for i in range(5): - obs.handle(("CH", make_header_t(sequence=i))) - time.sleep(0.001) # Ensure distinct timestamps - - assert obs._queue.qsize() == 2 - - items = [] - while True: - try: - items.append(obs.get(block=False)) - obs.task_done() - except queue.Empty: - break - - # Timestamps should be strictly increasing (oldest-first FIFO). - timestamps = [item[2] for item in items] - assert timestamps == sorted(timestamps) - # And they should correspond to the last two messages. - sequences = [header_t.decode(item[1]).sequence for item in items] - assert sequences == [3, 4] + def test_overlong_regex_raises(self): + with pytest.raises(InvalidChannelRegex): + LCMObserver(channel_regex="A" * (MAX_CHANNEL_REGEX_LENGTH + 1)) # --------------------------------------------------------------------------- @@ -214,7 +155,7 @@ def test_dispatches_to_matching_observer(self): r.inject("SENSOR", make_header_t(sequence=7)) - ch, data = obs.get(block=False) + ch, data = obs.get_nowait() assert ch == "SENSOR" assert header_t.decode(data).sequence == 7 @@ -226,7 +167,7 @@ def test_does_not_dispatch_to_non_matching_observer(self): r.inject("SENSOR", make_header_t()) with pytest.raises(queue.Empty): - obs.get(block=False) + obs.get_nowait() def test_dispatches_same_data_object_to_all_matching_observers(self): """ @@ -243,9 +184,9 @@ def test_dispatches_same_data_object_to_all_matching_observers(self): r.inject("CH", make_header_t()) - _, data1 = obs1.get(block=False) - _, data2 = obs2.get(block=False) - _, data3 = obs3.get(block=False) + _, data1 = obs1.get_nowait() + _, data2 = obs2.get_nowait() + _, data3 = obs3.get_nowait() # All three must be the exact same Python object (identity, not equality). assert data1 is data2 @@ -260,7 +201,7 @@ def test_unsubscribe_stops_delivery(self): r.inject("CH", make_header_t()) with pytest.raises(queue.Empty): - obs.get(block=False) + obs.get_nowait() def test_multiple_injects_delivered_in_order(self): r = LCMRepublisher(".*") @@ -272,9 +213,8 @@ def test_multiple_injects_delivered_in_order(self): sequences = [] for _ in range(5): - _, data = obs.get(block=False) + _, data = obs.get_nowait() sequences.append(header_t.decode(data).sequence) - obs.task_done() assert sequences == list(range(5)) @@ -298,7 +238,7 @@ def inject_loop(): for _ in range(2000): try: r.inject("CH", data) - except Exception as exc: + except Exception as exc: # noqa: BLE001 - collected and asserted below errors.append(exc) injector = threading.Thread(target=inject_loop, daemon=True) @@ -327,5 +267,150 @@ def test_subscribe_during_dispatch_does_not_lose_message(self): r.subscribe(obs) r.inject("CH", make_header_t(sequence=42)) - ch, data = obs.get(block=False) + _ch, data = obs.get_nowait() assert header_t.decode(data).sequence == 42 + + +# --------------------------------------------------------------------------- +# Lifecycle +# --------------------------------------------------------------------------- + +class TestLCMRepublisherLifecycle: + def test_stop_returns_promptly_on_quiet_bus(self): + """stop() must not hang waiting on a blocking lcm.handle() call.""" + rp = LCMRepublisher("LWS_TEST_QUIET_CHANNEL_NOBODY_PUBLISHES") + rp.start() + t0 = time.monotonic() + rp.stop() + assert time.monotonic() - t0 < 2.0 + + +# --------------------------------------------------------------------------- +# LCMObserver: conflation (latest per channel) +# --------------------------------------------------------------------------- + +class TestLCMObserverConflate: + def test_keeps_only_latest_per_channel(self): + obs = LCMObserver(conflate=True) + for i in range(10): + obs.handle(("A", make_header_t(sequence=i))) + obs.handle(("B", make_header_t(sequence=100))) + assert len(obs) == 2 + events = obs.drain() + assert [(ch, header_t.decode(d).sequence) for ch, d in events] == [("A", 9), ("B", 100)] + + def test_busy_channel_cannot_evict_quiet_channel(self): + obs = LCMObserver(conflate=True, queue_maxsize=2) + obs.handle(("QUIET", make_header_t(sequence=1))) + for i in range(1000): + obs.handle(("BUSY", make_header_t(sequence=i))) + channels = [ch for ch, _ in obs.drain()] + assert channels == ["QUIET", "BUSY"] + assert obs.drop_count == 0 + + def test_get_nowait_serves_in_insertion_order(self): + obs = LCMObserver(conflate=True) + obs.handle(("A", make_header_t(sequence=1))) + obs.handle(("B", make_header_t(sequence=2))) + obs.handle(("A", make_header_t(sequence=3))) + assert obs.get_nowait()[0] == "A" + assert obs.get_nowait()[0] == "B" + with pytest.raises(queue.Empty): + obs.get_nowait() + + +# --------------------------------------------------------------------------- +# LCMObserver: asyncio consumer +# --------------------------------------------------------------------------- + +class TestLCMObserverAsync: + async def test_get_returns_buffered_event_immediately(self): + obs = LCMObserver() + obs.handle(("CH", b"x")) + assert await asyncio.wait_for(obs.get(), 1.0) == ("CH", b"x") + + async def test_get_wakes_on_event_from_other_thread(self): + obs = LCMObserver() + threading.Timer(0.05, obs.handle, args=(("CH", b"x"),)).start() + t0 = time.monotonic() + assert await asyncio.wait_for(obs.get(), 1.0) == ("CH", b"x") + assert time.monotonic() - t0 < 0.5 + + @pytest.mark.parametrize("conflate", [False, True]) + async def test_no_lost_wakeups_under_concurrent_production(self, conflate): + """A producer thread racing the consumer must never leave it waiting with data buffered.""" + n = 20_000 + obs = LCMObserver(queue_maxsize=n, conflate=conflate) + + def produce(): + for i in range(n): + obs.handle((f"CH{i % 7}" if conflate else "CH", i.to_bytes(4, "big"))) + if i % 97 == 0: + time.sleep(0) # yield to vary interleavings + + threading.Thread(target=produce, daemon=True).start() + last = -1 + while last != n - 1: + _, data = await asyncio.wait_for(obs.get(), 2.0) + value = int.from_bytes(data, "big") + if not conflate: + assert value == last + 1 # FIFO, nothing dropped + last = max(last, value) + + +# --------------------------------------------------------------------------- +# LCMRepublisher: routing cache, taps, fault isolation +# --------------------------------------------------------------------------- + +class TestLCMRepublisherRouting: + def test_subscriber_added_after_route_cached_receives_messages(self): + r = LCMRepublisher(".*") + first = LCMObserver(channel_regex="CH") + r.subscribe(first) + r.inject("CH", b"1") # populates the route cache + + second = LCMObserver(channel_regex="C.*") + r.subscribe(second) + r.inject("CH", b"2") + assert second.get_nowait() == ("CH", b"2") + + def test_unsubscribe_invalidates_route(self): + r = LCMRepublisher(".*") + obs = LCMObserver() + r.subscribe(obs) + r.inject("CH", b"1") + r.unsubscribe(obs) + r.inject("CH", b"2") + assert obs.drain() == [("CH", b"1")] + + def test_regex_evaluated_once_per_channel(self): + calls = [] + + class CountingObserver(LCMObserver): + def match(self, channel): + calls.append(channel) + return super().match(channel) + + r = LCMRepublisher(".*") + r.subscribe(CountingObserver(queue_maxsize=1000)) + for _ in range(100): + r.inject("CH", b"x") + assert calls == ["CH"] + + def test_tap_called_with_arrival_timestamp(self): + r = LCMRepublisher(".*") + seen = [] + r.add_tap(lambda ch, data, ts: seen.append((ch, data, ts))) + before = time.monotonic_ns() + r.inject("CH", b"x") + assert seen and seen[0][:2] == ("CH", b"x") and seen[0][2] >= before + + def test_exceptions_do_not_escape_handle(self): + """An exception on the LCM thread would kill it; _handle must contain it.""" + r = LCMRepublisher(".*") + + def bad_tap(ch, data, ts): + raise RuntimeError("boom") + + r.add_tap(bad_tap) + r.inject("CH", b"x") # must not raise diff --git a/tests/test_server.py b/tests/test_server.py index 22ff1a2..2eacf32 100644 --- a/tests/test_server.py +++ b/tests/test_server.py @@ -7,27 +7,20 @@ """ import asyncio -import inspect import json -import queue import threading import time import pytest -import pytest_asyncio import websockets from stdlcm import header_t from lcm_websocket_server.lib.handler import LCMWebSocketHandler from lcm_websocket_server.lib.lcm_utils.pubsub import ( - LCMObserver, LCMRepublisher, - OBSERVER_QUEUE_MAXSIZE, ) -from lcm_websocket_server.lib.server import LCMWebSocketServer - -from tests.conftest import free_port, make_bgr_image_t, make_header_t - +from lcm_websocket_server.lib.server import ClientRequest, LCMWebSocketServer +from tests.conftest import make_header_t # --------------------------------------------------------------------------- # Helpers @@ -40,39 +33,6 @@ async def recv(ws) -> str | bytes: return await asyncio.wait_for(ws.recv(), timeout=RECV_TIMEOUT) -# --------------------------------------------------------------------------- -# Custom-handler server fixture factory -# --------------------------------------------------------------------------- - -@pytest_asyncio.fixture -async def server_factory(republisher: LCMRepublisher): - """ - Factory that starts a server with an arbitrary handler. - Returns an async callable: make(handler, **server_kwargs) -> (server, port). - Cleans up all started servers on teardown. - """ - started: list[tuple[LCMWebSocketServer, asyncio.Task]] = [] - - async def make(handler: LCMWebSocketHandler, **kwargs) -> tuple[LCMWebSocketServer, int]: - kwargs.setdefault("empty_wait_seconds", 0.001) - port = free_port() - server = LCMWebSocketServer("localhost", port, handler, republisher, **kwargs) - task = asyncio.create_task(server.serve()) - await asyncio.sleep(0.05) - started.append((server, task)) - return server, port - - yield make - - for server, task in started: - server.close() - try: - await asyncio.wait_for(task, timeout=2.0) - except (asyncio.TimeoutError, asyncio.CancelledError): - task.cancel() - await asyncio.gather(task, return_exceptions=True) - - # --------------------------------------------------------------------------- # Basic message delivery # --------------------------------------------------------------------------- @@ -81,7 +41,7 @@ class TestMessageDelivery: async def test_client_receives_injected_message( self, running_server, republisher: LCMRepublisher ): - server, port = running_server + _server, port = running_server async with websockets.connect(f"ws://localhost:{port}/") as ws: republisher.inject("SENSOR", make_header_t(sequence=7)) msg = json.loads(await recv(ws)) @@ -91,7 +51,7 @@ async def test_client_receives_injected_message( async def test_client_receives_multiple_messages_in_order( self, running_server, republisher: LCMRepublisher ): - server, port = running_server + _server, port = running_server async with websockets.connect(f"ws://localhost:{port}/") as ws: for i in range(5): republisher.inject("CH", make_header_t(sequence=i)) @@ -107,7 +67,7 @@ async def test_unknown_type_is_not_forwarded( self, running_server, republisher: LCMRepublisher ): """handle() returns None for unknown types; no WebSocket frame is sent.""" - server, port = running_server + _server, port = running_server async with websockets.connect(f"ws://localhost:{port}/") as ws: republisher.inject("CH", b"\x00" * 16) # unknown fingerprint republisher.inject("CH", make_header_t(sequence=42)) # known → delivered @@ -124,7 +84,7 @@ class TestChannelFiltering: async def test_client_only_receives_matching_channel( self, running_server, republisher: LCMRepublisher ): - server, port = running_server + _server, port = running_server # Subscribe only to IMU async with websockets.connect(f"ws://localhost:{port}/IMU") as ws: republisher.inject("GPS", make_header_t(sequence=1)) @@ -137,7 +97,7 @@ async def test_client_only_receives_matching_channel( async def test_regex_channel_filter( self, running_server, republisher: LCMRepublisher ): - server, port = running_server + _server, port = running_server async with websockets.connect(f"ws://localhost:{port}/CAM_.*") as ws: republisher.inject("IMU", make_header_t(sequence=0)) republisher.inject("CAM_FRONT", make_header_t(sequence=1)) @@ -164,10 +124,10 @@ async def test_handle_called_from_worker_thread( class ThreadCapturingHandler(LCMWebSocketHandler): def handle(self, channel, data): handle_thread_ids.append(threading.get_ident()) - return None # don't send anything; we only care about the thread + # don't send anything; we only care about the thread _, port = await server_factory(ThreadCapturingHandler()) - async with websockets.connect(f"ws://localhost:{port}/") as ws: + async with websockets.connect(f"ws://localhost:{port}/"): republisher.inject("CH", make_header_t()) # Give the server time to process the message. await asyncio.sleep(0.1) @@ -191,10 +151,9 @@ async def test_slow_handle_does_not_block_event_loop( class SlowHandler(LCMWebSocketHandler): def handle(self, channel, data): time.sleep(SLEEP_S) - return None _, port = await server_factory(SlowHandler()) - async with websockets.connect(f"ws://localhost:{port}/") as ws: + async with websockets.connect(f"ws://localhost:{port}/"): republisher.inject("CH", make_header_t()) # While the slow handle() is running in a thread, an asyncio.sleep @@ -220,16 +179,16 @@ async def set_event(): # --------------------------------------------------------------------------- -# Fix 6: task_done() called even on errors +# Error handling and cleanup # --------------------------------------------------------------------------- -class TestTaskDoneInvariant: +class TestErrorHandlingAndCleanup: async def test_server_continues_processing_after_handler_exception( self, server_factory, republisher: LCMRepublisher ): """ - If handle() raises, task_done() must still be called and the server - must continue processing subsequent messages without deadlocking. + If handle() raises, the server must log it and continue processing + subsequent messages. """ call_count = 0 @@ -254,16 +213,14 @@ def handle(self, channel, data): msg = json.loads(await recv(ws)) assert msg["sequence"] == 99 - async def test_queue_unfinished_tasks_is_zero_after_successful_message( + async def test_observer_unsubscribed_after_disconnect( self, running_server, republisher: LCMRepublisher ): """ After a message is delivered and the client disconnects, the server's - websocket_handler coroutine must finish and call unsubscribe(). This - proves task_done() was called (otherwise the loop would stall before - unsubscribing) and that cleanup is correct. + websocket_handler coroutine must finish and call unsubscribe(). """ - server, port = running_server + _server, port = running_server async with websockets.connect(f"ws://localhost:{port}/") as ws: republisher.inject("CH", make_header_t()) await recv(ws) @@ -272,12 +229,7 @@ async def test_queue_unfinished_tasks_is_zero_after_successful_message( # closed connection, exit the update loop, and call unsubscribe(). await asyncio.sleep(0.2) - with republisher._subscribers_lock: - snapshot = list(republisher._subscribers) - assert len(snapshot) == 0, ( - "Observer was not unsubscribed after disconnect; " - "the update loop may have stalled (task_done() not called)" - ) + assert republisher.subscriber_count == 0, "Observer was not unsubscribed after disconnect" # --------------------------------------------------------------------------- @@ -311,7 +263,7 @@ async def test_update_interval_ms_query_param_throttles_delivery( With ?update_interval_ms=50, messages are batched and only the latest per channel is delivered at each tick. """ - server, port = running_server + _server, port = running_server url = f"ws://localhost:{port}/?update_interval_ms=50" async with websockets.connect(url) as ws: # Inject three messages quickly; only the last should survive batching. @@ -354,7 +306,7 @@ def handle(self, channel, data): try: msg = json.loads(await asyncio.wait_for(ws.recv(), timeout=2.0)) received.append(msg["sequence"]) - except asyncio.TimeoutError: + except TimeoutError: break # We should have received at most 2 messages (the bounded cap), and @@ -371,7 +323,7 @@ class TestMultipleClients: async def test_all_clients_receive_injected_message( self, running_server, republisher: LCMRepublisher ): - server, port = running_server + _server, port = running_server url = f"ws://localhost:{port}/" async with ( websockets.connect(url) as ws1, @@ -395,7 +347,7 @@ async def test_slow_client_does_not_delay_fast_client( _, port = await server_factory(json_handler, observer_queue_maxsize=4) url = f"ws://localhost:{port}/" async with ( - websockets.connect(url) as slow_ws, + websockets.connect(url), websockets.connect(url) as fast_ws, ): # Flood both queues; the slow client never drains, the fast one will. @@ -409,9 +361,194 @@ async def test_slow_client_does_not_delay_fast_client( try: msg = json.loads(await asyncio.wait_for(fast_ws.recv(), timeout=2.0)) received.append(msg["event"]["sequence"]) - except asyncio.TimeoutError: + except TimeoutError: break elapsed = time.monotonic() - t0 assert len(received) > 0, "Fast client received no messages" assert elapsed < 2.0, f"Fast client was blocked for {elapsed:.2f}s" + + +# --------------------------------------------------------------------------- +# Request parsing and validation +# --------------------------------------------------------------------------- + +class TestClientRequest: + def test_defaults(self): + req = ClientRequest.parse("/") + assert req == ClientRequest(".*", None, False) + + def test_url_decoded_regex_and_params(self): + req = ClientRequest.parse("/CAM_%2E%2A?update_interval_ms=250&conflate=true") + assert req == ClientRequest("CAM_.*", 250, True) + + @pytest.mark.parametrize("query", ["update_interval_ms=abc", "update_interval_ms=0", "update_interval_ms=-5"]) + def test_invalid_update_interval_rejected(self, query): + with pytest.raises(ValueError): + ClientRequest.parse(f"/?{query}") + + +class TestRequestRejection: + @pytest.mark.parametrize("path", ["/[invalid", "/?update_interval_ms=abc"]) + async def test_invalid_request_closed_with_policy_violation(self, running_server, path): + _, port = running_server + async with websockets.connect(f"ws://localhost:{port}{path}") as ws: + with pytest.raises(websockets.ConnectionClosed) as info: + await recv(ws) + assert info.value.rcvd.code == 1008 + + +# --------------------------------------------------------------------------- +# Event-driven delivery +# --------------------------------------------------------------------------- + +class TestEventDrivenDelivery: + async def test_message_after_idle_period_is_delivered_promptly( + self, running_server, republisher: LCMRepublisher + ): + """No polling: a message arriving after an idle period is not delayed by a sleep interval.""" + _, port = running_server + async with websockets.connect(f"ws://localhost:{port}/") as ws: + await asyncio.sleep(0.3) + t0 = time.monotonic() + republisher.inject("CH", make_header_t(sequence=1)) + await recv(ws) + assert time.monotonic() - t0 < 0.05 + + async def test_idle_client_disconnect_unsubscribes_promptly( + self, running_server, republisher: LCMRepublisher + ): + _, port = running_server + async with websockets.connect(f"ws://localhost:{port}/"): + await asyncio.sleep(0.05) + assert republisher.subscriber_count == 1 + for _ in range(50): + if republisher.subscriber_count == 0: + break + await asyncio.sleep(0.01) + assert republisher.subscriber_count == 0 + + +# --------------------------------------------------------------------------- +# Conflation +# --------------------------------------------------------------------------- + +class TestConflation: + async def _burst_then_collect(self, port, query, republisher): + async with websockets.connect(f"ws://localhost:{port}/{query}") as ws: + await asyncio.sleep(0.05) + # Synchronous burst: the server cannot drain between injections. + republisher.inject("QUIET", make_header_t(sequence=1)) + for i in range(50): + republisher.inject("BUSY", make_header_t(sequence=i)) + received = {} + while True: + try: + msg = json.loads(await asyncio.wait_for(ws.recv(), 0.3)) + except TimeoutError: + return received + received.setdefault(msg["channel"], []).append(msg["event"]["sequence"]) + + async def test_fifo_mode_busy_channel_evicts_quiet_channel(self, server_factory, json_handler, republisher): + _, port = await server_factory(json_handler, observer_queue_maxsize=4) + received = await self._burst_then_collect(port, "", republisher) + assert "QUIET" not in received + + async def test_conflate_mode_preserves_quiet_channel_and_latest_busy( + self, server_factory, json_handler, republisher + ): + _, port = await server_factory(json_handler, observer_queue_maxsize=4) + received = await self._burst_then_collect(port, "?conflate=1", republisher) + assert received == {"QUIET": [1], "BUSY": [49]} + + async def test_periodic_mode_preserves_quiet_channel(self, server_factory, json_handler, republisher): + _, port = await server_factory(json_handler, observer_queue_maxsize=4) + received = await self._burst_then_collect(port, "?update_interval_ms=50", republisher) + assert received == {"QUIET": [1], "BUSY": [49]} + + +# --------------------------------------------------------------------------- +# Spy virtual channel +# --------------------------------------------------------------------------- + +class TestSpyChannel: + async def test_spy_counts_every_message_even_when_client_queue_overflows( + self, server_factory, json_handler, registry, republisher: LCMRepublisher + ): + """Spy counts come from the shared tap, not from the (bounded) client queue.""" + _, port = await server_factory( + json_handler, spy_registry=registry, observer_queue_maxsize=2, spy_emit_interval_ns=200_000_000 + ) + async with websockets.connect(f"ws://localhost:{port}/LWS_LCM_SPY") as ws: + await asyncio.sleep(0.05) + for i in range(500): + republisher.inject("NAV", make_header_t(sequence=i)) + deadline = time.monotonic() + 3 + while time.monotonic() < deadline: + msg = json.loads(await recv(ws)) + assert msg["channel"] == "LWS_LCM_SPY" + channels = {c["channel"]: c for c in msg["event"]["channels"]} + if "NAV" in channels: + assert channels["NAV"]["num_msgs"] == 500 + break + else: + pytest.fail("NAV never reported by spy") + + async def test_spy_not_sent_to_clients_not_matching_virtual_channel( + self, server_factory, json_handler, registry, republisher: LCMRepublisher + ): + _, port = await server_factory(json_handler, spy_registry=registry, spy_emit_interval_ns=50_000_000) + async with websockets.connect(f"ws://localhost:{port}/NAV") as ws: + await asyncio.sleep(0.2) + republisher.inject("NAV", make_header_t(sequence=3)) + msg = json.loads(await recv(ws)) + assert msg["channel"] == "NAV" + + +# --------------------------------------------------------------------------- +# Shared encoding and worker pools +# --------------------------------------------------------------------------- + +class TestSharedEncoding: + async def test_message_encoded_once_for_many_clients(self, server_factory, republisher: LCMRepublisher): + """Concurrent clients must share one encode per message (no thundering herd).""" + calls = [] + + class SlowCountingHandler(LCMWebSocketHandler): + def handle(self, channel, data): + calls.append(data) + time.sleep(0.05) # long enough that all clients request concurrently + return json.dumps({"sequence": header_t.decode(data).sequence}) + + _, port = await server_factory(SlowCountingHandler()) + url = f"ws://localhost:{port}/" + clients = [await websockets.connect(url) for _ in range(8)] + try: + await asyncio.sleep(0.05) + republisher.inject("CH", make_header_t(sequence=5)) + msgs = await asyncio.gather(*(recv(ws) for ws in clients)) + assert all(json.loads(m)["sequence"] == 5 for m in msgs) + assert len(calls) == 1 + finally: + await asyncio.gather(*(ws.close() for ws in clients)) + + async def test_heavy_messages_run_on_heavy_pool(self, server_factory, republisher: LCMRepublisher): + thread_names = {} + + class RoutingHandler(LCMWebSocketHandler): + def is_heavy(self, channel, data): + return channel == "CAM" + + def handle(self, channel, data): + thread_names[channel] = threading.current_thread().name + return channel + + _, port = await server_factory(RoutingHandler()) + async with websockets.connect(f"ws://localhost:{port}/") as ws: + await asyncio.sleep(0.05) + republisher.inject("CAM", b"x") + republisher.inject("NAV", b"y") + await recv(ws) + await recv(ws) + assert thread_names["CAM"].startswith("lws-heavy") + assert thread_names["NAV"].startswith("lws-light") diff --git a/tests/test_spy.py b/tests/test_spy.py index e2fe78b..177e383 100644 --- a/tests/test_spy.py +++ b/tests/test_spy.py @@ -1,167 +1,131 @@ """ -Tests for LCMSpy and ChannelData statistics accumulation. +Tests for SpyAccumulator (shared counters) and LCMSpy (per-connection view). """ -import time - import pytest -from stdlcm import header_t - -from lcm_websocket_server.lib.lcm_utils.spy import ChannelData, LCMSpy +from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list +from lcm_websocket_server.lib.lcm_utils.pubsub import LCMRepublisher +from lcm_websocket_server.lib.lcm_utils.spy import ( + VIRTUAL_CHANNEL, + LCMSpy, + SpyAccumulator, +) from tests.conftest import make_header_t +S = 1_000_000_000 # one second in ns +T0 = 10 * S # arbitrary monotonic origin + + +@pytest.fixture +def acc(registry) -> SpyAccumulator: + return SpyAccumulator(registry, window_ns=S) + + +def stats_by_channel(stats_list: channel_stats_list) -> dict: + return {cs.channel: cs for cs in stats_list.channels} + # --------------------------------------------------------------------------- -# ChannelData: per-message accounting +# SpyAccumulator # --------------------------------------------------------------------------- -class TestChannelData: - def test_message_count_increments(self): - cd = ChannelData() - cd.message_received("header_t", 64, True) - cd.message_received("header_t", 64, True) - assert cd._num_msgs == 2 - - def test_undecodable_count_increments_on_failure(self): - cd = ChannelData() - cd.message_received("header_t", 64, decoded=True) - cd.message_received("??", 8, decoded=False) - assert cd._undecodable == 1 - - def test_hz_estimate_after_update(self): - cd = ChannelData() - start = time.monotonic_ns() - for _ in range(10): - cd.message_received("header_t", 64, True, timestamp_ns=start) - elapsed_ns = int(1e9) # Pretend 1 second elapsed - cd.update_hz_data(start + elapsed_ns) - # 10 messages in ~1 second → ~10 Hz - assert 5.0 < cd._hz < 20.0 - - def test_bandwidth_estimate(self): - cd = ChannelData() - start = time.monotonic_ns() - for _ in range(100): - cd.message_received("header_t", 1000, True, timestamp_ns=start) - cd.update_hz_data(start + int(1e9)) - # 100 * 1000 bytes in ~1 second = ~100 kB/s - assert 50_000 < cd._bandwidth < 200_000 - - def test_jitter_computed_from_interval_spread(self): - cd = ChannelData() - # Irregular spacing: 100ms, 200ms - t0 = time.monotonic_ns() - cd.message_received("h", 64, True, timestamp_ns=t0) - cd.message_received("h", 64, True, timestamp_ns=t0 + 100_000_000) - cd.message_received("h", 64, True, timestamp_ns=t0 + 300_000_000) - cd.update_hz_data(t0 + int(1e9)) - # jitter = max_interval - min_interval = 200ms - 100ms = 100ms - # ChannelData stores _min_interval / _max_interval in seconds after update. - assert cd._min_interval is not None - assert cd._max_interval is not None - stats = cd.report("CH") - # jitter ≈ 0.1 seconds (200ms - 100ms) - assert 0.05 < stats.jitter < 0.2, f"Unexpected jitter: {stats.jitter}" - - def test_report_populates_channel_stats_fields(self): - cd = ChannelData() - cd.message_received("header_t", 64, True) - start = time.monotonic_ns() - cd.update_hz_data(start + int(1e9)) - stats = cd.report("MY_CHANNEL") - assert stats.channel == "MY_CHANNEL" - assert stats.type == "header_t" - assert stats.num_msgs == 1 +class TestSpyAccumulator: + def test_counts_messages_bytes_and_type(self, acc): + data = make_header_t() + for i in range(3): + acc.record("IMU", data, T0 + i) + snap = acc.snapshot(T0 + 10)["IMU"] + assert snap.num_msgs == 3 + assert snap.num_bytes == 3 * len(data) + assert snap.type_name == "header_t" + assert snap.undecodable == 0 + + def test_unknown_type_counted_as_undecodable(self, acc): + acc.record("RAW", b"\x01" * 16, T0) + snap = acc.snapshot(T0)["RAW"] + assert snap.undecodable == 1 + assert snap.type_name == ("01" * 8) + + def test_ignores_virtual_channel(self, acc): + acc.record(VIRTUAL_CHANNEL, make_header_t(), T0) + assert acc.snapshot(T0) == {} + + def test_jitter_is_interval_spread_over_window(self, acc): + data = make_header_t() + acc.record("CH", data, T0) + acc.record("CH", data, T0 + 100_000_000) # 100 ms + acc.record("CH", data, T0 + 300_000_000) # 200 ms + snap = acc.snapshot(T0 + S) # window closes + assert snap["CH"].jitter_s == pytest.approx(0.1) + + def test_jitter_zero_with_single_message(self, acc): + acc.record("CH", make_header_t(), T0) + assert acc.snapshot(T0 + S)["CH"].jitter_s == 0.0 + + def test_works_as_republisher_tap(self, acc): + r = LCMRepublisher(".*") + r.add_tap(acc.record) + for _ in range(5): + r.inject("CH", make_header_t()) + assert acc.snapshot()["CH"].num_msgs == 5 # --------------------------------------------------------------------------- -# LCMSpy: accumulation and emission +# LCMSpy (per-connection view) # --------------------------------------------------------------------------- class TestLCMSpy: - def test_handle_tracks_channel(self, registry): - spy = LCMSpy(registry) - spy.handle("SENSOR", make_header_t(), timestamp_ns=time.monotonic_ns()) - assert "SENSOR" in spy._channel_data - - def test_handle_ignores_virtual_spy_channel(self, registry): - spy = LCMSpy(registry) - spy.handle(LCMSpy.VIRTUAL_CHANNEL, b"\x00" * 8) - assert LCMSpy.VIRTUAL_CHANNEL not in spy._channel_data - - def test_multiple_channels_tracked_independently(self, registry): - spy = LCMSpy(registry) - for i in range(5): - spy.handle("IMU", make_header_t(sequence=i), timestamp_ns=time.monotonic_ns()) - spy.handle("GPS", make_header_t(), timestamp_ns=time.monotonic_ns()) - - assert "IMU" in spy._channel_data - assert "GPS" in spy._channel_data - assert spy._channel_data["IMU"]._num_msgs == 5 - assert spy._channel_data["GPS"]._num_msgs == 1 - - def test_get_stats_returns_sorted_channel_list(self, registry): - spy = LCMSpy(registry) + def test_counts_are_relative_to_view_creation(self, acc): + data = make_header_t() + for i in range(7): + acc.record("CH", data, T0 + i) + spy = LCMSpy(acc, now_ns=T0 + 10) + for i in range(3): + acc.record("CH", data, T0 + 20 + i) + cs = stats_by_channel(spy.get_stats(now_ns=T0 + S))["CH"] + assert cs.num_msgs == 3 + + def test_channels_without_new_messages_are_omitted(self, acc): + acc.record("OLD", make_header_t(), T0) + spy = LCMSpy(acc, now_ns=T0 + 1) + acc.record("NEW", make_header_t(), T0 + 2) + assert list(stats_by_channel(spy.get_stats(now_ns=T0 + S))) == ["NEW"] + + def test_hz_and_bandwidth_over_emission_period(self, acc): + data = make_header_t() + spy = LCMSpy(acc, now_ns=T0) + for i in range(10): + acc.record("CH", data, T0 + i * 100_000_000) + cs = stats_by_channel(spy.get_stats(now_ns=T0 + S))["CH"] + assert cs.hz == pytest.approx(10.0) + assert cs.inv_hz == pytest.approx(0.1) + assert cs.bandwidth == pytest.approx(10 * len(data)) + + # Next period: no new messages -> 0 Hz, but cumulative count persists + cs = stats_by_channel(spy.get_stats(now_ns=T0 + 2 * S))["CH"] + assert cs.hz == 0.0 + assert cs.inv_hz == 9999.0 + assert cs.num_msgs == 10 + + def test_views_are_independent(self, acc): + data = make_header_t() + early = LCMSpy(acc, now_ns=T0) + acc.record("CH", data, T0 + 1) + late = LCMSpy(acc, now_ns=T0 + 2) + acc.record("CH", data, T0 + 3) + assert stats_by_channel(early.get_stats(now_ns=T0 + S))["CH"].num_msgs == 2 + assert stats_by_channel(late.get_stats(now_ns=T0 + S))["CH"].num_msgs == 1 + + def test_channels_sorted(self, acc): + spy = LCMSpy(acc, now_ns=T0) for ch in ("ZEBRA", "ALPHA", "MANGO"): - spy.handle(ch, make_header_t(), timestamp_ns=time.monotonic_ns()) - - stats = spy.get_stats() - channels = [cs.channel for cs in stats.channels] - assert channels == sorted(channels) - - def test_maybe_get_stats_bytes_returns_none_before_interval(self, registry): - spy = LCMSpy(registry) - spy.handle("CH", make_header_t(), timestamp_ns=time.monotonic_ns()) - - # Immediately after construction, the interval hasn't elapsed. - result = spy.maybe_get_stats_bytes(interval_ns=int(1e9)) - assert result is None + acc.record(ch, make_header_t(), T0 + 1) + assert [cs.channel for cs in spy.get_stats(now_ns=T0 + S).channels] == ["ALPHA", "MANGO", "ZEBRA"] - def test_maybe_get_stats_bytes_emits_after_interval(self, registry): - spy = LCMSpy(registry) - spy.handle("CH", make_header_t(), timestamp_ns=time.monotonic_ns()) - - # Use a very short interval to trigger emission immediately. - result = spy.maybe_get_stats_bytes(interval_ns=1) - assert result is not None - assert isinstance(result, bytes) - assert len(result) > 0 - - def test_emitted_bytes_are_decodable_channel_stats_list(self, registry): - from lcm_websocket_server.lib.lcm_utils.channel_stats_list import channel_stats_list - spy = LCMSpy(registry) - spy.handle("SENSOR", make_header_t(), timestamp_ns=time.monotonic_ns()) - - payload = spy.maybe_get_stats_bytes(interval_ns=1) - assert payload is not None - - decoded = channel_stats_list.decode(payload) + def test_stats_bytes_decode_as_channel_stats_list(self, acc): + spy = LCMSpy(acc, now_ns=T0) + acc.record("SENSOR", make_header_t(), T0 + 1) + decoded = channel_stats_list.decode(spy.get_stats_bytes(now_ns=T0 + S)) assert decoded.num_channels == 1 assert decoded.channels[0].channel == "SENSOR" - - def test_does_not_emit_twice_within_interval(self, registry): - spy = LCMSpy(registry) - spy.handle("CH", make_header_t(), timestamp_ns=time.monotonic_ns()) - - first = spy.maybe_get_stats_bytes(interval_ns=1) # emits - second = spy.maybe_get_stats_bytes(interval_ns=int(1e9)) # interval not elapsed - assert first is not None - assert second is None - - # Fix 7: configurable interval - def test_custom_interval_respected(self, registry): - spy = LCMSpy(registry) - spy.handle("CH", make_header_t(), timestamp_ns=time.monotonic_ns()) - - # 1-nanosecond interval → always emits - result = spy.maybe_get_stats_bytes(interval_ns=1) - assert result is not None - - def test_long_interval_suppresses_emission(self, registry): - spy = LCMSpy(registry) - spy.handle("CH", make_header_t(), timestamp_ns=time.monotonic_ns()) - - # 1-hour interval → never emits in a test - result = spy.maybe_get_stats_bytes(interval_ns=3_600_000_000_000) - assert result is None diff --git a/tests/test_types.py b/tests/test_types.py new file mode 100644 index 0000000..652041b --- /dev/null +++ b/tests/test_types.py @@ -0,0 +1,105 @@ +""" +Tests for LCM -> JSON encoding (stdlib and orjson paths). +""" + +import json +import math + +import pytest +from stdlcm import header_t + +from lcm_websocket_server.lib.lcm_utils import types as T + + +class Point: + """Minimal lcm-gen-like type.""" + + __slots__ = ["x", "y"] + + def __init__(self, x=0.0, y=0.0): + self.x, self.y = x, y + + @staticmethod + def _get_packed_fingerprint(): + return b"\x00" * 8 + + +class Message: + __slots__ = ["header", "values", "ints", "points", "raw", "matrix", "flag", "name", "scalar"] # noqa: RUF023 - lcm-gen field order + + @staticmethod + def _get_packed_fingerprint(): + return b"\x01" * 8 + + +def make_message(scalar=1.5, values=(1.0, 2.0)): + m = Message() + m.header = header_t() + m.header.frame_id = "base" + m.values = list(values) + m.ints = [1, 2, 3] + m.points = [Point(1.0, 2.0), Point(float("nan"), 3.0)] + m.raw = b"\x00\xff" + m.matrix = [[1.0, float("inf")], [3.0, 4.0]] + m.flag = True + m.name = "n" + m.scalar = scalar + return m + + +EXPECTED_EVENT = { + "header": {"sequence": 0, "timestamp": 0, "frame_id": "base"}, + "values": [1.0, None, 3.0], + "ints": [1, 2, 3], + "points": [{"x": 1.0, "y": 2.0}, {"x": None, "y": 3.0}], + "raw": "00ff", + "matrix": [[1.0, None], [3.0, 4.0]], + "flag": True, + "name": "n", + "scalar": None, +} + + +@pytest.fixture(params=["stdlib", "orjson"]) +def backend(request, monkeypatch): + if request.param == "stdlib": + monkeypatch.setattr(T, "orjson", None) + elif T.orjson is None: + pytest.skip("orjson not installed") + return request.param + + +class TestEncodeValue: + def test_non_finite_floats_become_none(self): + assert T.encode_value(float("nan")) is None + assert T.encode_value(float("inf")) is None + assert T.encode_value([1.0, float("-inf")]) == [1.0, None] + + def test_finite_float_list_returned_unchanged(self): + values = [0.5] * 100 + assert T.encode_value(values) is values + + def test_bytes_become_hex(self): + assert T.encode_value(b"\x01\xab") == "01ab" + + def test_lcm_struct_becomes_dict(self): + assert T.encode_value(Point(1.0, 2.0)) == {"x": 1.0, "y": 2.0} + + def test_full_message(self): + assert T.encode_event_dict(make_message(scalar=float("nan"), values=(1.0, float("nan"), 3.0))) == EXPECTED_EVENT + + +class TestEncodeEventJsonBytes: + def test_backends_produce_same_document(self, backend): + msg = make_message(scalar=float("nan"), values=(1.0, float("nan"), 3.0)) + out = T.encode_event_json_bytes("CH", "ab" * 8, msg) + assert isinstance(out, bytes) + assert json.loads(out) == {"channel": "CH", "fingerprint": "ab" * 8, "event": EXPECTED_EVENT} + + def test_output_is_strict_json(self, backend): + """No NaN/Infinity literals, which browsers' JSON.parse rejects.""" + out = T.encode_event_json_bytes("CH", "00", make_message(scalar=math.inf)) + json.loads(out, parse_constant=lambda c: pytest.fail(f"non-standard constant {c}")) + + def test_none_event(self, backend): + assert json.loads(T.encode_event_json_bytes("CH", "00", None))["event"] == {} diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..fcf238b --- /dev/null +++ b/uv.lock @@ -0,0 +1,1613 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version < '3.12'", +] + +[[package]] +name = "annotated-types" +version = "0.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5f/56/a8120250d128bed162cd73c76d45f6ef9991f3e068f62a8ee060afa3104a/annotated_types-0.8.0.tar.gz", hash = "sha256:13b2beaad985e05e2d6407ee4c4f35590b11f8d693a258a561055cac8f64cab7", size = 15893, upload-time = "2026-07-23T20:16:13.995Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl", hash = "sha256:f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0", size = 13427, upload-time = "2026-07-23T20:16:12.938Z" }, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/67/6a0b94a7960d5e1b5eacd2fb529f3fccc47db4644f7f0a7cfdcfc3be578a/charset_normalizer-3.5.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:3d21b8b13c7592db2ac5e544a6d83187b995257472b0c9e8351b6d507ae37ed6", size = 370642, upload-time = "2026-09-30T04:35:06.91Z" }, + { url = "https://files.pythonhosted.org/packages/fb/94/01009e13b94041599004edf32e56e382c24e570f60f79bab8efe45cfe1eb/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d760fe2a4d7c3b226cb9026d6a842868d52a7901bd98420e1baf14e80da85cf5", size = 259280, upload-time = "2026-09-30T04:35:08.448Z" }, + { url = "https://files.pythonhosted.org/packages/66/85/3b5358f60a13210f0b67d3755c168ef758701b021e655d88d4da28554467/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c9790464842f85f437dbbb54417eda1e0e6bfc52dd8d22d6fd1c994b73b2dc74", size = 245335, upload-time = "2026-09-30T04:35:10.104Z" }, + { url = "https://files.pythonhosted.org/packages/74/75/77c1c479b09ecd751d1e767b251ea5c14d4d50ff757bf404afab2692f600/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4685902cf26edf013ed7a3da0f426ebba7a00ebb9541386d835afbf002c11cab", size = 291707, upload-time = "2026-09-30T04:35:11.575Z" }, + { url = "https://files.pythonhosted.org/packages/0b/0d/363f78cacb70f58f15f4b083961bbd9d292f335d3f5c66fc4f1cfe69cb90/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4495c5002a7b28557e7e222e77e0b661183e432b7d6d2e788101e3f240e05b8c", size = 286747, upload-time = "2026-09-30T04:35:13.022Z" }, + { url = "https://files.pythonhosted.org/packages/e4/ed/cf505d3011ffceb12c2067a7a5d3cfe92b875d4d44bb0ff0d69375e2c184/charset_normalizer-3.5.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:211d5a3eb6af8f513b8d4ca19a8c1b7accab1b5f0d3175f9826b03c1a920dc1f", size = 269972, upload-time = "2026-09-30T04:35:14.606Z" }, + { url = "https://files.pythonhosted.org/packages/15/d8/f0a93a431d170e7ca681d4f6650fee3de934d18560e474e7267eb4b0f987/charset_normalizer-3.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ef4fcbf3327382cd4c9f540babd61248208af7b93eec4de397b4d5f58a09e288", size = 269339, upload-time = "2026-09-30T04:35:16.087Z" }, + { url = "https://files.pythonhosted.org/packages/86/bd/9b2bd1c5b7af02462c9752d33994834ff972a96b4c483eefde9e594488e2/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd16aabe4a02a297c23417aa17ac6299dbd8c49f673bcd645b4929b11f5a4400", size = 261683, upload-time = "2026-09-30T04:35:17.488Z" }, + { url = "https://files.pythonhosted.org/packages/76/a5/cac540ab0fd61f3fec88ad3dbb64509e71424593d73cfdfff5ab3e4db279/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:fb9e68df06293761f9fe66ade60a9bc6d0f5e42b8acf2939a9158af86ab0e5bd", size = 248143, upload-time = "2026-09-30T04:35:18.849Z" }, + { url = "https://files.pythonhosted.org/packages/71/7a/ff467301deef2089fad87f72df9e000a26a78fec7acbb18e1999371b8369/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:59f63901b0031c3136cf64704dcb21de0bbae62ce2c9529bc39d27665463de37", size = 292358, upload-time = "2026-09-30T04:35:20.326Z" }, + { url = "https://files.pythonhosted.org/packages/ad/77/22d7e785d1e210afc2e2f58600dd1799d17a35665faf84383f002826c5f8/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:304d5463e65a35d7bb0850550e0780395395f6fcf452f04db7d5ca7cecc425ac", size = 268766, upload-time = "2026-09-30T04:35:21.72Z" }, + { url = "https://files.pythonhosted.org/packages/ae/91/e8e946267f1c2d9e2bd651726e2fbd2addf02c4d36cea5069e32ca9d7bb5/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9cf9b1a857e25c4baceeb3624e92a56df3668f398c4acba74e174d81fb4d1d3a", size = 287432, upload-time = "2026-09-30T04:35:23.273Z" }, + { url = "https://files.pythonhosted.org/packages/4e/88/7561d8a88d555e7df6623abe7c0070b4baf47549b9408783a2ae0a1a6cf7/charset_normalizer-3.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:114e4d0c92d618409ed82a99e22b5c5e768fe995f2973f78265f4524f49d4640", size = 272470, upload-time = "2026-09-30T04:35:24.655Z" }, + { url = "https://files.pythonhosted.org/packages/35/7e/578c702301ec036f01455f30744a08d2b42f6ab35b9b2d4bf8cae0ef2a80/charset_normalizer-3.5.2-cp311-cp311-win32.whl", hash = "sha256:2625388c6c754520c37abaf3b41eb34d1cc4a373f457898f08606c8e362b891d", size = 186688, upload-time = "2026-09-30T04:35:26.225Z" }, + { url = "https://files.pythonhosted.org/packages/e8/fc/fdf8cf52ff21cd5bf158f20978991cf985325842f74283eb6df26c8a39d8/charset_normalizer-3.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:87e50a3e7cb90af586b6c5faf23e302a970415ac73bd7bd90a515a04b427ef96", size = 214932, upload-time = "2026-09-30T04:35:27.796Z" }, + { url = "https://files.pythonhosted.org/packages/97/66/3e45a506d8110b632541faf9a9470185aa9878f1ed44020f31346c1c5e5b/charset_normalizer-3.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:254eb48b9fa5ee9898a3c445825a1f340fe53712a098904b39b0bddba8ea3cb1", size = 202828, upload-time = "2026-09-30T04:35:29.259Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c8/693809898870237d82785a03f3b2b58fe4c9f14669f84a7d4e623c92a59e/charset_normalizer-3.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed2a239c0ea213acc1908150a3037257083c7c083128f1a4cec2ec4b97dca491", size = 367780, upload-time = "2026-09-30T04:35:30.888Z" }, + { url = "https://files.pythonhosted.org/packages/c9/87/2fea8c13dc24b3ca9c6f803a5b2dfdeae73eb4f9e12c7885ed908ff0433c/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b91363207bd9dc966a691e959bb47f64b30f7ac4b072be9968b366982f7db77c", size = 246730, upload-time = "2026-09-30T04:35:32.286Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9e/09efac30b937722f46d3110ba30b875b24b2e3a266ed746cc4e376a94d80/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:38a873987f3be698494da8b2e3085e29da02da7b633dce73e79c699a113d7bf0", size = 237707, upload-time = "2026-09-30T04:35:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/9e/18/70d76670b13686237863a379928d60bd10e021f17d243ab3d7014c4a5f4e/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:355ad8011081dec5412240c087a9a0c9d4d5039f3ed11a3f13e18c2b29b56c51", size = 273050, upload-time = "2026-09-30T04:35:35.138Z" }, + { url = "https://files.pythonhosted.org/packages/54/e2/77a8b09d5adc013ed07b95b01b8b8fa5441c4e810e83ee7e4aae2fa4d91a/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ee21e28f0430bd6dc9086c6e525d5e818a44a5ad19720c8a0ef766792f3eb5e5", size = 270345, upload-time = "2026-09-30T04:35:36.502Z" }, + { url = "https://files.pythonhosted.org/packages/7f/c5/38806a25ab5e65fc178f39affeda20858efafede2fce1ffc2556cfc9fe73/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649", size = 257601, upload-time = "2026-09-30T04:35:37.919Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8d/213565184708fdb263ae55e2c04ee1ff748129dd65d48ed0e3502da9c85a/charset_normalizer-3.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5cde776b7cc66e4f6c99612cea4aa7269aa65863f7a15841b2c264f103822f4e", size = 252222, upload-time = "2026-09-30T04:35:39.544Z" }, + { url = "https://files.pythonhosted.org/packages/7e/24/76d2cefc25472531e4c5c7dfff68865eb1c39b78482f0fdc15b46f047830/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae4f5fea5b8b8ccff88238cc8569303e5ee95efae67fa62922a311397a71f346", size = 248482, upload-time = "2026-09-30T04:35:41.088Z" }, + { url = "https://files.pythonhosted.org/packages/7d/dc/65a801b66ab4c197e22c433ab25e7ac24324ac6f45a2269aca42cce309bf/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f7d486c83842422badd511868fd8a9a20e9407ace71564b6af47ce7e60a336c1", size = 241206, upload-time = "2026-09-30T04:35:42.59Z" }, + { url = "https://files.pythonhosted.org/packages/a7/95/ca9b5eabde673002c6f1e7ada1b223916fe18f6d661da7aabd4d643718f1/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11a4d68a6ecda3292cb1e50239e111543ba5d709bb62a6b4ea1afcfa729d8875", size = 273190, upload-time = "2026-09-30T04:35:44.347Z" }, + { url = "https://files.pythonhosted.org/packages/2d/8b/803b4d2a3f6e1740f63f1e87b04d14b42f3d4fdfe6ed7d4db2d34102b14f/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d6734d2ef8a50fbf8445c139477da401f50d62a0606bf00e20ec6d87773fefb1", size = 253527, upload-time = "2026-09-30T04:35:45.915Z" }, + { url = "https://files.pythonhosted.org/packages/a9/55/93c0e5dbd085ae0471346026abbe7e0db9ea2d6fea74e51f0b5a46f233a7/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a815775b6c38d4e0ff7bcffbeba67feded90202bb6a226b8dd35f1c855217413", size = 271285, upload-time = "2026-09-30T04:35:47.49Z" }, + { url = "https://files.pythonhosted.org/packages/95/69/0dbd0e0b9b16cfa816cdfcb3e2e3854a1f680dc07fb1245ea125e7448060/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869", size = 260010, upload-time = "2026-09-30T04:35:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/58/9d/e7b88e7b1bf403590c3b573277b5e1e488c68c7a6fbacca310a2c324e90c/charset_normalizer-3.5.2-cp312-cp312-win32.whl", hash = "sha256:db19d07e2e0129e974a0e65d0064fc222a446cd5122c2fd4184d2af9fc734a9e", size = 184125, upload-time = "2026-09-30T04:35:50.777Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e6/e6e083884cbcfd49c64865af05027fe7011be7b2d9179524f099a1b611f3/charset_normalizer-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:780fbe7cab297b81dad9fb8dc5eb003c0468ffb0d9e5f65068c53a34661a96bc", size = 207486, upload-time = "2026-09-30T04:35:52.194Z" }, + { url = "https://files.pythonhosted.org/packages/c4/e3/017aea0911ada7405a825c7d937eb3a13009664e2f5b38e8c4bbf2abf894/charset_normalizer-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:e2af3aad578aa6bd1384bcf4750fc285e5a9de53f40b7d41e5a0bf748edeb2b3", size = 196734, upload-time = "2026-09-30T04:35:53.636Z" }, + { url = "https://files.pythonhosted.org/packages/c5/34/68292d68512768591aaff07c59bb53ee31341c87759433a859c4641a50c2/charset_normalizer-3.5.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:ed905975ab14056a2e5eb1c376cb2e1ebc5396baf84163939c518556fccde9f5", size = 225946, upload-time = "2026-09-30T04:35:55.313Z" }, + { url = "https://files.pythonhosted.org/packages/e3/80/bee0b01b90ccd5322ae1d0abb33fab1bd95b7c2eadaf02aeccf22e04ee83/charset_normalizer-3.5.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a66c3bc5ab1f0ff2164fc9965ddd611ff0802173f4b9d24554c563f6ab7e1d6e", size = 238619, upload-time = "2026-09-30T04:35:56.863Z" }, + { url = "https://files.pythonhosted.org/packages/78/6e/60ce52a85a7fd631ae8482ae6d74521014ca2f255892679484dc04d7ef56/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2374b62878abb00cd8309b32af6c0b715cd02dec0ca74ef12e5069bdc64144a", size = 206701, upload-time = "2026-09-30T04:35:58.639Z" }, + { url = "https://files.pythonhosted.org/packages/36/8c/71aafad23f971afc84c2b295bc0c560739ce1dac558aad9fec22e39f3639/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d376bbd28b3a8999db1a103b3b388aee6f1ddeb3e51bc2172993efdcd86e064d", size = 210506, upload-time = "2026-09-30T04:36:00.147Z" }, + { url = "https://files.pythonhosted.org/packages/91/da/3c5a7798c046df7d2d68ad653cf5b6c5a8bfee225055a843c6f2f42aac1a/charset_normalizer-3.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6045373d5a89a5ec71afde535db987ca28e76dfa276c2d4c818265b375d4b055", size = 366626, upload-time = "2026-09-30T04:36:01.77Z" }, + { url = "https://files.pythonhosted.org/packages/e1/16/710ac3de2ee354e2bd1a9c94efe45a2d27b5c6ad39b2d6a905be2c094b6c/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849df64e889b2e17230d58410a03dba311a65b163508fd33679b2b737d4b7858", size = 244624, upload-time = "2026-09-30T04:36:03.389Z" }, + { url = "https://files.pythonhosted.org/packages/d6/39/45c7439f5b63d24f7d5b2a1d760f34af7628782d7144b4cc8ded45c2d4bc/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15c44f7edfd477b06f517a5cc317fc1707edb9de2c865f43d4b6513907473234", size = 235731, upload-time = "2026-09-30T04:36:04.987Z" }, + { url = "https://files.pythonhosted.org/packages/4d/34/38f3154785ce92e9f56eb226f4d35bdfae6b008480dd055f58837a89c810/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a89012d6d5476ee112d20d998570ed58df2260a852afb1758809cd6900411d21", size = 270352, upload-time = "2026-09-30T04:36:06.412Z" }, + { url = "https://files.pythonhosted.org/packages/04/f3/859f74e7babc977705026b30593b3be04049632a522fb7000f83c033d747/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0c951d5e6dd9c2ff60609476752bee49da4206adde960ebc247766937f72e718", size = 267393, upload-time = "2026-09-30T04:36:07.865Z" }, + { url = "https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4", size = 254660, upload-time = "2026-09-30T04:36:09.248Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/5d1a997587febe5b26d8daffe363b5c1a091cece19828eec6502fd09c5ef/charset_normalizer-3.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19a731138fc27d5682277d3b9df22855cea1239bce7fcec5f78f42ef2d1f3c3", size = 249996, upload-time = "2026-09-30T04:36:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1f/d1e78246f7ed60c8c8d606b4ac27f66ce49cc3e95f24893ccbeba9f77302/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62603db9a7caa0802eaa28c1c46fecd7b3a263a774069c24c3c28c302448721c", size = 247028, upload-time = "2026-09-30T04:36:12.294Z" }, + { url = "https://files.pythonhosted.org/packages/8e/37/eba316edd4f0c4d3a5d945924c4eeeae59abac4056aa815d8a4268f863a2/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b6856554c4f44d79fc2307d5768854310a8f0096e501c75637542c82292b0429", size = 240562, upload-time = "2026-09-30T04:36:13.887Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8e/aaa037d40ca9ef045977f1a661048b1aa33f223adfce3452fe9be9f79d14/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1bc0baf5ef96b6ede57d47f4b8fe4d9d84019c3bfcbeb20a41edc6a6ee341f1f", size = 271699, upload-time = "2026-09-30T04:36:15.41Z" }, + { url = "https://files.pythonhosted.org/packages/26/19/1c1c9f75974adf523b87f34b8a2adc5a435cd65916812bcbd0dfa45f9a29/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:56bc200a365efb37383b7852e4cc5898d3b2da5987289b543956cf8cad71018a", size = 252030, upload-time = "2026-09-30T04:36:16.839Z" }, + { url = "https://files.pythonhosted.org/packages/bc/90/0660ef18e18df0a4d2a1a0edff7dfbba42d4e50ef2425557a5bb7051f77b/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2c9ad19a6cfcd5ea5c0d41161d22f9df1dcc277e9bef2751391334546a314c00", size = 268565, upload-time = "2026-09-30T04:36:18.468Z" }, + { url = "https://files.pythonhosted.org/packages/79/ba/57adc269824e8658f1a0f97a9e514c247445a9632b3419b97e0ba37f16dc/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e243bd13217235fc7290c621941c3f5cc8b66e4872495be821d7436ba2fb838d", size = 257627, upload-time = "2026-09-30T04:36:19.938Z" }, + { url = "https://files.pythonhosted.org/packages/9a/85/33abd4315c052d3d4f54c92b1ee49bfbc0dc7115a981e462a793b6d2ab87/charset_normalizer-3.5.2-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:a090bb2c68df85450502e3e20d665e3a5af9c65a84d6508ed477badd49166fd3", size = 143407, upload-time = "2026-09-30T04:36:21.376Z" }, + { url = "https://files.pythonhosted.org/packages/4f/de/6435e18d1aaa5d910b896d551411c96af1f42a0c56c29afc2016c61ccc2e/charset_normalizer-3.5.2-cp313-cp313-win32.whl", hash = "sha256:2b7b3bbfb4fe8ef40600792d762fbaa9057559f9d3fad209525b7a22b99e91fd", size = 183207, upload-time = "2026-09-30T04:36:22.776Z" }, + { url = "https://files.pythonhosted.org/packages/9c/76/b8ec57f4e9ee3253541abf95e4a462c0175fe8032dcd070f1f2421240942/charset_normalizer-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:78456a747de8dc58360ffa581f30a002baf5aa28cb262536545e91f113ed7639", size = 206489, upload-time = "2026-09-30T04:36:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/3e/60/c647c6ae47480221e875ea5d743ff94946f7416e3c69415ab772928e8d32/charset_normalizer-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:11912e4bb14baae7c5d8791aa55ba0a3a03ec6729073307b0f57270abaa713d3", size = 195501, upload-time = "2026-09-30T04:36:25.846Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/7aa91362a2f77ac8e9e28a9b902a74f7d0e11a851ef0d27a74308da8cd90/charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187", size = 226010, upload-time = "2026-09-30T04:36:27.669Z" }, + { url = "https://files.pythonhosted.org/packages/a8/cf/ac8878d0322cf88a1aad4c7b147db32ca0bd806eb0060957b2e31486dbe6/charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad", size = 239266, upload-time = "2026-09-30T04:36:29.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6d/9a08d7e0b29b7208e2c6c01dc56c8e0520e7c7beadbbfb024b58fd69c8a5/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf", size = 206783, upload-time = "2026-09-30T04:36:30.872Z" }, + { url = "https://files.pythonhosted.org/packages/82/44/b0aa350280e6ff5a5492d17cf10460dd39d5ee848f872f7ba2df10607f60/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995", size = 210449, upload-time = "2026-09-30T04:36:32.625Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/40db9aa9f5907bb0e6f8b6d64064bf8852fb33d4b813ff9414911df7647c/charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424", size = 367815, upload-time = "2026-09-30T04:36:34.197Z" }, + { url = "https://files.pythonhosted.org/packages/7f/72/9c5e7707b57c8ddfa9ddf7b0b1d009d7fbab9e9e887d5b721060f37e307d/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13", size = 247095, upload-time = "2026-09-30T04:36:35.803Z" }, + { url = "https://files.pythonhosted.org/packages/83/09/71e453691e927de4ddf792770cfaab3f49d494e222f66ea5e404bbd5e39c/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d", size = 233942, upload-time = "2026-09-30T04:36:37.407Z" }, + { url = "https://files.pythonhosted.org/packages/9f/86/85c84e4da8b27dd409577d9437926ff581c5f9d3c66038dc68c1a526de51/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4", size = 273762, upload-time = "2026-09-30T04:36:38.904Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/564955a4b5f2ccb410ab480bbe8c6a18063ff27f2d35458731c4a5335df9/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438", size = 269514, upload-time = "2026-09-30T04:36:40.469Z" }, + { url = "https://files.pythonhosted.org/packages/18/24/bad3ac4271589df29cf5ce2f5ae490518a5739358052bd0d61209e6fea54/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a", size = 255056, upload-time = "2026-09-30T04:36:42.02Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3e/350d89ad49916b86554d6f5f2d03ec1152148f87e5ff735106c6a03b1a36/charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56", size = 251311, upload-time = "2026-09-30T04:36:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/56/5b/4970a2d154df502e133402906dd04e3ae7cada7b3011283c88d0479a2585/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd", size = 250190, upload-time = "2026-09-30T04:36:45.185Z" }, + { url = "https://files.pythonhosted.org/packages/88/8c/f1a91bddc8fb47c2889e29ea7ea49a194eb0d9868675d786806519c00d76/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204", size = 237098, upload-time = "2026-09-30T04:36:46.689Z" }, + { url = "https://files.pythonhosted.org/packages/24/0e/bb5dace3cc7e79068425386a6589c19b5a2ab5fefc2a46abea6919683332/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7", size = 274228, upload-time = "2026-09-30T04:36:48.31Z" }, + { url = "https://files.pythonhosted.org/packages/9d/79/b849ad523017ea9f5a45581bbebed91439e0cf42fd2860a6f64e358eb5a6/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd", size = 252401, upload-time = "2026-09-30T04:36:50.091Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/75469d690cf47200bce8f6cad7655724fc23148e147abfc5ce78b5f65863/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc", size = 271846, upload-time = "2026-09-30T04:36:51.719Z" }, + { url = "https://files.pythonhosted.org/packages/26/cd/6d52d3c7437cdcf2e310ce9f28f282e733d4ef60ed19105d1819c356255f/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874", size = 258151, upload-time = "2026-09-30T04:36:53.234Z" }, + { url = "https://files.pythonhosted.org/packages/f7/4c/070b38bdb5f49a70199fce923ec0726a49536a63ab262abbfcaaf351110b/charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655", size = 143570, upload-time = "2026-09-30T04:36:54.816Z" }, + { url = "https://files.pythonhosted.org/packages/81/84/9ebfc8ed6c8c4fcd8e726ff6bf220cc8deb3966e31dce9be8dd8aa017e64/charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0", size = 186412, upload-time = "2026-09-30T04:36:56.643Z" }, + { url = "https://files.pythonhosted.org/packages/d1/78/5ed86f743d4bc350db307e7636419a0a5ee1d91806d30c7f667bd5c80dae/charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c", size = 210965, upload-time = "2026-09-30T04:36:58.205Z" }, + { url = "https://files.pythonhosted.org/packages/53/94/a3a7698e9b1a395e1eb99ccd9a324be9347973bff4e72db2a06496d7cd27/charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253", size = 200406, upload-time = "2026-09-30T04:36:59.764Z" }, + { url = "https://files.pythonhosted.org/packages/c1/48/c5dd00d5ef7791f02666de250a5bb6071e29b7e133cf4b835800b6d3bc27/charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709", size = 396871, upload-time = "2026-09-30T04:37:01.543Z" }, + { url = "https://files.pythonhosted.org/packages/12/c8/8379554b42e8368161d898476686947a0fdbd3e8865170d7909dcabfdee8/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084", size = 249711, upload-time = "2026-09-30T04:37:03.111Z" }, + { url = "https://files.pythonhosted.org/packages/4a/eb/2ddb1035d17320caa9f41682935123a9a250277b261c3efc86b2d2a21343/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb", size = 231146, upload-time = "2026-09-30T04:37:04.721Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/2ecb4bde104322cd7859d6594fcfa74649f8d90b3221c9feecbef149875b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f", size = 271552, upload-time = "2026-09-30T04:37:06.295Z" }, + { url = "https://files.pythonhosted.org/packages/3f/98/9d5f6ebc3aee9fef5d30b4aff11fb2ab7a1222b4064f8ef2c7c87cde217a/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09", size = 269810, upload-time = "2026-09-30T04:37:07.905Z" }, + { url = "https://files.pythonhosted.org/packages/09/e1/a3b06a10461b1b7628853c934c644e03bc28e42767116afb52f19a56519b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80", size = 259845, upload-time = "2026-09-30T04:37:09.554Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d3/6f561f74a296cf27d61775a1dc665ad13f3bff6a798810ca05907f37a7c4/charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c", size = 252825, upload-time = "2026-09-30T04:37:11.274Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/69e13ca3b18f43e0eafcd34c04a45b732ae22a43b54a5fc9e119103356eb/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f", size = 252659, upload-time = "2026-09-30T04:37:12.941Z" }, + { url = "https://files.pythonhosted.org/packages/73/a9/ace29806a0dae18939919c76ba526472d83214afa101105fabff2cf30625/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03", size = 238819, upload-time = "2026-09-30T04:37:14.659Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c1/6116d52a2e3311ec80f21f5fb5e17b27405f10b9608af8f6e69516841a1b/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604", size = 272973, upload-time = "2026-09-30T04:37:16.346Z" }, + { url = "https://files.pythonhosted.org/packages/19/aa/9955c7e93bba10a9c7e8f7a5031b7ced66f3a1883a55c00712b8d5850ff3/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8", size = 253692, upload-time = "2026-09-30T04:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/bb/33/2a6ae7fdc1b10cb581cef91addd8cdfc5f40d50abb5702309369d5834579/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93", size = 268757, upload-time = "2026-09-30T04:37:19.877Z" }, + { url = "https://files.pythonhosted.org/packages/a2/22/80992720a0282cd39bba1db35868e6b9c22f41281160143a836544bc1d8a/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915", size = 262220, upload-time = "2026-09-30T04:37:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/92/9f/181fd07e1bffea1d95cd80c84ac537354f50699c22cfc4d3c02b6fc16208/charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5", size = 197797, upload-time = "2026-09-30T04:37:23.235Z" }, + { url = "https://files.pythonhosted.org/packages/49/1c/25d8415ec1c4f2f41f1680435e4c87cfb378ff2f677d950946f2a45d0632/charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc", size = 222765, upload-time = "2026-09-30T04:37:24.891Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b4/46b48f013dadfc0d0d33b375438e31bdf5a989dc68389c6bf627054d4df9/charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105", size = 210985, upload-time = "2026-09-30T04:37:26.634Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e9/34e597dee616d0b8ee4b34d29399e85c2204ade174157a48505d42baa4ff/charset_normalizer-3.5.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:87475fabc8d9996fd9c27debb395e642e8c838d78a00b6e932227a0e06b81e26", size = 367676, upload-time = "2026-09-30T04:37:28.329Z" }, + { url = "https://files.pythonhosted.org/packages/60/9f/a5d1c91c0263745e2cd344c5a4415d787c575501ab1d449f1148ac6b495d/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9409a8bf35cf78353942504b24a57de3d75b708997a1e4bd8db71ac8633ce364", size = 248414, upload-time = "2026-09-30T04:37:30.167Z" }, + { url = "https://files.pythonhosted.org/packages/26/79/e697f77464748a3ee3cf490c83d592459400d4898380d66c38366b03080c/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:498dc3188ca05a68231ac3fdbfc7f57eb67e1343c30e0fea17f8218c1599b253", size = 244775, upload-time = "2026-09-30T04:37:31.964Z" }, + { url = "https://files.pythonhosted.org/packages/ca/87/3d42a42e18ea066e2513936fd678a00696e77878b5ae04528976abdbcb83/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e242bb1c5e76e97dfa9e7f209a71e93a01d7f19ffdd5cfbb2e2d55b4f08f8ab0", size = 273877, upload-time = "2026-09-30T04:37:33.661Z" }, + { url = "https://files.pythonhosted.org/packages/c3/76/8a28136f3938ba9836f84280ce0c4d61ed1cf15a036b2034900c62634162/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def79fa35ef0cef8d2accec024f4fdc7ead3012ff02f5215c783f39f03ef8cfc", size = 269455, upload-time = "2026-09-30T04:37:35.573Z" }, + { url = "https://files.pythonhosted.org/packages/a0/a1/4fbf5d0f0f1b2a080474c1cf9a2f12c4c6531bb0e8ba591055e846d2b4e9/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df041de8887954562c9b261cba85ca0e9ded74048daf125f45edcfaa4832229", size = 257336, upload-time = "2026-09-30T04:37:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a2/8b50aa320adb880ad579518e6f718f24944804b42a88b83d267d5d444125/charset_normalizer-3.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04851f73ae72b8413dddadb16a49dfee95263553741fd42d546f7d66907e6be5", size = 257584, upload-time = "2026-09-30T04:37:39.522Z" }, + { url = "https://files.pythonhosted.org/packages/a5/57/50e3fed84e175f40349bd0da7a4fce94c87f0378f52d74f511d89e0bdc20/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:183b88127acdb4fabe59d951ab424faf1af7b63cdbb5f776186c1ea2ffcaed98", size = 251854, upload-time = "2026-09-30T04:37:41.23Z" }, + { url = "https://files.pythonhosted.org/packages/d6/54/f7fbb3493c9f49091213b9c2d6dd65800696f1ce1a3f196a4205f50417b1/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:16fa0eccf81304b79c5cd87f9271c3b85dd9dd99245e4422ae9c0dd45e0f99d3", size = 248767, upload-time = "2026-09-30T04:37:42.883Z" }, + { url = "https://files.pythonhosted.org/packages/d9/37/b3a6385acc5a1e45b39ae9c90bfb9cf838a09b9dd37ef2740ab4c6b4a2eb/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:7441d755b7ab94f8d4eb3e43ec05482d760842fd263d003a99102d742cd835e2", size = 274479, upload-time = "2026-09-30T04:37:44.658Z" }, + { url = "https://files.pythonhosted.org/packages/89/44/809913e2cfd279e635a9294fdbbfb1b1dc62a8189d473d561f649fce98d8/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:ca403d7e4798f525fdfc78e258820419cbbd0f0ecbab9de7840e3c017cf6b8cf", size = 258310, upload-time = "2026-09-30T04:37:46.529Z" }, + { url = "https://files.pythonhosted.org/packages/af/a2/f28400ab13359d91bd39179df8e149376b9bf36588e739a3a4f9de2b84b2/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:df29a0a7107f7011e77f4eebdddec4c7331e24d787a0b21a46d63bdf7445da95", size = 271100, upload-time = "2026-09-30T04:37:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/e9/89/9bab37955edf0adb3b66f8a3a6617d9f2f487e0d56f295a6a286cb640aa6/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f3c96f633825733f735c5a9cf21d21a257d8e1edf0b1cee0a064b9c424ca0f7d", size = 259936, upload-time = "2026-09-30T04:37:50.023Z" }, + { url = "https://files.pythonhosted.org/packages/23/b5/4459e08d45a679f903d50fea08bc52cfa728cca4d7bd02c757b5e5abda2e/charset_normalizer-3.5.2-cp315-cp315-win32.whl", hash = "sha256:281cb91036248400f4cc957495cccd44c275c2e0c5854f7e45ac5cf7dc193847", size = 186301, upload-time = "2026-09-30T04:37:51.722Z" }, + { url = "https://files.pythonhosted.org/packages/98/e8/55d5fd3935b4bce6da4fe0df61898e8c82653e317e677bd58aceb9c60f13/charset_normalizer-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:89b53f3cda69831909888e0494f4fa0bcd3537e3e138dabeb620bd6ad946bae8", size = 210858, upload-time = "2026-09-30T04:37:53.427Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/974423c2fd8e524c7a7f64318c1e02240ef954912fa2b4d70344107b9c68/charset_normalizer-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:6be488a102b8cf28d0391d8c4ba7748938ae28b78ad901f8585520fca33ead1a", size = 200309, upload-time = "2026-09-30T04:37:55.015Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f9/00ee0195db1013d8f7c416fd770fbeb560bb46eb2e36b054d05cb56f6cfa/charset_normalizer-3.5.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:915563965d418f986e7e145accc592eae9e1a1be3566ff98a05d7a9ec42a76e1", size = 395343, upload-time = "2026-09-30T04:37:56.743Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/c00b50e94c964cf934c7899cd47c97952fc11dad71cc5884b3c61795b09b/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65cd72beeeca9d3aaea1201e5923859f308f952f9c71de93f06063c79f0f7a3b", size = 250114, upload-time = "2026-09-30T04:37:58.607Z" }, + { url = "https://files.pythonhosted.org/packages/50/27/d102dc880bbcffd0479ab64dfc1fb96777a854355a55e2bda72a71efadcb/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b7fd005a73d9e657273b7a10dc71a9e03c8fb9ee6999798d6918ce095b81ac7f", size = 239997, upload-time = "2026-09-30T04:38:00.511Z" }, + { url = "https://files.pythonhosted.org/packages/a5/4a/bf7ef45794dd293fab5f98a9309817977fbb845b9998f171b8cc5d8437a3/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e54da4baf05720032d527874d40b65fa4d7e5c6c6a43d0c3adbeffcaf275a2b3", size = 272313, upload-time = "2026-09-30T04:38:02.509Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ee/008a2837737991474c5754bb3191010007663860979701990982a502cbaf/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:124fbf1a8ff966d87ae05bb8bd45a71f966055ed8bba320d0c7cf450bc5f4d0e", size = 269986, upload-time = "2026-09-30T04:38:04.435Z" }, + { url = "https://files.pythonhosted.org/packages/93/ad/bd74a283940dc910c5b14f8e4f80a248082bc9c0fcbe1f54530cb6d9cc5e/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28b4f0d66fb834ff90f28209ac7bce77868c45d8c93e26f906709d9b7c2e1af9", size = 260202, upload-time = "2026-09-30T04:38:06.549Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7b/ed341c66f69f688723501fac752be3d63c7159ca0d0d4174fc611e5710bb/charset_normalizer-3.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58ca3755ee7ff7f59b57789ec9833c9de9ea275405cdd240eda1f193112e398a", size = 259083, upload-time = "2026-09-30T04:38:08.311Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9d/e41588b777965e5031a43128a1e96173ebb35ac75fc53ec3b517e7c21cd4/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:443eae2bf318abeaf6f15d785138f71fd6de770e99a92158b8b814265e079115", size = 253081, upload-time = "2026-09-30T04:38:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/81/35/b761eb6d8c1eb218b9b42b9b4d5ac902afdc399fb6dac6f9a9aac7bda589/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:58f361dcbab699cf8f42db3f47c8e7fd1036f138c23a5d08de9fde5f425a730c", size = 248712, upload-time = "2026-09-30T04:38:12.317Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2c/147169a041b747759f37405c0a97157e8e92de967968373101ff14915cba/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b4cbc7c3491ccb4aa17fcd8165649d01cf39f76de1696da8631b5f71b85401d", size = 274176, upload-time = "2026-09-30T04:38:14.138Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2d/0ff8db0d373ba8538db686db11cd7e8912031490b9e4f383b41912e8d594/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ba0b1d2620edf869789c3879223f52bf2afc5d31b3cb47cc57b3a12c05e2aa9d", size = 259413, upload-time = "2026-09-30T04:38:15.841Z" }, + { url = "https://files.pythonhosted.org/packages/8a/8e/b4a085fb47c9d3a7e43576a4784fdd8fe23f907514a972de8086edaf7a48/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:5e2b6b57e9733d39f0c9fd3185efa6b8e29652c4cd8fe94180272cf6ed9a78c4", size = 269434, upload-time = "2026-09-30T04:38:17.626Z" }, + { url = "https://files.pythonhosted.org/packages/83/1c/d8d8d7322a7c3eecdf3237a4a419cf41d2eaad8e006ce7dfdd9d4c8fa2eb/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:51cf45226a9b588d0d2b4880c62d686934b63ab0bd79ca23ab0e9762eb27441b", size = 262716, upload-time = "2026-09-30T04:38:19.214Z" }, + { url = "https://files.pythonhosted.org/packages/a0/16/0e4c6ba9b44e97a2da150e52d331e8f9c968b21b358fbffa6c856cebcd89/charset_normalizer-3.5.2-cp315-cp315t-win32.whl", hash = "sha256:5fb29fb8cd1a46c27a1bf9613ad5ec2599310d46b4025d9556404a6b6a292800", size = 197159, upload-time = "2026-09-30T04:38:21.037Z" }, + { url = "https://files.pythonhosted.org/packages/be/33/e90bc2b1374f7f36ef106f56620de5a783907e19ca857efe2277e31cac3e/charset_normalizer-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a192e2c40070d92c3ccf777e3a5c4ff515573cd2bb7ed0c537fdadbbec5bbf21", size = 221322, upload-time = "2026-09-30T04:38:22.886Z" }, + { url = "https://files.pythonhosted.org/packages/66/89/dfa6dcb08c200b7830ab56439e8c1890f2971d51aafbb3937894a2e7fcfc/charset_normalizer-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:749e97e1b32313717a565abbe321bc2190bc8b35f1a67e4cdbc7c56c8d8ffe58", size = 209192, upload-time = "2026-09-30T04:38:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ab/176fbfd5b64939c55d652366aa5b9ef1d767af207a3aa6ebeb0d226c484d/charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd", size = 331815, upload-time = "2026-09-30T04:38:26.216Z" }, + { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/43/6f/c4fbae58febff71709c51bc7e18fdfa55341dc382704740f9f0cbf03817b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f", size = 241239, upload-time = "2026-09-30T04:38:29.732Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/458c3f42164a07d0c5210798e9e704b39e540a6793b05aba67f3a35243a9/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93", size = 231121, upload-time = "2026-09-30T04:38:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/09/54/ab9e89367076f6331bb6c65c4bf14a5361fa5191cb6561bf534f18504e1b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade", size = 260350, upload-time = "2026-09-30T04:38:33.239Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/061431ecc688d9d76602502cb57cc01e691e682c18f1beb45f9673b5bbd2/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0", size = 255430, upload-time = "2026-09-30T04:38:34.865Z" }, + { url = "https://files.pythonhosted.org/packages/8d/1f/20c8949f0676f7ab811abdeb7f4d7f1cbc6e61ff20bef08b44edeb092bc8/charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26", size = 250612, upload-time = "2026-09-30T04:38:36.649Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/46f2fa4c431fc98c4ae76a8cb5bdca54e0341e3cfc3fcfd8e82740250818/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011", size = 242083, upload-time = "2026-09-30T04:38:38.26Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/559be29a0c0f086e0bba6922babd38916cc5e0b58ced4de13ee01ea05508/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621", size = 232738, upload-time = "2026-09-30T04:38:39.81Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6c/387b0e4f756a282831c1d9fc6aeb6c51ca4507ca202767c8de15ce9b12e2/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4", size = 260703, upload-time = "2026-09-30T04:38:41.346Z" }, + { url = "https://files.pythonhosted.org/packages/96/92/1fdf015f09ef449f50d3ac4b67c90887c9c318b727daa95cc4f866e6521d/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e", size = 247622, upload-time = "2026-09-30T04:38:42.937Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3c/8e7b8a5671ad5d433669fb2a76f1a0164df2d9b1718b0206bc2a16d840cc/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c", size = 257500, upload-time = "2026-09-30T04:38:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" }, + { url = "https://files.pythonhosted.org/packages/31/68/fdec18a343f5fb3f310588dd478b09ac4799e0b187dbade3a8cd776f03ef/charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf", size = 174499, upload-time = "2026-09-30T04:38:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8a/b618149cc5207943a0242068d7a27897f56a62947b5a039085f2a22029f8/charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036", size = 200092, upload-time = "2026-09-30T04:38:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/03/cf/4c66866fa9e2b1c78e3c911516d1de497a677b7ac60f1eceda74ce777ca3/charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e", size = 294363, upload-time = "2026-09-30T04:38:51.312Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" }, +] + +[[package]] +name = "click" +version = "8.5.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/45/37/edbf1b0707709013c0cf2e8317e03d97ed29bf4cac709fe328904ae92a38/click-8.5.1.tar.gz", hash = "sha256:9bbfada76703fd1d784b83eea012e3e8c6a001a876543ef104fa56aaaeb072b4", size = 399151, upload-time = "2026-11-06T17:37:01.021Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/31/7d/164b7ffc8624fe9efb4221bf9af485d5c1e41b9ae118045d2b6dc5457d8b/click-8.5.1-py3-none-any.whl", hash = "sha256:8bb5376d2006950386f8c6427613334a2acadc5f559cb80e638d00b4df957e37", size = 126163, upload-time = "2026-11-06T17:36:59.287Z" }, +] + +[[package]] +name = "click-option-group" +version = "0.5.10" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/1d/03/454dafcda21ca579bfa3d3583edd91f283cf6fb7b9a63d00a3212e8e2d4c/click_option_group-0.5.10.tar.gz", hash = "sha256:22d6a7d102b4ead6a0b8601d577386d390deae91038662f2bd1d013806184ab7", size = 22876, upload-time = "2026-11-16T13:46:42.161Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/fc/cdebdc2595700ebc9a57890360750bcc8ae1bfa1863c028db5be5652f23a/click_option_group-0.5.10-py3-none-any.whl", hash = "sha256:667f9dafdbe15f69c7e877e14c94175ab2e16b6a1ab4b7ffac51513ed624a8dc", size = 11531, upload-time = "2026-11-16T13:46:40.911Z" }, +] + +[[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 = "deprecated" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wrapt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/49/85/12f0a49a7c4ffb70572b6c2ef13c90c88fd190debda93b23f026b25f9634/deprecated-1.3.1.tar.gz", hash = "sha256:b1b50e0ff0c1fddaa5708a2c6b0a6588bb09b892825ab2b214ac9ea9d92a5223", size = 2932523, upload-time = "2025-10-30T08:19:02.757Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/d0/205d54408c08b13550c733c4b85429e7ead111c7f0014309637425520a9a/deprecated-1.3.1-py2.py3-none-any.whl", hash = "sha256:597bfef186b6f60181535a29fbe44865ce137a5079f295b479886c82729d5f3f", size = 11298, upload-time = "2025-10-30T08:19:00.758Z" }, +] + +[[package]] +name = "distlib" +version = "0.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/d36966de7304047a1001a7559fbf266c464bb5d8cc85464536ef8c9bcc32/distlib-0.4.4.tar.gz", hash = "sha256:ca4175b4ac7f71223cc30ed7248c45d2b38c2439d8ee6e498ab67ed63cf3508d", size = 621304, upload-time = "2026-10-16T13:56:34.203Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/2b/238f02a4927fa2e27aa995371d240a468b52e42eae44a678434aff736b38/distlib-0.4.4-py2.py3-none-any.whl", hash = "sha256:cf09d55b1e85a89576b036aeb71550bfd68320f3f21761ca329eadadad918638", size = 472099, upload-time = "2026-10-16T13:56:32.053Z" }, +] + +[[package]] +name = "dotty-dict" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6a/ab/88d67f02024700b48cd8232579ad1316aa9df2272c63049c27cc094229d6/dotty_dict-1.3.1.tar.gz", hash = "sha256:4b016e03b8ae265539757a53eba24b9bfda506fb94fbce0bee843c6f05541a15", size = 7699, upload-time = "2022-07-09T18:50:57.727Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1a/91/e0d457ee03ec33d79ee2cd8d212debb1bc21dfb99728ae35efdb5832dc22/dotty_dict-1.3.1-py3-none-any.whl", hash = "sha256:5022d234d9922f13aa711b4950372a06a6d64cb6d6db9ba43d0ba133ebfce31f", size = 7014, upload-time = "2022-07-09T18:50:55.058Z" }, +] + +[[package]] +name = "filelock" +version = "4.2.12" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/aa/8ccff8da9a27e089727fcffd3c5b61708383217e47eb1e1b8af37b1dd166/filelock-4.2.12.tar.gz", hash = "sha256:7e7da24d3ac39268b0f156e56870001de44886318f092f9d851e692f7114d6dd", size = 680837, upload-time = "2026-11-18T01:20:03.951Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/c9/eb6b6528c7edb958d4c24ac47a8b94113d9de36e4cfc6eecd599b1a4f349/filelock-4.2.12-py3-none-any.whl", hash = "sha256:21decfec02f116ed4c954433cdb31f28c3b346b784543177b6d7059da2702ee9", size = 222442, upload-time = "2026-11-18T01:20:02.439Z" }, +] + +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/61/5c78b91c3143ed5c14207f463aecfc8f9dbb5092fb2869baf37c273b2705/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf", size = 62794, upload-time = "2025-01-02T07:20:43.624Z" }, +] + +[[package]] +name = "gitpython" +version = "3.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/ff/fee293f1ec3e1b64db6eb270e00964f29c086d769201474cedb8d1608930/gitpython-3.2.1.tar.gz", hash = "sha256:0f1229ec5c057bdabdeeda8bda4f17bda679ab33dbccc00f24e6a480553c8613", size = 241688, upload-time = "2026-10-14T12:20:20.589Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6b/50/2a923c4dc02522ff9567f07c67ed1deca6d5fa9474f4708168b8088dfa37/gitpython-3.2.1-py3-none-any.whl", hash = "sha256:d66b0832aa8755c1a84892937282df0befb16c97e5a64aeebd68be9c5e323f53", size = 231548, upload-time = "2026-10-14T12:20:18.844Z" }, +] + +[[package]] +name = "identify" +version = "2.6.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/53/35/d70c0006c7cee65999ea94a6273e60b2094f600a3d8b71b04318253fc643/identify-2.6.20.tar.gz", hash = "sha256:ad729860a923858d26917c2f4fb0a1d83d27a75b1e090c06440c573f048f3285", size = 99681, upload-time = "2026-09-26T20:29:07.187Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/70/fffc9613501877c0a10a1ef73a165e6ded3e53f6e7502227fef56d973933/identify-2.6.20-py2.py3-none-any.whl", hash = "sha256:6a16b69b93187244e0548cbfd25b3e4a6f9a7a2ad784625c3bec2b8d27b81aaa", size = 99506, upload-time = "2026-09-26T20:29:06.054Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/01/e1/2069291243c926a2ff1cd706c7f3eeb9b62144bf60f77c9fb9ff2fb26bd3/iniconfig-2.3.1.tar.gz", hash = "sha256:67f4b9c50da0dedf52af349e7749a80a9057a5031199791b906c3bb3ae878960", size = 21209, upload-time = "2026-10-06T22:48:38.076Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/56/43/4ca9e49d27a1fcf6bece6f6aec0ea46bb9112489b93d4b688fb415457bdb/iniconfig-2.3.1-py3-none-any.whl", hash = "sha256:9121e2c1fdb355232495be3194c8dfe87ccc2d5dee45947b78e68f499790d7a7", size = 7552, upload-time = "2026-10-06T22:48:36.959Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "lcm" +version = "1.5.3" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/08/83/da474e7c44490d84c02fac5db37ec3932a80315b1bced0a8d13e4c8f7ecc/lcm-1.5.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:5e953f1fe27760d6775075e262abf9f320b6d0f318c17808765a82b1caf87041", size = 3509054, upload-time = "2026-09-24T16:33:16.146Z" }, + { url = "https://files.pythonhosted.org/packages/27/f4/4e865881df26b2f89f614613818655a0410f86db240655f85510fea4a764/lcm-1.5.3-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:92732d4521c05c4c012a51a418287b20c413eca611174c461b3c2801262ccd47", size = 2870134, upload-time = "2026-09-24T16:33:18.063Z" }, + { url = "https://files.pythonhosted.org/packages/79/4f/79a901aa70a642453003f86858bcb07f369f599f1ec9858c5110e113aa36/lcm-1.5.3-cp311-cp311-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:dfdbebaba43b016874c97e9d1bfcfea001f630ec38b873bb50c9c44dc3f4d98b", size = 2864990, upload-time = "2026-09-24T16:33:20.136Z" }, + { url = "https://files.pythonhosted.org/packages/92/18/4c2af578018f19aae17d23fa22307737f4965a7d9d247d8f2756d423b87e/lcm-1.5.3-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1d4eb1e1a3fe20242a7149d6d56192f652d25701feae18d9774b4f69f10ef445", size = 2892752, upload-time = "2026-09-24T16:33:22.429Z" }, + { url = "https://files.pythonhosted.org/packages/be/56/8bb8d171b2d78cb5c47810ecdd8f809562f1a547a9dfab7099eb511ad91f/lcm-1.5.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:107c3e17872112af7c6ccc2ff9ad03472ac905b00c8bb196144c99d4cabfbaa2", size = 1530090, upload-time = "2026-09-24T16:33:23.718Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/a1358443090ee18e916fa047e99cec53d860954ebfa09113530d82a3c5fc/lcm-1.5.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:679047d864493ea3f236f68a5982c4da3ba3529fd1ca66af843595bd657664ce", size = 1373405, upload-time = "2026-09-24T16:33:25.023Z" }, + { url = "https://files.pythonhosted.org/packages/89/50/4e51f9930e1c6d3a796be3769ad69322edaaed63f54beef64fcc1bea2a92/lcm-1.5.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:25e72755d278cb8abd30de6d5fe273945abe69f4eaeafc22198439341947c4f4", size = 1581047, upload-time = "2026-09-24T16:33:26.573Z" }, + { url = "https://files.pythonhosted.org/packages/a4/85/38c841811655c8ae50c6cc7c35f83067c38e9d63b40605b392662c0a8ca9/lcm-1.5.3-cp311-cp311-win32.whl", hash = "sha256:621a33adaff471c4f745df26074915937bf9848d86c6d58e84b5ba696407f2b0", size = 4213000, upload-time = "2026-09-24T16:33:34.744Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a3/09711f36f70fff1918ba2f53e2b39b43409739825f01b517929baf3c12a4/lcm-1.5.3-cp311-cp311-win_amd64.whl", hash = "sha256:2335b340538981a675a0967fdd2251ee08c4c688c1a956d8a4de88e317d44dca", size = 4432242, upload-time = "2026-09-24T16:33:29.062Z" }, + { url = "https://files.pythonhosted.org/packages/ff/70/e7a74c4a1de7a37e5039eb3b63fe4f7b8137afeb091974a80528351088dc/lcm-1.5.3-cp311-cp311-win_arm64.whl", hash = "sha256:b60190067a94f11df6af1b9ec1508c460d0c32d5c179933a00f64cae0c9b6a84", size = 4299344, upload-time = "2026-09-24T16:33:31.616Z" }, + { url = "https://files.pythonhosted.org/packages/e5/8b/b50152878c5b16c3c31a8e69b95c2bc18e0c4eb7e8b043675dd179cbfe1d/lcm-1.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:590da83628816a506f8eb1bdb8a011cb80ec582177106d5b3e1327dc22d5a664", size = 3509106, upload-time = "2026-09-24T16:33:38.425Z" }, + { url = "https://files.pythonhosted.org/packages/75/2f/ffe0f2bdfa6c9d4abe1bcff0849caf22ac717901833fd887629d891d6359/lcm-1.5.3-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d0b6a59a4adb2016f7c696321e3d43d22c1881f02e34a1be7e9673ae29efc53a", size = 2870155, upload-time = "2026-09-24T16:33:40.909Z" }, + { url = "https://files.pythonhosted.org/packages/66/fc/c3d325fad5ee79c5e718ff1dcb98b906f55bc896c73a01deb2b2eec2547c/lcm-1.5.3-cp312-cp312-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:dbb958f2555ad113cfcd5be0f3d358f3a4aed4d1fbaf7dc02d273d1166839a19", size = 2865024, upload-time = "2026-09-24T16:33:42.878Z" }, + { url = "https://files.pythonhosted.org/packages/9e/fd/991435ef3bd0e2758cd0c6f27607d7da0ebc20a30a3818327d3214fe8c5b/lcm-1.5.3-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:697542c081780499384595066238dd64f5751dc945e210712df57fecb24dc6ad", size = 2892809, upload-time = "2026-09-24T16:33:44.809Z" }, + { url = "https://files.pythonhosted.org/packages/c7/72/0779e6cc2140e04b1cd4689a2ee38c770e42964570a0ecf6be237f48e24c/lcm-1.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ea6a78a276afd503ae8867959db891ae5a2fbd27d0f1b7ea5a19e3904eaed35f", size = 1530115, upload-time = "2026-09-24T16:33:46.651Z" }, + { url = "https://files.pythonhosted.org/packages/3b/a1/4532a8a371d5abc106f943c8d655ec83ecd96205cb578e9bfec89e75ad7f/lcm-1.5.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:55d2220dbdf1504fde36b8cbede4e7f54e82209800a8f3189228a372b1d6f32b", size = 1373440, upload-time = "2026-09-24T16:33:48.391Z" }, + { url = "https://files.pythonhosted.org/packages/6f/8c/9e111cd903c2f49bc1fa3f7423f1a6369fe3fdfae7e7d99edb0bd99d1099/lcm-1.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4f662faf3fe783d0b2b1acf8a9387e95aa73e035d99a095c667435a0bc09188e", size = 1581170, upload-time = "2026-09-24T16:33:50.495Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a2/b08a8741bbb8985f73a6b4153274886c7630d33001a307b4facf6c76b002/lcm-1.5.3-cp312-cp312-win32.whl", hash = "sha256:e060489c6fc4042b10d8f77586dfe08cf08167ccb92d4a970a4b12d913e581f3", size = 4213144, upload-time = "2026-09-24T16:33:58.191Z" }, + { url = "https://files.pythonhosted.org/packages/17/11/dbfb47f99f23c97ccfb9b5e0a242d4d64a444f316c35627959d23355c0a6/lcm-1.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:1fbe78efb88c73b7ed6db091a7478443697449ee30338f697ce0a27f70c5819d", size = 4432335, upload-time = "2026-09-24T16:33:52.966Z" }, + { url = "https://files.pythonhosted.org/packages/75/86/49d3b9af504cba8cb0c9ae3fc1ce3124480e5639716e23845ffcd85bd2a6/lcm-1.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:3f7853390e1e14e8906489650d9926e5b09c9eff6f8704546a9c93415dbe2b9f", size = 4299410, upload-time = "2026-09-24T16:33:55.288Z" }, + { url = "https://files.pythonhosted.org/packages/bd/85/08de910437f9bb3c00867047c3f3bf47a057ccfc043542664c11677988d2/lcm-1.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:a88b6346f5847d519b03bc83800d87b136f7704e41caef9484c85f71ef6b105c", size = 3509156, upload-time = "2026-09-24T16:34:00.688Z" }, + { url = "https://files.pythonhosted.org/packages/5d/02/78dff4d4c82fea5c4ddee776e0bd43a3d1921e3a7a9d096a791a84fd3154/lcm-1.5.3-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:c9dab29ea28bb8d356b58cc8596e96f8e3494fecc7348593a049044d4d675528", size = 2870160, upload-time = "2026-09-24T16:34:03.136Z" }, + { url = "https://files.pythonhosted.org/packages/da/26/05b9b345a4305a68ff67fb8b983f0c27f2447c09b028d92abc660d084f92/lcm-1.5.3-cp313-cp313-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4d7b49e7c73f447c680a3eb28d29f694424149dbef28b977bf4f7155d4428c0b", size = 2865046, upload-time = "2026-09-24T16:34:05.127Z" }, + { url = "https://files.pythonhosted.org/packages/d8/6f/7922dc7e34c75b49dc9f033b54af6d7b6595d84e1cd5f8dd45b9dbd302b5/lcm-1.5.3-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:3076624bf6376ba9dd7868acc82b01ec722f77dd59c091a58ab94a8487210c5c", size = 2892824, upload-time = "2026-09-24T16:34:06.928Z" }, + { url = "https://files.pythonhosted.org/packages/20/e5/c2a8b01d5e130d3f924080f13ec03145fa1bc44e4e47bc4c1160f5edf85b/lcm-1.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b7fa6e2bd16c391ea3d285776dce6f5befbabdd70daf5d5aba47f917b1b70029", size = 1530112, upload-time = "2026-09-24T16:34:08.329Z" }, + { url = "https://files.pythonhosted.org/packages/0d/da/ff8b7d378f6f731c7b1af06c177fbad7d1c501498e5334bd287384def4a9/lcm-1.5.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:e530c873c4b78299acea823113c69aa37766c2f60a8d4440344209c00708abeb", size = 1373432, upload-time = "2026-09-24T16:34:09.663Z" }, + { url = "https://files.pythonhosted.org/packages/79/aa/ac104aa596cc746cad3b89255ca52b73e49512228fa4936edf693f0cd756/lcm-1.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e740345147a1e1b358b2cc58990c41f7a4b8f9d566e98049e376a54210957fd3", size = 1581186, upload-time = "2026-09-24T16:34:11.102Z" }, + { url = "https://files.pythonhosted.org/packages/ec/9c/c94f915b0af06ef080c9c061e3ab8011e7295e098fb3dd191aee1bbfcf73/lcm-1.5.3-cp313-cp313-win32.whl", hash = "sha256:321605e0f9123d63136e972de503e18d8058b8d70f9dc88ee11c78751b2b3947", size = 4213120, upload-time = "2026-09-24T16:34:18.634Z" }, + { url = "https://files.pythonhosted.org/packages/5d/e8/fd7a1b1f9bdc0d2c5976342a9004fc6a28ffc3b443d4ada18ab1d0a3835a/lcm-1.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:e6ff4e01a99f49421d99ef847b6163cba72cbfe1a53d29223ae626654ec8e3e2", size = 4432398, upload-time = "2026-09-24T16:34:13.528Z" }, + { url = "https://files.pythonhosted.org/packages/72/21/73aab2e17f5436c461dcff006a1c74336d02c2121fa90bb3cff3690d2e2e/lcm-1.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:cd5d6be1d8e95ad762e91f2ceb1a1ed50fd0ac9c298e3445a908a4b0bc44ea00", size = 4299444, upload-time = "2026-09-24T16:34:16.241Z" }, + { url = "https://files.pythonhosted.org/packages/cd/03/68ea4c1cf5fb4cf2b393c1f425e0866bc7de65e03c099d22e046debea249/lcm-1.5.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d813f088dc21ecc2bae7d3e78ff7591ea2932fe90ed8d14d332004477ca6ebe7", size = 3509174, upload-time = "2026-09-24T16:34:20.824Z" }, + { url = "https://files.pythonhosted.org/packages/19/c3/cbcfc56d8b7c9ccbbcf6bfd79b460f61747ce443143b8bbbf3a713ead092/lcm-1.5.3-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:274a12d019d7ae02b6fe465b598f3607bc7329bdcd9c88ea0e99a3bca4da7df8", size = 2870176, upload-time = "2026-09-24T16:34:22.885Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fe/e97d65042991ae7de87aeee880f05dd26861770ae8ac2368c51f3e4aa422/lcm-1.5.3-cp314-cp314-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e31bf53a1c5acf30003b488a9f41b058eaed834410862f218c92bf76c812e7d3", size = 2865149, upload-time = "2026-09-24T16:34:24.693Z" }, + { url = "https://files.pythonhosted.org/packages/4c/78/43b019134ba2cda99074a68aa79e0a04d777b40516d5746cda744e263e99/lcm-1.5.3-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:c4ba0b905da64a2bf670b90155fd3b8860ce272e4a02dbc548b4d9b6dc7f56fb", size = 2892730, upload-time = "2026-09-24T16:34:26.609Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2a/41f12c09cafea91312974f954b5f4f019c90f965f635dd28beec608bb5d0/lcm-1.5.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:093d0c5449387c1335fbe775fde3d540bab92696e7fdae7703aa95c408f66e60", size = 1530122, upload-time = "2026-09-24T16:34:27.997Z" }, + { url = "https://files.pythonhosted.org/packages/dc/18/5cb49629da58913afe553c5328ad48d62cd230f1cb992140f1bdbc889307/lcm-1.5.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:298f54bf52ca30e26d0024b1aa3e19a93be48630306ec06509ebcfaa49b0d2d5", size = 1373434, upload-time = "2026-09-24T16:34:29.299Z" }, + { url = "https://files.pythonhosted.org/packages/80/c0/5259a62b03637e2962e3a54f7ce7e90208bbbd33327005ba255847a7cf1d/lcm-1.5.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7f6155e7add5fff5f724319d7fb90eefb010e29d0284925b901b1a5bb46fa53f", size = 1581138, upload-time = "2026-09-24T16:34:30.641Z" }, + { url = "https://files.pythonhosted.org/packages/5a/a5/0bf9231a799fae457f5b4e9c2e1caa3b2131649687041a7268194588d2c1/lcm-1.5.3-cp314-cp314-win32.whl", hash = "sha256:697051a2936ea2d5b0f603f53899b62df7f6591afd54731d32811a1ffb90430a", size = 4262312, upload-time = "2026-09-24T16:34:38Z" }, + { url = "https://files.pythonhosted.org/packages/16/1d/ec5ec855c38f589c5319b7e91248adb7a34528f074e7301f010c656209b1/lcm-1.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:407331434bb53208e0f8fa03b65897d94ed9aaf485e3b2233bb4813e989a34e0", size = 4489598, upload-time = "2026-09-24T16:34:32.985Z" }, + { url = "https://files.pythonhosted.org/packages/f0/92/06150ffeba8e7686d8c30f7232f56a0dd4114cf4426e01fdca9ec8073580/lcm-1.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:35e32dc78298e3215cffc77135480985446a872f6a4b1b6b3e4979af994e0f47", size = 4354550, upload-time = "2026-09-24T16:34:35.513Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9e/defb574850af31ddaba51ce040517c565918bf95c2538f278378bcd9f789/lcm-1.5.3-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:1ce54b4c3588f6e9b8e9f989b960609813da973c76a217752ac54f8beca007ad", size = 3509121, upload-time = "2026-09-24T16:34:40.204Z" }, + { url = "https://files.pythonhosted.org/packages/a2/a8/da7fbe33ae436580182a556053d505a967d09043604214b2487e97fda668/lcm-1.5.3-cp315-cp315-manylinux_2_28_aarch64.whl", hash = "sha256:881c40512fbf70d04dea2c3137f585e62d2344753a71fd2853a68d26aacbe72b", size = 2870115, upload-time = "2026-09-24T16:34:42.102Z" }, + { url = "https://files.pythonhosted.org/packages/8f/2a/a1cc7f64f6aa197019aa0bc4c5f664f96455a8fb25552890368a088fab76/lcm-1.5.3-cp315-cp315-manylinux_2_28_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:ea8d799a4208d0ef9fb309d97f5fade56001bfcae02b962ecddff30df0bb555c", size = 2865049, upload-time = "2026-09-24T16:34:44.256Z" }, + { url = "https://files.pythonhosted.org/packages/16/78/d9b7289f66c48f87c3802cd9f94137767b3f201bcaea9389d29a9ae8a291/lcm-1.5.3-cp315-cp315-manylinux_2_28_x86_64.whl", hash = "sha256:642034326d30251c5930ec90ebc6ce5b3485400ec6a57338945dd1f0f07ed263", size = 2892775, upload-time = "2026-09-24T16:34:46.224Z" }, + { url = "https://files.pythonhosted.org/packages/a4/af/0a6a0af3a25006330448a6524c9e8e7214ff8acc4c4a4cb62237db185b8c/lcm-1.5.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:7fa94491a85eea85eb9acc0985170ecb3bd4c26511cc484d892302df17270e22", size = 1530125, upload-time = "2026-09-24T16:34:47.885Z" }, + { url = "https://files.pythonhosted.org/packages/78/f2/7aec26ab5e0bb0cf37b8f7ea12811f41f5829ef366078828ce075b0f3382/lcm-1.5.3-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:0f890224ab1ed3b569e8ed4cc7ef41621a096985dab7f3ee2821a70b4407b8ec", size = 1373422, upload-time = "2026-09-24T16:34:49.262Z" }, + { url = "https://files.pythonhosted.org/packages/14/78/be1e880ac933be22133e0db6b56a240bd33504e1ed3d9160a3d7b1fdd45b/lcm-1.5.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:639f0bea52825f5f12dad39a661abbd4b92afe49552fa3d01511e564a0342f80", size = 1581135, upload-time = "2026-09-24T16:34:50.661Z" }, + { url = "https://files.pythonhosted.org/packages/cc/87/c7004f7b013544459635a5e3dd369872f26321d84c8ba298976a1f5ee41a/lcm-1.5.3-cp315-cp315-win32.whl", hash = "sha256:a88ba129a0f7756201b3b2f2709a57608a1fb9afa42557fd703958ac9225b879", size = 4262413, upload-time = "2026-09-24T16:34:58.389Z" }, + { url = "https://files.pythonhosted.org/packages/a8/07/ffafe261fc09d0cf7231bfc8a6584198a443d96f6ce40c5a3f5f4b2b7a7b/lcm-1.5.3-cp315-cp315-win_amd64.whl", hash = "sha256:4c97783731819368a065f9c920457ecfb065abce3029158c006db6e80e8bd51e", size = 4489450, upload-time = "2026-09-24T16:34:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/27/ca/bcf7c1d60c09a876f045daab3dccd7db7e5108788ac0a8f8f30c1ef43ad0/lcm-1.5.3-cp315-cp315-win_arm64.whl", hash = "sha256:d9dd602f00cfd49ec105e72949de311b1d499086d1fe799ac03571d7b9a91d5d", size = 4354547, upload-time = "2026-09-24T16:34:55.872Z" }, +] + +[[package]] +name = "lcm-websocket-server" +version = "0.8.0" +source = { editable = "." } +dependencies = [ + { name = "lcm" }, + { name = "lcmlog-py" }, + { name = "lcmutils" }, + { name = "websockets" }, +] + +[package.optional-dependencies] +image = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, + { name = "opencv-python-headless" }, +] +orjson = [ + { name = "orjson" }, +] +uvloop = [ + { name = "uvloop" }, +] + +[package.dev-dependencies] +dev = [ + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "ruff" }, +] +release = [ + { name = "python-semantic-release" }, +] + +[package.metadata] +requires-dist = [ + { name = "lcm", specifier = ">=1.5.0" }, + { name = "lcmlog-py", specifier = ">=0.1.0" }, + { name = "lcmutils", specifier = ">=0.1.1" }, + { name = "numpy", marker = "extra == 'image'", specifier = ">=1.26.4" }, + { name = "opencv-python-headless", marker = "extra == 'image'", specifier = ">=4.9.0.80" }, + { name = "orjson", marker = "extra == 'orjson'", specifier = ">=3.10" }, + { name = "uvloop", marker = "extra == 'uvloop'", specifier = ">=0.21" }, + { name = "websockets", specifier = ">=16.0" }, +] +provides-extras = ["image", "orjson", "uvloop"] + +[package.metadata.requires-dev] +dev = [ + { name = "pre-commit", specifier = ">=4.2.0" }, + { name = "pytest", specifier = ">=8.0" }, + { name = "pytest-asyncio", specifier = ">=0.23" }, + { name = "ruff", specifier = ">=0.17,<0.18" }, +] +release = [{ name = "python-semantic-release", specifier = ">=10.7.0" }] + +[[package]] +name = "lcmlog-py" +version = "0.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/de/a3/3bc23453afc785bb04d711e5c7c1a2e1b9f16d541b578eb52bcee9b0914a/lcmlog_py-0.1.0.tar.gz", hash = "sha256:e435d6016c40d42df657ccbf171a66b0ceaed34d4f8dd5fea49d5a552e46005c", size = 3225, upload-time = "2023-01-09T20:51:49.888Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/b6/06d212a03f8b21db9ffcdd7cc9ff950da22e35d644ce6d9a85d5484e2f92/lcmlog_py-0.1.0-py3-none-any.whl", hash = "sha256:2d64d5974516128301919fff9fc995ba715172b2060e7faab7a79834b3a5aded", size = 3566, upload-time = "2023-01-09T20:51:47.555Z" }, +] + +[[package]] +name = "lcmutils" +version = "0.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "lcm" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/31/84/abf2703c3db20370ad593c5044af8503d894effe9399c1d84036230d50c0/lcmutils-0.2.0.tar.gz", hash = "sha256:2a55dbb87debe8daa7b50e565c51e88d679f62330653b45d35592e97dce621aa", size = 5539, upload-time = "2025-04-25T00:12:26.649Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a3/41/e481a7ffd581fd4b6f704b7f629c95b955b2c87fd765b6df0bc6db04c4a9/lcmutils-0.2.0-py3-none-any.whl", hash = "sha256:00ca19e0927fdbefecc9ce90d26544dc368947add060d8eb5963f639a28e3e4f", size = 5026, upload-time = "2025-04-25T00:12:25.786Z" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/16/fc/cee2c45553c9a9bf77d8b0c391560c556d7ed756b1f0bb35eb5d48db09ea/markdown_it_py-4.3.0.tar.gz", hash = "sha256:91a58fa5b72c71a40cf7177250fd767480d7a2bb3ac426ccfb76fb90305fdaaa", size = 242701, upload-time = "2026-11-10T16:18:30.467Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c9/31/5f0ac2f1a1c67423c995c731a11cd4ad05d081a2be969d74f868bdb9cc70/markdown_it_py-4.3.0-py3-none-any.whl", hash = "sha256:7aa1511a46c39138de78d9eba92ce47e63124d8003fc98b3a351909e04239efa", size = 96951, upload-time = "2026-11-10T16:18:28.975Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/9b/e422a865e1d5d57d0e509b4e0bf1c1a70a7f6382c29a5aa428df994c8bc8/markupsafe-3.0.4.tar.gz", hash = "sha256:2e9ad7dd851bf45fab9f75cbff4cb493fee9979e8d8c7c9c3ee119022518edd6", size = 153777, upload-time = "2026-10-02T23:07:22.29Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/55/18dbb4778b30ada5ce071608503cc3edc9e14e13d868c17a6d178fc30f7a/markupsafe-3.0.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9e25feb9e330b63edb0278a0acdf85e50d0cb0fbf49c3084abbe4e24ae195346", size = 11520, upload-time = "2026-10-02T23:04:36.299Z" }, + { url = "https://files.pythonhosted.org/packages/6c/14/0b05f79b4733e264a18d08fe08fa1df7347630ff32a6cb82180d9dccec55/markupsafe-3.0.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7d3391b2188d18737cb2fa147028b1096236eaa7e156446c650a489fa2cadc91", size = 12063, upload-time = "2026-10-02T23:04:37.291Z" }, + { url = "https://files.pythonhosted.org/packages/ca/3a/63ba10b6c1463216b3e4df669a9f0e5a3b0c3071557d2e8229e3968c79fb/markupsafe-3.0.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849dd2bb0e5e4ab2b71c7191726a4a8d5aa8a610daa584728cbee0b710ddc4ef", size = 24321, upload-time = "2026-10-02T23:04:38.262Z" }, + { url = "https://files.pythonhosted.org/packages/1a/2e/5f015261b76ad633d187ef6f388b413aedd64a8773c4df59e530a0be5525/markupsafe-3.0.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:befb4158af32106b9a93db8d6d1d1cbbd418c0d5aca0cabb7b1780abf0c89169", size = 28845, upload-time = "2026-10-02T23:04:39.295Z" }, + { url = "https://files.pythonhosted.org/packages/33/cf/26e594b26be40c2f1fec63ccf8a8b99d0335a5b2cbe84835c7d82a994375/markupsafe-3.0.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:71f88e749ea29f67f21f3b36433c1dc54c7729ed2a6d9e2da2e0d9e0d7b224eb", size = 24701, upload-time = "2026-10-02T23:04:40.348Z" }, + { url = "https://files.pythonhosted.org/packages/81/a5/a513b76c139a3915b43404324e55c0b7979ae4f0d39eb6f075b0282e90a8/markupsafe-3.0.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6da83a088f8ef93b2d483a8232a4dbf4d69d3d8496b568a03c56becac43e1808", size = 22961, upload-time = "2026-10-02T23:04:41.372Z" }, + { url = "https://files.pythonhosted.org/packages/46/cf/4c66192c100b4542bcbe392ae06696b670f66927be3ac38a213234778ff9/markupsafe-3.0.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8f0fac8b13d14bb06c68195f849371924ae53dd7b1c00fed24650f704383b692", size = 21920, upload-time = "2026-10-02T23:04:42.429Z" }, + { url = "https://files.pythonhosted.org/packages/cb/17/ac3662678bfbad649893117ada2ba44dc30bf56884e84f13154a792b10f1/markupsafe-3.0.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:4a7cdc2a420ca01058182da4253329764d4bfa055564d1eced90e6ba1e8b1d3d", size = 23726, upload-time = "2026-10-02T23:04:43.531Z" }, + { url = "https://files.pythonhosted.org/packages/f7/af/fe47cee339180a69ebca3c57fb3483d0f5cbd1e8337d1871fb1d9c1aebee/markupsafe-3.0.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:83b3944fea42a8400edf92fd1770fb8d0d4f7de651353bd2d8525a92dba69a21", size = 22539, upload-time = "2026-10-02T23:04:44.618Z" }, + { url = "https://files.pythonhosted.org/packages/12/32/d55440ba140442800e02d799c9cb5ab597bf6ebdb1177b5ea39a11f797bd/markupsafe-3.0.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:8138eb83940ec7299024d92d4dee45f601b9e6c5ffde9d25f4e35e326203c707", size = 23963, upload-time = "2026-10-02T23:04:45.656Z" }, + { url = "https://files.pythonhosted.org/packages/50/9d/9c86042cb364c2ad4c971e6d1247929effd25f714cd7ee11b05e6316445b/markupsafe-3.0.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:811d02d5122171c1941357efd8f9bf4ffe907b7f0a1a4e729a880e4be3f46e3e", size = 21506, upload-time = "2026-10-02T23:04:46.671Z" }, + { url = "https://files.pythonhosted.org/packages/75/ef/5b824f03ba40c3b3652b6272d083d2fc4fcdd440de519a3a39ba2c3e7262/markupsafe-3.0.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:50b5bedc9ed8a94fc8857a42ef4f84a81ea88f8d4f05dc8705fb23ee6d8dcca7", size = 22955, upload-time = "2026-10-02T23:04:47.698Z" }, + { url = "https://files.pythonhosted.org/packages/1e/e8/44cfcb5ea40e5e43cec7793ef90704ed0c475280839076c4345757eb8e59/markupsafe-3.0.4-cp311-cp311-win32.whl", hash = "sha256:2e5a7cd7fdd14fcb1ae5d7d8bf23d24fbd1daefd1fbca2580132e1ea75f098b5", size = 14094, upload-time = "2026-10-02T23:04:48.788Z" }, + { url = "https://files.pythonhosted.org/packages/91/89/f2b509f7bf79352e40117824c1070dbeafd4df67031d3fa98165a3134228/markupsafe-3.0.4-cp311-cp311-win_amd64.whl", hash = "sha256:fdb4ca07ab75ffadab4a8b135ad59cdbb3156b99310f3d565370da74a15d6bd3", size = 14328, upload-time = "2026-10-02T23:04:49.801Z" }, + { url = "https://files.pythonhosted.org/packages/2b/5a/ccf22672a0f64dc682306e288f0dabcb06c7a201f3bb6e6cbf86d9e8ad03/markupsafe-3.0.4-cp311-cp311-win_arm64.whl", hash = "sha256:569d65055d367e3dcdf30c3f41119467b73d9ee9faf332bdf40402644f5ac08e", size = 14188, upload-time = "2026-10-02T23:04:50.847Z" }, + { url = "https://files.pythonhosted.org/packages/81/09/4c59d56b8461ae8eb0d8ba34bb25b7e618547044679d58a82ef9b2479fc1/markupsafe-3.0.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:61631e08084be9e21a8967ec3139c7616ed7c5e9368e05c86d1b39562c8a57b6", size = 11658, upload-time = "2026-10-02T23:04:51.876Z" }, + { url = "https://files.pythonhosted.org/packages/a2/f0/d6613774d86fbf6d145751d43c59875e47a6f9f17daee0aef173bd36d90e/markupsafe-3.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0930db9bdc62d22944e10b066448bb65dc9abe9112880c7cab8da54db4284d5f", size = 12050, upload-time = "2026-10-02T23:04:52.931Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f2/8f18e0b806eb13c1f8d07d917a720831ead54253a6dec011fbc78098a6f8/markupsafe-3.0.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a45c3d514f2436064db00d7fc8778d888f0236ebfed649b53d13a59e69ad51b", size = 24363, upload-time = "2026-10-02T23:04:53.895Z" }, + { url = "https://files.pythonhosted.org/packages/60/ce/fa07dbe8a5675558fa36dea033e19995bc783de2dec5f540ccb9030b06aa/markupsafe-3.0.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1e1451fab512d1bcc3dc26988ec1edb0b82c2db909132872cd9356070a6b63df", size = 28525, upload-time = "2026-10-02T23:04:54.905Z" }, + { url = "https://files.pythonhosted.org/packages/85/40/be87c01f3868ec217f8a2015089d71c22c8c5a75324822e5ed1cdd87210d/markupsafe-3.0.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bd3ce56ae2cbae3ba82b683bc425cd7e48d2ed8b10f3e818186b6f5646d9271c", size = 24733, upload-time = "2026-10-02T23:04:56.229Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a7/aeedb5140afa41fc74c225e9184ab96723a6e873b6ee1c9fede7283456d8/markupsafe-3.0.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e124f974786f831d6043728e38296969d3579db8896fe004682f5758e613581", size = 22985, upload-time = "2026-10-02T23:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/c3/fc/e91352bb08c6a59da3ef0909d457bf95a5f5908fbf151b30a06d9dbcfbb4/markupsafe-3.0.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c02e8f18bdedba082cef725942ac823b9b60656db07f7e265cb31618dfd00d77", size = 22001, upload-time = "2026-10-02T23:04:58.597Z" }, + { url = "https://files.pythonhosted.org/packages/5d/f8/bffee5e7d2a3deb59748a797650a48af7e672025cf641a79344a771ad106/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9f098115c247e11d138ab83a28fa0323c77015007ea2df73ba5fd714dfefd67c", size = 23793, upload-time = "2026-10-02T23:04:59.686Z" }, + { url = "https://files.pythonhosted.org/packages/ed/59/b853d6628ecb4d658e1d637224846d5e9bb4adf4f8df97f3be9f29dce2ec/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d5f93ebbeb8032d47e349328ec8662d973d9b05a70b3c35df1f91fe419b84749", size = 22640, upload-time = "2026-10-02T23:05:00.768Z" }, + { url = "https://files.pythonhosted.org/packages/09/b2/1506df394f0f075797c418d0301498f49e43be194e3ffcb49e6fe6ccf022/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:64511c54db4e4987aef4c41923235927428729e8174c5dba488429be70a998ed", size = 24074, upload-time = "2026-10-02T23:05:01.813Z" }, + { url = "https://files.pythonhosted.org/packages/c7/81/5ed69cda630ac69ef60d06c09ba5a7f84ff66a2e28cf986fd5614ab3c6e6/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e1a622f13970d81f95d0c72f9dc090dce9085fccfa4c9f2174377ee32bd15786", size = 21563, upload-time = "2026-10-02T23:05:03.239Z" }, + { url = "https://files.pythonhosted.org/packages/0c/fe/fb1e79be0fea60aa32602ebefc9c35a82bb42b4df157285ab7dfec12341a/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c9a7f43c0b202b334cc9184af09bb8f21d3a209e038efaf106936fb69e6b026e", size = 23048, upload-time = "2026-10-02T23:05:04.479Z" }, + { url = "https://files.pythonhosted.org/packages/c8/52/7632a53360671a9b750cdbabaf9cdd89f18b42248b8e4cb42c0b0296e459/markupsafe-3.0.4-cp312-cp312-win32.whl", hash = "sha256:f0ec3b750b59375eab5b0fb2b9254810c00a3375be6d789899f1055a1d556237", size = 14108, upload-time = "2026-10-02T23:05:05.513Z" }, + { url = "https://files.pythonhosted.org/packages/3f/bf/62495e180b7000aaf30000fff849e933f74264638057176cf46852500adc/markupsafe-3.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:11935df9bf455ed0c04eb87bcd720f02b1fe5e02128a9430f23aed6f93336fc7", size = 14303, upload-time = "2026-10-02T23:05:06.538Z" }, + { url = "https://files.pythonhosted.org/packages/c5/8e/4c24208776a65878d656996945aacfbfe010d3720d1a98fc0eb8491fc03b/markupsafe-3.0.4-cp312-cp312-win_arm64.whl", hash = "sha256:a4bbd2d87dd233b9fc5812160c3d0ffbe42edc22a26ce0469f58479ede633fe9", size = 14174, upload-time = "2026-10-02T23:05:07.617Z" }, + { url = "https://files.pythonhosted.org/packages/6d/18/4bc5ba32499e87bb2b0ef5b3a9bb9c00a131fa961ddf0be548cb550f548b/markupsafe-3.0.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:de8b364c423ef0a4bad9069657d617f9a5d2b2062457a89b1fa16ee199c399c1", size = 12786, upload-time = "2026-10-02T23:05:08.709Z" }, + { url = "https://files.pythonhosted.org/packages/4e/6f/17f0c099bf25f3e31e63cc19244d9f6af861a9a4ab778c203997903cfdd0/markupsafe-3.0.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:34bdde374c5932765d7dc685c4a1d191a3207852d67e8e0a9eb6ea85156181f1", size = 12510, upload-time = "2026-10-02T23:05:09.93Z" }, + { url = "https://files.pythonhosted.org/packages/11/af/1a141081b905036ee904ec4bd945e1f70b4e1b32d33c4e59e8cf1d58b247/markupsafe-3.0.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:6bd9e1788e15bfcf6a9082de42e30387e7b85d211ab21e57a939bb8cfaaf8d96", size = 11583, upload-time = "2026-10-02T23:05:10.884Z" }, + { url = "https://files.pythonhosted.org/packages/e7/0a/a89385ae590232622a03e091805cff12f24fabe6c11e0e8bae096cece81c/markupsafe-3.0.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:5066b244f576f91afc8ee3ba029a89f99d39c79b1853fe9d39bea9f0afbec148", size = 11801, upload-time = "2026-10-02T23:05:11.913Z" }, + { url = "https://files.pythonhosted.org/packages/ed/85/ea548dc013962eb73653124bc595635fbf9e0fa41d1f181a967ccb784dfb/markupsafe-3.0.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7a83aa6e4805df46fed18e989d3d16f86ef60cb50bbc8d9ce3a6be89165fbf6e", size = 11443, upload-time = "2026-10-02T23:05:12.887Z" }, + { url = "https://files.pythonhosted.org/packages/cc/72/15f2e5ec9cf2eb00d5cdfe968d94e4156a7bd7303832c3f3b2c403a36839/markupsafe-3.0.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2d1b7d9308288661f56672b1b157d75fc536714d3638487bbea17b6318a78248", size = 11665, upload-time = "2026-10-02T23:05:13.829Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e0/4030bea613677e333c8a2c901fd405055f657f9d06acba5b7357984b6ef7/markupsafe-3.0.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:73e77980c7207854f00fc4e71fb1626868d5740ab4012623d55c7a99ad122a72", size = 12061, upload-time = "2026-10-02T23:05:14.807Z" }, + { url = "https://files.pythonhosted.org/packages/f3/a5/28b76a7449eb702966b88bef599e2360b411fbb3afeee8fe560939be06ec/markupsafe-3.0.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7018d4af1cd272e847aa5917983ab5e83e4f6579f9dbfecd4a79c0ca80b144c2", size = 24395, upload-time = "2026-10-02T23:05:15.909Z" }, + { url = "https://files.pythonhosted.org/packages/07/6c/21232811afc3a063b5e934b1ae2efda52f46154ec382f585149c020e61fe/markupsafe-3.0.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c90d5b3d4e944e065a301d741b3c1d784f6bd1f503aa68b4967e32b2ba313d85", size = 27183, upload-time = "2026-10-02T23:05:16.976Z" }, + { url = "https://files.pythonhosted.org/packages/14/38/6ccdfa5b59049cb36fb80cbc80aee9cf1fc9bb77d1335ad435f2070b08cf/markupsafe-3.0.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:18a801868a884f216e784d7d14db2a4077143ce7610440aee2ce8f734e7cfcde", size = 24772, upload-time = "2026-10-02T23:05:18.209Z" }, + { url = "https://files.pythonhosted.org/packages/63/e0/cec6865dfe88cb48fedd4b20aed6af5158e41092adcbf3e028bcc6ec2108/markupsafe-3.0.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:434139499bb20b502ed3baa1f169e618f924a97e7a777fea1a49446d80106cf6", size = 23017, upload-time = "2026-10-02T23:05:19.286Z" }, + { url = "https://files.pythonhosted.org/packages/ee/76/6ed4940bb7648a9aac457c14f870cfdd5105f139a0fb1f29cd61fafa47d1/markupsafe-3.0.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9e227f3dbe6bde7491cf0a9965d00b88c6b1a4a95d11480ddf88bb96d397c19f", size = 22036, upload-time = "2026-10-02T23:05:20.352Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4f/ed476226d4fe46a09090a36025bf319296810028df55eb12f1253b540f3a/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b8cd1f918b26fd7b1832ece557cc18f2d8747309ff8b3f0ef9d4250c5ad67a39", size = 23786, upload-time = "2026-10-02T23:05:21.576Z" }, + { url = "https://files.pythonhosted.org/packages/9a/35/66ff30450e35ef5fba9ebc930c9411747e537fd9447b65e44f5007e2b84d/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a5fcffb37e602b0b3c1638a97746b9b96125caa9bcf6fa41d337a9261de231ee", size = 22672, upload-time = "2026-10-02T23:05:22.922Z" }, + { url = "https://files.pythonhosted.org/packages/32/0b/72f45ce4b4efcbca4b80cf1b06703eff0be8d37e82abb78f66c85a7ead1e/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5989cb26b2e1efc6a42216a9f6b5ee495ce5ace2e5b352a9af489976b32d1ee2", size = 24107, upload-time = "2026-10-02T23:05:24.175Z" }, + { url = "https://files.pythonhosted.org/packages/d2/03/71776e5fdcba04614b384cc102e8a4198208579d896fd1394cb7cb9aa900/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:add96447a86d205ab616665d53b2950ee81083757f56e6ea833c8b2917646b46", size = 21615, upload-time = "2026-10-02T23:05:25.215Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/801ce02a02e7aee0f784b1ec7843026178f6adeb9c93ac67eb1992a9a84d/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2628d3a8cb648ecebb3c5d6b0a1052d400e4d8b7ac0fb786be8d285b50040d17", size = 23076, upload-time = "2026-10-02T23:05:26.423Z" }, + { url = "https://files.pythonhosted.org/packages/4a/85/c43776625428f3bb4a61e8633940400e3efe6409e3c6f5bff26de5e45618/markupsafe-3.0.4-cp313-cp313-win32.whl", hash = "sha256:672d207103e6b16ca098611b0f9efad6bc00afd47c03d6ef62186495ca677dc0", size = 14118, upload-time = "2026-10-02T23:05:27.716Z" }, + { url = "https://files.pythonhosted.org/packages/6f/36/163da64de88a13db79214ef75fa041be7fa13bdb42261cf5b7484de14bfb/markupsafe-3.0.4-cp313-cp313-win_amd64.whl", hash = "sha256:1f1f9477e174582b0a1b583d60b66e1f2cf5d3fe12cee985e4aedf44766600e5", size = 14313, upload-time = "2026-10-02T23:05:28.749Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a8/9b662783ffaa1149221432a923cee562f78b9cbbb8baa3df9b3753e63e1e/markupsafe-3.0.4-cp313-cp313-win_arm64.whl", hash = "sha256:06de8ef6331f6e822c28d577dc8bf43fe398800477c49498f38fc38b67ff33fc", size = 14189, upload-time = "2026-10-02T23:05:29.917Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c3/a944f3b0df22bd129e96915b9f4e98d2eeca6516687d7618304a966c3c74/markupsafe-3.0.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:4ed644d75aa94a2baf7ec3a96eaa160ea58c742eb9d27c6506053c5c40fc84ed", size = 12787, upload-time = "2026-10-02T23:05:30.971Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d6/a44863f69d88b6c7e27889108f70d47aed259edf89d5df3c5fca1eac87d6/markupsafe-3.0.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:6d2a9efe686f9de00d0d1ea32a4a5a86d558a2277501bd78d964214eab625e59", size = 12525, upload-time = "2026-10-02T23:05:32.263Z" }, + { url = "https://files.pythonhosted.org/packages/17/8f/168ba80e532dd6a93f96f8f706f1ad41d7990b6e1aeedc1cc0d211a33497/markupsafe-3.0.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8781a792a070cf2bd1b86d3aa943894115faaba6e88122a7bf32d62072742453", size = 11589, upload-time = "2026-10-02T23:05:33.251Z" }, + { url = "https://files.pythonhosted.org/packages/32/b3/aa2c95a574d3af39403a469b295886eb9b6d448da568cbebb5a2cbfdc2e5/markupsafe-3.0.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:971a3bbb75d97ae4e2e8f7d4834236f86f85f0c85e04ab2e191db1123b04f80b", size = 11801, upload-time = "2026-10-02T23:05:34.315Z" }, + { url = "https://files.pythonhosted.org/packages/60/d0/34b810107d83840e768bf485de795893ebbae35b26ab061b487adfa0a692/markupsafe-3.0.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:8909c2f1c6dd65e054ac4b573a91c8384d1492281e55d82d159d653f7a13adf6", size = 11447, upload-time = "2026-10-02T23:05:35.302Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ab/2f8488f0f817a39fca068d2b17daf446bf5cdb3eae28c3720af534d873b4/markupsafe-3.0.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4cf3468d5ec187ffffcaca8e61929a37448f215dafc1386a12c750a72fe53634", size = 11722, upload-time = "2026-10-02T23:05:36.363Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/e2d117b048d47282ade906fbfd92814cbee5647afc13fda88a3406039372/markupsafe-3.0.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:52704c5d36eb6dda8866493decd61111fff86244c9b1ad225ca01b9e91e5970f", size = 12061, upload-time = "2026-10-02T23:05:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a8/73a81135e85ba66217f5af7facb03bbb386807e1a729ab64532e4c802652/markupsafe-3.0.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1caa2fa5a6184fb233153b35f654e6687bd555476f6170f29d8ee9be1a8b0af9", size = 24434, upload-time = "2026-10-02T23:05:38.407Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ca/fa9216dd01efee2dfdacafe7df32b4d0170fbac694b0c258a193d6e53999/markupsafe-3.0.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:387d8cd30e69b3f0a72877b9ae717033396404e19095b17fe89753a981fda44f", size = 27183, upload-time = "2026-10-02T23:05:39.581Z" }, + { url = "https://files.pythonhosted.org/packages/fa/4e/a469509e538d37af51103b17b073126973f2b1cbf197ff32c7ddf025cfe5/markupsafe-3.0.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:051417f74bcaaefa316276e0ff723f541616ca51043d070da00249d9bddd3e3c", size = 24813, upload-time = "2026-10-02T23:05:40.671Z" }, + { url = "https://files.pythonhosted.org/packages/8f/db/d7282caf7ab03af44d5d6fdbaa019b35c7d7f1c90588b839c07cba640d6a/markupsafe-3.0.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8e9f292fcda89b324f2f5c91d13f1424a153e40fc2756f38ee23b15835ff300", size = 23049, upload-time = "2026-10-02T23:05:41.864Z" }, + { url = "https://files.pythonhosted.org/packages/30/f3/b6a425206e6964efda6acee544d0eb01d1501784d0b8e2dcc74986f33b17/markupsafe-3.0.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:df1ae86ff54725a01fa1a0510b914ca53a161b7050be74f6204e24aded5971d0", size = 22088, upload-time = "2026-10-02T23:05:43.014Z" }, + { url = "https://files.pythonhosted.org/packages/ea/8a/84d3582fc1f0d5bd466cdf2eebf175e172158a6e70701aacec1de1b35430/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8965520ac587c94a4ac48b729be3d8b8de00af39699b17585dfb599babe77977", size = 23846, upload-time = "2026-10-02T23:05:44.098Z" }, + { url = "https://files.pythonhosted.org/packages/1c/65/db101cce51b7ba4864ac491a9859d297dd1adf0e55b103fee9db9c47c527/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:340cbb1957ba99929cbf19a75626d36ba1ae21d1730b287d1cf7f824a20c4fc7", size = 22674, upload-time = "2026-10-02T23:05:45.23Z" }, + { url = "https://files.pythonhosted.org/packages/e0/49/ddee9813d71db0c7a5c9d97c832125e6758a0c844777f1cf076569bb0e22/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:3a93d9616ddecfb393727a0041a562cf0b15a244e20f2bd25efc7949be4c4f17", size = 24104, upload-time = "2026-10-02T23:05:46.398Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0e/7d8518d726726870a2399d69fd30d0fa36c5e57a2132c336b58d7c491073/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d2e56fd3b00222722abfb3f5f0759ddbae4b90811b5ad4343c64030ad1bde70c", size = 21637, upload-time = "2026-10-02T23:05:47.48Z" }, + { url = "https://files.pythonhosted.org/packages/b4/b0/b505e8a361ba557dbf3b3aa7331ea39b00d2022a26e925ff8463b9714bb3/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0d9c47709875fdb321452056622e930c52afbc07a7d780762fbb8b4d91ce6fa4", size = 23081, upload-time = "2026-10-02T23:05:48.611Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ea/9cc3cea873f980c75cbdb6f4277ce30ee955de38be0b3d02f14c108e0698/markupsafe-3.0.4-cp314-cp314-win32.whl", hash = "sha256:38fc55594dab834470b6733dead2ee9e3f657fb0608c769dcafa0ba5ab52f45c", size = 14272, upload-time = "2026-10-02T23:05:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/80/f0/5792ff768a410f93ee3f84fc19345295ffc352d2c936b424cb37e514714c/markupsafe-3.0.4-cp314-cp314-win_amd64.whl", hash = "sha256:c1bc67752d5f21013cfe430df4062441714eab79f65a6a05e01505957e9c35fe", size = 14501, upload-time = "2026-10-02T23:05:50.788Z" }, + { url = "https://files.pythonhosted.org/packages/5f/cf/3d074a8edffcc6899355232ff2543ae8d929733239596423b7db79698bc9/markupsafe-3.0.4-cp314-cp314-win_arm64.whl", hash = "sha256:7e1636da3d8dfc220b6dd10264db5f2b165e4888c4518594898fbe381049af8a", size = 14364, upload-time = "2026-10-02T23:05:51.857Z" }, + { url = "https://files.pythonhosted.org/packages/d9/31/87ce42159aae2163cf3bbbd0c44bc87780510eecab1ea3859099aed95dcb/markupsafe-3.0.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:805c8b84534fa10891890f0e4be39f3a99e94615d93e8836bf9fa1fdca2feeb2", size = 11759, upload-time = "2026-10-02T23:05:52.951Z" }, + { url = "https://files.pythonhosted.org/packages/5f/53/b047207eeb7752e960aca3eb1df5fb7eefa7dd4c62ac49bb156456c8a702/markupsafe-3.0.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fa95848c929b6a75f6848d3c9793e59db365ee436776e57db835cdbfa79ba977", size = 12096, upload-time = "2026-10-02T23:05:54.066Z" }, + { url = "https://files.pythonhosted.org/packages/ee/51/4326c88a13c7b755657d44b4bb986f8c3d9843ecba7e22d98661d87f9a57/markupsafe-3.0.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e916035e3e9930cbdfdd10abf48861340221857f45509565898e012263f7b289", size = 25699, upload-time = "2026-10-02T23:05:55.15Z" }, + { url = "https://files.pythonhosted.org/packages/f2/bb/990581b7474bfcf2cf34bed6ba5ea23bd87adb9d671213d68e88620e7a6b/markupsafe-3.0.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b4d12837e0203bbace818ff4a7461afdcd78bcd782351cea148139180d7bcffe", size = 27804, upload-time = "2026-10-02T23:05:56.29Z" }, + { url = "https://files.pythonhosted.org/packages/6b/89/89491878c28e8291f5aa2fffe2c2d57230d10ae366d55dd810b840513d78/markupsafe-3.0.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5086f9975abb1ab531ee6afca1761e4b59a19b446f3f6522ed776963228cfe5a", size = 25912, upload-time = "2026-10-02T23:05:57.416Z" }, + { url = "https://files.pythonhosted.org/packages/30/77/680998b54efdea06fc114565cd739b6d059f826a0279219b218dfa750d29/markupsafe-3.0.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4a635a0487774f841cb1fb62e907e7195cc95bc761e053184b8acc3ceb20733", size = 23623, upload-time = "2026-10-02T23:05:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/ae/75/2709f5ac5de9467b40b10e2bb8f89cc63dfb74582e09aa734b1124a217de/markupsafe-3.0.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb96e6e088d6cf71c1ea977510948320234824cf226e32f6f6e044f7a9c82b34", size = 23301, upload-time = "2026-10-02T23:05:59.94Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c8/39eadc6c5b14c9c7679bfb98f4d4c6a97863b5beb91839aca4d2d6e16e55/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8b5d563170ff8ba3181caa967c99a3c804d1dedb702c7cb93a6a7c32247da978", size = 24950, upload-time = "2026-10-02T23:06:01.289Z" }, + { url = "https://files.pythonhosted.org/packages/1a/5e/01037f8a43e8ccb0bffb4fbdc5212db05bf080fdd7286cd392332d58128a/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:396ec4e65cc889f69786b3b89478b471cee5a3bcf468b9d9bb03e1a30fb291fc", size = 23330, upload-time = "2026-10-02T23:06:02.441Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f4/23e83ce0596bb0cbe670502d31df8f757bbd01a392aa486fa3b40d1ed399/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:15ba9e28640feef770374b116a6f019c21f52404aeabe516aa7f800587b98cfc", size = 25239, upload-time = "2026-10-02T23:06:03.579Z" }, + { url = "https://files.pythonhosted.org/packages/88/5b/3708897368073cc683d524750474f41a77d2986152c380dcc55b20fdf340/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d920abdfa61279ba1a2ef9484aab07bf03331f8c08a10120fa332353d06e6932", size = 22767, upload-time = "2026-10-02T23:06:04.699Z" }, + { url = "https://files.pythonhosted.org/packages/c6/61/ebda1307864b409e6b3115757a3d4a09cca46cfb6cc65191b5de226b424b/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a9f54054101545a9a9cccefddf54316aa6e4491611fcbef9e91b3b6bebec04f6", size = 23668, upload-time = "2026-10-02T23:06:05.9Z" }, + { url = "https://files.pythonhosted.org/packages/09/15/98075cceac3b5ba0dbb8e4762a847be967d2befc349a2cf2d0ac77f62c9d/markupsafe-3.0.4-cp314-cp314t-win32.whl", hash = "sha256:12a606a492de952afcb43b59a14aaaaad120e708d3663dd0fdf2d738d427a691", size = 14301, upload-time = "2026-10-02T23:06:07.109Z" }, + { url = "https://files.pythonhosted.org/packages/0b/a3/768b560fcc4156685cb563d922b217810cfa7bc135773367f62f1f9d2078/markupsafe-3.0.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a18f38cafc329bac5e3c2b96c765b4c96d3d103421ed22ab7988c1e3fce27464", size = 14526, upload-time = "2026-10-02T23:06:08.276Z" }, + { url = "https://files.pythonhosted.org/packages/93/63/da554b4c97a6b0ea3229ca7fe8cbfb620be81613d517f482e85958550537/markupsafe-3.0.4-cp314-cp314t-win_arm64.whl", hash = "sha256:eba154571c16e032112afac0dc2dfe9e63c2ceb7aedd07bb7eecf2ce26d4dd4c", size = 14421, upload-time = "2026-10-02T23:06:09.402Z" }, + { url = "https://files.pythonhosted.org/packages/a9/30/54d11c8ca027114898cab97421fb39e4ffd9ddf47cdbc44df2ec76722da9/markupsafe-3.0.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:737c9c3981998eba27f11786f84fddcbabc74068b72a4a1f454ea02094b57b65", size = 12791, upload-time = "2026-10-02T23:06:10.485Z" }, + { url = "https://files.pythonhosted.org/packages/10/6d/97c913e253a14bd3cd0e15a5c56d13203b823fa7ee32498342896a072dc4/markupsafe-3.0.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:489505b03f692c3f376394e49194fa7a7f9e8558d6e293a7056a0032b0c38163", size = 12527, upload-time = "2026-10-02T23:06:11.834Z" }, + { url = "https://files.pythonhosted.org/packages/26/f9/b86d032042a4d597d9e1997f0e5f63a3eedaf11258e0a05760b0a0a826ea/markupsafe-3.0.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:077293e425f28ec737dbcad442a71752e28f8ae27cde3d68acd1fb212091cd92", size = 11602, upload-time = "2026-10-02T23:06:13.122Z" }, + { url = "https://files.pythonhosted.org/packages/f2/dc/73c14c1eedf0ac5fa3292ba43435e6c49d2c2050f33cebde541f8f4807f1/markupsafe-3.0.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9348cbb300d224fe3b89793262cb093504d4ae927004468463f745188a193e4a", size = 11817, upload-time = "2026-10-02T23:06:14.227Z" }, + { url = "https://files.pythonhosted.org/packages/8f/69/2c2fcaa5fcee22d72c7819c0d536fd181c74a688e6143845419579cd2863/markupsafe-3.0.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:b807e598953730f82e4eae3bd30f6a122cf6b31c398c6b504c0e04c13c170429", size = 11446, upload-time = "2026-10-02T23:06:15.574Z" }, + { url = "https://files.pythonhosted.org/packages/88/54/9e5ec76c62e6e2834d5a93623018c943e8b3bb41d663e3fd4c03303b9b85/markupsafe-3.0.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:799c39bdf5e2f1292fedd3009f7b3c9e760f10b2420cb9638d56920840ff6db8", size = 11719, upload-time = "2026-10-02T23:06:16.701Z" }, + { url = "https://files.pythonhosted.org/packages/96/24/3ec292b44064c16229e064d770b2625bd8ea941aa61f44905a9fa44942c0/markupsafe-3.0.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:ae9dcb8fbe244cb82f8a6458b455b927a03685e383d9bacf1ea5ce180b96dc97", size = 12075, upload-time = "2026-10-02T23:06:17.855Z" }, + { url = "https://files.pythonhosted.org/packages/aa/85/b64fdb1f304848518742136983c24e96d967bfb59a0ea160e92736901ab0/markupsafe-3.0.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bced6e2a6dba6a28f7dd3c6ce14df1b2dd495923f16ea484cad03decd463b2b", size = 24656, upload-time = "2026-10-02T23:06:18.963Z" }, + { url = "https://files.pythonhosted.org/packages/9c/18/23997d4c65b355da6390d61cd56e0ab3befd6ba8dda25cb40c602bd0fa6b/markupsafe-3.0.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3882fb412298575bae3b9c46868251f15cc69307359f87bb1b382e53d6e5a2c9", size = 27737, upload-time = "2026-10-02T23:06:20.117Z" }, + { url = "https://files.pythonhosted.org/packages/d4/36/35998dead3c6af88c38265a56e58100211f036234ab88eb2283fd4cbce44/markupsafe-3.0.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04e7902ba80ee4bac1d50a549606527a1dcf0476cd81403db41099d3b60ec653", size = 25003, upload-time = "2026-10-02T23:06:21.284Z" }, + { url = "https://files.pythonhosted.org/packages/82/96/ef49135ce260db4ca4a12b119ed468449cd248db6b1468e2112b546d7a2e/markupsafe-3.0.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:925f929d6b59a8b3f8b8c6ac363cd0af7eecc81efb3071770b3c6717c450a369", size = 23111, upload-time = "2026-10-02T23:06:22.524Z" }, + { url = "https://files.pythonhosted.org/packages/50/7d/83126e338bd88c17a220668235368ad719fd4638e426739858cbb8508f77/markupsafe-3.0.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f68edfc67aabac33708941f26f22a7b8e9f81429bc0cf249fcf7d66b23af8d19", size = 22403, upload-time = "2026-10-02T23:06:23.785Z" }, + { url = "https://files.pythonhosted.org/packages/83/dd/daf7e420de23c8206c365204e7b85e1251d8e19d34196a56336f316e5ed2/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:e5c802729725bd07e2bc3ab7b76dc7e0bbfc53129d8f1eb1c002c24cf774717e", size = 24083, upload-time = "2026-10-02T23:06:25.037Z" }, + { url = "https://files.pythonhosted.org/packages/19/3c/11eecdc06bc44ad5570350085b572ebf049e8f9a38d1ece6d76640b739cd/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:55ffd6ce583d97dc71dc92e930324c8c0d25aea7e3ade6ae54ef77cedb096811", size = 22931, upload-time = "2026-10-02T23:06:26.328Z" }, + { url = "https://files.pythonhosted.org/packages/0d/9e/ac0fd77f2a726e56ecc3ca0235d095feace1358d1b822406c2a2ef26a4dc/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:2cb3dd71fc6be918ad4264346a8ed69485f9b7ed7bf35495d8e22807cd6b8bea", size = 24299, upload-time = "2026-10-02T23:06:27.742Z" }, + { url = "https://files.pythonhosted.org/packages/d7/09/c6bd842ad58ff5b3bc76eeed7e9a42a6f11adc5d090ec697b72c9672731e/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:94f5407f7bc64fa6463906b896f9904beeeb7dd8dc116ee8e9056c8714ff9916", size = 21948, upload-time = "2026-10-02T23:06:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/a3/46/82f586711fed61e86faa1ee1bc317d68cd45a10c8bdbe3f7d1fdf9026ad8/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2dad610540cb2e6272855c178f08ae9a1c7ac258a7fb71660553a5f104b42741", size = 23150, upload-time = "2026-10-02T23:06:30.583Z" }, + { url = "https://files.pythonhosted.org/packages/19/2d/2dfdce99318abbfa26925195fbc17db188c46a1ec6457be121b6f9cfeb42/markupsafe-3.0.4-cp315-cp315-win32.whl", hash = "sha256:03470d1a8268e692ecf79ecd565593e59d44219377a7ead61f1f1b94c1f7ff6b", size = 14269, upload-time = "2026-10-02T23:06:31.949Z" }, + { url = "https://files.pythonhosted.org/packages/5b/ec/6000fd82e8791e58fcd0456ec20f098957e2b03d5ed02eb73241a577c0ba/markupsafe-3.0.4-cp315-cp315-win_amd64.whl", hash = "sha256:d882a373d8093c2941e01291b7ced96e9cbe4781da9a7751ca7e6c70385e5214", size = 14496, upload-time = "2026-10-02T23:06:33.258Z" }, + { url = "https://files.pythonhosted.org/packages/bc/66/e73bd5016421d5d6e2fb6de7dd609f9de020942ac8c626526bd8c6eeaf82/markupsafe-3.0.4-cp315-cp315-win_arm64.whl", hash = "sha256:353bd63081912ab8cfa6a0c7d185934cdf8426f04c618bba6bc4b394f2069b67", size = 14361, upload-time = "2026-10-02T23:06:34.539Z" }, + { url = "https://files.pythonhosted.org/packages/90/df/cb8c3dc98d313a951df2f8968f44e4cb5643df6d3cab749a530ce2f7d972/markupsafe-3.0.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c61750fadcd119d0825bcb7d7d675dd264dcc89cc05292aab5be68ebdbb374ad", size = 11760, upload-time = "2026-10-02T23:06:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/d6/bb/4af9b3ca0753d654ac75f9531d5bd741bb77ca6e696f36807c475ffc099a/markupsafe-3.0.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:1c0df495a977d10460a94941799c72d5b5ab03d3858d949b55b5a66c8f371c99", size = 12108, upload-time = "2026-10-02T23:06:37.089Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d4/b56429313aee5fd59b079c3df5615299959e25e7113eb6d8caadbdd7d38a/markupsafe-3.0.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02fa4acbc6a3fc5c693c34d4dd8c1130b7fe99cc915181b0ddd6f72aeb296002", size = 25762, upload-time = "2026-10-02T23:06:38.419Z" }, + { url = "https://files.pythonhosted.org/packages/65/f5/34c181e891aa4f7d59c918584672e0c5eb7fffe76c1387d1246008bf4081/markupsafe-3.0.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:05295589e619b9bed252a86b532b8e27350abc372d18ba89b59375325e91ec1e", size = 28400, upload-time = "2026-10-02T23:06:39.819Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b5/ad14694fd0ac9a5ce30bc6498f2999378f418583dd1679cca5a1b512957e/markupsafe-3.0.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:be6cb0c799abb0e2ba3e618e6d28ddddf7e485f6c2ce938dfa237daf3905072c", size = 25946, upload-time = "2026-10-02T23:06:41.381Z" }, + { url = "https://files.pythonhosted.org/packages/d6/a8/26b606445387d0ceb1eb1f21840094b84e4e3c3c3983d80d10b89823b490/markupsafe-3.0.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26e9867520db70d37f7fb421a7f0d8adb40171011fb84ce869afa1a83370dfa8", size = 23634, upload-time = "2026-10-02T23:06:42.748Z" }, + { url = "https://files.pythonhosted.org/packages/39/a2/b8814de672f1f0094d498bf646f2fec9d6356b503d28ef500b71c5095377/markupsafe-3.0.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f03460ff076f70ab595bb45a0205ccea1971443575b6920c52e755dec2b3fbfe", size = 23488, upload-time = "2026-10-02T23:06:44.176Z" }, + { url = "https://files.pythonhosted.org/packages/db/c7/287223376fb73335a3cc5d6eb22c6ab01358cf33945a9c39c06b9dac3f4b/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:436e3ffc6310d3c41878c601db29098102fe5d8a467c49da4a4125254e0980f2", size = 25037, upload-time = "2026-10-02T23:06:45.646Z" }, + { url = "https://files.pythonhosted.org/packages/f9/29/4df8355e313426d19e62ba33e0253c009ca12a0894ee77d67fa67255361c/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:4e2c4809c14559aa7ef426f27fb35afbb38104c349a903bf8f3600456764bb38", size = 23543, upload-time = "2026-10-02T23:06:47.264Z" }, + { url = "https://files.pythonhosted.org/packages/71/e5/8377731e8495668dcc768f645e717df18318c841edaf023a99395f6da9b4/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:da2af0d7aebfc2074080d72efa6ab8317c62481ef1f896f65d9999c1c01f4494", size = 25282, upload-time = "2026-10-02T23:06:48.795Z" }, + { url = "https://files.pythonhosted.org/packages/ed/5f/373456e37ceb1478d657d6fe769cbe0a39f0a8dfc1548eeb19c471eefdd9/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:aa2c838cc024642cc04c6854232f32b43e5e22833dd11119c1766c7873b8370d", size = 22993, upload-time = "2026-10-02T23:06:50.31Z" }, + { url = "https://files.pythonhosted.org/packages/d7/93/2cbd5628435afb6f541bbaced4bce0c2edac4b09a142e6e928b8b0da9858/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b91cc9d336957239ff200f30097e6fea2dc6d6fb3c81e853eaa09eac904fd894", size = 23712, upload-time = "2026-10-02T23:06:51.759Z" }, + { url = "https://files.pythonhosted.org/packages/81/99/157e10966b033b363aeda5263e82596ee232a0b1d082fdbf90aa417ff083/markupsafe-3.0.4-cp315-cp315t-win32.whl", hash = "sha256:e49fb0d1ce92cfa0cb198cc5b1b11cdf9d0638658e2a2db2687e39db7c87fc78", size = 14300, upload-time = "2026-10-02T23:06:53.241Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/55884815414c9706a23deca150b72c25a62109e65b0b6ce232077802c719/markupsafe-3.0.4-cp315-cp315t-win_amd64.whl", hash = "sha256:4f6e0852a0283b1b1fd776eeb7b766a5f440b3e2bd31ab51af3b400585f3965c", size = 14522, upload-time = "2026-10-02T23:06:54.729Z" }, + { url = "https://files.pythonhosted.org/packages/92/f9/ecbde7149e95b8a0f18e16d5d747f7dc06049d5da2e4f77f6f5e4a1f46a8/markupsafe-3.0.4-cp315-cp315t-win_arm64.whl", hash = "sha256:39dbacefc411633db5b4378b066a9aca70a3d7e2922c9e578d825f844026eeba", size = 14417, upload-time = "2026-10-02T23:06:56.246Z" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.12.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e6/99/d27cfc9518f49e4cbc25c683ec7cf8704a9d31311341c291c0e78ddf791b/nodeenv-1.12.0.tar.gz", hash = "sha256:4ea7f88339310afebc3253f2c7a91b94bacf97d73a36a5c108962abdfaca501e", size = 131292, upload-time = "2026-10-31T19:03:18.847Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/6a/8a9ac7d5e2f7cf53c459bfef90ebc17a2f8cd54b665af96799d4c534840e/nodeenv-1.12.0-py3-none-any.whl", hash = "sha256:80644d65c10cc2be12e3e4b54b3367ff288c7ad24ae75c2dcc65454fc7449d4d", size = 39442, upload-time = "2026-10-31T19:03:17.427Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.12'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d0/ad/fed0499ce6a338d2a03ebae59cd15093910c8875328855781952abf6c2fe/numpy-2.4.6.tar.gz", hash = "sha256:f3a3570c4a2a16746ac2c31a7c7c7b0c186b95ce902e33db6f28094ed7387dda", size = 20735807, upload-time = "2026-05-18T23:37:14.07Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b3/49/ec46835a70be8fa6446c495126ac84fdb28cb2558e1620ffb87a10c8b64c/numpy-2.4.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0280e0356c0829a18d9de1cb7eee50ec22ca639878d7240307ca0943d73cd2c4", size = 16969194, upload-time = "2026-05-18T23:33:13.503Z" }, + { url = "https://files.pythonhosted.org/packages/0e/0d/f5957185c0ee2f3e12f78715aa9e3b353fd83633316c8532b38faa37e3f6/numpy-2.4.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:110f8b71aacb688ec69062bb7f6938a0f8acb01b7c1c4beb453c65b6d234584d", size = 14964111, upload-time = "2026-05-18T23:33:17.795Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/40a40ee0ddf7ceb782c49af278894b686e586d65d8c1889c8b5da01a3d7d/numpy-2.4.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:4cfe66903cc32a9921a6733d96b19bb6abf310397581bbad89c228f5abaf0ee8", size = 5469159, upload-time = "2026-05-18T23:33:20.654Z" }, + { url = "https://files.pythonhosted.org/packages/63/13/f9a8046535cb21deae82f8d03de9617e08882d274fad2539630761888228/numpy-2.4.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8155154c7c691289fe18f510b5d4657c68c67989f293f0535a91360392ff6538", size = 6798936, upload-time = "2026-05-18T23:33:22.987Z" }, + { url = "https://files.pythonhosted.org/packages/33/a8/6fa8c1a345a8c85dbb21932c447bee07c30a2c2a3f31e369c0a84b300147/numpy-2.4.6-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ab0a9c4ffb1a6d95ef519fe4247dba8eb6b18ad93999f76b7f657039acabd47", size = 15966692, upload-time = "2026-05-18T23:33:26.62Z" }, + { url = "https://files.pythonhosted.org/packages/02/03/74fe2a4cb3817d94d86402f2506554130a2f01414e299b5a843e5a8a957f/numpy-2.4.6-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:89cd468399cfd2504718f0ba50e410dca55a170b61a02ad92bb18c8a65186e93", size = 16918164, upload-time = "2026-05-18T23:33:29.955Z" }, + { url = "https://files.pythonhosted.org/packages/c5/80/3615be3313f7e7696609bc194b9f0101da809df79e859bdb84e0cd043f46/numpy-2.4.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c2d37ab77531417474168eb79d6d80b14f821a966818505d03013d0833edb7a8", size = 17322877, upload-time = "2026-05-18T23:33:34.724Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ac/a691e0fe2675e370d0e08ff905adc49a1c8830e8cae03efe4477e92cd55d/numpy-2.4.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f407cb6b8e9d6d8c626bc73c945db1706035af8fd632295547bf1c9e46d092d6", size = 18651487, upload-time = "2026-05-18T23:33:38.217Z" }, + { url = "https://files.pythonhosted.org/packages/15/a7/9bc1cd626d7bf6869bfedf27b91b6ab5dd607758bf8e959d6fa80c6a59cb/numpy-2.4.6-cp311-cp311-win32.whl", hash = "sha256:ddea102b48f9e339f3948bf22040944184627a30fdf7f858667673b9c5f033c8", size = 6233945, upload-time = "2026-05-18T23:33:41.331Z" }, + { url = "https://files.pythonhosted.org/packages/c5/31/7fc6239c12bce7e931463251cca4426c465e1876ba3cc785402ef4dd8f4e/numpy-2.4.6-cp311-cp311-win_amd64.whl", hash = "sha256:1e254a00cdf42b1e4d5b3d68d33af63268d41340d8885df2ab6470f2e1500147", size = 12608406, upload-time = "2026-05-18T23:33:44.131Z" }, + { url = "https://files.pythonhosted.org/packages/27/83/140f85a466595a16382996a1bf06b2b54bcd597488921b0c9daaeeda72af/numpy-2.4.6-cp311-cp311-win_arm64.whl", hash = "sha256:ed9749eef4cbd126da3dc1d6bcb3a57f5eb7ac6a6484146bdbf743f552dfc577", size = 10479528, upload-time = "2026-05-18T23:33:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/95/2a/3d7b5ac8aac24feaf9ad7ed58f45b0bbc06d37e4338ae84c9f2298b570f9/numpy-2.4.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:001fbb8e08d942dd57599e781f2472269ee7f2755fae407b4f67b2f0b17da3f1", size = 16689119, upload-time = "2026-05-18T23:33:54.065Z" }, + { url = "https://files.pythonhosted.org/packages/ea/12/92c4c131527599e8288d6918e888d88726f84d805d784b771f32408aeaef/numpy-2.4.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ebfb099f8dcf083deef3ac1ca4c1503f387cf76296fcb3816b66f5ecb5f54fdb", size = 14699246, upload-time = "2026-05-18T23:33:57.621Z" }, + { url = "https://files.pythonhosted.org/packages/ad/fe/c0a6b7b2ca128a8fb228575147073b660656734b8ebe4d76c8fd748dcc79/numpy-2.4.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:3213d622a0283a39a93d188f3cf72b26862df52fbb4ca3697f51705016523d41", size = 5204410, upload-time = "2026-05-18T23:34:00.302Z" }, + { url = "https://files.pythonhosted.org/packages/f3/d4/9770d14ba719432bb90a421bfd443872ed0f70f7264b64bec12ea363d5fd/numpy-2.4.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:357cc07a6d7b0b182ff02249616a03742827ebb1277546b5c7cd7f7620a45698", size = 6551240, upload-time = "2026-05-18T23:34:02.852Z" }, + { url = "https://files.pythonhosted.org/packages/c9/c6/50a46a6205feba2343f1d6d17438107c5dc491ed1c736e6ea68689fd906b/numpy-2.4.6-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f9fb9157b4ce2971008323afe46053787b526ef624fea915b261468a8421a0f", size = 15671012, upload-time = "2026-05-18T23:34:05.485Z" }, + { url = "https://files.pythonhosted.org/packages/99/60/14115e6364fa676c5397c2ad3004e527e9aa487abf5d0706ec81bbd08529/numpy-2.4.6-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f9849678c75fe7afa2d348ac842c168b0a4d3d61919687216dfc547976d853", size = 16645538, upload-time = "2026-05-18T23:34:09.265Z" }, + { url = "https://files.pythonhosted.org/packages/ae/c5/693cbe59e57db94d2231fa519ca3978dc9e19da5a8f088588f5c6e947ff2/numpy-2.4.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c1a2af6c6ef86344a6b0db6b97834208bf598db514f2b155042439b62605601a", size = 17020706, upload-time = "2026-05-18T23:34:13.053Z" }, + { url = "https://files.pythonhosted.org/packages/ef/fc/85b7c4eff9b4966ade25c2273cf7e7012e92366c032058653934b37de044/numpy-2.4.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e5805d5a22fd19c8ccff10a9561f9df94436b0545619ea579db2d3c35294bce2", size = 18368541, upload-time = "2026-05-18T23:34:17.024Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/e1b27545deedce7f4a0b348618c6b62d74e36a4dc9ccd42f3eb2f85eee32/numpy-2.4.6-cp312-cp312-win32.whl", hash = "sha256:e3eeb0aabd6bd5ce64faae67e9935203a6991b4bc2a485a767fbafb2c5125f45", size = 5962825, upload-time = "2026-05-18T23:34:20.3Z" }, + { url = "https://files.pythonhosted.org/packages/ab/ca/feab00bd44aa5fe1ad2c18f08b4d3bb92e26484b0b1d1443897809ed528c/numpy-2.4.6-cp312-cp312-win_amd64.whl", hash = "sha256:d8e8286dd7cea7895157318d1b91cdacac64c479f3cbc8dce548331728484751", size = 12321687, upload-time = "2026-05-18T23:34:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/63/cf/5a6d34850a39d1093558564f77ee8e8e0bee5061151b8f05a55711001ec7/numpy-2.4.6-cp312-cp312-win_arm64.whl", hash = "sha256:4081eb135ac24158bd51cdfbef16f1c64df7063b1143f24731387137c092bec8", size = 10221482, upload-time = "2026-05-18T23:34:25.876Z" }, + { url = "https://files.pythonhosted.org/packages/fb/82/bdab26d7438c6791ca31b7c024ca37c1eab8b726ba236129005cd4a06e45/numpy-2.4.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:511dbaf848decaaaf4b4ca48032619fb3138710c4bf7da7617765edad1ef96b0", size = 16684648, upload-time = "2026-05-18T23:34:29.41Z" }, + { url = "https://files.pythonhosted.org/packages/1b/30/a80189bcc7f5e4258b3fbc3968d909d1756f54d023299ecc39ad6fdb9ef8/numpy-2.4.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:bf162abab1c1a736333192707cef898e735a5ca00f38f27eeedf44b39d9e85eb", size = 14693902, upload-time = "2026-05-18T23:34:33.013Z" }, + { url = "https://files.pythonhosted.org/packages/97/12/70b5d0d7c15e1ebb8a6a84a8caa1d19e181d84fb58bb6d70aca29099dec1/numpy-2.4.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:043191bfa8eab18c776647b62723ac9dddece59743b13f49b2016094129c2b3f", size = 5198992, upload-time = "2026-05-18T23:34:36.132Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/ebd2a8f8a83541f8d38cc5667e8c2b69cecfd30da6e45693e8158857d44b/numpy-2.4.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:6180d8b35af935aed8ece3a85e0a43f87393ae0ac87c8d2c8bd2c993f7270ef3", size = 6546944, upload-time = "2026-05-18T23:34:38.484Z" }, + { url = "https://files.pythonhosted.org/packages/bb/c5/7b863a97a91671a0338f4253bd3b5a3d3852f0692dae91711c9f4a10e787/numpy-2.4.6-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72fbe16c6fac95aedf5937fa873445cec2110be35d8a4e9433d7501fd98dae6b", size = 15669392, upload-time = "2026-05-18T23:34:41.257Z" }, + { url = "https://files.pythonhosted.org/packages/a5/9d/3584b9984ca4c047aea75214ce1a4c4c73d849bd71b604264b7f5653f8a8/numpy-2.4.6-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a7830bab239b79cda9c08c2da014761cafb48da6150e1da17ac06283f43b6089", size = 16633220, upload-time = "2026-05-18T23:34:45.075Z" }, + { url = "https://files.pythonhosted.org/packages/05/ae/7c67fba23bd98caec7c99261f3a16072ade14813486b0282cb29846de832/numpy-2.4.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ef4aea96ce4d3b074422cb4f2f64e216bf9e213004bb58ecfdf50ea02ea8eb9a", size = 17020800, upload-time = "2026-05-18T23:34:49.065Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5d/3b6725cb31d983c5e66916f5d36f6d7e5521129e4c4404d64f918292a5b6/numpy-2.4.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:dfa20cc6ca228e6b155b11da03825975ce66aea520985dbbddf0f2a5a495c605", size = 18357600, upload-time = "2026-05-18T23:34:52.709Z" }, + { url = "https://files.pythonhosted.org/packages/f7/da/2ccc6c2fe8898dee01d90c75c5f5f914a23daf99e3e0f59516a08760c8b5/numpy-2.4.6-cp313-cp313-win32.whl", hash = "sha256:56b39e5e0622a09a25bf5baf62f4bcf0cb8a41ae6e2819cf49bbc5a74c083f91", size = 5961134, upload-time = "2026-05-18T23:34:55.618Z" }, + { url = "https://files.pythonhosted.org/packages/b5/cd/9cc4dc876fb065d5c220aae4d5e14826b2715331bb7618ce1fb07a679d99/numpy-2.4.6-cp313-cp313-win_amd64.whl", hash = "sha256:c4fc99836233ea196540b17ab0983aff60ed07941751930f5f4d05bc3b3b7359", size = 12318598, upload-time = "2026-05-18T23:34:58.928Z" }, + { url = "https://files.pythonhosted.org/packages/39/1e/c0bcba1f8694116485fe28fd1be698c278fcda4141c5b0e53a2aed8b12a8/numpy-2.4.6-cp313-cp313-win_arm64.whl", hash = "sha256:a7c711e21628b52034bb5ab8d1bce291f752fcc5e92accc615778acee1ff4778", size = 10222272, upload-time = "2026-05-18T23:35:02.167Z" }, + { url = "https://files.pythonhosted.org/packages/63/6d/cc5619247c8f4204e507f5883528372e4ac4bb189e579fb859a12e480b1f/numpy-2.4.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:112b06a867b235ef466ed3508ddf0238050df9c727cafb5301ac385b899189a1", size = 14821197, upload-time = "2026-05-18T23:35:05.468Z" }, + { url = "https://files.pythonhosted.org/packages/00/58/f1c39161c87d9e9bed660f1ed4bafc0e403d5ec9650b6dd77aead07d489b/numpy-2.4.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:eaf7fa2de5c0be8ae6ff8e9bea2ccd725e980541244521d8d4b5f3354a27babe", size = 5326287, upload-time = "2026-05-18T23:35:08.693Z" }, + { url = "https://files.pythonhosted.org/packages/af/57/3917ab0fd97f271a8694513581b8a36c655f111c446852c302f04ccdb6fc/numpy-2.4.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7265a2f3d436e54ef9f2b52b5c937e6be778781bd97a590319d7348f1c1ca997", size = 6646763, upload-time = "2026-05-18T23:35:11.459Z" }, + { url = "https://files.pythonhosted.org/packages/eb/0f/037e64c494b67581ae18193d770adef354c41f3f2c8ebf865602d949bf8f/numpy-2.4.6-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f74a575920ab21fe304421a3fc28793d82e299cae9eccb37084e9fc7f3617c20", size = 15728070, upload-time = "2026-05-18T23:35:14.79Z" }, + { url = "https://files.pythonhosted.org/packages/21/a6/5d2bae9c9542eb4df16dc9c46dc79c186e9bad53805dfa5399a6023c6db0/numpy-2.4.6-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ede83e07a75dd06bc501566c1eca2afc0d61677c1472ac9ad93fdee6e638a48d", size = 16681752, upload-time = "2026-05-18T23:35:18.836Z" }, + { url = "https://files.pythonhosted.org/packages/92/14/23d1dfb410ae362cd59ce53e936b1513d545eb40db3949ced632e19a459e/numpy-2.4.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:68bb27509ac1b9a3443094260f6326150663b06abe40b73a2f81160623da5b67", size = 17086024, upload-time = "2026-05-18T23:35:22.52Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/23595a2c642cdf3bc567877064bdd7f91c8b0038a4453cf2daf7248eafe9/numpy-2.4.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a0df0043bdb289bde1f62da130d20df23d58b45429f752bc7a8fc5325a225ecd", size = 18403398, upload-time = "2026-05-18T23:35:26.398Z" }, + { url = "https://files.pythonhosted.org/packages/8a/90/0ac3bc947217e66dec77e7cbc6a1979d1af70b6461b82f620d3bccd5e4c8/numpy-2.4.6-cp313-cp313t-win32.whl", hash = "sha256:29a287e0cf63ff528da061de6b9f64a4618da591ca1046aafc54062e40ca7eab", size = 6084971, upload-time = "2026-05-18T23:35:29.387Z" }, + { url = "https://files.pythonhosted.org/packages/77/71/5673e351671a1d2bd6063b91b44f70c0affea7d1516fa7a6572941ba4aa1/numpy-2.4.6-cp313-cp313t-win_amd64.whl", hash = "sha256:25c692919ac5a01f170a3bfcd62d745b24fd095c353d50812637d6fcab442e75", size = 12458532, upload-time = "2026-05-18T23:35:32.175Z" }, + { url = "https://files.pythonhosted.org/packages/3f/88/19d3503c5046e688f049274b27a3ef3d771152fa80d3ba3d01a3dff61abe/numpy-2.4.6-cp313-cp313t-win_arm64.whl", hash = "sha256:1e978ec1e8bd0e0e4de6bb75de9d30cbb74db6b6a2bb727618613703ca0167dd", size = 10291881, upload-time = "2026-05-18T23:35:35.465Z" }, + { url = "https://files.pythonhosted.org/packages/f8/91/3ab2044d05fd16d343c5ac2e69b127f1b2854040dd20b193257c78028bd3/numpy-2.4.6-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:06ca2f61ec4385a07a6977c55ba998a4466c123642b4a32694d3128fce18c079", size = 16683458, upload-time = "2026-05-18T23:35:38.353Z" }, + { url = "https://files.pythonhosted.org/packages/8e/62/764ce66fa4147ae6d73071a3abf804ffe606f174618697c571acdf26a7c9/numpy-2.4.6-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:38efbc8de75c7a0fc1ac190162d892787f3f47b57cc291231aafee36b80982b7", size = 14704559, upload-time = "2026-05-18T23:35:42.14Z" }, + { url = "https://files.pythonhosted.org/packages/60/61/23f27c172f022e04025b7dc2367f4d63c1a398120607ec896228649a6f48/numpy-2.4.6-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:d581b735e177fdcdce6fed8e7e8880a3fb6ee4e3653a3ac6af01c6f4c03effc5", size = 5209716, upload-time = "2026-05-18T23:35:45.377Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/21cf70dc6ea3e3acb95fc53a265b2fc248b981f0194ceb5b475271b8809d/numpy-2.4.6-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:0a041d3d761dc3c35cc56ce0351506a02bcbc25f7b169f652435141a17db9096", size = 6543947, upload-time = "2026-05-18T23:35:47.926Z" }, + { url = "https://files.pythonhosted.org/packages/d5/91/64288395ee1799bd2e0b04a305dce9666da90c961e1f3fe982a05ee1c036/numpy-2.4.6-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:40fdc1ae7125e518ea98e53e69a4ebc27e1fd50510c47b7ea130cf21e5e1d42b", size = 15685197, upload-time = "2026-05-18T23:35:50.863Z" }, + { url = "https://files.pythonhosted.org/packages/f3/eb/ebffaa97dc55502df69584a8f0dcf07f69a3e0b3e2323670a2722db9aa39/numpy-2.4.6-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a2c306dea656c12c68f51f4cea133cbe78ca7435eb28c735eac1d3ebe73be6e8", size = 16638245, upload-time = "2026-05-18T23:35:54.752Z" }, + { url = "https://files.pythonhosted.org/packages/b8/0b/54f9da33128d7e350fab89c7455902eeae70349ee52bddb448dc4a576f45/numpy-2.4.6-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:33111801a01c12a8a1e3721f0a9232f8cfc8ae2c6b7098167e6f623c6073f402", size = 17036587, upload-time = "2026-05-18T23:35:58.355Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f0/fdebc1052db1cc37c64beb22072d67cd6d1c71adca1299f53dec2b5e20d3/numpy-2.4.6-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ae506e6902902557576a26ff33eda8695e7ecb3cb36c3b573a0765dee114ebdb", size = 18363226, upload-time = "2026-05-18T23:36:02.845Z" }, + { url = "https://files.pythonhosted.org/packages/aa/b4/298628d98c72b57e57f7165ae6a481a1deaf6f3c28262a6e4c739c275930/numpy-2.4.6-cp314-cp314-win32.whl", hash = "sha256:aaf159caa35993cb1f56fb9b8e4610d35758e7ca005412eb1daa856a78c9c4b1", size = 6010196, upload-time = "2026-05-18T23:36:05.92Z" }, + { url = "https://files.pythonhosted.org/packages/df/ac/46de6dda46478f7942f839e094970be2d4a861e005c4b3bf07c92e291a09/numpy-2.4.6-cp314-cp314-win_amd64.whl", hash = "sha256:b507f5c4c1d508876d1819b6bf9a49d365b96320b5d4993426b33a23ca4b8261", size = 12450334, upload-time = "2026-05-18T23:36:09.107Z" }, + { url = "https://files.pythonhosted.org/packages/78/92/b8b798ac784102c0da830d2257d59358e3d3d90d1e2b3f2575dad976c5cf/numpy-2.4.6-cp314-cp314-win_arm64.whl", hash = "sha256:6f41ae150c4e32db4f3310cdaf64b1593a03dbabe29eec77fc9b50fe64061df6", size = 10495678, upload-time = "2026-05-18T23:36:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/30/34/ec28d1aa8115971537c01469ab2011ee96827930f0a124de1000cc2a7ed7/numpy-2.4.6-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ece3d2cfe132e7d51f44a832b303895e6f2d499c5e74dfbdb06ee246147a304a", size = 14823672, upload-time = "2026-05-18T23:36:16.473Z" }, + { url = "https://files.pythonhosted.org/packages/16/bd/f6d1fede4e54e8042a7ff97bb495510f3c220f94bcd9e8b228e87c92cc0d/numpy-2.4.6-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e3e5193ef5a3dc73bceee50f7fdc2c90dbb76c42df8d8fae3d1067a583df579e", size = 5328731, upload-time = "2026-05-18T23:36:19.767Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f0/e105b9e2fd728a9910103884decd6951d9dd73896b914a98d9a231de02ee/numpy-2.4.6-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:17f9ade344e7d9b464a084d69bcf18fc691cb1db67c62ed80820bf4926d78f0e", size = 6649805, upload-time = "2026-05-18T23:36:22.266Z" }, + { url = "https://files.pythonhosted.org/packages/82/dd/1206a7ca6ab15e3f02069707ca96222e202af681bb73756da7527f3cb837/numpy-2.4.6-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9cd5ffd25db4e7ba6a375693b3fc0fc1791ec636c17db3720da19bde7180ec43", size = 15730496, upload-time = "2026-05-18T23:36:25.713Z" }, + { url = "https://files.pythonhosted.org/packages/51/e7/38d3ea825dcab85a591734decb2f6c67caa7c8367d374df1a1c3842f9b07/numpy-2.4.6-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7d92c3819208a60205a12a245c91ad70cb0a85336659b19b834205573ac8456e", size = 16679616, upload-time = "2026-05-18T23:36:29.652Z" }, + { url = "https://files.pythonhosted.org/packages/93/b7/caabfdf53edf663e0b4eb74d7d405d83baef09eb5e83bcd32d601d72b93e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e85b752a1e912b70eaad4fafbd4d1238007ab221de2009b9a2f5ae7461239895", size = 17085145, upload-time = "2026-05-18T23:36:33.449Z" }, + { url = "https://files.pythonhosted.org/packages/f9/45/68d7c33a6bcf3e5aa3bdbd57a367e6f615286dfd6482f97e8ffeb734306e/numpy-2.4.6-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:29cb7f67d10b479ff07c17d33e39f78c07f71c40ef30d63c153d340e96cd3fb4", size = 18403813, upload-time = "2026-05-18T23:36:37.369Z" }, + { url = "https://files.pythonhosted.org/packages/9c/50/0753655aa844c99cd9e018aacf76f130f1bd81d881bb74bc0aef5d73a8ba/numpy-2.4.6-cp314-cp314t-win32.whl", hash = "sha256:260a5d70215b61ab4fadf5c7baacd64821842975eea312125ed3c39a6391b063", size = 6156982, upload-time = "2026-05-18T23:36:40.817Z" }, + { url = "https://files.pythonhosted.org/packages/b2/d4/7c67becf668f973cb490cec3e98dfd799d866f9c989a54d355672cfa0db6/numpy-2.4.6-cp314-cp314t-win_amd64.whl", hash = "sha256:81a1cca95ed5bb92aa8b10dd2cdc9a0d3853a50fad926c28b5d7e8ea54389627", size = 12638908, upload-time = "2026-05-18T23:36:43.996Z" }, + { url = "https://files.pythonhosted.org/packages/43/bb/e1c71a4295b1b1d1393d50dbb4f2a36283c6859d9d3892e84f00ec5a91d5/numpy-2.4.6-cp314-cp314t-win_arm64.whl", hash = "sha256:0c9136e14ed34a9e343a31c533d78a9813a69a3148332bce5e9821cb2f996e66", size = 10565867, upload-time = "2026-05-18T23:36:47.114Z" }, + { url = "https://files.pythonhosted.org/packages/de/12/b422cc84439adc0d00de605bf4a308890ae5c26f2c71fbd73e5d08fbb0dd/numpy-2.4.6-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:55cced7c52e981362f708ad635198e97a752dfba412cc03c23bbf3bd8d5cd662", size = 16847511, upload-time = "2026-05-18T23:36:50.673Z" }, + { url = "https://files.pythonhosted.org/packages/44/53/f481bef68011740f8849418d82db07230e825013f31f4eef5ba5b805316a/numpy-2.4.6-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:d6da64deb6b8ed903e7560180a92f2d804ee1ba5eeb849ac2748b8c1aba1f6d7", size = 14889064, upload-time = "2026-05-18T23:36:53.879Z" }, + { url = "https://files.pythonhosted.org/packages/7f/57/42ed575c10ced8af951d426bc4e1f8aff16fd851db33f067036215a7f860/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:68a5124b13fa6cc2086764a20005d30bc0548146f7f5322f02fce212ca14317f", size = 5394157, upload-time = "2026-05-18T23:36:57.194Z" }, + { url = "https://files.pythonhosted.org/packages/6a/ef/f66cc724fcc36c1e364c67f51ae9146090b8b584f27d58b97fdae3edd737/numpy-2.4.6-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:948424b06129ce883307e8cff868c31396d8dc7630a59c61d70d98dbe70f222c", size = 6708728, upload-time = "2026-05-18T23:36:59.575Z" }, + { url = "https://files.pythonhosted.org/packages/1a/9c/c531f2293b91265d8b48e9b329f54fdd7ffae73cb4134ea10cca4237e9cc/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5dbbdb29840ca3d91ee0fece42fc29278886d908280bfec0a5846c6f901a3eb0", size = 15798374, upload-time = "2026-05-18T23:37:02.674Z" }, + { url = "https://files.pythonhosted.org/packages/1a/b0/413077f6b1153ed3cba361401c6783bbad6114804a000cc22eb71c13e190/numpy-2.4.6-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8ad03c0965fb3c692200e74d458ca28c1dbb4ce96f9a479a8aa041ad5fabca02", size = 16747286, upload-time = "2026-05-18T23:37:06.327Z" }, + { url = "https://files.pythonhosted.org/packages/15/ce/e5ec180bc41812edcd8daeb8639d205622c0e8c02259d8ab25a0201b3c2a/numpy-2.4.6-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:2803abfebfc990042cd494d8ce2d5f82e9d847af6d35ec486923aa19dbad5e73", size = 12504263, upload-time = "2026-05-18T23:37:09.715Z" }, +] + +[[package]] +name = "numpy" +version = "2.5.5" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", +] +sdist = { url = "https://files.pythonhosted.org/packages/4e/3a/8770c288c47f0b5c2a786d3c20e79f66fd245f2d42cd232d7cd5e00e83e5/numpy-2.5.5.tar.gz", hash = "sha256:5cddc243c75114ba845f01b1f87aca1572dbf7b6c2d88636ed3e1d2bccd7f1bf", size = 20873892, upload-time = "2026-11-15T21:32:28.607Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/74/5b99f425938870958d43dc9f7b17c684e793ce47ec46b7885cdc7acea285/numpy-2.5.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7da9a248f149cfbb220c6da964a59c8d051d516704f7758acfb81eb382a05d97", size = 14750374, upload-time = "2026-11-15T21:30:10.113Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f4/06db317e93dd6d618786004c1761214b113832bb77294c8513776956702a/numpy-2.5.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b96e9ee49ccbdb5676359f852a4497f7a9c5df6c377d8877f5330d6fd3ff42e4", size = 10749920, upload-time = "2026-11-15T21:30:13.092Z" }, + { url = "https://files.pythonhosted.org/packages/8a/92/6de34324a266b73c04ba977db5864b9016500076b26f09078a565f527d34/numpy-2.5.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a3856a97e48ed8371c680fb04120b99fbcc29f2076ebe6dc3deb34f77947c5ca", size = 5513680, upload-time = "2026-11-15T21:30:15.201Z" }, + { url = "https://files.pythonhosted.org/packages/1e/a1/6563b74cd67e3873f9897afebb3244529b1494d4c0df30f3201329a7e316/numpy-2.5.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f5e8603f0892d1b848e12124863b5b29af72383ee9b25ddc6fe4967d4c1ee6ef", size = 6797540, upload-time = "2026-11-15T21:30:17.172Z" }, + { url = "https://files.pythonhosted.org/packages/c2/22/82184e9a5b50a4a298e9f8fe0bd8cfc483672dbfea8a3b57c78e2376b139/numpy-2.5.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0750f2156d53446caca85663d0b65d67214e1664b9050454a731ea1418d176a", size = 15284117, upload-time = "2026-11-15T21:30:19.167Z" }, + { url = "https://files.pythonhosted.org/packages/99/61/522b973ba38987b22a4a71beaed2ea6ac9fd4f687baaa2bc9a45100625e0/numpy-2.5.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:704d819265e5d1064d932968e9ee85fff2103ccc78c05b878c06943ba27b8507", size = 15720599, upload-time = "2026-11-15T21:30:21.273Z" }, + { url = "https://files.pythonhosted.org/packages/25/cd/182cf60bd9c34e617c516f138f2f68988760062fa65fca8fcc97875cf7cf/numpy-2.5.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86868185bf4b6c4e5a8628ac42cfa165cd9530266c731f7dd1d11b4ad7e7cd1c", size = 16503566, upload-time = "2026-11-15T21:30:24.023Z" }, + { url = "https://files.pythonhosted.org/packages/f3/57/4fa4723e80be805f68af552731ed483974b2a11e511284a9ef6aafbcb3cf/numpy-2.5.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7fb87c4bcc73850ef433a0c42f096b010d3d3d284e9d00028bb030b43df3d078", size = 17082560, upload-time = "2026-11-15T21:30:26.224Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0b/73d2bd5be85d3178a862e8354e2d6441b4040fadf1e7d999e01b0bdfa5c6/numpy-2.5.5-cp312-cp312-win32.whl", hash = "sha256:263b2aa236d752b18f90c5107137d24b2e3856d7db37725609f0ab5bcdb58881", size = 6146378, upload-time = "2026-11-15T21:30:28.328Z" }, + { url = "https://files.pythonhosted.org/packages/d1/71/b1ce51834c21020d189332979d38ba7350eb6cd7ca8c8ec424a663b0ca6f/numpy-2.5.5-cp312-cp312-win_amd64.whl", hash = "sha256:919eb420662b0b4ba34889df503f3d5329775b0c1d5f7e5f5af4fba8315b1e30", size = 12580189, upload-time = "2026-11-15T21:30:30.025Z" }, + { url = "https://files.pythonhosted.org/packages/c2/5e/09ae9d0d02fbfe6b160043349bbe73e6bbbbfb2565bb46146dd943687271/numpy-2.5.5-cp312-cp312-win_arm64.whl", hash = "sha256:f6622e32cb46c60bee3b2c7dd7f5c22bdc86fcb8630336b4822ec81c3986111a", size = 10535386, upload-time = "2026-11-15T21:30:32.112Z" }, + { url = "https://files.pythonhosted.org/packages/0f/fa/4ae71d860267f2f9eaf7640516f693acf61c9575d48157cdea459c0215aa/numpy-2.5.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:228e3d90e967495d61ddc79dd64e95267aae3bcf1b1c516a6186429106a0b444", size = 14747053, upload-time = "2026-11-15T21:30:34.251Z" }, + { url = "https://files.pythonhosted.org/packages/d4/9a/01a332ebb0899ddb14d782f86ed66d080463e5387a8778029462d1902019/numpy-2.5.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7e71ac4284c700afa654e2d15b1b174166710dca932f24045e5dc92001b5bda0", size = 10744599, upload-time = "2026-11-15T21:30:36.23Z" }, + { url = "https://files.pythonhosted.org/packages/03/bd/a1a721ab8da5632c811caf56b7735646a440eddbbf6e57817ae1a900c9c9/numpy-2.5.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf407a83118faf0463ade48a4533982f1737c7c58aac29e08855f7d9ad2977", size = 5508218, upload-time = "2026-11-15T21:30:38.357Z" }, + { url = "https://files.pythonhosted.org/packages/9c/63/eb5311935b313926d9127ec59632cc74bdf1fa815089fba4dbee9c6dd90c/numpy-2.5.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ac910558645a4b006f70596b450712b8564730c1b2ac10291fcedd656d321ec0", size = 6794377, upload-time = "2026-11-15T21:30:40.026Z" }, + { url = "https://files.pythonhosted.org/packages/57/06/de83b859944409bb9058bc6110581a3d7fc1f54d6df1222744911d7f6b19/numpy-2.5.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2b8285d0b4eed24739c3ca9ec0fa424a0247489c01e1d5fe2815a599e11d33", size = 15278148, upload-time = "2026-11-15T21:30:41.819Z" }, + { url = "https://files.pythonhosted.org/packages/40/d6/68dd5a83914bbcaf32b3165993f7955979916708cb0156d1e28231e18803/numpy-2.5.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:824025655df929268bfe6b47ed91a00d14209a6f760847cf150be446829e1ce4", size = 15713899, upload-time = "2026-11-15T21:30:44.066Z" }, + { url = "https://files.pythonhosted.org/packages/1f/6e/a78932a1a838ce0d7d759cee2aca225054da8aa4151688edb5867b4af491/numpy-2.5.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4302902ebf82d37f446664757be59db53587822c8b35f16368ca69fe66ec4315", size = 16501259, upload-time = "2026-11-15T21:30:46.469Z" }, + { url = "https://files.pythonhosted.org/packages/bc/08/f4da0ebfa6b684c18f1c300b279bd706f68f3828a2c9aaa1bca54c93a16f/numpy-2.5.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3cedc2980b45794a6a2cfee9c8c3a80f04517082cc1d387e4cc895506c481696", size = 17077101, upload-time = "2026-11-15T21:30:48.916Z" }, + { url = "https://files.pythonhosted.org/packages/1b/81/0ccf314229450ec76363f3f6ec13d0ef54a24c53188787fc13136d6e52e6/numpy-2.5.5-cp313-cp313-win32.whl", hash = "sha256:10396f7c5ebc37d8f3cbdec44e3313912ccc2dc5841cc905de5de54ebbe8e2d3", size = 6141929, upload-time = "2026-11-15T21:30:51.528Z" }, + { url = "https://files.pythonhosted.org/packages/45/74/bb9161943fb65caf24e4bb04c788f5c7815e6cb78ac595e7f46781033c82/numpy-2.5.5-cp313-cp313-win_amd64.whl", hash = "sha256:e0608d1585557b68dcb6a70a41654f7536567960afad79d91752d2863b242b68", size = 12573354, upload-time = "2026-11-15T21:30:53.308Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b0/792631d03588912e948c1249c03a78ca9af0c548670f8fd63ea014cbc14a/numpy-2.5.5-cp313-cp313-win_arm64.whl", hash = "sha256:e0b87886bb45621d9279dad4ab9f2d154b5db0b019d378c107b8f71527b06a4a", size = 10528296, upload-time = "2026-11-15T21:30:55.681Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9a/f1493d897f51947644c45516ba63a67e66a7b06692f930fe37c58346cfbd/numpy-2.5.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ab3ff087826c49d07953d0219eb00663ce5b1a0ef0a6b757e1ac041b09387428", size = 14754557, upload-time = "2026-11-15T21:30:58.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/46/5d1c70b54257a56b3137d6fcc90c6db306f6177c02951eac7ebb42e7e1c7/numpy-2.5.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7ca51125c76817de53473dae31ddc17213776472761bea9cca68a1a0037a4827", size = 10754769, upload-time = "2026-11-15T21:31:00.146Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e1/016c3d9c9c6e5a457d615cfbcf6bcd01a4cabde82c639776be23365186c1/numpy-2.5.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:229743571f901a082f031f511dc4f926b4b4a714075d98b1ff2af62d836365ac", size = 5518338, upload-time = "2026-11-15T21:31:02.38Z" }, + { url = "https://files.pythonhosted.org/packages/12/7f/f2369b42edb1a32a7f048c2126e6ab5b8bc527308ce9eb6e680ad9c3d2e7/numpy-2.5.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:1c24be6a82f5f257afc4dbefde4c3b56dee02146dfed2be2811940e79576b237", size = 6800110, upload-time = "2026-11-15T21:31:04.211Z" }, + { url = "https://files.pythonhosted.org/packages/26/5b/5cd4b88a64bb57ca6d3bd6a9e057db445544a2179a2ebf985660e0454648/numpy-2.5.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc6eb7502facce90349b4097a26821af224aaa0ab36e78304711cdb544352882", size = 15300777, upload-time = "2026-11-15T21:31:05.967Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1f/fcdce1061fba2bfb2e9bfda01fbd8132d5f7522a4f7c8e2b2f629d54ee38/numpy-2.5.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c48960d420e90cf305cb1fde0d4e6082cc90512cda87a9acf0b6e04e91cf4abe", size = 15718051, upload-time = "2026-11-15T21:31:08.12Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/9b7de1d0b747e3d1d24874b1cba374c8b0eab6c2034b785387677ecc4dba/numpy-2.5.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5e202d5facc9c0681834018062466d0b3eabd48c540c3570f72905c97f641a90", size = 16518123, upload-time = "2026-11-15T21:31:10.714Z" }, + { url = "https://files.pythonhosted.org/packages/66/14/60c3fc30e63876e44212392eacd4ea1bd201c29835c99f42daa04c2501e4/numpy-2.5.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e10e81d1db6c8fa507f61bebfd1ea383971dbc40c2005ed4db88fac5538b1ef6", size = 17079719, upload-time = "2026-11-15T21:31:13.245Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b9/c0d3a63804a58823155ae221ce48afa4530e0cab8a33fcfb76a7b46b11ef/numpy-2.5.5-cp314-cp314-win32.whl", hash = "sha256:ef2a874cc70e2132c1c499268bdc34e211a715e481bc33c97b8a0190f2559295", size = 6193548, upload-time = "2026-11-15T21:31:15.602Z" }, + { url = "https://files.pythonhosted.org/packages/74/e2/494516771374b43060c1b778b371cba53d576abd3aee1275eecd73896e3b/numpy-2.5.5-cp314-cp314-win_amd64.whl", hash = "sha256:20145b11776d2f7570cd61351b156a51d3a341822282095baa819d87272bc710", size = 12710543, upload-time = "2026-11-15T21:31:17.461Z" }, + { url = "https://files.pythonhosted.org/packages/1b/e7/abe56b23f4dddf8277429d0efa442abac4c1940ec776c1b707c1e58435e8/numpy-2.5.5-cp314-cp314-win_arm64.whl", hash = "sha256:2abd39cfbb3d2af11e9bc8cc92b08cd089b0975fe9b1a30c8b7c740c67d397ce", size = 10812026, upload-time = "2026-11-15T21:31:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/06/76/2974340b984ecd43bb4ee91c06a3fd59968330752c316d36fb8a23310ac1/numpy-2.5.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f82a7567c590ff266f8c18fd527a0662edde074de11be256541a656e274f2b05", size = 10857031, upload-time = "2026-11-15T21:31:21.953Z" }, + { url = "https://files.pythonhosted.org/packages/38/d2/cc6d1f0f4c848f18e30d0f464a70598369336591920952f6aee440da4a2f/numpy-2.5.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:31e5be6cd4b896004cb9e416741612ade530fc9a04bceca5219cf66a675113b4", size = 5620763, upload-time = "2026-11-15T21:31:24.1Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d0/2d014e5b68965530ebe46c0d2b07b1242210a029acba5800f53fcb4d4973/numpy-2.5.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:b3d328eebe0056c634878c251131d73d74e0c4af317a3aea718816d6fa0bb963", size = 6897520, upload-time = "2026-11-15T21:31:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ee/a0fb000c6a57602a7a2958f72a5d07837dd88cb9a158f1edb0a279126428/numpy-2.5.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e99bf8a3d54693f2063fa6c7d13955d460a9f543d9dbc80e69a92da288259b28", size = 15342131, upload-time = "2026-11-15T21:31:27.707Z" }, + { url = "https://files.pythonhosted.org/packages/93/43/85cfae380e4e2fe1d246c39a12c88c7a224e751604b6fa13236df3b86600/numpy-2.5.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:479e43c183049ec1a820eeb36549e493924f56b3e893a1d5865d0fff12abad47", size = 15751077, upload-time = "2026-11-15T21:31:29.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/41/5938f05404d2f4531409b658cfd578b0b653a87f22915759afa7f414b4f3/numpy-2.5.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9f44875964889bd9088cf838d191b58c04088d10b4dc9b140e9da2431ecfbb60", size = 16569544, upload-time = "2026-11-15T21:31:32.017Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b1/75f51d9e2fb970228bd7599d46f34eb0829070b4df8b293c43fdf1c81c44/numpy-2.5.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2a9c502cdb9a3050ac1686774624cc278658b11f72e11b971a3a8542d6ded357", size = 17122494, upload-time = "2026-11-15T21:31:34.267Z" }, + { url = "https://files.pythonhosted.org/packages/71/1b/68f54066eb445a98e7c677863d1ece9667151f8d8565eea5860d8445fb72/numpy-2.5.5-cp314-cp314t-win32.whl", hash = "sha256:dec156cda7322bcb1479ca992794705fe226a911b0ffebe13bff97fa1f3be63c", size = 6350011, upload-time = "2026-11-15T21:31:36.491Z" }, + { url = "https://files.pythonhosted.org/packages/58/29/c57eca063b680b23c0ca8d07789b3011a9e962fd4994a656b11f7a21226e/numpy-2.5.5-cp314-cp314t-win_amd64.whl", hash = "sha256:84dfb1611993a3525b250c955b1e2ebab6ce0ed36e4ab4dd5746432dd362fb5d", size = 12909875, upload-time = "2026-11-15T21:31:38.311Z" }, + { url = "https://files.pythonhosted.org/packages/72/06/70b2717589eb8ba57bce789c0f1e477fc5869c720fa0ad444e31fb9aef55/numpy-2.5.5-cp314-cp314t-win_arm64.whl", hash = "sha256:567994389edd2963b643d63d826138402a63401176f1daf84dbb3204eb838b39", size = 10899621, upload-time = "2026-11-15T21:31:40.518Z" }, + { url = "https://files.pythonhosted.org/packages/9c/61/8578c9fdbfb59ba2c4ee633102666937ce4e66f8c3de8bc700573c856af5/numpy-2.5.5-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:ad0c8b963f9281f2eb118e283eb61964c716c8e344ed8e8c309b49c586d41ed1", size = 14752489, upload-time = "2026-11-15T21:31:42.902Z" }, + { url = "https://files.pythonhosted.org/packages/a7/ef/d0f38ea7ca697c03af3d687cb70d8ddc8414dcf430f8f7194ab7359d80f6/numpy-2.5.5-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:d7d9be35d50366fe5ac28188364154c9e1e22ad1b977a06c9465c0680c8eeefe", size = 10753050, upload-time = "2026-11-15T21:31:45.123Z" }, + { url = "https://files.pythonhosted.org/packages/84/b7/de9e6d1ffbc33cc7bcf452c7924a7953daaf06bde559b73ebef93b7f85c6/numpy-2.5.5-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:d0c7c0dfabdcb7cde080b7c9ef301c7533e90110198b39965141a903c7dddcf8", size = 5516639, upload-time = "2026-11-15T21:31:47.537Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ac/a95824882c5818a7e31893ebdab2944f5e65b4108bc8bed9e240e3c624be/numpy-2.5.5-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:b7dd0287b6cdd35a27d5678a56b1bc508ff206c2b78b30b4821dd5c3197b393a", size = 6797936, upload-time = "2026-11-15T21:31:49.2Z" }, + { url = "https://files.pythonhosted.org/packages/08/64/c39a7b41df0d433ff37fd4fdd6e32b3fa3b51a82110bbcd386d0e37f5da6/numpy-2.5.5-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a207eb88a18e30add597c366c1db7e79f48fc94084b8e7dbd0eefb95a645db12", size = 15294336, upload-time = "2026-11-15T21:31:50.908Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ce/ef0ca1a7dbf657a68ec52ce150cc477a7cdd8d09c7ef77662cdecbca39e4/numpy-2.5.5-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c3e1ac3cd5d3329f4d38709ff4c21f0621bbe8779c094d6de8ec8347246fcdc", size = 15713633, upload-time = "2026-11-15T21:31:53.261Z" }, + { url = "https://files.pythonhosted.org/packages/dd/08/023029d269a7adec40749ef98439af4260ee92bc203d8a7749cc4eee8183/numpy-2.5.5-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:095113ee2ceab6a9501b184eff5ea806973d3a63d74a8cbc15e4911e754da9c1", size = 16510376, upload-time = "2026-11-15T21:31:55.401Z" }, + { url = "https://files.pythonhosted.org/packages/9f/0b/38e65a5ff61b174df3a930898a3b31e94b24caaf4155c719d18417ad63b1/numpy-2.5.5-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:bea7de36bb304a850710c1dfbb35e7cdb9a005928106a3adfc6dc3a753469dec", size = 17078342, upload-time = "2026-11-15T21:31:57.714Z" }, + { url = "https://files.pythonhosted.org/packages/4d/3e/09a62f920e5869888387ba988eeba560057c1f718404cc737e5dbc07e81e/numpy-2.5.5-cp315-cp315-win32.whl", hash = "sha256:fd47c92e0d1e53f9498b1a30305072434fbae6b5a305cbcab514f959e9ce0fab", size = 6192918, upload-time = "2026-11-15T21:31:59.798Z" }, + { url = "https://files.pythonhosted.org/packages/5a/7e/a4c5b4b30dbab285b380130dbf780bccece06de020221491058ea2c66310/numpy-2.5.5-cp315-cp315-win_amd64.whl", hash = "sha256:ae9cfe4e985139c5f2db69d4310de7348bd0abc02cfdc06991c4419065f6fdca", size = 12710024, upload-time = "2026-11-15T21:32:01.352Z" }, + { url = "https://files.pythonhosted.org/packages/7d/57/bdec7de41e7442b9ea0ac938b7597f754d4d625d853551466e8a208e3e64/numpy-2.5.5-cp315-cp315-win_arm64.whl", hash = "sha256:08f1b9abf1707fa89c125aaa17e78389c063fb20ce37a141b47821e996f4a1db", size = 10814707, upload-time = "2026-11-15T21:32:03.326Z" }, + { url = "https://files.pythonhosted.org/packages/f0/e9/7f20d2144d4fbe2876d567a1ae1266cb62a67498af7d3006e2a0ba93deed/numpy-2.5.5-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3d59ab8f6bfc4ffd29b0f558450e17922c1bc88459882e37726fbcd5834afbfd", size = 14845589, upload-time = "2026-11-15T21:32:05.476Z" }, + { url = "https://files.pythonhosted.org/packages/66/02/ded297ac4c917f7cf90254a50f888f992c028e2ed9a3efd82349c12d4904/numpy-2.5.5-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bf6fa5a4d73b3a9699a57b8824d4863acde7241808a5305882222843537f02a2", size = 10851494, upload-time = "2026-11-15T21:32:07.944Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ac/1ae013866575827dcec6239ca413b76c05652fa5ac405afd8d904940197c/numpy-2.5.5-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:d64daa409e9b1ac818b0c59e47b005f802e130c8281e40c6a2f7e70c43f75e0f", size = 5615246, upload-time = "2026-11-15T21:32:09.876Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e2/2d89896606a325e584157fe669578ac1b22558e4b3e45e0cb554970e5a19/numpy-2.5.5-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:ff5c1ab54a637c0adcdbb69ad10e5c4f1c4dedba69c0d1de383249b70c36908f", size = 6890873, upload-time = "2026-11-15T21:32:11.545Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a0/de0484dbe0665ae69cbf9c2bb777c2fa4f402e03a102384c54fe54048d44/numpy-2.5.5-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:178cb1eaed819b2cb4e398c554b0776d1499f307e30cb58b9bae1921de35dae6", size = 15340077, upload-time = "2026-11-15T21:32:13.223Z" }, + { url = "https://files.pythonhosted.org/packages/39/d8/60a70cb61b8063e4dfc5b8b55f93c247cb7f1a36515d810e70ca94446396/numpy-2.5.5-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6e30929e3443f46aa7be2749fb003fefbbad6b6a1e2168bf8850a55b657914a", size = 15752447, upload-time = "2026-11-15T21:32:15.629Z" }, + { url = "https://files.pythonhosted.org/packages/09/14/db7e8f5560a329a118bcea53da883f077bac5f00124799c5ac7e9eb1823e/numpy-2.5.5-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:2efb2ae4e0414b6bd636dde7235c158cd65dd52891ff64a320a4847a8ce7400f", size = 16566475, upload-time = "2026-11-15T21:32:17.974Z" }, + { url = "https://files.pythonhosted.org/packages/ec/33/060b8c68e2ed79fe50a20139f7f89fa2d9862f2d3e127fc353d8e6b2589c/numpy-2.5.5-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:32dce94d74bb4d5bb058d65b0d9dad7fa61d07ff9375fd7695d8aa7ea82ee73d", size = 17120613, upload-time = "2026-11-15T21:32:20.094Z" }, + { url = "https://files.pythonhosted.org/packages/99/3a/ab02c902cb380d0b950eccda4f0b67ac4f66ba490c98756d38adc4b3ccb5/numpy-2.5.5-cp315-cp315t-win32.whl", hash = "sha256:b5d08742de581c9eb61102768ccca125a2982913de399611b56981a07278de74", size = 6344124, upload-time = "2026-11-15T21:32:22.058Z" }, + { url = "https://files.pythonhosted.org/packages/fd/49/b04b1f12231e6fbcf26fd5e7949f629530e11c46a6fcd91923f61b017243/numpy-2.5.5-cp315-cp315t-win_amd64.whl", hash = "sha256:410eab02c6718cb42d06ccbb8604659f3522d2ce06ae70cacd5042092659f5af", size = 12898288, upload-time = "2026-11-15T21:32:23.871Z" }, + { url = "https://files.pythonhosted.org/packages/36/7b/935a5896b0bd441c6dd6da81f39bc5ebf8d5da891b7dcff768e1e1c088b5/numpy-2.5.5-cp315-cp315t-win_arm64.whl", hash = "sha256:b6ecbc1ff292c6799067d8064a4dd35cd25ba9d1a24aa41dd635d701691a49b5", size = 10891314, upload-time = "2026-11-15T21:32:26.357Z" }, +] + +[[package]] +name = "opencv-python-headless" +version = "5.1.0.95" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.4.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.12'" }, + { name = "numpy", version = "2.5.5", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/6b/51/33b8c7255f3bdd920d6238aa478faf1e2136d5a51f17d826c13902ca7195/opencv_python_headless-5.1.0.95.tar.gz", hash = "sha256:9002add14b121b9a0d64dcaff48e5cac69a7987efcf2847f7db075c2d3b9633b", size = 83423991, upload-time = "2026-11-17T18:19:14.93Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a7/76/95bb6ecdb317bf839fc653d26055df7355b9290876ffebc0a8a68f0c8740/opencv_python_headless-5.1.0.95-cp37-abi3-macosx_15_0_arm64.whl", hash = "sha256:512f5c704eeedd0c550cf2daca42e4312f6d30bb047680f1563c661eb9ee7e82", size = 25824488, upload-time = "2026-11-17T17:40:36.008Z" }, + { url = "https://files.pythonhosted.org/packages/e7/ba/e4773fad5195bbb33e4acbec6710315e90b487c23d101f8b886d8341ed7c/opencv_python_headless-5.1.0.95-cp37-abi3-macosx_15_0_x86_64.whl", hash = "sha256:1193ffb8a60d0496dbac652f052791dc0f0da6a298e215c93d1d8c9dd67b89e9", size = 47012519, upload-time = "2026-11-17T17:40:59.708Z" }, + { url = "https://files.pythonhosted.org/packages/8c/2a/e42c34358d69a26bd5e88ba9241437c58b78876cf0d13ecc09df9042ed4f/opencv_python_headless-5.1.0.95-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:58835db7491d6564e816c4fbbedffe72afa3976dc19ccd7439916ec0e534f6c2", size = 35797194, upload-time = "2026-11-17T18:17:12.136Z" }, + { url = "https://files.pythonhosted.org/packages/37/63/6f18cf6b25aca818c5432317f9c9db3ee87d9f03d576d1e5953910429be3/opencv_python_headless-5.1.0.95-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:93cc83677f07791a9d3284bb6b9bbf7c2ffcca05aabcee239e68ca4abaf50aa1", size = 57722171, upload-time = "2026-11-17T18:17:22.507Z" }, + { url = "https://files.pythonhosted.org/packages/26/db/73313673e5c07eb4023c929022e6ef5f7cfd7885f7ea14019b1e1f74540a/opencv_python_headless-5.1.0.95-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:11d9753e15b8b3c56e6aa765139f722ca19ff26016d43bc81035f5d122731a81", size = 40022516, upload-time = "2026-11-17T18:17:30.669Z" }, + { url = "https://files.pythonhosted.org/packages/c2/be/cdf44e32b580af6c0e8f237665c538e6a5a37872f865e92e08fb854d5fd9/opencv_python_headless-5.1.0.95-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:7d387d4a64abe0c737440d38b5a90822f9bbcc10c8ce06a35904d6ecf7a2fb30", size = 63704594, upload-time = "2026-11-17T18:17:50.623Z" }, + { url = "https://files.pythonhosted.org/packages/a0/fb/2a03c688595f0c1541c31fe5a767072102f7bed82e3122e9348723c347fb/opencv_python_headless-5.1.0.95-cp37-abi3-win32.whl", hash = "sha256:3d57365e8050a968a60095fa78a108f765b094914f5ad863c45ff5cef8844069", size = 37076072, upload-time = "2026-11-17T14:37:37.864Z" }, + { url = "https://files.pythonhosted.org/packages/26/d1/a52c8d8e1cecf86725930170dfba1c7c1f59674ac8f131e96583aa41433d/opencv_python_headless-5.1.0.95-cp37-abi3-win_amd64.whl", hash = "sha256:2fd11ce2e88feb28869ad5762a31546ce0062e7c55c130c425ccd3918a19e4fa", size = 47789463, upload-time = "2026-11-17T14:37:33.153Z" }, + { url = "https://files.pythonhosted.org/packages/a5/72/0af4755ec5ea9fd7d478900405193f6e2d895383f26a31875e7fc7d22a12/opencv_python_headless-5.1.0.95-cp37-abi3-win_arm64.whl", hash = "sha256:a508c7c30815ccb5990d15427daf1397e33c850d8aab6efc3a5eaff035bebc80", size = 15631616, upload-time = "2026-11-17T14:37:27.735Z" }, +] + +[[package]] +name = "orjson" +version = "3.13.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f2/72/380b97dc45bd162d23afe5194721ef678d9eac7cfaa549fe2873f7f0a518/orjson-3.13.0.tar.gz", hash = "sha256:d1de5eb04485110c5da4c657e49168995d55e076b1ce60f1a042e254f4186c4f", size = 2732604, upload-time = "2026-10-07T14:09:25.719Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ce/a3/0be3b115907fea61ed340639fb0e1562cd18969bad5b3f486f808197aaff/orjson-3.13.0-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:948bad47f2e2e43527f14248364a0e5dee26dd3184691010ec4a1ebeb0fd6771", size = 223146, upload-time = "2026-10-07T14:08:06.474Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f7/665935edb16163f8b764182e29a30cf056947a66893ed032191e5f01eb3d/orjson-3.13.0-cp311-cp311-macosx_15_0_arm64.whl", hash = "sha256:1807c2fa49d393c7ee95fd1ef1b39cbb24aa3ccd81f30b84503ba59407666960", size = 123546, upload-time = "2026-10-07T14:08:08.324Z" }, + { url = "https://files.pythonhosted.org/packages/67/ec/e7cde480c0e212594d17ba2b2bd210c002052e9147fc1a1aeafaabe722fb/orjson-3.13.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:637dbca1fccffe83780e806fbc0f17427c0c59bf822528eb0acc8f0aa9f19acb", size = 113290, upload-time = "2026-10-07T14:08:09.816Z" }, + { url = "https://files.pythonhosted.org/packages/36/59/4455fb11a297af73611dfc437f0f89456220227ed1cb1544a5a0ee9d6c03/orjson-3.13.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:554948becd1110123ef9f6a6e1310fd92b2d07d2cbac6dbf65df3de75702e736", size = 130342, upload-time = "2026-10-07T14:08:11.253Z" }, + { url = "https://files.pythonhosted.org/packages/ca/80/0eec5fbde2e52407646b4cb3118f63175bdcee1e2390c2759dc96e0bc62a/orjson-3.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd9d9a101bd8dbfad112170f009cd155e52bb8c936468821a0d03cbb96c0e426", size = 129138, upload-time = "2026-10-07T14:08:12.814Z" }, + { url = "https://files.pythonhosted.org/packages/cd/cc/c0874f13819ae346d69ca00d074d464710b494abd4442bdebf75ac404a98/orjson-3.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89bcf2d4bc6c9a7e1763c8cf534f38712e66b76a0fefda7fb7785462f0d635e4", size = 130518, upload-time = "2026-10-07T14:08:14.392Z" }, + { url = "https://files.pythonhosted.org/packages/25/ab/140dd9adff84bf64b862c4fcfe2d055af6014d5ba03a075f95c9addb2ec7/orjson-3.13.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a79cdc4934fe81f593072c94e13da3095e9d41c2deef8f6ff2901794ca1c5042", size = 134924, upload-time = "2026-10-07T14:08:16.09Z" }, + { url = "https://files.pythonhosted.org/packages/08/0a/e8f6deb032b1d98a39043cf99b863d8b9e842e2ffc2d2067d2e2a88c18e4/orjson-3.13.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:50a5202ba388b3850ba24437951727d3aa6d79a21964a30ae8dc6a059a5fd34c", size = 126704, upload-time = "2026-10-07T14:08:17.439Z" }, + { url = "https://files.pythonhosted.org/packages/af/cf/be64b99ff75f7983488390d4ef5df72115119770eed295691c0a715d492a/orjson-3.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a0377d6962fa431c93ecd78fdea771bb62ec545b24ee0c5d4e32acf2260af259", size = 121287, upload-time = "2026-10-07T14:08:18.843Z" }, + { url = "https://files.pythonhosted.org/packages/ca/ab/1b8ca186baf3420f12db1f2819fcc5f2cae69e4cf051168501726a64c0fa/orjson-3.13.0-cp311-cp311-win_arm64.whl", hash = "sha256:1d84820b2ec4ac975cba482214032de5b0dbdd17046170c98e642ef9c4a4ee4b", size = 126314, upload-time = "2026-10-07T14:08:20.452Z" }, + { url = "https://files.pythonhosted.org/packages/98/17/ed65f84ed5ed6a1e06eb628611b4172e7480fc4ad92594856751a6363cac/orjson-3.13.0-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:fb8644dc6d705e1269ed2842bf4dbe2b4e50d670de503bf79d5cef3a5148a4c7", size = 223063, upload-time = "2026-10-07T14:08:21.979Z" }, + { url = "https://files.pythonhosted.org/packages/6f/4d/9332eb96d2e379384be0f211f543835eebc81f460c9403b84abe1294c431/orjson-3.13.0-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:6ff2a2c67f35202f7d823753d38ad371a9b7fc297567cdfff4420e763cb9f6f8", size = 123364, upload-time = "2026-10-07T14:08:24.026Z" }, + { url = "https://files.pythonhosted.org/packages/b4/06/558456b7da27e974a8c9ea09117b07119f6fa131cd62b8b9ecad9eea94e1/orjson-3.13.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:65c4e0e106ccc7265b488385659117a6805c37d042f737558ecd68aa0c67ad8f", size = 113199, upload-time = "2026-10-07T14:08:25.476Z" }, + { url = "https://files.pythonhosted.org/packages/b7/f2/1187a9c09965620348262ec0f406868f6d7c234b2e9b5ee51020bdde5748/orjson-3.13.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:fbbad6b9b1da43f25c1f5b20cd5a268e028a2fc95d5a8d1ade6059973bc71584", size = 130329, upload-time = "2026-10-07T14:08:26.877Z" }, + { url = "https://files.pythonhosted.org/packages/46/07/5d1a151bc11600434fe799e73abfc6a4d463d02e149a20e47c59d3a985ae/orjson-3.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ae1d895cf7bbfd50ef34bb63bb727b14514f259f3e3f8dd010783bd38e864c6e", size = 129072, upload-time = "2026-10-07T14:08:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/ea/8c/bb07c368abbf4021c4cd01c12edb526e00090f7f750ff1b88da6e6b6c7a6/orjson-3.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bceadfd314bd238f584fc229a4bbaf0e573597e7a026dec5429fbf29fd66c641", size = 130612, upload-time = "2026-10-07T14:08:30.041Z" }, + { url = "https://files.pythonhosted.org/packages/d2/8d/4b66d19619ed344ac000ffea7c006477d0061d580646e736ef0e203759e8/orjson-3.13.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b74c30e56346aad067937d766846ee74c231d1d18aad3f324e9b9261de3b2d5e", size = 134632, upload-time = "2026-10-07T14:08:31.474Z" }, + { url = "https://files.pythonhosted.org/packages/ea/88/f8221f6593e37eb26ec4706e185b9ac6f38ff0c8f7bad5459844031ffd2d/orjson-3.13.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4329c19b8a25693f60a77b867c9d2a3ab637b20e36f5b7bea7f5acb492b44b15", size = 126807, upload-time = "2026-10-07T14:08:32.914Z" }, + { url = "https://files.pythonhosted.org/packages/58/9d/a1ca7321eeafd7d72e174cdc388cc96301f41516d863e7b1f64f0a1735be/orjson-3.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:b571236d8393edcd3236e07423f762bfcf571f852aad667a3bce9e7b755e0790", size = 121538, upload-time = "2026-10-07T14:08:34.325Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a0/1f19b4779c910104370932fceb9ed436b47ac077f297db74008062525c04/orjson-3.13.0-cp312-cp312-win_arm64.whl", hash = "sha256:8594956a75223f657e1e68c568c0eeb3dd145f02cd6b78a47fd9a8095dbc4eae", size = 126259, upload-time = "2026-10-07T14:08:35.765Z" }, + { url = "https://files.pythonhosted.org/packages/a9/56/f8ad2546150168858c16915c452b00eecb79597597524d1ad6ae14ad4eab/orjson-3.13.0-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:64e8f345048d988c8b68d3882e5d41028fca1219a9939b32e4a77be34c8ae8e3", size = 222892, upload-time = "2026-10-07T14:08:37.495Z" }, + { url = "https://files.pythonhosted.org/packages/1f/19/725d23160b2471a3f27026c55bb79af34687652d8be8f5f583cee5dcd42f/orjson-3.13.0-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:ded33b972cffdaf4ca0ac917338ab61d2bb10d68987dbcae641c313fbfdbf499", size = 123319, upload-time = "2026-10-07T14:08:38.989Z" }, + { url = "https://files.pythonhosted.org/packages/ac/08/e5d81a00b22c73dfcb60d80da3bd92d5a7684346593536565f184dbae3c9/orjson-3.13.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:45e34deb3437509f4ec9888dd9ee5dc426cfe21be10f1eb4ea3a9e4d33034f9e", size = 113196, upload-time = "2026-10-07T14:08:40.383Z" }, + { url = "https://files.pythonhosted.org/packages/67/78/fda6117c69a43e470b1e9dff38dd8c5f0bc6fd8a47e4d4561ab023039335/orjson-3.13.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:9825b954155b345c4759f24e5f8d652b9aec2261bb5d4e1abe06bba0a1200535", size = 130245, upload-time = "2026-10-07T14:08:41.878Z" }, + { url = "https://files.pythonhosted.org/packages/6d/31/d0cfebd456defb234414795ae7599696bf124843dfe077d0c9ece0c93554/orjson-3.13.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b081f0e7b600ff24513dec4ca75507fa05e904607847e386e8310d5b7b96b6c7", size = 128981, upload-time = "2026-10-07T14:08:43.716Z" }, + { url = "https://files.pythonhosted.org/packages/45/46/f8d83189ff5b7b2ff225a58c5908618cc4e86afe09e65d17a30ac68c9da4/orjson-3.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cbed5f4c4b88d94bcc36115f4c3bb3aa25da1563a5c3328aa3acebce2b083040", size = 130370, upload-time = "2026-10-07T14:08:45.132Z" }, + { url = "https://files.pythonhosted.org/packages/e6/6a/d6344c305003ea826b3fa0482645a897a3cd6d477ed74e1fe15d3322cb23/orjson-3.13.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e9b61676116f755126b90e740a9cff36b91562f47ec330056cc88cc3b9f02f4b", size = 134595, upload-time = "2026-10-07T14:08:46.63Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/d73fa44f88d53e02d10de1cf77c16ed13204ff5bca47e1692da6b406619c/orjson-3.13.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ef75ed7e81dae34a3649f82df52cd85f9ac839a7d6ec78ab355b33b3b27ef7f", size = 126513, upload-time = "2026-10-07T14:08:48.111Z" }, + { url = "https://files.pythonhosted.org/packages/fb/f8/bcfc50b4ab851c4f9c0ee62f52bf3b28f0bcd0d9fe08e0ad98d4585148db/orjson-3.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:4ee06e53b998c71ce3eb93b86222912fdd9dcced685ac64d4525d36fac338ea4", size = 121371, upload-time = "2026-10-07T14:08:49.549Z" }, + { url = "https://files.pythonhosted.org/packages/7b/7a/d6927845712ec2b1e89263cd12d7203531db185dbad67f914226f2fca156/orjson-3.13.0-cp313-cp313-win_arm64.whl", hash = "sha256:89efecad02515df7f318d0613b5dfd6d2a1acd323a2b8294712789a715945525", size = 126134, upload-time = "2026-10-07T14:08:51.118Z" }, + { url = "https://files.pythonhosted.org/packages/f0/10/98b5a3cdc086abf78d8cd20bb0cba124485d4b6a745722197bd209d967a5/orjson-3.13.0-cp314-cp314-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:a7bfc7db961c7d96cb75889dc6a1e4ae1e91d87ee61da564f582bd742b8dfeef", size = 222889, upload-time = "2026-10-07T14:08:52.673Z" }, + { url = "https://files.pythonhosted.org/packages/22/7c/7728c5280ab5202f4891ff4b0b96e2e1dbd5520dfee53edf083c54409a64/orjson-3.13.0-cp314-cp314-macosx_15_0_arm64.whl", hash = "sha256:91d933e668ff0ffe164d7c2daec36beba6d1ce7fadb71538fbe142a71f8a1e6e", size = 123312, upload-time = "2026-10-07T14:08:54.25Z" }, + { url = "https://files.pythonhosted.org/packages/a9/a5/d9a44321e6f66c0f64b45be587395f87ad94cb447bce7d92286f6b97d46a/orjson-3.13.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:6c8bfe728b81b0fd58a3c7f3f9c5a113f87f2992c9948e0f28707aafd737c0bc", size = 113146, upload-time = "2026-10-07T14:08:55.803Z" }, + { url = "https://files.pythonhosted.org/packages/80/da/d95c80d413f288feb471e16d82e5c1512d2439728e3bac917d058c31f098/orjson-3.13.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e8e05549f3b30f9d8a8e28c5aba11cc2a4b90b90961ec685ca58444b0815fc09", size = 130348, upload-time = "2026-10-07T14:08:57.31Z" }, + { url = "https://files.pythonhosted.org/packages/04/0f/36fdfb32ad1852997bac00e3ce52c7888d8a1094ba9dcdcbb22fcc6b953a/orjson-3.13.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c749ab3ac30b5ab1ffb7677f8b92eacfdfdc5260210baa398f845bc3714c05d8", size = 128971, upload-time = "2026-10-07T14:08:58.843Z" }, + { url = "https://files.pythonhosted.org/packages/25/de/a82acf93bdcca0c79ccff25ef0c6868d24ccbc2e72f21fae39c8cabce4f1/orjson-3.13.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58a9619d88f8818d9ab6b39d70d203789457ba13c1ed5d274f33ce9ae7e81a36", size = 130359, upload-time = "2026-10-07T14:09:00.412Z" }, + { url = "https://files.pythonhosted.org/packages/71/ca/2bc4f7697cb9f6897bf61aca11803df096a5d971bf69ef5538b243bb1fa8/orjson-3.13.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2715c4808d1571029ed18fd07a82140bf3ba7def0dc89f8d015c416e3649bf87", size = 134583, upload-time = "2026-10-07T14:09:02.047Z" }, + { url = "https://files.pythonhosted.org/packages/23/b3/12b1af9b87ff9fa0aaf4e5724c87672b30bb5de76f275f7fac64e8219c1b/orjson-3.13.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:08bf722f923d2100bc5e5a5dcf72c656db557049c1bea26582fdd5dd9d5395a1", size = 126500, upload-time = "2026-10-07T14:09:03.863Z" }, + { url = "https://files.pythonhosted.org/packages/ad/ea/cf257fc8a7f4b18f5677c22b3a9673a1b51d4b7161f25177ed389b76560e/orjson-3.13.0-cp314-cp314-win_amd64.whl", hash = "sha256:6adcaa85d79977659a448b4123a88eb33511a11ed2db243535ad7ea88a6668e0", size = 121378, upload-time = "2026-10-07T14:09:05.375Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/9f4643f849e9918eab11983b83928af3aac14bedb04002e28e885ee1936f/orjson-3.13.0-cp314-cp314-win_arm64.whl", hash = "sha256:83705c12b4afde10c62a5dd3fe6fdb21b7900bd0dcd5af1c85612ae94d0ee590", size = 126123, upload-time = "2026-10-07T14:09:07.085Z" }, + { url = "https://files.pythonhosted.org/packages/8c/15/d265f2b556c0c7c0b30ea830316d6e5af5b85dde08f234a1ebed60fab386/orjson-3.13.0-cp315-cp315-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:5ef4d4157392a0439b74f7e49e5636b4ea43d9616bd0884effc0195fffcaa2d5", size = 223305, upload-time = "2026-10-07T14:09:08.84Z" }, + { url = "https://files.pythonhosted.org/packages/0c/97/781be8b80a33b8171b3f5acea941af47182c8b4b5827c2b7c3fea706f21c/orjson-3.13.0-cp315-cp315-macosx_15_0_arm64.whl", hash = "sha256:84d87e322e1674408f85adea63f11aa19201eba082755aec20ebc217f493bbd2", size = 123515, upload-time = "2026-10-07T14:09:10.792Z" }, + { url = "https://files.pythonhosted.org/packages/20/68/011bb98fa7da7b430b363db1bb7ef9160c438fc5c43e7468fb593c220037/orjson-3.13.0-cp315-cp315-manylinux_2_39_aarch64.whl", hash = "sha256:8c2ac5c09b017c484df1b4c68b2cf250b4e8ba08204cb58e7cd6cbbc71a9c902", size = 129222, upload-time = "2026-10-07T14:09:12.542Z" }, + { url = "https://files.pythonhosted.org/packages/86/7f/d96fa2aedaaec14c095ea9cd48d2158fdf33c0f4fd6e7a598d899d536b03/orjson-3.13.0-cp315-cp315-manylinux_2_39_armv7l.whl", hash = "sha256:51d11525bc3ca736fa97ce4e4c7da9999cc00bf261522bede43b4e7531bd7965", size = 113152, upload-time = "2026-10-07T14:09:14.059Z" }, + { url = "https://files.pythonhosted.org/packages/e9/2d/ee77aa685c54bd920a1f0e2936986b46269adb0d72bf5098c2c694dbeb36/orjson-3.13.0-cp315-cp315-manylinux_2_39_i686.whl", hash = "sha256:ac81530647c3423107cf61c3481e91f57134e9ddfb6ef83f5150ccbdcbc3a3ee", size = 130749, upload-time = "2026-10-07T14:09:15.835Z" }, + { url = "https://files.pythonhosted.org/packages/48/eb/3411fbfdad61b3f3af22343b5af7ed5c8a1679e35f442e8f1b229b33040e/orjson-3.13.0-cp315-cp315-manylinux_2_39_x86_64.whl", hash = "sha256:0526a3456db67b264c6d661b5f090077f326b6cd074d0ef53a72763595dec5d7", size = 130471, upload-time = "2026-10-07T14:09:17.463Z" }, + { url = "https://files.pythonhosted.org/packages/87/71/abdc2b8c70b8d85a6cb22f404da0f52d7d712f9d49cda039a0cb1adcb973/orjson-3.13.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:dd61e64802d51d1e4f16531c64536354fc3bc67932dc0cff254044f72bf0f187", size = 134793, upload-time = "2026-10-07T14:09:19.084Z" }, + { url = "https://files.pythonhosted.org/packages/0a/2e/1c13552d8b0241083116de02b2f284ee38501ef06ebfb79893f741538168/orjson-3.13.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:c5e3ccaac3106e8fa6e2f2f6962449d7c757d7b067e41b395a19d6f0d6cec892", size = 126711, upload-time = "2026-10-07T14:09:20.645Z" }, + { url = "https://files.pythonhosted.org/packages/85/f8/d4ece953a519d064cf690adaa68cd389d5b64fd261726334841b32978d6a/orjson-3.13.0-cp315-cp315-win_amd64.whl", hash = "sha256:7804dd1d6161da0e53b284c2aebf20f23e78eaac617300803e1467d1828d987f", size = 121496, upload-time = "2026-10-07T14:09:22.359Z" }, + { url = "https://files.pythonhosted.org/packages/70/cf/f691388c4a9bc4af7dcc1648c4b40845869908b517d7c0009d005c7d1fa1/orjson-3.13.0-cp315-cp315-win_arm64.whl", hash = "sha256:f5c05a8fee59309f537590a1ff12d3c1009c485e96a50a9ac60dd085c09d0fc0", size = 126260, upload-time = "2026-10-07T14:09:23.928Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.14.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/2c/ec57eede0db493e61443c76ac7b4d24e94a24050afb3d598bf3678487f75/platformdirs-4.14.7.tar.gz", hash = "sha256:5472257c1cf97a14658af52997011c7e59e4aebf3a24950b973c11b579e1b074", size = 75132, upload-time = "2026-11-17T20:03:32.656Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f8/46/3737af9f971f3934794103256d7f1ed6200a62be0c7b7ff09ac4cf6b3422/platformdirs-4.14.7-py3-none-any.whl", hash = "sha256:391513b74707c42335fff3ea17eaac657a7ee9ffcadd809634d34ea594d0122c", size = 89658, upload-time = "2026-11-17T20:03:31.16Z" }, +] + +[[package]] +name = "pluggy" +version = "1.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/bf/db/7fc19e6f2dc92a966727031389fc2e08b558f0f25eb7403c1119ad4713cd/pluggy-1.7.0.tar.gz", hash = "sha256:d1eaa46ebb595891b860ab086b4d09c8588af65ebd4361b8e8f4bb8920b90ba8", size = 123304, upload-time = "2026-10-15T09:50:58.343Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/9e/2b38731e0fc536806f16490e1a12d7f0dc2a1235aa8cc07bcc75416a7daa/pluggy-1.7.0-py3-none-any.whl", hash = "sha256:7dd7b0d8832ba3cb632c306926ded123429211b83641b35dc5c41ad2d34f9bec", size = 27082, upload-time = "2026-10-15T09:50:56.808Z" }, +] + +[[package]] +name = "pre-commit" +version = "4.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/3a/c3/6965c2690ddce885ec75121572d065a5b94c5a5d8d3e657927ecda9fd715/pre_commit-4.7.0.tar.gz", hash = "sha256:1f3deee12b914c8fa184bd2b5953391c2e4f36763e403d4a23dc9983fa7c6e86", size = 198120, upload-time = "2026-10-12T20:45:40.32Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/eb/83/ce0a196e4f7b20b11ce3aa1fc72fb973f64b7628d51c1b8aebad37fb7f81/pre_commit-4.7.0-py2.py3-none-any.whl", hash = "sha256:2e229038ad3656081b70c27913157e4b636ef306f643f024a8a8e3f0f7b2f877", size = 226261, upload-time = "2026-10-12T20:45:38.858Z" }, +] + +[[package]] +name = "pydantic" +version = "2.14.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8e/25/3ec212432a6031b65f043eaca9c820ddf87c0d0aa330023e64f79fcb5db6/pydantic-2.14.4.tar.gz", hash = "sha256:7c19f1d46f8accf55a4617a6116e1ade64840870f397b846a2c53fb9019414ba", size = 927354, upload-time = "2026-11-19T12:57:39.767Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/8c/824a686c4ba815ddb0722f9e66272088bccd4e1ae1d2f7015375e4a4fc7f/pydantic-2.14.4-py3-none-any.whl", hash = "sha256:653a2ad9f6d8858529c77c72717d0ea991d6c6837fe683246b2f4b2bbfc3fadc", size = 494865, upload-time = "2026-11-19T12:57:37.688Z" }, +] + +[[package]] +name = "pydantic-core" +version = "2.50.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/fb/63/0ceb815a7762576027ce388544c573d440574f95afb1302a2496b96db548/pydantic_core-2.50.5.tar.gz", hash = "sha256:1e740886083ff95530d694e6a3f09ed914bcf92a496d16acd307c6c3484fc36d", size = 523285, upload-time = "2026-11-19T12:56:38.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2e/13/38388fd381879499d83dec38826fdb9457ab67b77f6e32c2dddcfc604dae/pydantic_core-2.50.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:bcc830e4f48499fd30a870f07c30752273ae2ddccce34d65d51c9fc880c380ab", size = 2173303, upload-time = "2026-11-19T12:53:40.749Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3b/8b75df5dbcd09d81e536edc17d1d77767a4044fa5b90cf875c4100bb7ce7/pydantic_core-2.50.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:40d5da89a632e6c6c938f93fdf54c534882d258a80f51ccfe1650cdedc12e82c", size = 2135436, upload-time = "2026-11-19T12:53:42.276Z" }, + { url = "https://files.pythonhosted.org/packages/de/55/862dcd360026869daa74e828375a5f8d4071d160c4499121c4eb6748d325/pydantic_core-2.50.5-cp311-cp311-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:f7509c6f8a0f9d9eac58340dd567f0eb71ce2f762df09f0d51280e30da3fe687", size = 2287206, upload-time = "2026-11-19T12:53:43.562Z" }, + { url = "https://files.pythonhosted.org/packages/8f/bd/029b44924c3df7cf74f2127384ed628aa9070df05881582cca17e5a113c8/pydantic_core-2.50.5-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba2b34529984a8e3cb1bc62a7687617722695a2cb4e57958de32a0eba128a07a", size = 2133843, upload-time = "2026-11-19T12:53:45.093Z" }, + { url = "https://files.pythonhosted.org/packages/f3/6e/48927f3224125c67939d70c697b9785a15cb53dccf2300b4fafec788da9e/pydantic_core-2.50.5-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:f8dc2008577c5e02eaa1eb3fbfa8fe0eba9af27ff6a740e9f1dae6661e88efcb", size = 2215985, upload-time = "2026-11-19T12:53:46.384Z" }, + { url = "https://files.pythonhosted.org/packages/4c/18/b7dc6bb4e46f6c6a097d44c16bfb917d6b1af905a7c77a4d0d17799c9787/pydantic_core-2.50.5-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:4dcf7b2cdfb9c59c1d377de318f3c8462121f32db939299999484ea0b1eadf18", size = 2408931, upload-time = "2026-11-19T12:53:47.884Z" }, + { url = "https://files.pythonhosted.org/packages/8e/cb/7be07fe1a633d915f8b02d6d3740a016521e826914216c179974b7b02f4c/pydantic_core-2.50.5-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:ed4a01922af0d41b2a3b9433818cbb73b6b28e8dea344c90917c1fdcceb9960f", size = 2458757, upload-time = "2026-11-19T12:53:49.451Z" }, + { url = "https://files.pythonhosted.org/packages/bd/77/9520ca4c8f9bac81c2c4124389a8413c9d0e97e054b1d0c854b71e104297/pydantic_core-2.50.5-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:488319076ec92908b91fc6265ce761f1d78748f69f85518564fd16bf333e1b70", size = 2257712, upload-time = "2026-11-19T12:53:50.865Z" }, + { url = "https://files.pythonhosted.org/packages/0a/47/53ee8d0124583ec6ad88bd9797dcd95d8269cd02e2524d4f9d63bf5fcbcf/pydantic_core-2.50.5-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:50d12ba7cab98b355ba65d65655e969f66934ab7a3d2d0c8abd61ae2282efce5", size = 2284545, upload-time = "2026-11-19T12:53:52.338Z" }, + { url = "https://files.pythonhosted.org/packages/78/af/69816722a0847162b5e7127f29bba0694cd2cfd5ec42d88a19941ac985f0/pydantic_core-2.50.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:be4615d4b5f90c65dce2295dcf32eff7f05ea5d0d3a82421c03c572785cb9bf8", size = 2323712, upload-time = "2026-11-19T12:53:53.779Z" }, + { url = "https://files.pythonhosted.org/packages/cb/f7/07e5551c38c1997f02079ee89b6094d3bb94dd1febfb8852724b69f0275d/pydantic_core-2.50.5-cp311-cp311-musllinux_1_1_armv7l.whl", hash = "sha256:65b0f52abcd06dbb53961db9cc3610929f4f6518c3726d965a9babdaf7bd79c9", size = 2492159, upload-time = "2026-11-19T12:53:55.072Z" }, + { url = "https://files.pythonhosted.org/packages/92/fc/48f6134b7691ea8453f0f8f1b41761118ff2a27a47599f276a34303c9074/pydantic_core-2.50.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:05815bbe2c7bec58d1ce456cc0a98f368e6ef9345b1d9311f42b814d34ad7086", size = 2500209, upload-time = "2026-11-19T12:53:57.775Z" }, + { url = "https://files.pythonhosted.org/packages/f6/dc/ca894248073c89beb14944493c587be807cbb7327f1befdc2ca8b2a5865c/pydantic_core-2.50.5-cp311-cp311-win32.whl", hash = "sha256:e65f78eb3d930ac30ff3557fc74a0771300096fb002f588a6fe8d946e83f14ad", size = 2137200, upload-time = "2026-11-19T12:53:58.973Z" }, + { url = "https://files.pythonhosted.org/packages/ac/61/5948dca31a355a03bbc4284cfb6f93e9d8add875ebcb38c90b848c28b522/pydantic_core-2.50.5-cp311-cp311-win_amd64.whl", hash = "sha256:d4ebf349b1b60049e80df5d9ea6725b1b7e434a7d006474b0f664fa72a6b3c75", size = 2271411, upload-time = "2026-11-19T12:54:00.291Z" }, + { url = "https://files.pythonhosted.org/packages/80/df/453c5e77d90768c576d2881474882e958197fa41e48f644b2250efb02eef/pydantic_core-2.50.5-cp311-cp311-win_arm64.whl", hash = "sha256:736782cfbca37b4d81e6f3c7a3414de25db045dcdb7a05e55b64191a33c5ac45", size = 2202753, upload-time = "2026-11-19T12:54:01.573Z" }, + { url = "https://files.pythonhosted.org/packages/2e/ce/c79f87db419571137da902afa5cb16f7a981943bb9e0a520886fc4ed06e6/pydantic_core-2.50.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:24d23de96195ff9637e5940a7fbde3bea6a355b26fb5f491737dd803aa5d5a93", size = 2233897, upload-time = "2026-11-19T12:54:02.758Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6f/4e172894c2a4ca3bacd6c5f823ea5576df25eafe7593ffeb3576895b92aa/pydantic_core-2.50.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9bcf23628860d5a90cacdc188ee3b7d0547a38eb985214f03e7002a6ca0e558", size = 2111013, upload-time = "2026-11-19T12:54:04.084Z" }, + { url = "https://files.pythonhosted.org/packages/08/3f/80d4525a45660f1a8d9ccc33fbd81c5650e62857d75e008c2ac37c1b2717/pydantic_core-2.50.5-cp312-cp312-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:30988977d38909df645183a9869a9d12211485639ac4757de18585f0ccb6f3dc", size = 2262195, upload-time = "2026-11-19T12:54:05.347Z" }, + { url = "https://files.pythonhosted.org/packages/5d/55/02aacb1a5294a227e44dfba6ae921d1ffe3fd296fad6caceef3ec685d10f/pydantic_core-2.50.5-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:07a62d44515d674d750cfd86b7ce1dd93111be870f378d7c27b37aeb78d0cb4a", size = 2131910, upload-time = "2026-11-19T12:54:06.821Z" }, + { url = "https://files.pythonhosted.org/packages/ed/5e/38190b580e1cd1c9264ccbf3ac6baeedf5b0459887abfdd9a44a0879b4d0/pydantic_core-2.50.5-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:7dfc0431e94659ae8449303ca4fb1588dc1e00282d6636d00d72bb4bd6459b4d", size = 2198229, upload-time = "2026-11-19T12:54:08.316Z" }, + { url = "https://files.pythonhosted.org/packages/9a/ef/467df68c04913f359b8b388def9229c5a3df52aafa20bc185073e6e94d67/pydantic_core-2.50.5-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:004c784d4642bd1112a9fa9a022543aa17793fd32004f7e903ee97df2086bad4", size = 2387400, upload-time = "2026-11-19T12:54:09.832Z" }, + { url = "https://files.pythonhosted.org/packages/a6/36/d7d90c0180f543904bea4b1c2a2464f3fe638d2fa570e001c391e22ce9d7/pydantic_core-2.50.5-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:fa66340c6d3e08a276803812e7665312dfc75dd24eedfa8e09f18a0f8e3e0e8f", size = 2463534, upload-time = "2026-11-19T12:54:11.406Z" }, + { url = "https://files.pythonhosted.org/packages/be/5b/897bf2e3cc5f65dc01507d90323c13cab659c0432cc3c70b353e5be40f2f/pydantic_core-2.50.5-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:470bbc2495367f60d3ca849a8039e4c164701d10637e7743f4427d92651bdb6d", size = 2264846, upload-time = "2026-11-19T12:54:13.244Z" }, + { url = "https://files.pythonhosted.org/packages/4a/85/2646b0e6f74805325dc8582fec6b5fecb289cd54515d25213e6c5b5aef1c/pydantic_core-2.50.5-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:43a6eaee9eeac4a54f2ff6567e1b0ec51651b37a40d862cab2e6fd16109e6528", size = 2264716, upload-time = "2026-11-19T12:54:14.59Z" }, + { url = "https://files.pythonhosted.org/packages/c2/3d/dc7a1ceb248a04047e744b70b8f0d8b3b64eafdd49005b67c4e8447c1b4c/pydantic_core-2.50.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b66f2434c895652ac21c030d5a3a92c7811f0f9b98af41bf35be899c2d34aa4c", size = 2303511, upload-time = "2026-11-19T12:54:16.1Z" }, + { url = "https://files.pythonhosted.org/packages/de/93/8ab4188a5884e6aa8a632b80dbefc60872b1419ed3f69aeceeaa02907b88/pydantic_core-2.50.5-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:2cb80e0323b31d4669c4d72a466d99c885e13deb06205aa079ea6594e7ad1ef8", size = 2474575, upload-time = "2026-11-19T12:54:17.379Z" }, + { url = "https://files.pythonhosted.org/packages/08/b6/697b1f2af3fc0ea26934dc269458d72ef2340797a9dbe60e79ca36a589f9/pydantic_core-2.50.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:3cf575867ecaf89aca440e5a4253d2facf1ca37bab30a4e8c205ec611228126a", size = 2501161, upload-time = "2026-11-19T12:54:18.653Z" }, + { url = "https://files.pythonhosted.org/packages/dc/de/6c5e2096f2f76939f554bdb5ce0892ebaf3aa46e7261815204ae2ec37efe/pydantic_core-2.50.5-cp312-cp312-win32.whl", hash = "sha256:57d4350167130c9c136b7efa35e6e7ee9539779698755b01007834d32c7a1f7d", size = 2125052, upload-time = "2026-11-19T12:54:19.992Z" }, + { url = "https://files.pythonhosted.org/packages/65/9d/666343e8bf3c1540f82e3a7bd1d3a844746e6827889c9b0a68561795e933/pydantic_core-2.50.5-cp312-cp312-win_amd64.whl", hash = "sha256:baa107902f8e38011a5f79836d905eb6bfaac1d4b0bd09fc86509b711d0b09c8", size = 2269672, upload-time = "2026-11-19T12:54:21.23Z" }, + { url = "https://files.pythonhosted.org/packages/db/16/65761cc402edd31a37cf9e91975ea1b230af89f6baeb33d9ef6f01f9f14b/pydantic_core-2.50.5-cp312-cp312-win_arm64.whl", hash = "sha256:2d785ae9ff0ac485567f27f4fc53712268916e04be4a590160e5bf55b096225a", size = 2171863, upload-time = "2026-11-19T12:54:22.86Z" }, + { url = "https://files.pythonhosted.org/packages/60/32/1a87aca62759be630ef981b735d732ffa17ec8defac0271fa7894a815f9c/pydantic_core-2.50.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:e5d5d77a9446f44688a5ef420d92c9facac0865ef5565215db54be184ab7906f", size = 2235184, upload-time = "2026-11-19T12:54:24.697Z" }, + { url = "https://files.pythonhosted.org/packages/6f/8a/53d7448d3e0c3fd8fb30621ef493e5340d6779f80cba2d515fc81915f96e/pydantic_core-2.50.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:639a51931869c0594d8723b2f529c547db1aa33dc9571d001dc205d896170c08", size = 2110593, upload-time = "2026-11-19T12:54:26.231Z" }, + { url = "https://files.pythonhosted.org/packages/ac/66/fa127513da383218051a4e7c76ec63b42eb0b073d010d94215f930fa9a4d/pydantic_core-2.50.5-cp313-cp313-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:c69eb2e09d2830949e6e8f395d4eb8c714ba083213ccff64932ded681fe69a4e", size = 2261527, upload-time = "2026-11-19T12:54:27.79Z" }, + { url = "https://files.pythonhosted.org/packages/e8/35/70928b77f724fa0f4824e0527891df02cf9b34101aab6e2ab348fd127f06/pydantic_core-2.50.5-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8bbe282e79dc71b24ba7be284eacf27c8ddff8f26911e2030a0dd123c6aed326", size = 2131539, upload-time = "2026-11-19T12:54:29.441Z" }, + { url = "https://files.pythonhosted.org/packages/e3/e0/7d03f6521da1cb43de3fa2c1740e7d0e0d34f971acdd5f6c6462d360f195/pydantic_core-2.50.5-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:43917f090dfda561575a72f75814f76a0680964b70d7b44c84e44d217bdeade7", size = 2197447, upload-time = "2026-11-19T12:54:31.007Z" }, + { url = "https://files.pythonhosted.org/packages/b9/57/bacad2d6251565b1b428383175f0b7edcb841d96e37130a85e87636ecb15/pydantic_core-2.50.5-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:93ee3b4f9c64fb1c39892413c4196d0a84790a7e0e5d72b463882c432c1ffafe", size = 2387397, upload-time = "2026-11-19T12:54:32.779Z" }, + { url = "https://files.pythonhosted.org/packages/fb/f7/95e23d389b7bd796127f783950aeaee408ffea4d77d165cdce2c3f3b5638/pydantic_core-2.50.5-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:57b79401d870c9df395799c596d81875b647ecf3030129d86659a54f6bfcc0db", size = 2463652, upload-time = "2026-11-19T12:54:34.303Z" }, + { url = "https://files.pythonhosted.org/packages/13/c2/62015187d0e986dafc530ea4df390fce3d3379c744959148806668d40ab9/pydantic_core-2.50.5-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:cbfde3ad127786f1dea1a6cd89a5eb824a16203f24743ad2b4e07506f43bc844", size = 2264332, upload-time = "2026-11-19T12:54:35.918Z" }, + { url = "https://files.pythonhosted.org/packages/73/22/e4421a2018ee909a5e0cfd4410ed88d12481e31fe37abe272bc392f74675/pydantic_core-2.50.5-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:1793ec63c8f247131aa4dfc8c4da645b9c5872cf26b53ce240f143f59ad116e4", size = 2264563, upload-time = "2026-11-19T12:54:37.356Z" }, + { url = "https://files.pythonhosted.org/packages/28/a0/3cd863a51470341405579257cc84d4df2e70ddb5ed17160859687868cc9d/pydantic_core-2.50.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:5027c263fbceb821cfb4b385d36d485e19efca1d9adcc4e5bec69c04ca3cdc83", size = 2302938, upload-time = "2026-11-19T12:54:38.777Z" }, + { url = "https://files.pythonhosted.org/packages/c6/50/0b71fafde186b95a7a9fd704ef5dfd7c28b2b9a4645449912267c7457884/pydantic_core-2.50.5-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:dac78f91e263c4c9a4d587b9d97b3b5b2561293b33247452cc3cfe5b500e8cfb", size = 2473911, upload-time = "2026-11-19T12:54:40.3Z" }, + { url = "https://files.pythonhosted.org/packages/6b/8f/0106ea256e51e9b0d21c8aa7b32091d5f8869597282c5c09a7144f2208bc/pydantic_core-2.50.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:b9348cfd798b8199d34da5258becf2fc8f5e4e7a3b51da30c34b81b996a07b34", size = 2501611, upload-time = "2026-11-19T12:54:41.758Z" }, + { url = "https://files.pythonhosted.org/packages/da/b8/d3923395ada2e5738eaa985e2d9c623cb00f6687f94565a2abc0ddf573f8/pydantic_core-2.50.5-cp313-cp313-win32.whl", hash = "sha256:22f5f0c37251611191a55e801a5150aa21f348fa10eac8eac9fa43c29937a7b1", size = 2125035, upload-time = "2026-11-19T12:54:43.281Z" }, + { url = "https://files.pythonhosted.org/packages/7b/08/2759efbffc5643787a5a0a6e19b98805d102346a8e52ad2a181a92bd55ea/pydantic_core-2.50.5-cp313-cp313-win_amd64.whl", hash = "sha256:d34c0d4dd4a318f2be788a60a972c3a1ed5da0155a7c06d6dd810dc5d60ad704", size = 2268229, upload-time = "2026-11-19T12:54:44.905Z" }, + { url = "https://files.pythonhosted.org/packages/c7/18/b4491f24c42f6d31b149d30c2b1bb5a062e3a79ee626cc0aa2161e86eb5a/pydantic_core-2.50.5-cp313-cp313-win_arm64.whl", hash = "sha256:cbec4aad328be58961c738b83fc2c7bd993242d2366f949d914e8c09266dee0e", size = 2172693, upload-time = "2026-11-19T12:54:46.368Z" }, + { url = "https://files.pythonhosted.org/packages/91/86/570c4fedb8eeab9062032bc45875490090477fddce932328a20b9cb834ff/pydantic_core-2.50.5-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:00598ae680c6e4a17cda01910e49c0da8ce15610505e6c57cec3f15d83daef88", size = 2239820, upload-time = "2026-11-19T12:54:47.806Z" }, + { url = "https://files.pythonhosted.org/packages/5b/a6/5bc38ad74a5705bcfdf1fd4e2009a62638a45dc246e3b0fc8a86e8c9ff4b/pydantic_core-2.50.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:e8fe516a4b3b06e4ff83b9adee4a786d28a617e5fb5fe90bda49fb6f52a5ac19", size = 2111039, upload-time = "2026-11-19T12:54:49.244Z" }, + { url = "https://files.pythonhosted.org/packages/d8/b5/a494d5d4ffd2dc1b06f1572d7651a4d6ada7881c5a527930be8f0171fc34/pydantic_core-2.50.5-cp314-cp314-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:63a0ba0d7ccf37c8c724bb7ed13c3aa0aa4c743f4f5f376c92c47e584844c7b1", size = 2264771, upload-time = "2026-11-19T12:54:50.701Z" }, + { url = "https://files.pythonhosted.org/packages/cc/13/099f19c4be6dbe10e327b17447e137ebd679cc64a3833a87f4597dcffc2a/pydantic_core-2.50.5-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:27bc22dc8d50335bc62296261a7dc4c2572149910ba7c274ef0f945b5be0d570", size = 2133839, upload-time = "2026-11-19T12:54:52.33Z" }, + { url = "https://files.pythonhosted.org/packages/10/4c/9eec8f71877124a093a0fc0033747489ea7e18d364ec562a7d170c483f4f/pydantic_core-2.50.5-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:2f6a8c9b8647378c0dc128805e6b98da39d36019a0e7cac134badeaedb14f849", size = 2200176, upload-time = "2026-11-19T12:54:53.745Z" }, + { url = "https://files.pythonhosted.org/packages/51/45/79ed6028c3e19a5376057da8545977d6f74d37afccdeb684ee7274d05994/pydantic_core-2.50.5-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:feb8c87dbc4684777ddafbf37c922d9e2748272ba61e362ebf85db73ebda6234", size = 2393117, upload-time = "2026-11-19T12:54:55.28Z" }, + { url = "https://files.pythonhosted.org/packages/c6/cc/0b9d5b6652e55cbe6d2eb5c56947bb19c106be388157a410847362b2fd8e/pydantic_core-2.50.5-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:e0a7ae307b4e1eff195cd23a757da07f70a115e45175039caf5f3979a20c7edb", size = 2469324, upload-time = "2026-11-19T12:54:56.758Z" }, + { url = "https://files.pythonhosted.org/packages/79/e3/df03dc4e10c460d37dad8921ec9c6f177bc33d4f2da808d5ae4d8f11acfe/pydantic_core-2.50.5-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:88b543705849d0c59343f97c38296dbf59eb7b3c9565bd4fe1ed638ba38da5ed", size = 2269323, upload-time = "2026-11-19T12:54:58.209Z" }, + { url = "https://files.pythonhosted.org/packages/d5/28/4779dd7ba7f2187222c4ee42f492a451d3425202fdd2b5970b701feab16c/pydantic_core-2.50.5-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:4ae5c9f84dfa43643d10328a212f709c7602c5e70df376d217ae5770d374ccd9", size = 2271462, upload-time = "2026-11-19T12:54:59.719Z" }, + { url = "https://files.pythonhosted.org/packages/0c/48/51f4d0d26e36341330a933c9c5660696023101a0e933552dbc00db49b1cd/pydantic_core-2.50.5-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:922455cc5baddb0f2c82b7ba649e57e89183442b32fe512670db6ebb9b66b251", size = 2305488, upload-time = "2026-11-19T12:55:01.168Z" }, + { url = "https://files.pythonhosted.org/packages/53/53/17892228fd2e66aa2791f97f984bdd34081c1d6ec98997c8e5b8467d04c3/pydantic_core-2.50.5-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:aa69eaeed433cfe5de809fb84c95536a5aed991b28290d0db059fe6766c69274", size = 2475854, upload-time = "2026-11-19T12:55:02.687Z" }, + { url = "https://files.pythonhosted.org/packages/58/11/c4daab94156b26f779aca920b710138dda04882f295f7e802f237da1082d/pydantic_core-2.50.5-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:9f2bf218dbc93363fe3e31cc53d36db8d6ff4122179406bec05f33bb79c0e2c1", size = 2505669, upload-time = "2026-11-19T12:55:04.137Z" }, + { url = "https://files.pythonhosted.org/packages/83/47/375ab34f3907a0f40cebe2c3cea3e2c25dcf58e0f591991b85604b7258fc/pydantic_core-2.50.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:b2910ec0fa5aeb9bef70156f2b79f4783978fdcfaa7b2f1b5d1814458d2e79a1", size = 1496394, upload-time = "2026-11-19T12:55:05.468Z" }, + { url = "https://files.pythonhosted.org/packages/48/e7/e64fa77d1d335ad21d821adbe3d2590b9d7cc05d210ca11fa524a1c6902d/pydantic_core-2.50.5-cp314-cp314-win32.whl", hash = "sha256:1deb966176b1b66be4281c83f10a0b6b1cecedeb25f53ee894bf27b22376facd", size = 2128110, upload-time = "2026-11-19T12:55:06.797Z" }, + { url = "https://files.pythonhosted.org/packages/bd/da/feb489c6252364355d1f314a284a542cd6788cebe83f9507d4af81c95f4a/pydantic_core-2.50.5-cp314-cp314-win_amd64.whl", hash = "sha256:887424ba7c2145e97f131bc2cc73383a8c464d7bcd56eb98bbd941afb6868b95", size = 2278977, upload-time = "2026-11-19T12:55:08.188Z" }, + { url = "https://files.pythonhosted.org/packages/cd/81/a3bc7bee867be70ec58b3ef3d84e88420fc2d6fd52a8830a3f3a75f0891e/pydantic_core-2.50.5-cp314-cp314-win_arm64.whl", hash = "sha256:e7dd59f498ef42077f22db607571249db41997227018cb84644ba0059f8b5719", size = 2169842, upload-time = "2026-11-19T12:55:09.474Z" }, + { url = "https://files.pythonhosted.org/packages/2d/18/24bc9decf37a81ed5ab979a19ac0a23b457633d525e2c71d4b96476b1bf9/pydantic_core-2.50.5-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:372f4ab3e67b2387871950cfa27d94d644c3475e650836ea52e25c2e4fbd7975", size = 2227397, upload-time = "2026-11-19T12:55:11.022Z" }, + { url = "https://files.pythonhosted.org/packages/46/4f/d958789f577f91af3c9639e6c127cd729be7117d6318fcfa4b773e3bb220/pydantic_core-2.50.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0c9f0002e4ec37db931e4ee8b7dafab2c7288ef66354e74fe16484e60eac6616", size = 2091300, upload-time = "2026-11-19T12:55:12.395Z" }, + { url = "https://files.pythonhosted.org/packages/16/86/b2f630ebb50c18df1603a3d2b03b4722005c27dd4a54e3291b302dcaa54a/pydantic_core-2.50.5-cp314-cp314t-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:d16cb794449c2bc0e5cb0ab0022813419bf5283266f2a7ff1fc54e5c6e27dcee", size = 2277674, upload-time = "2026-11-19T12:55:13.728Z" }, + { url = "https://files.pythonhosted.org/packages/91/8e/06b5d2da6c7bd8e817edd1dcce595a904ef295e66f1e243cc768ccfcaa41/pydantic_core-2.50.5-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:71633f82d51d4796a48026bd6eca5ec83e4a0edbe6187d59bbc45ace1111ebae", size = 2116208, upload-time = "2026-11-19T12:55:14.971Z" }, + { url = "https://files.pythonhosted.org/packages/40/0e/b818e7903883e6e51d10fd6ec43d2837cdea3861571d050942ff5d873327/pydantic_core-2.50.5-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:f20c692c599ebac7f04f3a0102b969f3f9d6667ffe1e72629fc7fbf8b6375234", size = 2210100, upload-time = "2026-11-19T12:55:16.308Z" }, + { url = "https://files.pythonhosted.org/packages/d0/aa/8c062145581453ac1b0fb3577ec193926b8973dc4b990283c304a955d80b/pydantic_core-2.50.5-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:2f0a86887c644247eff4cc7b9e609042a49833dcd72f84574e7b8beea89729ab", size = 2410440, upload-time = "2026-11-19T12:55:17.611Z" }, + { url = "https://files.pythonhosted.org/packages/18/08/a4782611257ce1a85d194348a011dea09f0bf6344b28b8f8fee6c501b8a9/pydantic_core-2.50.5-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:655d0cc2ddbc3fb1f4f8a8e3724552ee2ba6b8561289e9e6e06186982b27bceb", size = 2474759, upload-time = "2026-11-19T12:55:18.847Z" }, + { url = "https://files.pythonhosted.org/packages/48/64/6391407d76fdd16b43c0e377998f38142b433e2f28325764bcea37e8b1e5/pydantic_core-2.50.5-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1d53befcfd415bd9212e685372c825e62f29b83820db78512c9d3659f13d29e9", size = 2264144, upload-time = "2026-11-19T12:55:20.163Z" }, + { url = "https://files.pythonhosted.org/packages/a5/d3/54c432da68129a4e5b9d83f01fc0359b87abb72929fd0ed19f208fb72889/pydantic_core-2.50.5-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:5f33c92da4aa5714fb6fcb086358274598e8ff62b6607afd132a38657aa64f02", size = 2267290, upload-time = "2026-11-19T12:55:21.551Z" }, + { url = "https://files.pythonhosted.org/packages/18/b9/4f1fb301cf4ea6c325da205e82887260e71a780ac21b2f0baf837b82c0cd/pydantic_core-2.50.5-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:3129b52ee2861d0270db8bd140fc9b53ee9821247ca47fda2613a899ce9a1ea3", size = 2308710, upload-time = "2026-11-19T12:55:22.858Z" }, + { url = "https://files.pythonhosted.org/packages/eb/a2/423f7defa257419098f186ad3c4bd5e7e983956d8ff7c3e65582a70a6835/pydantic_core-2.50.5-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:041f4730fa7a8bf975e88436d439bdc72f3f16e584a470ffbe47392628d99de6", size = 2485824, upload-time = "2026-11-19T12:55:24.175Z" }, + { url = "https://files.pythonhosted.org/packages/ce/7f/3b9148a4d9df1a8f682b3dc7cd70b8855e0e3b27ce49180aa7dd18f164a3/pydantic_core-2.50.5-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:48b5deaaee4f1b99603173cd291127523e43ee9f51db58c7ff98d16dc5c6fc93", size = 2518300, upload-time = "2026-11-19T12:55:25.422Z" }, + { url = "https://files.pythonhosted.org/packages/52/f4/ff11826851f17477e6e0ac28da74dcabb9d5848db450fd67bfddfc147f89/pydantic_core-2.50.5-cp314-cp314t-win32.whl", hash = "sha256:8c7244134b93ce028e9166c1b5d3e4537349307ccf3e65d746b4c6b1bbed8c89", size = 2107419, upload-time = "2026-11-19T12:55:27.203Z" }, + { url = "https://files.pythonhosted.org/packages/8b/6c/41c3e9f11befcb6fe576e95703d2d8d9dde3f3fa0de5e4c432d60644aeed/pydantic_core-2.50.5-cp314-cp314t-win_amd64.whl", hash = "sha256:159f6bc1b616e0ca0938eb568d87ca03c633d6f06306ac47b9c3e5dd8c14d39a", size = 2246337, upload-time = "2026-11-19T12:55:28.704Z" }, + { url = "https://files.pythonhosted.org/packages/b6/98/ae8e3f2182a0ddf5f868b4e7830032d9b0ff34cbdd64549bb0b57a2e52c4/pydantic_core-2.50.5-cp314-cp314t-win_arm64.whl", hash = "sha256:5274f8314ce3be1df07ae8ebceeb97a73b8409d842fd7677c5d0a85a68793ec1", size = 2174036, upload-time = "2026-11-19T12:55:30.029Z" }, + { url = "https://files.pythonhosted.org/packages/34/7c/7ab4dd1eaad75d20c596a4b2a36961a98f344aa0bad2938edbe644214baa/pydantic_core-2.50.5-cp315-cp315-macosx_10_12_x86_64.whl", hash = "sha256:c4c4313dc66f45822b3d7f39aa74e59e7987cf7572b3309005b26d956a0098a9", size = 2245524, upload-time = "2026-11-19T12:55:31.444Z" }, + { url = "https://files.pythonhosted.org/packages/ac/29/2cc2423f489d4526825d2371d047de505760260462eb72d838fc5e934aca/pydantic_core-2.50.5-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:e93587aaa5660536b9188686e8fe0544b577ec57d896d424b5b2118b151a6845", size = 2116389, upload-time = "2026-11-19T12:55:32.66Z" }, + { url = "https://files.pythonhosted.org/packages/b5/f7/f7fdfbb6ccacf4ef3a4757eab9ecb9d5809b2568bf38e8f41b1872524f23/pydantic_core-2.50.5-cp315-cp315-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:0a7d599d0c5afbab98c0e4441f5b76163c6fcfd2ecf73dd6418e468a7ac452b8", size = 2266368, upload-time = "2026-11-19T12:55:34.366Z" }, + { url = "https://files.pythonhosted.org/packages/91/3f/8d12c17b4a55097c164759b38136bbd2abe3f2668f0d908fd3d0d4a7e0fd/pydantic_core-2.50.5-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:568e928322f0b6b94671fc1a4dbc867627af74695b0c060ac6d4f25b6a7425d8", size = 2138673, upload-time = "2026-11-19T12:55:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c0/54c3746f13409b9674f812cd37c98da25df970d030d9260e9e904205893c/pydantic_core-2.50.5-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:bdafd6b05bf012772b7d7325a98d26f19b7918e21dabdd5970c885262245aae3", size = 2203145, upload-time = "2026-11-19T12:55:37.366Z" }, + { url = "https://files.pythonhosted.org/packages/79/3a/91f0e7ffc5626a673804fdd33a007186c06352020199653e3df4b5a43ad5/pydantic_core-2.50.5-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:008de9d97f2b0c8e596fb5d93d49b63be158e8be5ac35856903b338cbcfd21f3", size = 2397558, upload-time = "2026-11-19T12:55:38.615Z" }, + { url = "https://files.pythonhosted.org/packages/a6/51/bc916df37f46f77d5159e4a438033702bdbde47814dd407e97fb1aef6fb1/pydantic_core-2.50.5-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:f8fd7e9c44bb4c9214d41c3bef79cba5a513b29c3bcbfdaaf0440ca6f5fb65ea", size = 2478927, upload-time = "2026-11-19T12:55:39.847Z" }, + { url = "https://files.pythonhosted.org/packages/e9/8f/a8f56878763b6fdeca69b73d9b4c44aa4526bfa6a386da21792ed0b766ce/pydantic_core-2.50.5-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0d6e614776c8c99495dcfc6ce8f826277fb4388a5e5cbee23c199cbe39e6dcb3", size = 2276148, upload-time = "2026-11-19T12:55:41.379Z" }, + { url = "https://files.pythonhosted.org/packages/a5/bf/2c28071bb81fe07595ca8d08011ea1005bae92d2b0cb43ce768a135105e0/pydantic_core-2.50.5-cp315-cp315-manylinux_2_31_riscv64.whl", hash = "sha256:bcd9d9b38e61dfd43e00f621ce00da2ffed35047fad532c4afcadf4f9ca0d672", size = 2279590, upload-time = "2026-11-19T12:55:42.856Z" }, + { url = "https://files.pythonhosted.org/packages/62/d9/905d95bdb65ce24ca27149796fba3869db2bed08e0688c8dbe863d916b56/pydantic_core-2.50.5-cp315-cp315-musllinux_1_1_aarch64.whl", hash = "sha256:4888829471cd8d85c096ef0e1f41a066c7d76e88309a4fbff4069f70d07673be", size = 2310233, upload-time = "2026-11-19T12:55:44.114Z" }, + { url = "https://files.pythonhosted.org/packages/08/d0/6d63888afef31cda359ba122d768ae83c59213afc3cde4a528a67f4e7d80/pydantic_core-2.50.5-cp315-cp315-musllinux_1_1_armv7l.whl", hash = "sha256:ad0e0221deec2a2385300d76b9259da7036c0ed784502c154ae237dafd67605f", size = 2478319, upload-time = "2026-11-19T12:55:45.299Z" }, + { url = "https://files.pythonhosted.org/packages/33/f6/de8de17435f95dd8ad0db86d74beea9195cfbfce5434946a0bb53e025be5/pydantic_core-2.50.5-cp315-cp315-musllinux_1_1_x86_64.whl", hash = "sha256:20337f547d79911457cd4739bb6699213a53089f946af87633a48fad3f74f5e1", size = 2508289, upload-time = "2026-11-19T12:55:46.634Z" }, + { url = "https://files.pythonhosted.org/packages/f4/39/aae7e3187162752675094b970cb6294bf10ba091f33eebc35376d1b3f0aa/pydantic_core-2.50.5-cp315-cp315-win32.whl", hash = "sha256:09c732c097816c89d46ddb70f89d72e853e3a1bbac6475961c60a88aad9fe612", size = 2131982, upload-time = "2026-11-19T12:55:47.819Z" }, + { url = "https://files.pythonhosted.org/packages/c6/81/abd633f5fafcb06991a311293b37783ea3ea0b23c11845282bf24d7ddab8/pydantic_core-2.50.5-cp315-cp315-win_amd64.whl", hash = "sha256:0d4edc3350e21e0ef773ef9395227ca072832f05e484cadcf4d8663b63a231c0", size = 2285739, upload-time = "2026-11-19T12:55:49.198Z" }, + { url = "https://files.pythonhosted.org/packages/69/6c/0b678e369c45edf0e47b4ceefcb9ac86cf81d7440ad780c384dfeddf7eff/pydantic_core-2.50.5-cp315-cp315-win_arm64.whl", hash = "sha256:af453c0c20372ca8acf3c46de2a89b242491853dc61d0171ba24608d33310e09", size = 2176798, upload-time = "2026-11-19T12:55:50.779Z" }, + { url = "https://files.pythonhosted.org/packages/4e/f2/9907ab2bb673ae2f4ccb6b026e201a5d38cbf9a4f109050b681b8aebf7e9/pydantic_core-2.50.5-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:9e255e7c32d9c2f396d3daa833e7d8d701eec7bf8e13ca092b4b83ce7d9487fd", size = 2235810, upload-time = "2026-11-19T12:55:52.04Z" }, + { url = "https://files.pythonhosted.org/packages/65/c4/caa101ff8599aedb41816c987f44bd7c9d8d5ae42740589da1cf60ce4545/pydantic_core-2.50.5-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c334b8759496f9e597b68e1309b2fb3d824fd24a29e562afa86b61005eb9d54d", size = 2094628, upload-time = "2026-11-19T12:55:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/91/34/253060ed9f5df44edc3632261b0a457407935b3454dfd40230f5a60f6503/pydantic_core-2.50.5-cp315-cp315t-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:90dabbf4f38f37de1663ce932d37c6f694a005f6470ae2f0d97755d9e3f90ffd", size = 2275436, upload-time = "2026-11-19T12:55:55.061Z" }, + { url = "https://files.pythonhosted.org/packages/9f/bb/2c0b69f1959370f21abb84751c1ef42d73edad84ee6ed67975e6ca6aa194/pydantic_core-2.50.5-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5ec2e8caf5eadea7be683fc7025d60563e920f1f52fe18ae46c49558e67b8cd0", size = 2118960, upload-time = "2026-11-19T12:55:56.573Z" }, + { url = "https://files.pythonhosted.org/packages/3f/74/f6c32d48da403d63fd8860af73c2edf7f0b05346078fa7d3fa7b9af59492/pydantic_core-2.50.5-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.whl", hash = "sha256:44e6c35bf3a9b6785db0c083df8a6929343f9c8fc27186991d21653242c77c19", size = 2204816, upload-time = "2026-11-19T12:55:57.807Z" }, + { url = "https://files.pythonhosted.org/packages/fb/10/a2cb0da341bd09c2d102d50f126827fe79d78611526f8d26c55e1d9e13a5/pydantic_core-2.50.5-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f33be114a0ee27870cffd31057ed60bf5a0cd522dcbdc1dda0bdad70f8302cb0", size = 2420693, upload-time = "2026-11-19T12:55:59.129Z" }, + { url = "https://files.pythonhosted.org/packages/40/31/f8c0ab3f77fb4e348ff818f49f272d2f833aadd3478de4919ccfce10736e/pydantic_core-2.50.5-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:12178e58af383bd4c32b2fe141188bc7e540c5eb33ad550856fa5863b4c31bd5", size = 2482316, upload-time = "2026-11-19T12:56:00.438Z" }, + { url = "https://files.pythonhosted.org/packages/82/fc/134b0a1a06971c84f2a3bc6e1123cac9c3d58e8a67b6ef951a0b97f160d1/pydantic_core-2.50.5-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:679f15dd3bd2a82bde350ec8c94c0f8f05f05dba39fb3464cd4136a724da9844", size = 2268676, upload-time = "2026-11-19T12:56:01.985Z" }, + { url = "https://files.pythonhosted.org/packages/7b/c0/b5f34860606866a918cd934172b24fd6069ffbac13179635f65ca3516aea/pydantic_core-2.50.5-cp315-cp315t-manylinux_2_31_riscv64.whl", hash = "sha256:11806d9b4888f1645d74fc24237f21dad559b42fb8930481b3df414997be6ee5", size = 2276349, upload-time = "2026-11-19T12:56:03.265Z" }, + { url = "https://files.pythonhosted.org/packages/7a/6c/728833b2c94a446f0bfcb5fc82e039aa6da648fdcd925aa8b612e66e142c/pydantic_core-2.50.5-cp315-cp315t-musllinux_1_1_aarch64.whl", hash = "sha256:b43115385de7db83bd2fe7a08dea8580bce3acc3f54200c4f4fe32a4a49688d4", size = 2320015, upload-time = "2026-11-19T12:56:04.519Z" }, + { url = "https://files.pythonhosted.org/packages/4b/c6/c9a9c08eb46517a2028d40cf6cd58674c82ba0912e172ed7a37362e1219c/pydantic_core-2.50.5-cp315-cp315t-musllinux_1_1_armv7l.whl", hash = "sha256:86bd5aad5ccbaced98139d08b4314f253c086897830f4bcf9c1d1f02f740683d", size = 2480855, upload-time = "2026-11-19T12:56:05.809Z" }, + { url = "https://files.pythonhosted.org/packages/4b/e4/7cdac28f4e0b587d66ef34ec5a0e3114ed8a383db958122495d85c03377a/pydantic_core-2.50.5-cp315-cp315t-musllinux_1_1_x86_64.whl", hash = "sha256:90ff55049623eccbfa997332e2b91358dc2c4c30ca6e664b45438723cbe181df", size = 2525363, upload-time = "2026-11-19T12:56:07.301Z" }, + { url = "https://files.pythonhosted.org/packages/82/99/70305ab96334631da7cf3b20de4ea433589a5a022b28b9a3a0cc1c08b435/pydantic_core-2.50.5-cp315-cp315t-win32.whl", hash = "sha256:7c3faea08d44b4a7b57b30f1113e6404e6aa62a4f3489a22359fb27d6003d8b1", size = 2114429, upload-time = "2026-11-19T12:56:08.521Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f2/98c0c74b43877bad2aa16332498626b375ff63d4e5f85c4d09b08d14f861/pydantic_core-2.50.5-cp315-cp315t-win_amd64.whl", hash = "sha256:b2b64d3204f9c33f03ed3111eb754902ea76ca5aa61ab4b2bdf9f767a4a1f279", size = 2251995, upload-time = "2026-11-19T12:56:09.711Z" }, + { url = "https://files.pythonhosted.org/packages/70/17/8ead84e326315b8c99165f3388ccc2b2355a4a2c8bdcba4b9241823dc064/pydantic_core-2.50.5-cp315-cp315t-win_arm64.whl", hash = "sha256:8ba2dcbeea0ab8836e804c54e905075125c702cf78e592d998eecf2764b64144", size = 2185080, upload-time = "2026-11-19T12:56:10.948Z" }, + { url = "https://files.pythonhosted.org/packages/28/f0/9d804817a9c0d599c43fbf20cf6e7e8c196c97962f85c4f63a58fe7c227b/pydantic_core-2.50.5-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:68334f281460fb2a85bbb9e2545438bf2fd2c9a166823a60b84541a3c8f2d2e0", size = 2216148, upload-time = "2026-11-19T12:56:12.439Z" }, + { url = "https://files.pythonhosted.org/packages/27/45/1cba006b06e017732c40960bce5bd7a17ec4fc6f49bea40435517e3124a4/pydantic_core-2.50.5-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:851a78a30265bb203186fd0e19712c1a4431083eb5a1e1715f758a029cd8aa6e", size = 2053985, upload-time = "2026-11-19T12:56:13.736Z" }, + { url = "https://files.pythonhosted.org/packages/87/35/0ce9aae400887cfe1d2699f53542cf5ae25bb8ce6c26a84f1b007f653165/pydantic_core-2.50.5-graalpy312-graalpy250_312_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:47f4d79fe4876feace216a5b2263c40d792476b4a6508c38d66a2facd3f1f4cc", size = 2125321, upload-time = "2026-11-19T12:56:14.973Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d1/a720b66b4e13e0b5623370bd71b1e376a193d92e20e7dbef7748678c00df/pydantic_core-2.50.5-graalpy312-graalpy250_312_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98b92dad690e6578cc0b504eda53d53adaa4f34bd09c97a547a957e419544eb7", size = 2283625, upload-time = "2026-11-19T12:56:16.458Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1d/0e2d5bb47dc729ddf21fb846cb1ac85baf6290eca5ef1ee3d871712496f4/pydantic_core-2.50.5-graalpy313-graalpy253_313_native-macosx_11_0_arm64.whl", hash = "sha256:d7826407ed74ff8e6cc6e6df7ffbf180e9b449ab1516f28eb5f6e2a489bc5129", size = 2054207, upload-time = "2026-11-19T12:56:17.916Z" }, + { url = "https://files.pythonhosted.org/packages/59/61/f1b75d2dffa662c4326adc6b16881f98158717cfd461936c2f0c36d9d1c8/pydantic_core-2.50.5-graalpy313-graalpy253_313_native-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c415a8da7c89a3dd32d988a9117bf0a52371769b77b0943bcfd50b281ecefb8d", size = 2125491, upload-time = "2026-11-19T12:56:19.202Z" }, + { url = "https://files.pythonhosted.org/packages/e5/78/104a8c414f58132acaa6b2ce4cc3441b8cc556df0f7fcc9ca8c07473f17a/pydantic_core-2.50.5-graalpy313-graalpy253_313_native-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ea7429e3adb2f2fd81e2d6e8942e5c1cd760a6e6be5b7574d2ee5499b5e19e67", size = 2284742, upload-time = "2026-11-19T12:56:20.825Z" }, + { url = "https://files.pythonhosted.org/packages/c6/fa/9cb4e5a3de7bd4444746cc8013b9e2e4c418ca231e5030d08b19ff951623/pydantic_core-2.50.5-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ea215f7f5d2df866e3b5448c0bbb4a35285086ac6ab18687796704cbd5f2c5a3", size = 2170574, upload-time = "2026-11-19T12:56:22.059Z" }, + { url = "https://files.pythonhosted.org/packages/41/f7/288ed9853187c415adf6145351ffbb43a00fd778901a9932675f9c93bb8a/pydantic_core-2.50.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:4ac243e358837f62d085f07b98625fa3831abdb28e8f77196934345bbff0fb0b", size = 2091109, upload-time = "2026-11-19T12:56:23.3Z" }, + { url = "https://files.pythonhosted.org/packages/58/3a/fe47e18113c6f194202a27b1f307db8ff17bad527f7edecea13da6be21d4/pydantic_core-2.50.5-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_5_i686.whl", hash = "sha256:d3ada66d0601feeeba504a6daac73e47ed164357e46930366f135c4121594d53", size = 2288892, upload-time = "2026-11-19T12:56:24.647Z" }, + { url = "https://files.pythonhosted.org/packages/60/30/b335f56abe44aea1f78e80742eb160e17835069c71af5d7488ae7ca2aaf1/pydantic_core-2.50.5-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0dd037d96e98f6db8b69a44ab7d5c20a07fb0a2051775746a9e1b5fc8f52867f", size = 2281693, upload-time = "2026-11-19T12:56:25.898Z" }, + { url = "https://files.pythonhosted.org/packages/d5/07/4db8ee1ed1837344e288cb5b999d9734410617ba6fde93485ec529c751b7/pydantic_core-2.50.5-pp311-pypy311_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3f800fc0f304f3b0e09d07d4287f9f0bc9bfe5319d1d7cabeaf265737c516083", size = 2301333, upload-time = "2026-11-19T12:56:27.362Z" }, + { url = "https://files.pythonhosted.org/packages/a9/d7/31f5d05507b9f851693188965cd31925192f20cffb662c091c07db6b4ed2/pydantic_core-2.50.5-pp311-pypy311_pp73-musllinux_1_1_armv7l.whl", hash = "sha256:a5f6622451fa3cd71c8ff15df24307cb3f8b5dc35a723de281646c34872d7179", size = 2471021, upload-time = "2026-11-19T12:56:28.797Z" }, + { url = "https://files.pythonhosted.org/packages/34/ce/5075d634804891e31f52c8cfc419a6b11bf60be84937b68cffceb077fec2/pydantic_core-2.50.5-pp311-pypy311_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:2f5f29ff80ce0cf93102198cddebdbb3411881de177359c770e5c9c99495a6b3", size = 2506558, upload-time = "2026-11-19T12:56:30.267Z" }, + { url = "https://files.pythonhosted.org/packages/c3/66/a6fa0aa7f5b6a3f9acdee809f1f05a36a27668cc00fc57dc936e2a6db0a5/pydantic_core-2.50.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:6a069ceeca397bd8da2e8ef6383595c63ea17de37d5f2d5cde729bdc0dfe6774", size = 2339507, upload-time = "2026-11-19T12:56:31.581Z" }, + { url = "https://files.pythonhosted.org/packages/c6/51/7ee80cc035e5d3503cea953c9edb8f90dd453cec154abb94079399138f45/pydantic_core-2.50.5-pp311-pypy311_pp80-macosx_10_12_x86_64.whl", hash = "sha256:e8faa73de2e9231f604cfa44c471d0986e7e9c45129d7888839a34196e46a7df", size = 2170571, upload-time = "2026-11-19T12:56:32.864Z" }, + { url = "https://files.pythonhosted.org/packages/85/4c/9c4e2eff5ab28816b5ab3d615d193294f80a945671cb4e2daa16cd0dd6c8/pydantic_core-2.50.5-pp311-pypy311_pp80-macosx_11_0_arm64.whl", hash = "sha256:ef461e9299ae665fab67c6f054847178b8fd510da10b4ef745a074b922efbf0a", size = 2091110, upload-time = "2026-11-19T12:56:34.328Z" }, + { url = "https://files.pythonhosted.org/packages/a5/38/f0790736e0baf5307b473d123555af947d9bedec509726db5e670c09cd76/pydantic_core-2.50.5-pp311-pypy311_pp80-manylinux_2_28_x86_64.whl", hash = "sha256:1f22c36d952f33bac936273ca0be115693a1d7c1c9496ca7d699e6a338656d6e", size = 2282074, upload-time = "2026-11-19T12:56:35.597Z" }, + { url = "https://files.pythonhosted.org/packages/78/85/8c9120a1910ace8990fdfecbf9beb785e7d642fff94281df2df2b5735a16/pydantic_core-2.50.5-pp311-pypy311_pp80-win_amd64.whl", hash = "sha256:b6f48c4bf1c77ace644b125f168418438fbc9b8e4c3b290915cc7d055d83c8b1", size = 2339507, upload-time = "2026-11-19T12:56:36.826Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.2.0" +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/79/42/bb4641652e58dedeac2ec51abc1f8cae4fee4ec63899a0999016229a0f2a/pytest-9.2.0.tar.gz", hash = "sha256:97c4f3b1f3c7414aa36465e09b8220f1d03627993bd51b1282e193753c80557b", size = 1797555, upload-time = "2026-10-27T21:30:20.728Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/39/1f5d8c8877a0fa327db959c19341d4be61660de1ab6b7391f9eb805bcd67/pytest-9.2.0-py3-none-any.whl", hash = "sha256:07acdcf88ec174f907dc01af70bf52d49b014bbab03faeeade31c96b18c2e588", size = 411776, upload-time = "2026-10-27T21:30:19.131Z" }, +] + +[[package]] +name = "pytest-asyncio" +version = "1.5.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/2c/de/80724f9b5b9eca1a654179cae6edc51aaa0a355a9834a736e2a188b91780/pytest_asyncio-1.5.0.tar.gz", hash = "sha256:92c8fa83ca419fd0d4bd6a34df6520dae435841d3733c319343249492adf37f7", size = 146227, upload-time = "2026-11-12T16:35:49.845Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/2d/e600d8f47597a803641704aba367c7266cd621f86561ec36da9888f160ec/pytest_asyncio-1.5.0-py3-none-any.whl", hash = "sha256:557f255ee03cc84f84a8d5f438bc9c6e0f714bf86970ae743c7ecb5a38d7e07d", size = 17215, upload-time = "2026-11-12T16:35:48.446Z" }, +] + +[[package]] +name = "python-discovery" +version = "1.9.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cb/4e/20a9c45c4bb839e6e03e5971a546c623d12f950aa496cf344dc8e9f07167/python_discovery-1.9.6.tar.gz", hash = "sha256:383aa67858d73a9585a843a37a4383c6be98e4d86a981a031328e393a6eb2632", size = 147742, upload-time = "2026-11-18T00:32:26.272Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/34/65e66e8c384dc08f0e58c474587c05c4bc952f60facd8a15e80748118bd1/python_discovery-1.9.6-py3-none-any.whl", hash = "sha256:93b10b90363d4151964cdeee2ec6601f3041b17fc2b253a1c3da7d6e7ddd8337", size = 98453, upload-time = "2026-11-18T00:32:24.849Z" }, +] + +[[package]] +name = "python-gitlab" +version = "8.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, + { name = "requests-toolbelt" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/5c/dc/292d32245ca35447b265c47a0ed9f35de1ab280a05da1da306b61a035833/python_gitlab-8.6.0.tar.gz", hash = "sha256:d1602164fb58ab280ceef460faf015cec6e7d83bb2d9cbae44ba448adb5568ef", size = 423347, upload-time = "2026-09-28T03:13:53.86Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/55/aa/9c96a88d79453eaea91f301c318dc3c5e95b195087759fd94fedf1104386/python_gitlab-8.6.0-py3-none-any.whl", hash = "sha256:34fee7e5576cf01982c4bfa98f94d50e24733edb66beba3cb8ef286287723019", size = 159654, upload-time = "2026-09-28T03:13:52.285Z" }, +] + +[[package]] +name = "python-semantic-release" +version = "10.7.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "click-option-group" }, + { name = "deprecated" }, + { name = "dotty-dict" }, + { name = "gitpython" }, + { name = "jinja2" }, + { name = "pydantic" }, + { name = "python-gitlab" }, + { name = "requests" }, + { name = "rich" }, + { name = "shellingham" }, + { name = "tomlkit" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/bc/5c/fa247870125123aef3373feb8544ddadbd2c6019fb8660e8d79953b25172/python_semantic_release-10.7.0.tar.gz", hash = "sha256:258da019ce594fa2e1f4f0b6c21c84bbd51657c71581c847c93fb63108e72001", size = 630470, upload-time = "2026-09-22T07:42:00.703Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4b/59/25f4f143e61c616de79f604e1f5f4fb429013f70be3841e828d236e4faf5/python_semantic_release-10.7.0-py3-none-any.whl", hash = "sha256:85c0ab86357693c7b43ac3097475a0039ddd765ddc9c2fac11f5c3db7db3554b", size = 156632, upload-time = "2026-09-22T07:41:58.692Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "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 = "requests-toolbelt" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "requests" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/f3/61/d7545dafb7ac2230c70d38d31cbfe4cc64f7144dc41f6e4e4b78ecd9f5bb/requests-toolbelt-1.0.0.tar.gz", hash = "sha256:7681a0a3d047012b5bdc0ee37d7f8f07ebe76ab08caeccfc3921ce23c88d5bc6", size = 206888, upload-time = "2023-05-01T04:11:33.229Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3f/51/d4db610ef29373b879047326cbf6fa98b6c1969d6f6dc423279de2b1be2c/requests_toolbelt-1.0.0-py2.py3-none-any.whl", hash = "sha256:cccfdd665f0a24fcf4726e690f65639d272bb0637b9b92dfd91a5568ccf6bd06", size = 54481, upload-time = "2023-05-01T04:11:28.427Z" }, +] + +[[package]] +name = "rich" +version = "15.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/3b/64d4899d73f91ba49a8c18a8ff3f0ea8f1c1d75481760df8c68ef5235bf5/rich-15.0.0-py3-none-any.whl", hash = "sha256:33bd4ef74232fb73fe9279a257718407f169c09b78a87ad3d296f548e27de0bb", size = 310654, upload-time = "2026-04-12T08:24:02.83Z" }, +] + +[[package]] +name = "ruff" +version = "0.17.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/8e/6929d337aa5380aafc7355f3149f3ccfe55cba5fdd34a045697ebaceb5a0/ruff-0.17.6.tar.gz", hash = "sha256:2b04276561331300325040bdca21460770029ec574d4c479099e39e8ad1ed43c", size = 5374388, upload-time = "2026-11-19T15:56:27.106Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/5d/38ef6310c22cacb094e9ae0ff7964062e04ffeecb45ee296894c2b1acc54/ruff-0.17.6-py3-none-linux_armv6l.whl", hash = "sha256:084d9c8f5ec718e7eba007dba339e7cb4f7571d2f267558ae080bf428fb6a69b", size = 10174693, upload-time = "2026-11-19T15:55:52.414Z" }, + { url = "https://files.pythonhosted.org/packages/a2/ed/fd35261049920a4888ef7c787a5c27089502077a4910f6ca8f1213157d6d/ruff-0.17.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:9d44ef2140402043fd6f689ef541858b80883a8b0a02e38539ef0614ebe57d0c", size = 10221650, upload-time = "2026-11-19T15:55:54.962Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d4/c31391b36c729cd9fafa65b7a52a58850b99afb2b65da6be4263a53302f2/ruff-0.17.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:9fbddc08577592e283c265d865e0182de6e33db185494db7b06290d989d888e5", size = 9580986, upload-time = "2026-11-19T15:55:57.391Z" }, + { url = "https://files.pythonhosted.org/packages/eb/11/f3032684dcb3a676d7924545153d76fb56f76753e038f2ea650b99c71bdf/ruff-0.17.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:435241c61af5909a022f76219d3d1bf24730dc1bf0acabb5ddf4b569ab3cbb30", size = 10271368, upload-time = "2026-11-19T15:55:59.654Z" }, + { url = "https://files.pythonhosted.org/packages/08/30/c1e024eeb5bae99ae78c6b896ed108f64c9c845a03b56eaeff098e99b6e6/ruff-0.17.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d006bbb2945edb17b0ce6a0c1b5f5a8d81ba11dbac294a0a925effa22ce34feb", size = 9981564, upload-time = "2026-11-19T15:56:01.807Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/da3e0c2d4bf02b3ca6c1d7fa4bb04d0081e340b1dd03c4f83b1bec3e15c1/ruff-0.17.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd661702202a89c00a4c9d0339008805fa5876bfa1c57e165495c2e62230dfbf", size = 10641991, upload-time = "2026-11-19T15:56:03.981Z" }, + { url = "https://files.pythonhosted.org/packages/4d/c1/6d7f981e86201c9db457cca99fd2c09b77574ebab37dff3e9239b218603c/ruff-0.17.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6a12c50a33936dc00db2be21ba25fb168a8b95c55eda2a3ac85005af69885e4b", size = 11403484, upload-time = "2026-11-19T15:56:05.778Z" }, + { url = "https://files.pythonhosted.org/packages/c3/92/8182f07b94998541d5f8f38f53da465aa28062afce24ecc398f45bfc62f1/ruff-0.17.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b5aba93b3db4b70c5697e4fee6e0d5b9c8452a9a3a03679611cadc25915a2173", size = 10892316, upload-time = "2026-11-19T15:56:08.016Z" }, + { url = "https://files.pythonhosted.org/packages/be/48/3df7d81249fd69ee6a49519b149fb5d11e13118fd7d0e8d65329a237087b/ruff-0.17.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa3b08254a732acba246891089a152c47c5733dc36b8ecb76ce8602f8326e5e4", size = 10645279, upload-time = "2026-11-19T15:56:09.785Z" }, + { url = "https://files.pythonhosted.org/packages/71/80/4d232281544345d7beb98d1d32c24dae804ed360780a6f7753738b81225e/ruff-0.17.6-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:0692088e6b33455572fb18465e891b443f196e98dc1986825685c77ff6f4c5ac", size = 10534501, upload-time = "2026-11-19T15:56:11.718Z" }, + { url = "https://files.pythonhosted.org/packages/98/0a/b477f075a4a94eb541bf1c759a3e72b2a3d6390af7a13a5be0887229f67c/ruff-0.17.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:fb589e032806bb942e4fb526f30b80a1a64112147ed9f1d38cc3de2e255b6f45", size = 10136036, upload-time = "2026-11-19T15:56:13.779Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d8/cf32fbfeb1fcda1470fb5c3bee50c69ee6bca257d487ec1eb17a0387edb4/ruff-0.17.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:1939b3d701c7b6981b7cf93473de5bf88b129b9ba84efaed5154cc517c44634d", size = 9969640, upload-time = "2026-11-19T15:56:15.738Z" }, + { url = "https://files.pythonhosted.org/packages/a7/22/bb9f9752f7fcdfdc8b9c51576cc142bb377ade745290e35085173963c7be/ruff-0.17.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1a0bea6aa1216e0ec4cd35d3dbccec0d772a7c2aad28ec9c6e82571dff2c20b0", size = 10389427, upload-time = "2026-11-19T15:56:17.617Z" }, + { url = "https://files.pythonhosted.org/packages/81/c7/e09d220818ab146b736d62e0676dad215215d7de0884bbdad9fa075dc7d2/ruff-0.17.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:3db61f5015600543a581b07fa7f6f64afa0eeedefe16034cadd88c4074087582", size = 10760296, upload-time = "2026-11-19T15:56:19.463Z" }, + { url = "https://files.pythonhosted.org/packages/2e/09/28329441dfa2c463e2d377a69d4ebbe4d51665e9dbd49fb421f3bc80d775/ruff-0.17.6-py3-none-win32.whl", hash = "sha256:c2f4af6670b7a0501904e881bb3f1f24bd0d964dec1eedbd85f0eb73786e1128", size = 9966266, upload-time = "2026-11-19T15:56:21.581Z" }, + { url = "https://files.pythonhosted.org/packages/4b/9d/18ba9730addfc7554c70d6f171fb8dc2c08e774d9fb2b98e7946ef845c59/ruff-0.17.6-py3-none-win_amd64.whl", hash = "sha256:9cd2fd9923e9806b8b6b67a3469e2258e84bd4d21e45d5a1a690afdfb9c8e57d", size = 10365847, upload-time = "2026-11-19T15:56:23.582Z" }, + { url = "https://files.pythonhosted.org/packages/70/8a/59c33e2a64a4f9672f7f842a0dc522915cfbbaffd13d37d0cec57d1c5c5d/ruff-0.17.6-py3-none-win_arm64.whl", hash = "sha256:d8b14e1473dc86ab9069cf7a2ba5041dc012f59110201844ed04cfddf07055a0", size = 9926224, upload-time = "2026-11-19T15:56:25.269Z" }, +] + +[[package]] +name = "shellingham" +version = "1.5.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310, upload-time = "2023-10-24T04:13:40.426Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, +] + +[[package]] +name = "smmap" +version = "5.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1f/ea/49c993d6dfdd7338c9b1000a0f36817ed7ec84577ae2e52f890d1a4ff909/smmap-5.0.3.tar.gz", hash = "sha256:4d9debb8b99007ae47165abc08670bd74cb74b5227dda7f643eccc4e9eb5642c", size = 22506, upload-time = "2026-03-09T03:43:26.1Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/d4/59e74daffcb57a07668852eeeb6035af9f32cbfd7a1d2511f17d2fe6a738/smmap-5.0.3-py3-none-any.whl", hash = "sha256:c106e05d5a61449cf6ba9a1e650227ecfb141590d2a98412103ff35d89fc7b2f", size = 24390, upload-time = "2026-03-09T03:43:24.361Z" }, +] + +[[package]] +name = "tomlkit" +version = "0.15.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/08/72/fc01563df95c189a9f65850096bdc205bc2fe37da6c740cd64afaf18d07e/tomlkit-0.15.2.tar.gz", hash = "sha256:83e32755ba1d20d9340bd069ee97e9f6232ba2346b63ffcba425de01f7e327a6", size = 190522, upload-time = "2026-10-16T04:07:08.166Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/46/7d84138a60a8bd796825b2d38ebe92d0d16501ca57d501b7c5d677401bbc/tomlkit-0.15.2-py3-none-any.whl", hash = "sha256:05562412163a3037b94497385fb7f9204c637bc605af7a48199e41cf2272f437", size = 52225, upload-time = "2026-10-16T04:07:09.216Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.16.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/cc/6253133b5bb138fc3306cebfbda2c520f545d36b5be2c7255cc528bb45d6/typing_extensions-4.16.0.tar.gz", hash = "sha256:dc983d19a509c94dba722ee6abd33940f7c05a89e243c47e907eb4db6f1a43e5", size = 113555, upload-time = "2026-07-02T08:40:05.92Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl", hash = "sha256:481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8", size = 45571, upload-time = "2026-07-02T08:40:04.659Z" }, +] + +[[package]] +name = "typing-inspection" +version = "0.4.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ff/50/0195198eb1d75bab716bb0a813abea4cc394bfa17a92a189f021a34859af/typing_inspection-0.4.5.tar.gz", hash = "sha256:7f16c411e7930dc79596d42ab44672a3fe5f60eb34b781a1647e7872363120c7", size = 81194, upload-time = "2026-11-04T14:13:23.774Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/de/0c/ea2544850a7c135e15033a5c7a8e7211136184b7ae63e2239d557c2b3019/typing_inspection-0.4.5-py3-none-any.whl", hash = "sha256:bc210535442b39e1bf2805e0c7a17dfd6a4ace760c84c7f7d16245d23a6b1c39", size = 14874, upload-time = "2026-11-04T14:13:22.616Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +] + +[[package]] +name = "uvloop" +version = "0.23.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fa/42/02c739ce85fb2ee8d99212c61417da8140c6b87e9d97c430bea520d76044/uvloop-0.23.0.tar.gz", hash = "sha256:28d160f51ab4da3b187063652e643dea6831072add4adc1e6d62afbe73b6be27", size = 2559185, upload-time = "2026-10-01T03:17:04.4Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2f/b1/948067eab45d5307f04b34e50eb7bd1f7352aee866fa5f0706b061ddacf0/uvloop-0.23.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:24c58ae4a83e93a04c504bcc678125e36a0bfc44af928ad69444880c60f187a5", size = 1415276, upload-time = "2026-10-01T03:15:32.634Z" }, + { url = "https://files.pythonhosted.org/packages/8a/6f/ee3ee84c5d27f2f0a47ae8b67a6adeacf9841b193c0e07412a1403586ce2/uvloop-0.23.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0efdd55bddbd36bb2fcb842d64c0d5f6407c6958c68088cc25df8c09edc5b5fd", size = 779533, upload-time = "2026-10-01T03:15:34.062Z" }, + { url = "https://files.pythonhosted.org/packages/25/0d/b5f69dae3736d96a8753c6ecd32d676ecd212be7ba3252e9c379ad9cc05c/uvloop-0.23.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8fcd721113260ffb5e38bf14a8725b17d431f34209f7d1c7005b667946e630b3", size = 3896377, upload-time = "2026-10-01T03:15:35.816Z" }, + { url = "https://files.pythonhosted.org/packages/16/fd/8cbf6124607863399008ae4b0d2bb50c22ed83526deec28dca08d635eb6d/uvloop-0.23.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ab17b3a8aa754be0de0e397f7b95f13b14e56f077a4c6ae295e3d4afd199b325", size = 3956355, upload-time = "2026-10-01T03:15:37.688Z" }, + { url = "https://files.pythonhosted.org/packages/a7/7a/b73007866e7198519067a1f1afc343b4973ae924d2b7afcea67c44320a98/uvloop-0.23.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:80cac5cb90ed7b9b72a217a1d6982b15b829cdbd0ee6bc19b93e3a9e47fb0ac9", size = 3755618, upload-time = "2026-10-01T03:15:39.27Z" }, + { url = "https://files.pythonhosted.org/packages/3c/28/e50816f1ce38b97b28d62bc4adf7c82c33b7c68fa902e41a39adc8a3d189/uvloop-0.23.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:93087a845cdfb35753e539354ac9551bdd2ff528c202a98df0ae46e852bcf021", size = 3863192, upload-time = "2026-10-01T03:15:40.882Z" }, + { url = "https://files.pythonhosted.org/packages/05/98/04e766a6de99e6f7f955ecb7829e8d5a557de3427cb85be2236de54dda0c/uvloop-0.23.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:93935ab27b6eaef4c3e5489aebc84284f0644592f7ab516df60ee1b27eaf5eb3", size = 1393055, upload-time = "2026-10-01T03:15:42.526Z" }, + { url = "https://files.pythonhosted.org/packages/33/8a/499e7b863a848ede009539bce39806b66205da5f8779354228e785601144/uvloop-0.23.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4448e9124537620f9c25d004c227bb5104440b58955c19bbd312d910af919a63", size = 768909, upload-time = "2026-10-01T03:15:43.974Z" }, + { url = "https://files.pythonhosted.org/packages/3d/95/a880f8ce3b87ac5b307c354e8ee480be4658d24bf01f87921d57e3530b4a/uvloop-0.23.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f7548ede3ee908cfabc0d068106e303a9a2d811af959cdf6ab85676344cedcda", size = 4419106, upload-time = "2026-10-01T03:15:45.551Z" }, + { url = "https://files.pythonhosted.org/packages/51/27/c1d2f9fa977f8f42ea294604166df10e0027e6dc6cd17f85ede386c9bf36/uvloop-0.23.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:090865d8ce7a03986755a3ce711b7dd0d4b44eb14ab74368b717f3fad1180208", size = 4532597, upload-time = "2026-10-01T03:15:47.258Z" }, + { url = "https://files.pythonhosted.org/packages/42/dd/2cb6a2c8a30ca55c07a882dd4ae4ceae0fa7d8c15b25b3b7cb9a4b6cf4ca/uvloop-0.23.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd6f2f81c7b9da99d301c0b16b82044e76fe887086e42e1590ecf520b94dbdac", size = 4230048, upload-time = "2026-10-01T03:15:49.119Z" }, + { url = "https://files.pythonhosted.org/packages/f4/52/29989cbaa4022dc4ef35c1dd60a4ab989e4c2065f341ed483ae71d2bd950/uvloop-0.23.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a6ac96da66c35bf789bdcde78a88dc7d56b7907d8379648c54adc1c61594575d", size = 4394152, upload-time = "2026-10-01T03:15:50.829Z" }, + { url = "https://files.pythonhosted.org/packages/5f/83/eb980d64e6dd5da46d4dc35755fa6afd6b5b47141437cf89615f1117c5a6/uvloop-0.23.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2dcff2d69be43e6559e5dad2c5a7a2dbfb60e05a77311b6c4b7a4a8123d86c65", size = 1412726, upload-time = "2026-10-01T03:15:52.49Z" }, + { url = "https://files.pythonhosted.org/packages/04/c1/02a725e7698134c647904bdee6589e2be14a0e7fc9942c74f86e2b90d48b/uvloop-0.23.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:19c64108b507cd0bc140e400e3396bacebd9d504956aa7726272bf6de7d9aabb", size = 779071, upload-time = "2026-10-01T03:15:54.02Z" }, + { url = "https://files.pythonhosted.org/packages/0b/1d/cde53c79e8c01884ad1cdca8e407e086d523362cfe4139e2c2a8dde27304/uvloop-0.23.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1748321e3c59a14a75404b1ae8d5a8d81c4e201803ea0e14c1b6fd84421024b5", size = 4395323, upload-time = "2026-10-01T03:15:55.549Z" }, + { url = "https://files.pythonhosted.org/packages/98/54/b12915bebbf99d7ae0796211e7f5977b95f069830dca45dc1a346d84125d/uvloop-0.23.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e2cba180d6451822763eda8364f342435a873bcfb3849cbd82fdeca248ca65eb", size = 4480449, upload-time = "2026-10-01T03:15:57.362Z" }, + { url = "https://files.pythonhosted.org/packages/f7/8e/da6de68c31549a052a105fc76f5a9a204f6df22cb0909440aa4dbb06f9a2/uvloop-0.23.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:dc61e4f9e37b507069dc7e659ae28bca7adcb04c993c3508214315d12c63f848", size = 4219177, upload-time = "2026-10-01T03:15:59.351Z" }, + { url = "https://files.pythonhosted.org/packages/a1/c3/1b53c6a89dc9c9d5cb75eb9a0b891ad69b32e1421ad3aa01617a9cbdcc78/uvloop-0.23.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7337b06a9f9ed9ea3049f04b76f65819db9b19bb832ee598e97b388eadf25e5f", size = 4346132, upload-time = "2026-10-01T03:16:01.064Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a4/00e85345871c59c834a23c136c1771205856028ecc8ba940b3951178e59b/uvloop-0.23.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:b90397a50ad6332ed3e459c648ac20d182cce24a557354363ad85fc9ea4a17cd", size = 1421363, upload-time = "2026-10-01T03:16:02.599Z" }, + { url = "https://files.pythonhosted.org/packages/d0/a9/e5f0f3cfde30af3ec32eba8ec07bccdba2b5116afbd1ecc53edfeb0a0790/uvloop-0.23.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:be53e1d5f83de43dc175c87612ecc128d444b38e5c56cb3f807f5a73d6887476", size = 785177, upload-time = "2026-10-01T03:16:04.018Z" }, + { url = "https://files.pythonhosted.org/packages/9e/79/9ddf78f8cd75a15c14a09a57f59c587b8cd9d82802c5c8368b9c3ebefa0b/uvloop-0.23.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b3cbc4f96ddfa1fb88a78a69dd851369825b7816d9702eee8c4461505ba172e", size = 4381060, upload-time = "2026-10-01T03:16:05.642Z" }, + { url = "https://files.pythonhosted.org/packages/1e/20/57d63c44d32326878fcad5c63854afc9deb394ed95673c1b1a429178c79d/uvloop-0.23.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:31e0cf90bc8fd88784f6802cdba968a51fb1aec1cc3feec74d862b2d371d1330", size = 4418891, upload-time = "2026-10-01T03:16:07.326Z" }, + { url = "https://files.pythonhosted.org/packages/12/c5/0795abecda2cc3dfe41033f880a32a9ff103be4e6b177ac736833c153a0e/uvloop-0.23.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa8ed556fcc87a4091cf61587ef172fa104323dc89ecc085a618ba7ff8629a8f", size = 4214811, upload-time = "2026-10-01T03:16:09.13Z" }, + { url = "https://files.pythonhosted.org/packages/20/18/9010dacd5221eec1bd79a4a83ac68f3db6a42d7bb657f7b640c4838ca6b6/uvloop-0.23.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f3fbfe82829d8e381426a289b87e59e585278728361db9ce975b88b51f64f410", size = 4294876, upload-time = "2026-10-01T03:16:10.875Z" }, + { url = "https://files.pythonhosted.org/packages/b1/08/f6384a03c771d00067cba4f542a69b2fc1a982e9fd78b357c2f788678d72/uvloop-0.23.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:7e35c9bc977760981693e1a7a51493b58ee5a501f9ebb1e547565ee40b6c6208", size = 1494811, upload-time = "2026-10-01T03:16:12.399Z" }, + { url = "https://files.pythonhosted.org/packages/ac/01/756a4fb24a449f313cf4a153eb0c6210b49cfe5539255ec9fb1e17d2c4ef/uvloop-0.23.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:5bb9be71d9ee39b4359b832f9569518ec9bc08704194034e79e4958e6bc4d46d", size = 819396, upload-time = "2026-10-01T03:16:14.094Z" }, + { url = "https://files.pythonhosted.org/packages/3e/45/e314b0c600b14f53dad3a3c2d7a922a249a88225fd727652b53e1854b9dd/uvloop-0.23.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e84575f11873c109cf3962ad0bdf679094466184125f4cadcc41a73febff41f", size = 4734966, upload-time = "2026-10-01T03:16:15.815Z" }, + { url = "https://files.pythonhosted.org/packages/66/0d/8686a7f0b1b2d55ebd770ba21f8e0e4ffa0cde5ab738f43ffb8264499052/uvloop-0.23.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbbdb8fcd5e7062e546eec1ac78c28bb21ae7df54c18f8e4b06e15a18d661a49", size = 4584963, upload-time = "2026-10-01T03:16:18.198Z" }, + { url = "https://files.pythonhosted.org/packages/78/b2/034a2d47e435ac02357c42956246887167bdc0357bdd6ad31c5f6d94497b/uvloop-0.23.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:76345f51367fb1f23e08605c6efb18374f669be5b223658fbab6b17627950507", size = 4421388, upload-time = "2026-10-01T03:16:19.953Z" }, + { url = "https://files.pythonhosted.org/packages/f0/77/131f4b583e6b4b715c404a66b51c812d701db20f25c9018b188a2b00062c/uvloop-0.23.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c7ef4701a96553514b2688e342ef1bf2beae6cfd172d89a76c768292aabf405", size = 4402414, upload-time = "2026-10-01T03:16:21.716Z" }, + { url = "https://files.pythonhosted.org/packages/58/3d/ee11f4718ea1280595c67ed25c83d4c92115dc100bbdfd192d3ed9339168/uvloop-0.23.0-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:f1341c6abcee1c31277cfe28d34e46196f2143ec3d755e6efe7452126e1f626d", size = 1418095, upload-time = "2026-10-01T03:16:23.241Z" }, + { url = "https://files.pythonhosted.org/packages/f8/0c/7ca516a0671418517d79a09d3ff2ccbb44af94c75711afa6e4cf58aa6f65/uvloop-0.23.0-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:e095f9e105af76593b4c183bb0bcbdae64bd913a59ec595732dc108b48730ab5", size = 784837, upload-time = "2026-10-01T03:16:24.666Z" }, + { url = "https://files.pythonhosted.org/packages/35/95/75d4e28e596d505b7ae11de517646b4ca3d369fb8537ba755410380da11a/uvloop-0.23.0-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f673d835bdb1a60229cc3609a113fd2c9ce3f4a3c75ad4eaed111180c00199d2", size = 4380276, upload-time = "2026-10-01T03:16:26.389Z" }, + { url = "https://files.pythonhosted.org/packages/10/99/68daf827ad62efaf4667d1f3fda127046d42161178396bdd93aab3684082/uvloop-0.23.0-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c3f23f403a273900d57de6ee5ca0614c650f7f58563065dad1a4744498960e53", size = 4451496, upload-time = "2026-10-01T03:16:28.364Z" }, + { url = "https://files.pythonhosted.org/packages/71/69/f67e696ee688f426a96f99099bae26fec14a1d0fa75dccdd6518ee267c0c/uvloop-0.23.0-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cbe8d03d4efcccdb7fcedecbaa1e1fa02913eaf3a74cb933634a6bc6d2ea9e2a", size = 4212541, upload-time = "2026-10-01T03:16:30.014Z" }, + { url = "https://files.pythonhosted.org/packages/f1/6a/c8c436a9d7453297b4be70bdf6a9f9fc9400da45e0059ddf7b28ab63f4c7/uvloop-0.23.0-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:4f1798f56c6f4ba5ac11fa2869e5717926e4470d97a1dd42b4f59219d43b5027", size = 4319377, upload-time = "2026-10-01T03:16:31.705Z" }, + { url = "https://files.pythonhosted.org/packages/3b/2c/8fc15a03489299aab8a6212dfe0f137dc39836f915c87f7fd9d9ddd814de/uvloop-0.23.0-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:098a85e1393ef5202767b7e5fb41a32cd8bd81e6ee4af364c179801c4aa3f6d4", size = 1493428, upload-time = "2026-10-01T03:16:33.859Z" }, + { url = "https://files.pythonhosted.org/packages/b7/7c/05e4a210790229607f71460fcb2ed4a2c7bc72668d8a928ce577c22e38f8/uvloop-0.23.0-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:5a2bbad3a63007f7e9524d4903ba04fee252557c2acd86f9a3d4f91786695254", size = 818115, upload-time = "2026-10-01T03:16:35.45Z" }, + { url = "https://files.pythonhosted.org/packages/65/14/a40b11c6c024213803b13955664a15754c72f64c873a33d986b26ec9ff5b/uvloop-0.23.0-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a08875543bbd4519faf30497506c9cda8a48470467ffdf967c7313c7a5981a8", size = 4734149, upload-time = "2026-10-01T03:16:37.025Z" }, + { url = "https://files.pythonhosted.org/packages/9f/83/f421a077712c1e87603bfec62744c3cd3a2f4b47378025db3d740df9af0d/uvloop-0.23.0-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:12634f15e6625f78b3f2922f91404c4d7173487eba11746764153f556e9852dc", size = 4661763, upload-time = "2026-10-01T03:16:38.719Z" }, + { url = "https://files.pythonhosted.org/packages/f5/62/25dcaa6b7e7b48f82ce633854ce96597ab768f9650931f4f86c572de392c/uvloop-0.23.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:378188efbb1524f2219d05246a3e1e5907217848d2882144dff59585f1b81d55", size = 4421324, upload-time = "2026-10-01T03:16:40.488Z" }, + { url = "https://files.pythonhosted.org/packages/05/46/04628239b43dcef703af314202a3307d6060918e2d76aa86c5b1188f5551/uvloop-0.23.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:4b8e207c67d207a8608fec57e116511030af3495dc0109b8c333cf9cb412b16f", size = 4462501, upload-time = "2026-10-01T03:16:42.359Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.15.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "python-discovery" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ae/66/8dd793701fa14a32086a7b7c3acaa7c22d8de6a7359b34eb7467d2d00c51/virtualenv-21.15.9.tar.gz", hash = "sha256:adc6799981f513ce852aea17ea592e0d342ce48e87f5d17a3d997966df582a67", size = 5676072, upload-time = "2026-11-18T18:12:23.394Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/97/b18afd39e22dcddb79656a7d3b69b7a6bfa2c3bc65159744f0c12a1bcb50/virtualenv-21.15.9-py3-none-any.whl", hash = "sha256:c0fbae7de061402e31897d96cfbe7dc35ce93cd464fe05f9bdbecf61313447bf", size = 5730190, upload-time = "2026-11-18T18:12:21.088Z" }, +] + +[[package]] +name = "websockets" +version = "17.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/75/79/590c5f0cc7d1661195aeefccb0e342b79f4c77d368d526d028821a390332/websockets-17.4.tar.gz", hash = "sha256:09d3939b70df0c8ad2da145ebd50978bccaee1d565e838b0e7921a34d38571eb", size = 191391, upload-time = "2026-10-30T15:10:35.873Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/d8/2d4ec550208432538d152a41f0c36dc6728cfae0050c6b1442605456d3bd/websockets-17.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:06ea46717553cdd10f2682126cf7a66e91c8ed17b6969f4a95e94b4e01d06188", size = 218746, upload-time = "2026-10-30T15:06:39.361Z" }, + { url = "https://files.pythonhosted.org/packages/56/99/3090fc0e2e343cc7ee60d532b67a2d413830c8fbb0be9ec3bcfbe3371f2e/websockets-17.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:75b32cf33ea40f945f226f97bc1d43151e1a5adff21f420b5e63c468b1a28114", size = 216437, upload-time = "2026-10-30T15:06:41.324Z" }, + { url = "https://files.pythonhosted.org/packages/3c/e9/3d4fb98e5d8aecc7bdbc59c4edf6380fdeddf935445e7f4a205466682991/websockets-17.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b8451f31ae24620cc9372acd2728d87922f2bb0cae3fa57aed68b152844cdf08", size = 216709, upload-time = "2026-10-30T15:06:42.995Z" }, + { url = "https://files.pythonhosted.org/packages/0c/4d/5c7d4f53cc0d7c6f268bbd93865b185e05f65f37f84712a41ab311118f8f/websockets-17.4-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3b76837cd051d8875913f3934b27205f7a592f78b8a4f4a1f3abc36a2420c5bc", size = 225773, upload-time = "2026-10-30T15:06:44.607Z" }, + { url = "https://files.pythonhosted.org/packages/57/70/80f870701f8610e88649d3cd173a0e7ce66433913da3683035a4370063ad/websockets-17.4-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cebad8f4796248b91fc2168515e507e5cb6b663a32befd09f3b1e7920acdcb1a", size = 226041, upload-time = "2026-10-30T15:06:46.224Z" }, + { url = "https://files.pythonhosted.org/packages/a2/bc/f2e84b5a933c86d52184814d38b0f9d51fc90fd3205cb7af0d9417ebbff2/websockets-17.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:954d43574f72be244b65f0fa61e2f814214b024f2ec849f487aa2f553f7c6e71", size = 227279, upload-time = "2026-10-30T15:06:47.619Z" }, + { url = "https://files.pythonhosted.org/packages/34/7e/4710475f46afbfe5390b4139556aa4fa0692d3d31878a25a1b26e8a6d78a/websockets-17.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b529ad6c81ad21db2f4e3d6e33db78ce3b9f272066b438b5d673361f9282898d", size = 230592, upload-time = "2026-10-30T15:06:49.357Z" }, + { url = "https://files.pythonhosted.org/packages/bd/10/cca6dc2316dd8c3b1a62fbf7f8986926ad8c4b2ae3d3be7888059a96b142/websockets-17.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:799c5a23126c9589cb10b6c6b54f9087246940dad20cd74bf3f06fc9ae3bbab5", size = 227837, upload-time = "2026-10-30T15:06:51.015Z" }, + { url = "https://files.pythonhosted.org/packages/68/21/ac1c3d7781d756bd40fbe501890b54a0205b1f0528a559fdcabcede0bd54/websockets-17.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f01a680d4b66fd15cc7513fae55c673cc8cc340d41340305b7f9a782abdbefed", size = 226613, upload-time = "2026-10-30T15:06:52.556Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a0/bd122578f2765fb3714eeef80bd66074e355ff80e0a6de7fefa10de5f36a/websockets-17.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0e51546a3bedadd80dfa5c2efaed840ac51b8632d8db7f9f502175f5349382a9", size = 223893, upload-time = "2026-10-30T15:06:54.106Z" }, + { url = "https://files.pythonhosted.org/packages/51/50/a5214db6b778995b7fe1bfaab6228ba967cb6fd523d4b7af83154aa0ac66/websockets-17.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6686d29eaafddeeab9e48af92103dc0d26161035faa4be083b8b488f1ab47219", size = 226768, upload-time = "2026-10-30T15:06:55.889Z" }, + { url = "https://files.pythonhosted.org/packages/fb/41/5d62d4889ff8a400cf32c8ad35e58b18e92b0e936db0bae785307cd1b105/websockets-17.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:7b23db4b469d9e051ac74d96db9bf61e27c9054de64f8263fefa32bf72867ba1", size = 225358, upload-time = "2026-10-30T15:06:57.706Z" }, + { url = "https://files.pythonhosted.org/packages/b4/94/c344744fad06ae721a6ec69f728a3dd4bd1b94beb7bb64400a8cd0efc644/websockets-17.4-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0132e3cbd3f5cfc1ec77588961b302d72a02e2603b82c2c23fd5fb59dc4fa206", size = 226125, upload-time = "2026-10-30T15:06:59.125Z" }, + { url = "https://files.pythonhosted.org/packages/0d/00/90d66792bf1ce315fabe18f838eb2090ebad3425139047ed4c4ad354a90c/websockets-17.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:98f16db5e79f2605194c0f899d0532005bb12269e698bf96f62a5635bcf33010", size = 227169, upload-time = "2026-10-30T15:07:00.687Z" }, + { url = "https://files.pythonhosted.org/packages/24/7f/c069129b20504c35bd22abb276a6562e92dccb69c974ca93021a23fb00ce/websockets-17.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:ee48728a07566c32e097d267f4d4d01b85123c9ae748a42da02185b908cbedc4", size = 224750, upload-time = "2026-10-30T15:07:02.077Z" }, + { url = "https://files.pythonhosted.org/packages/4e/3a/0fcb37d6da690aa2512faadb0e9cb5e1043fff659fd415dc8b518883789e/websockets-17.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2103982762460a764a7ef0021443bb471f46d45ecc6858276e4fe699ebac6b94", size = 225782, upload-time = "2026-10-30T15:07:03.783Z" }, + { url = "https://files.pythonhosted.org/packages/49/61/422745448862b18b8d373347bb73debcd440330f21dd899feac5f920d531/websockets-17.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:648adde345cfd13335342e23cfe94871c7f7f55a43fb254f3b95acb071072968", size = 226021, upload-time = "2026-10-30T15:07:05.237Z" }, + { url = "https://files.pythonhosted.org/packages/96/74/3ea38c6758b497a5d1b7bd953542e9e6446b84aa075a061e9a47e24ceb75/websockets-17.4-cp311-cp311-win32.whl", hash = "sha256:679eef0123861ca381dd8fd9bdc1920e87636ac55eae6cff875c53dcb05fbcf8", size = 219255, upload-time = "2026-10-30T15:07:06.871Z" }, + { url = "https://files.pythonhosted.org/packages/55/66/00ca8b75a634c9fcf70579f9a242b96a7f7a3abeb21a02e2380fff491d2c/websockets-17.4-cp311-cp311-win_amd64.whl", hash = "sha256:e4beaef2f4796558e738e15ca0b8802e35f419a9fa374a978e41706f43c48b26", size = 219556, upload-time = "2026-10-30T15:07:08.538Z" }, + { url = "https://files.pythonhosted.org/packages/4b/7b/c8ccb313439f4803779f186b8133563e6c49c023467a265ae52da7b7e25d/websockets-17.4-cp311-cp311-win_arm64.whl", hash = "sha256:ddab54dc0ec46ed09ef9ac131252cb5740ed21fbe6fc145f3c6fed0b575a8f15", size = 219487, upload-time = "2026-10-30T15:07:09.94Z" }, + { url = "https://files.pythonhosted.org/packages/af/71/b020221345ea6c012dcf7496827a48a744b58696470b2b07fef95a32905a/websockets-17.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3d512e3a6c528c42ce220ed9c3caff83c6fdcd98a1b98249f08ccfc66ad111b1", size = 218779, upload-time = "2026-10-30T15:07:11.522Z" }, + { url = "https://files.pythonhosted.org/packages/8e/84/1c372ae7c032021a84e5c9e9b76b0dddefb354e9b4af783a97efd4d80ab3/websockets-17.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7390e060f830b3d132f484b21ac2783a2d227b682ef62bb8146e1c1b4ca0e45a", size = 216457, upload-time = "2026-10-30T15:07:13Z" }, + { url = "https://files.pythonhosted.org/packages/74/b6/cff249107473f149c6c916a49cba967379fa63b0a7d2dce6896d6848f0a3/websockets-17.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bcad49104711f88b2b7c3ba166de172857d837248205e541b044a552558fecc3", size = 216726, upload-time = "2026-10-30T15:07:14.468Z" }, + { url = "https://files.pythonhosted.org/packages/77/5d/aff8ecbf1c55c4d96f6dacc46a52102895f58b85bb284c8d325aaf31606a/websockets-17.4-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cf99debb17227a50620aee16647bb33a0387f5fa5418d628666c0f05745e0d2a", size = 226043, upload-time = "2026-10-30T15:07:15.937Z" }, + { url = "https://files.pythonhosted.org/packages/cb/18/6229d6583031ca81d092a0cd887a13a57b402fb555acc323d39b45967eb7/websockets-17.4-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9ae1429ee9e52b139167ed0169757806a27ed7307e942e8c62037a9184e9843b", size = 226321, upload-time = "2026-10-30T15:07:17.563Z" }, + { url = "https://files.pythonhosted.org/packages/b8/61/7aba018fd53873e792a25afe1f4c005518133477b727d7455f2f7550c425/websockets-17.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51adfc30f467077293a6695d8149bcef501c0728386f3a491054f835dadb60b2", size = 227559, upload-time = "2026-10-30T15:07:18.998Z" }, + { url = "https://files.pythonhosted.org/packages/fb/66/37b207df9cdacaa017aa4487f3a9f2fcd668f6f7cfbafdac5b95ea258ee0/websockets-17.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c564d1e6531611bf87078c28780456ecc75459dcca189629fff2fe7c020d8e67", size = 230386, upload-time = "2026-10-30T15:07:20.431Z" }, + { url = "https://files.pythonhosted.org/packages/ad/f6/87507e11fbae53817a435945273953b5b020589e309fac4fd60527ee5999/websockets-17.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4c792e6cce24d08f92199d907785c9e64f74c357deeed3dbaf7d699ed5930b64", size = 228193, upload-time = "2026-10-30T15:07:22.112Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3d/90a04f0aa989b68fbd2efcd38237420afe2abe5a1cab0b5d7c2aa4f0dbb6/websockets-17.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c44776f82b04e623eb9e1b81fcd17ac6e9808ae1ba5cdf8edce1f7c869a95a9b", size = 226952, upload-time = "2026-10-30T15:07:23.643Z" }, + { url = "https://files.pythonhosted.org/packages/ad/3e/50952af22b8e3e2d03f7e83f0e335851c6b484c3fd88586626fb1c2a34b3/websockets-17.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4d2636a5b61c69e32db0e74b57073dd4a66f1ad195e9398c5f01bba41090deea", size = 224183, upload-time = "2026-10-30T15:07:25.507Z" }, + { url = "https://files.pythonhosted.org/packages/c4/73/2a4a5d9c6bca1127f24af7bf08f406a69052d7f341bc81f08d9e8eb446b4/websockets-17.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cfbbba4597f19ad717f79fd3f2a67ae7efae647bd6a61e14554e1b5ad242a5bf", size = 226991, upload-time = "2026-10-30T15:07:27.355Z" }, + { url = "https://files.pythonhosted.org/packages/68/de/90d96a579839bfe541ef214315df81d2bd519d952847c303328518ffdd02/websockets-17.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c7b996c02de5e032cb63dc65482b73693b7ecaa586654126be2749ddea239c40", size = 225600, upload-time = "2026-10-30T15:07:28.973Z" }, + { url = "https://files.pythonhosted.org/packages/91/17/12c15ed446d842e40918cd16e79b56ee4422d6fbf210258cb8882f50bbd5/websockets-17.4-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a920e99155d75d1b1c08172da8aaa7200e7b30871fb628d1631d7891a333e30e", size = 226366, upload-time = "2026-10-30T15:07:30.472Z" }, + { url = "https://files.pythonhosted.org/packages/9d/73/cb4c927e806a73a0377696e031ef3c0db409028cdb2373f96ee863e8df8e/websockets-17.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8c00c5c49f80a588a2c4f99d519d2abed4ce26cdca11273041bc8b7e60af60de", size = 227470, upload-time = "2026-10-30T15:07:32.122Z" }, + { url = "https://files.pythonhosted.org/packages/33/b3/e682b3ea069933044f4bf4809eea0cd83e3a5bdbdff601d1777a9ae90795/websockets-17.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:52c31d123f5adf14dec694c2a4036bf42c523df7cefc641d31cd05653de56e49", size = 225026, upload-time = "2026-10-30T15:07:33.544Z" }, + { url = "https://files.pythonhosted.org/packages/2d/e9/d039757260705e5a265a31c9fff36b0d4567b842ce2b54e5d14369f200bd/websockets-17.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d0acd8191c0e5a61d1c27bfa33b6ec8431982299f5d71c02129aa4f16f182ad0", size = 226007, upload-time = "2026-10-30T15:07:34.954Z" }, + { url = "https://files.pythonhosted.org/packages/db/e7/cb9907fac6f9b28f93beded6efda2953960cd02b633d432acf3451590859/websockets-17.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2a9cb5bbfc33b4ebd3c8d3714d6e09805437f60a14977774e4bd11b5ace46c23", size = 226286, upload-time = "2026-10-30T15:07:36.292Z" }, + { url = "https://files.pythonhosted.org/packages/39/99/85f6f4dd104a5d9a33a1ef272f501d0f2e8527ddf66be1b383d51f90ce56/websockets-17.4-cp312-cp312-win32.whl", hash = "sha256:c63c0d7832956d5f3bb77888b93c854569d13f806289ff75c43926d25c6e5fd2", size = 219256, upload-time = "2026-10-30T15:07:37.686Z" }, + { url = "https://files.pythonhosted.org/packages/59/31/d1636ba67ee9232a60033d90483e48686aa3856014e59110f29015f97bd2/websockets-17.4-cp312-cp312-win_amd64.whl", hash = "sha256:dde9cd67f18803949ebf96de8aba12b8ec5ee3115e34c75a2db85a3b0a6c20d5", size = 219561, upload-time = "2026-10-30T15:07:39.19Z" }, + { url = "https://files.pythonhosted.org/packages/23/aa/e3859d52188f041a5a05c9f3ac005a9c829723f521f0fe60e2c5f9c93bb9/websockets-17.4-cp312-cp312-win_arm64.whl", hash = "sha256:c634053459278cf31fb404ddb5ecd38124e4609e8b609166da621edc2d5796db", size = 219487, upload-time = "2026-10-30T15:07:41.161Z" }, + { url = "https://files.pythonhosted.org/packages/cd/58/eaf27fce59e3f5b9997cd7c77749ef214e077daeffac95479be6ff9f5cfa/websockets-17.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f24bed98595b9d854da8d6debaf82754abf3e8fe63ec90505ef560566814df7e", size = 218769, upload-time = "2026-10-30T15:07:42.558Z" }, + { url = "https://files.pythonhosted.org/packages/13/8e/287eca6d399a953253492189153976676994dfba1b7e82f0f992d14c1404/websockets-17.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:156221ad7638b5abccefd6f798916bf3f8ffd6ac51480eb4ba5b05df914ccbf3", size = 216454, upload-time = "2026-10-30T15:07:43.874Z" }, + { url = "https://files.pythonhosted.org/packages/b3/65/098fd4d221d691395492fcba88c895dde19a51d371b06b8d0be71d3f781b/websockets-17.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:74e46409666c358b93fce0d8c6f4cb107d8dd7cba1302a38d49adf6fa8193c7e", size = 216715, upload-time = "2026-10-30T15:07:45.409Z" }, + { url = "https://files.pythonhosted.org/packages/e9/29/9f9833bc83c1bf2e5597d1ef374d3ccd6467b9b45400cff399c85331ef6c/websockets-17.4-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:e3e80cad85ba68c07c1e8d4ccc9cf51e63bf6a73d6bf631640be947bd72b6b63", size = 226096, upload-time = "2026-10-30T15:07:46.929Z" }, + { url = "https://files.pythonhosted.org/packages/ef/75/6a95f93661bba2f1a4ec82eb26c6d30e6ba253569ecabb7a675139db6051/websockets-17.4-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:25eb661d8ba7e2b85ebb4e7a1bb9f6a3280910ed10b84330a7abfb5ed32d2764", size = 226382, upload-time = "2026-10-30T15:07:48.332Z" }, + { url = "https://files.pythonhosted.org/packages/80/b0/b0d9427dde0609e2727a9a966fb5fc5c6ef6aa7eba4cfc98791f8b7f1b75/websockets-17.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c74954409ea5789f7a60daa5f94580c00ad0b60b20751c47b35c4784877b5057", size = 227617, upload-time = "2026-10-30T15:07:49.799Z" }, + { url = "https://files.pythonhosted.org/packages/3b/00/fb1016d850d61676d1732434e2361d116c1de369078e59d21f4713115a19/websockets-17.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:47beedf07a706140b50786457e082497ee6b5970c41e49bcd1572ee3f4c73f80", size = 229054, upload-time = "2026-10-30T15:07:51.258Z" }, + { url = "https://files.pythonhosted.org/packages/77/c4/bb666e196541e42237fdb625303ad099005cc835c4e2e0a5d97bb9c4185c/websockets-17.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e282f35ece8895b9fa5af406fc6a4cb42f01e1009525cf46641de584781c83b", size = 228243, upload-time = "2026-10-30T15:07:52.975Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f1/32ae0f45d8464e1606ef3f6a54318d8754b27889de18bb1b2176a19bea39/websockets-17.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:361f9a21a33191d5287e7a75f508fc3b9bf47aaffb0241198d6b7be3384f294e", size = 226995, upload-time = "2026-10-30T15:07:54.574Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9f/5680151ef10e0bfb6f3bf09a992ce6c3e93bbb84fc8ec5d03ad570ac6532/websockets-17.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4073ab7cefe5a2e7dc368c1f01eb27716dc8ea8f1c69e9b7725ebce05aa53cf7", size = 224244, upload-time = "2026-10-30T15:07:56.158Z" }, + { url = "https://files.pythonhosted.org/packages/e2/66/409117b6882b91960598d62b95fac33d70a7aa2e1e1e854c6b64e76712f6/websockets-17.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a50bd9b44dd9b7b845802030b4d88610c01c7f95571b4cbd3a1aeec17a34c9fd", size = 227058, upload-time = "2026-10-30T15:07:57.539Z" }, + { url = "https://files.pythonhosted.org/packages/35/e6/34cab5913bea9d011ae2592a7672340179ff14fb98e889e5e41b071d8134/websockets-17.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ad2e9e152bec6c4f7e4cdb4adcea6b708400090eec04bfe5ee5b30d368ffd721", size = 225654, upload-time = "2026-10-30T15:07:59.044Z" }, + { url = "https://files.pythonhosted.org/packages/a6/b0/6cfe18e12f23618a3d69723c828037c1282fee7ffce006ae7b5cc0e58ca4/websockets-17.4-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5830f94a7190a33e55d06d89242ea951ee2009c3a27fc31538f3ac9386b27edd", size = 226425, upload-time = "2026-10-30T15:08:00.492Z" }, + { url = "https://files.pythonhosted.org/packages/c9/71/14d31ea34bafc07c6d96b362a44b301b9a0f2fb260490a8a6cb7db682bc4/websockets-17.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c0cc2cb47face4dae64bd70a9268dbebddb3e48c1b48cf6d7b6ac1471609fd88", size = 227532, upload-time = "2026-10-30T15:08:01.932Z" }, + { url = "https://files.pythonhosted.org/packages/28/69/df3398ca1320a8b76e57ee41053d5c09955383cf60888ffa5771f51a4cc8/websockets-17.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:d0b6a9bd86f865ebc9d847a1eb0a655a0e2b447cbcde743dda97c4298415cc0b", size = 225090, upload-time = "2026-10-30T15:08:03.328Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/06afe778cf9893e9ac10209c0d4c70aaf0b72289245a8b7efb92cc80927c/websockets-17.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7a7e9321822ca59ba56fa8744c3e3f01ef74d547aafe0d383d000d7a4d11eb79", size = 226041, upload-time = "2026-10-30T15:08:04.714Z" }, + { url = "https://files.pythonhosted.org/packages/c6/7a/28e9822dbf0bc63341dc45d8d5f1f1f7f375991fc8895bc731105fbde371/websockets-17.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:de29795f23833cdfb68ba45c8a5cc0ec49778ea5deb670188f4465bba5930d25", size = 226323, upload-time = "2026-10-30T15:08:06.103Z" }, + { url = "https://files.pythonhosted.org/packages/5a/d8/606c9c404e82731e4520f6397c8c16549e9cbd39ac583e7ea7d8972a6ae7/websockets-17.4-cp313-cp313-win32.whl", hash = "sha256:37ed7782972545e67d97ef9a172e9499d25459b1e32cb99d1c2a30c572f2441b", size = 219248, upload-time = "2026-10-30T15:08:07.617Z" }, + { url = "https://files.pythonhosted.org/packages/60/a1/17e507dadbfccb755758ba977b165fec92924dfc4a8d2573b4fc1561b0cd/websockets-17.4-cp313-cp313-win_amd64.whl", hash = "sha256:203e42eb77e06f85778a908b34c5ad032f34e98a68ef33920d6685c1e65a9420", size = 219560, upload-time = "2026-10-30T15:08:09.108Z" }, + { url = "https://files.pythonhosted.org/packages/01/ba/4f51fe8db73889ea3ecfdeee283d4ac3b7ad7a609c0e4c1fc6de04078021/websockets-17.4-cp313-cp313-win_arm64.whl", hash = "sha256:d8255971f6789cf0cb365e3e22b9b166eba978548a26241eaa5b7af0440d885a", size = 219496, upload-time = "2026-10-30T15:08:10.574Z" }, + { url = "https://files.pythonhosted.org/packages/1f/5b/085530961668661300de7248f9bf3ba84e98f47875f0fcc87637d024f82b/websockets-17.4-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:d0f943b53bb1d7389d72a5380078670e5fcc34a1328142148b72d20fd82031c7", size = 218810, upload-time = "2026-10-30T15:08:12.14Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fb/5a29e9569f74988822b7bc076287dd7f9f5b68a2070cf5eb4cfada5863d8/websockets-17.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2fd562372d4afaf18d1c7f1c68e39bd32818bb16d5f57f778a4a4ed88eedcaae", size = 216506, upload-time = "2026-10-30T15:08:13.561Z" }, + { url = "https://files.pythonhosted.org/packages/df/73/eb8544367c13cd87df39d41b74853741fb7182e2a4bb659ad7d36f9066c8/websockets-17.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a0457561e8a87a6a3b509e21c35084d7d207ced262139de3f738e9676a476bbd", size = 216719, upload-time = "2026-10-30T15:08:15.08Z" }, + { url = "https://files.pythonhosted.org/packages/24/fe/c3707e426d9bd779dfad9f319b2b431e5e60d563d7547d3780cbd1646028/websockets-17.4-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7b4ee34acefa9ba1333f02b817982f1e4127f6f9b975017a707c4e738d7f9fb9", size = 226098, upload-time = "2026-10-30T15:08:16.581Z" }, + { url = "https://files.pythonhosted.org/packages/c1/24/d203439f909ffbf37260ca28a3432381412d2e79912ebf98be572e63055e/websockets-17.4-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:ef03fb4b3685df0ed9dc6a074a090f030345cad2c23c61818da3e08e693a9caa", size = 226449, upload-time = "2026-10-30T15:08:18.29Z" }, + { url = "https://files.pythonhosted.org/packages/4b/17/3ae5d9486a170a222dd0437b4f2bc02ecf324177498a942dcac200e65d05/websockets-17.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c5e970d3996c597186c9dbb6e77a8048737a834ac03cb13186a54999e0e1c31e", size = 227695, upload-time = "2026-10-30T15:08:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/34/37/1307a8e30a961726f2350982fc01b0b3498db29b030c78c566e65ba64487/websockets-17.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6afc32a7a1a40b071070419537df3559d26907086556769683fa97b7b6e90fd5", size = 229069, upload-time = "2026-10-30T15:08:21.682Z" }, + { url = "https://files.pythonhosted.org/packages/9c/bd/4c6167744e202d20a3c770bcde8fae5d427317b1885712c2e02718cd8133/websockets-17.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5da7f7f1ecf866186f195f7ecc374c915e1838496b86f2f3b41da27c798a25c3", size = 228296, upload-time = "2026-10-30T15:08:23.371Z" }, + { url = "https://files.pythonhosted.org/packages/14/b3/3438eee41b39afb44c3c6e45dd686b88a7f8d742b96877b77de4fe0e0255/websockets-17.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:043945a43873c7c11a3f75238d475c95f902e967de329eb8763704546cfaa6b6", size = 227045, upload-time = "2026-10-30T15:08:24.749Z" }, + { url = "https://files.pythonhosted.org/packages/46/39/0bac9052d402efaad1b202ff2f1a57b6334aa624d20f509312765601b507/websockets-17.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:927d602fb8fb595a69e6b1ae998a6ec19851d0fb9391759456e6425090996647", size = 224297, upload-time = "2026-10-30T15:08:26.275Z" }, + { url = "https://files.pythonhosted.org/packages/a1/7f/5809f6ba5a7d1065301800daf605bdb661a9db5ef868ed189dbf691122ac/websockets-17.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:769e4f7b090e10cae4c082e3e39b9458ec2444505df84953c16c0468b16539c4", size = 227169, upload-time = "2026-10-30T15:08:27.703Z" }, + { url = "https://files.pythonhosted.org/packages/fc/f7/c8f6771e7cc2a038cf78bb12d04d29dbbbabf2a84d76999bcc94532f3020/websockets-17.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:03ddf4eb76ced8725dcbb000ff60b0fb8d7330ed011f6dc725a1925c5fe02051", size = 225632, upload-time = "2026-10-30T15:08:29.441Z" }, + { url = "https://files.pythonhosted.org/packages/2c/2f/9104786d952978ca2d011321109e35c05be24c3937ef2a62b4d6e25f7515/websockets-17.4-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:94622cf24e80d03054ceb69a06a86c950e12fe993ed06b933f7895232cacbc3e", size = 226415, upload-time = "2026-10-30T15:08:30.962Z" }, + { url = "https://files.pythonhosted.org/packages/ae/a7/2e1606b3d616b86bb6c70a62d5f87fc9a3dbd81f0bbe24c4706ace76751d/websockets-17.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:bc581579885728bb54ef15000295c20e6a64a200b1b73d5cfca71879a3eb3e1f", size = 227594, upload-time = "2026-10-30T15:08:32.443Z" }, + { url = "https://files.pythonhosted.org/packages/67/2d/78ca44e2be6d397aee63a4e68d3a99a33bb14bb3405e94688bc5a2160db5/websockets-17.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f42671900e0b602d05a074c52fd3d757c2f8e5c4f73f771794dae1aa4aea5f0e", size = 225146, upload-time = "2026-10-30T15:08:33.888Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/6dad684e54fc8e09d70c9a095506db5c836207d8e846e3cb1e79424e3492/websockets-17.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:2b23dacf7a8a88afe92f77bcdbf4cf043a84692bac2f2da02f4011c687e19b48", size = 226095, upload-time = "2026-10-30T15:08:35.285Z" }, + { url = "https://files.pythonhosted.org/packages/d9/e5/7b04bad7c11c1f92238429352defbac1406743338049afe1328c7a7f95c0/websockets-17.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:d48795c7d64ca1c42e3d61fcc6478cb15a19b6ad3f9c882bc8d8dee49d4a420f", size = 226395, upload-time = "2026-10-30T15:08:36.8Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/4eb29c4b12f77b3139470063308ae1e6a0860b9073b1d27d56e8ce19c512/websockets-17.4-cp314-cp314-win32.whl", hash = "sha256:8588edf317fbe4f16a949bc5a6ccdd22b6e6fd5b4745d128bc40bccf31024ce5", size = 218784, upload-time = "2026-10-30T15:08:38.263Z" }, + { url = "https://files.pythonhosted.org/packages/6d/85/2496a24de80c215b55a15f037bc368a2ed0ce7ecb1e909039ff4e76395de/websockets-17.4-cp314-cp314-win_amd64.whl", hash = "sha256:70293c25d79d1f084fdd665894481547575e429d2a75e8d72caec2f6b6b07af8", size = 219137, upload-time = "2026-10-30T15:08:40.112Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a3/cfe95d4eb569035e5a1d2e5cbeb4ccf0eb15a19e1ef2ad819a85960bf375/websockets-17.4-cp314-cp314-win_arm64.whl", hash = "sha256:adc30e5d064c9e33049e825408fa4e952f4e8a0cf4c329dc2ded72e1bb5bae08", size = 219017, upload-time = "2026-10-30T15:08:41.778Z" }, + { url = "https://files.pythonhosted.org/packages/2b/dd/4143048a2b27303e7de8ef53d7d0ee3987734fbf93e09491d5a1b0a55187/websockets-17.4-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:bbb6bed49f083e2ec8ae0bb21c00c7c5171ab8e08a8b008c61a43fc6c944fdac", size = 219141, upload-time = "2026-10-30T15:08:43.184Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3e/a63b5f3a5c24be2898eb22a3093a56d4ac4cd24ae79e7ab7a1b971ed4611/websockets-17.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c7a56140fcbf4662cb263754a754c651a16fe2196cae1fd232d18f89acd30c83", size = 216675, upload-time = "2026-10-30T15:08:44.682Z" }, + { url = "https://files.pythonhosted.org/packages/d6/80/f238a10f0b23853c665c602a42784023995ac26674e480252c21af39f4f8/websockets-17.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:18d3710becc612ec6f0229425bd6495133dfcbf30f7b6569585acc8ed2f1b452", size = 216880, upload-time = "2026-10-30T15:08:46.304Z" }, + { url = "https://files.pythonhosted.org/packages/d1/b1/899b69aba1e8d65ac5bfe90b97ada22a815f1dcd3840bf188104738aac33/websockets-17.4-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:00ad98e4bb0df7a6711c645eec16d5a9fdf99f0692bd4f5b6cb85a68677ba8df", size = 226462, upload-time = "2026-10-30T15:08:47.723Z" }, + { url = "https://files.pythonhosted.org/packages/28/a8/598c2b2a22dfe14d352400df804db8b78a68c1498b3f775a658f07f21618/websockets-17.4-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:7849a096d6fdba3f2bdf849eb89f2d233a24400c92faa3efb25fa8dc615b706c", size = 226741, upload-time = "2026-10-30T15:08:49.314Z" }, + { url = "https://files.pythonhosted.org/packages/6e/ad/84a6de3cc3dd4ee336428c31f89a82e002299f83e10d967f0e9a5cbaf591/websockets-17.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e30550965c78223439815dbdf40c93eb8931dfbf12427110dcfcaeebef76feb6", size = 227914, upload-time = "2026-10-30T15:08:50.746Z" }, + { url = "https://files.pythonhosted.org/packages/69/ab/1e191b97d60a934c071b7b73c39c5db39721a925cc53acd929c615f85550/websockets-17.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:725be1aff55f1c873a79cea0f612df9dff21a9d2c2e05783665b824b8aa7c24e", size = 230059, upload-time = "2026-10-30T15:08:52.596Z" }, + { url = "https://files.pythonhosted.org/packages/f2/57/ef8a64732ef4367091ab05f9b22c1ee4c28657d4a0d088a644198eb5ded6/websockets-17.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b6c7f91520c29420639925fd1cecceac9ca07366b50c09ea24eac1cd116b4866", size = 228486, upload-time = "2026-10-30T15:08:53.967Z" }, + { url = "https://files.pythonhosted.org/packages/48/1f/dbad3afcacf2c52d1fdf83b611d849598f0a047d7333ff476266532877b8/websockets-17.4-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6531540aa63e6864cb0615a3a5da70ae03191334507852a5385320bb7916df3f", size = 227216, upload-time = "2026-10-30T15:08:55.687Z" }, + { url = "https://files.pythonhosted.org/packages/5b/47/59e325d6ca3e04ba5cc7a139d891ef83cad3fb460a183c8f359f378b69a9/websockets-17.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0a57b99f2e28922b5a2434317580fd23fdf118caff4c5b752f5452836426205a", size = 224755, upload-time = "2026-10-30T15:08:57.203Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b6/28a471318dfb0060b58c47d0a252cb5078528a1aa1fdf5e6e88e2a61cf18/websockets-17.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8fd30d217a4275107667fe1d4f601e2d50c797d0727148cfbb384536d65f04d3", size = 227508, upload-time = "2026-10-30T15:08:58.597Z" }, + { url = "https://files.pythonhosted.org/packages/ee/29/7485ac6fc4b342b43964811381f56276fec967cae6a851ae4b815613b10c/websockets-17.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cc0cd4065a65ac98f3e2742ee9f314da9d224db49b07dc17d3a20cef0d79658d", size = 225961, upload-time = "2026-10-30T15:09:00.414Z" }, + { url = "https://files.pythonhosted.org/packages/95/a6/520e1f7aa9644ddf58f5a51fc37f46e15293a68cd35b70d5b81b7331ca1e/websockets-17.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:71f76bb8e59be847330b8a8d3753f85397677e128f9f9692c215f8cf721cefc7", size = 226851, upload-time = "2026-10-30T15:09:01.979Z" }, + { url = "https://files.pythonhosted.org/packages/e5/0d/444799abe7418f361da8c201c6858b64b4e8d47265f90851e5cb68b4d90f/websockets-17.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:c2db7b9e2d726f7e051bedb67abcf460b84b11437b2f9fdacda7e6931dace85b", size = 227869, upload-time = "2026-10-30T15:09:03.405Z" }, + { url = "https://files.pythonhosted.org/packages/cb/86/6da20322a07364a0ab0787a2b0d4367770f59404fdab6e35122413a7f63e/websockets-17.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:332b88022d0acd47c44158bcd43f47f14eaddcd979247f242b1a33291c45cdd1", size = 225562, upload-time = "2026-10-30T15:09:04.891Z" }, + { url = "https://files.pythonhosted.org/packages/2a/da/53e44d96238dc207011ad5d93b0540c58e1c680a86f48dc3fa8e5138b343/websockets-17.4-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:5cec3e7fbc911ff4fcf43b24aaf1b96906381ad36030f42897def3ff4b78729e", size = 226334, upload-time = "2026-10-30T15:09:06.42Z" }, + { url = "https://files.pythonhosted.org/packages/18/08/82cea972a87f229ee1903e9adf74c17d1e6c4371d581ebb11ccbed4e3a7b/websockets-17.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cbdf4b42f4514422051889424fd03bc269be8c5d751bf39ec29ad761590bd10d", size = 226767, upload-time = "2026-10-30T15:09:07.837Z" }, + { url = "https://files.pythonhosted.org/packages/96/f3/ee6afff802e39e8d6ef29ee4bdc30f8272aaa38295c19a911fad91fe95fc/websockets-17.4-cp314-cp314t-win32.whl", hash = "sha256:16550e24ac22c27e0a728100d8de196b5f054bab6748ef9f0b168fb8b3c32e35", size = 218918, upload-time = "2026-10-30T15:09:09.31Z" }, + { url = "https://files.pythonhosted.org/packages/11/56/b0b07917f9c85a4d24a37300f4ae888bfa7c20f08902dd6a5c61a0d1b26f/websockets-17.4-cp314-cp314t-win_amd64.whl", hash = "sha256:5ec906bb21b35e66cfdcc2ea0133f249f52b7d89e3e45ec8d2bd2d84a0255d7d", size = 219260, upload-time = "2026-10-30T15:09:10.832Z" }, + { url = "https://files.pythonhosted.org/packages/19/a6/a63113909ea602d3d22b0f32a7a9950d8d18b725cfdce735eab9b5f5d198/websockets-17.4-cp314-cp314t-win_arm64.whl", hash = "sha256:c00f0c45851a2c61efffd03dde8fb4d594026b5cc18196c94e15460f1225f2ed", size = 219176, upload-time = "2026-10-30T15:09:12.444Z" }, + { url = "https://files.pythonhosted.org/packages/ee/be/4032fde05e62d1c52edd250fda475e910cac0cd180e377690bff24147b5e/websockets-17.4-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:8c51ac7b31578a7275650f580aac985940985b6d2e57247ac6d5e07f2c936cd6", size = 218740, upload-time = "2026-10-30T15:09:13.833Z" }, + { url = "https://files.pythonhosted.org/packages/74/1c/b47f5786eb45599072411571651606fb22f6e825d522d627daad974ea636/websockets-17.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:023dc13bdc42a55e152acc81c39c90ec6cc4159ed17d23c6d73460fa2a73ab16", size = 216470, upload-time = "2026-10-30T15:09:15.394Z" }, + { url = "https://files.pythonhosted.org/packages/70/98/0021f55de633617b4a8390cca17e700c9ba5d99323103128412dc2c15aca/websockets-17.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:6fd8cac4907fec8302726d49e6969acfffaf720bc39b1cee23f473b81f4dce01", size = 216695, upload-time = "2026-10-30T15:09:17.185Z" }, + { url = "https://files.pythonhosted.org/packages/28/56/2c67389b47c4b9e9e9318d9b3e4bb52a2fef3749ff00b0b151a342c4d42d/websockets-17.4-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4441d655a53185ef1b01b1d42ad9b3a96b905110a9219043e3fdaec855ba3b6e", size = 226134, upload-time = "2026-10-30T15:09:19.156Z" }, + { url = "https://files.pythonhosted.org/packages/75/bd/ee3a679a10741a0cdd7aa8bdd6d03999069672826aa7a6495fdf589ed961/websockets-17.4-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3acc45494c08a4d27375a2c28474537f68910219f42624a08011221b04623d04", size = 226569, upload-time = "2026-10-30T15:09:20.587Z" }, + { url = "https://files.pythonhosted.org/packages/c4/42/b293a5d07099549797138d09fda5bf878d302b4980e61678981c8dfdc98f/websockets-17.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b78b39377630a70aa2198e5f03be416e690364a046b1d8af80a9263733083d0", size = 227726, upload-time = "2026-10-30T15:09:22.015Z" }, + { url = "https://files.pythonhosted.org/packages/2d/81/d048ff83c4d0fc386f6008529d12690d0dcb410f73570430f13fe4d543f0/websockets-17.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6cf4c002268da5c11cae9083aec71ac943bce9d95e0f83c8bf9a95a3ce421fbb", size = 229426, upload-time = "2026-10-30T15:09:23.444Z" }, + { url = "https://files.pythonhosted.org/packages/e6/21/1df51f94047dfb76c32fd7508036e4b55352d0f04fd0e3bee525a2122225/websockets-17.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed7fe197b8bb66eef4f62c052e33752d456d2fdda74805469d4bd954950ab339", size = 228211, upload-time = "2026-10-30T15:09:24.902Z" }, + { url = "https://files.pythonhosted.org/packages/cf/13/33d6a28471da4c30a98a2313c76f984be2056a703c5c532225dc28f5dba3/websockets-17.4-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f0494d3d97502e270282cc6a1f8648cd7335b4fe8d5c452006e5b7f9d62b8892", size = 227106, upload-time = "2026-10-30T15:09:26.315Z" }, + { url = "https://files.pythonhosted.org/packages/4a/86/ff8441e56ca677e51f9c826868fccde2a82bafe0ffa337fd38823b64253a/websockets-17.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ab9e4bd60796866c578e3afa0a17c98636887827a39c2e238a61989c18fd8e7b", size = 224499, upload-time = "2026-10-30T15:09:28.116Z" }, + { url = "https://files.pythonhosted.org/packages/da/91/470d7a619ce4aa837ff5b6a5836227c43bdfdc42ef837cce48f508992438/websockets-17.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:8d148b4b295224d3a19e7bd9f02ebe7344de254b3b2c4d0628ce42ade0bca119", size = 227213, upload-time = "2026-10-30T15:09:29.847Z" }, + { url = "https://files.pythonhosted.org/packages/a4/ba/55ed1422d6c73b5b81996ca195f2a256a339b26c553f5686afc2a926bc2b/websockets-17.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:6597a1f7413189b4bc58437babcdf39b79da416e5c477ae98323a88ecc108188", size = 225876, upload-time = "2026-10-30T15:09:31.249Z" }, + { url = "https://files.pythonhosted.org/packages/e9/59/f133d260e7a48d3e231c3a495eeb6114b880c1e96bfc781a949c1f73991c/websockets-17.4-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:a9b0026538719f7a532998d84640ab2e91ca1a051ce4b8d924fdcb607307e921", size = 226403, upload-time = "2026-10-30T15:09:33.199Z" }, + { url = "https://files.pythonhosted.org/packages/45/16/bb3355453ffdc31d3a14ddc0b50e058f13a97d2ed019ba6c380e03456169/websockets-17.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:a703f23ca15a51251fc94f1774683f5aa511588a7ad6bbb83960cdb2a4dcd978", size = 227558, upload-time = "2026-10-30T15:09:34.703Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ab/f3d55a83c2a4daa8bf62594b00a721dc8767518ccb833f932b0178eb6c19/websockets-17.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:6b061ea7ca94966af7cd7a87cb189ff15972c103244611a2b1e8408c04f1dbe6", size = 225369, upload-time = "2026-10-30T15:09:36.204Z" }, + { url = "https://files.pythonhosted.org/packages/88/66/3a320bfb718d9ae1eff15ba7790979c0e6fdec74e388430f426e6647d7f4/websockets-17.4-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:e6d2a185ec4ff0478089305abd833da3a9fda8803eb77325b89ebeae5585a3b7", size = 226268, upload-time = "2026-10-30T15:09:37.565Z" }, + { url = "https://files.pythonhosted.org/packages/da/ee/1f9cdeeaaa2d5e158b7a40f971e74b641b35f977674b46229a5bb14e270a/websockets-17.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:9a4e95d56994a45ac76541853796720436ffe462957d0b1b89e87ff3d3b1627e", size = 226530, upload-time = "2026-10-30T15:09:39.171Z" }, + { url = "https://files.pythonhosted.org/packages/da/28/506406ef09e6e168796f0187bdac0767f38a560e6785c4ee26e583aaaf76/websockets-17.4-cp315-cp315-win32.whl", hash = "sha256:b7ea61af293a153f2d67430038cf0efc10140caa623f2bdf5a9f5a457ff20f57", size = 218751, upload-time = "2026-10-30T15:09:40.748Z" }, + { url = "https://files.pythonhosted.org/packages/25/a6/818647a9a9b3ee8bf131e9ab4fa1f2db9c6539f08e7084dd57549e0bd49d/websockets-17.4-cp315-cp315-win_amd64.whl", hash = "sha256:8b45d40f07081b377f0b837ddbfba4a9ab4a89a7b569d3c095436564e767a27b", size = 219045, upload-time = "2026-10-30T15:09:42.251Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b2/0338a9abec3df8556627af987352657ce1c8456f2060b54741570b174122/websockets-17.4-cp315-cp315-win_arm64.whl", hash = "sha256:29b615c2d5dd883f89c107a782681b73a7aa8b2bd894130310e45eb09b143913", size = 218957, upload-time = "2026-10-30T15:09:43.866Z" }, + { url = "https://files.pythonhosted.org/packages/68/92/22e83d003cdbd22be5d35e28c260203e9fbb6c73b17a8e1509f4ad49e74d/websockets-17.4-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:c568e72f5425a74616daeb824afe28da460cbeea036432f41c6af5380b83300d", size = 219056, upload-time = "2026-10-30T15:09:45.528Z" }, + { url = "https://files.pythonhosted.org/packages/2f/ca/071d38e7237f6ada4f577b74f7cbf5bc2ff7e1f9360ebd2837e74a22dfd4/websockets-17.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:bfc86dff091104eec770c29ea1831dbe191968a70aa2d8ae8eda3240d863970a", size = 216630, upload-time = "2026-10-30T15:09:46.951Z" }, + { url = "https://files.pythonhosted.org/packages/fa/76/22d4523f92d88b8f5ebfd3df7ab5e825146af100f7e2caeae7d359ae51ea/websockets-17.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:f5f06f59e19aa0770aaf651ce91c196fa620b35aed49a7e6c36e7335f3f83db7", size = 216841, upload-time = "2026-10-30T15:09:48.285Z" }, + { url = "https://files.pythonhosted.org/packages/87/29/bc94be4a8bc19ef518e9efecd90a992f2991b7cfc6eb8a7430c4e2dc097c/websockets-17.4-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8f32a6cb0b101170abc2d8053af1473a2a29ef2a06d7130994ee8455a50f5dbf", size = 226992, upload-time = "2026-10-30T15:09:49.776Z" }, + { url = "https://files.pythonhosted.org/packages/fa/25/58f69b5fec064764ddf5b88045397433cdb028f5b17c82fbe047fd31fff7/websockets-17.4-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:72d0a731eccf482d5661c6711abfcd5921f3dbfbbb0789061e1918ef4bc89c70", size = 227258, upload-time = "2026-10-30T15:09:51.172Z" }, + { url = "https://files.pythonhosted.org/packages/21/7c/bc932a54c5f1bd78461574aea539fc562fd2de494738a2c0675c4de860be/websockets-17.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48c83103f82fce36191a9e3a8a80731d4340e2da544eae8c5aaaf6a45280e7d0", size = 228589, upload-time = "2026-10-30T15:09:52.628Z" }, + { url = "https://files.pythonhosted.org/packages/c4/92/57ec83066d0bfa8a9b9f594bc61951073c4a86e34c562a5292604118dab6/websockets-17.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c8052c3058c402d53602583da5ddcf1a15a63ab1efe0222f47c7be59944e6463", size = 230217, upload-time = "2026-10-30T15:09:54.058Z" }, + { url = "https://files.pythonhosted.org/packages/6e/fc/0f2fe533b5b4dc22ac704b3357f5c99fa60a3837218b3c6c6ad63a60120e/websockets-17.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0c22a9c6b2349204f56123dd0ca7779e989d68e336d0dc02ad823485d44925de", size = 229026, upload-time = "2026-10-30T15:09:55.727Z" }, + { url = "https://files.pythonhosted.org/packages/7c/cc/ed28307835106a9a2dbd1a5efc597e8befa3d0a5f2b46a4c1e466b2f4759/websockets-17.4-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0dcce83837328e6795225ead920d3aa8d867cc9d6922aa558b0e9111599fdbb9", size = 227904, upload-time = "2026-10-30T15:09:57.221Z" }, + { url = "https://files.pythonhosted.org/packages/39/4d/24ad7deddc7b31c3e430acc1c00c7b384ae42f1f973e9cc01aa42d19628f/websockets-17.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4b79ea31cf277c72d2307c6cb8bd32a2c151959e80a2f24fa85df620c5f2860c", size = 225253, upload-time = "2026-10-30T15:09:58.624Z" }, + { url = "https://files.pythonhosted.org/packages/93/f6/9c92230ebfab42fee482b236c45c32ed34b24f7360080b400cce6cfcac11/websockets-17.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:3d27153a0413696767b98b5d96173a2a7e27cbfca02000a6069cea7b977765a7", size = 228089, upload-time = "2026-10-30T15:10:00.308Z" }, + { url = "https://files.pythonhosted.org/packages/fe/7a/f523830e562da9b1d7a610174752753720c5e47e84b59b5fc47721d416bd/websockets-17.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:e0feb03a338f8f5e819ae23a73aabb7b46fd3b73f15f7df782dd12d99e2b02ad", size = 226743, upload-time = "2026-10-30T15:10:01.744Z" }, + { url = "https://files.pythonhosted.org/packages/2c/e6/d1a56495cb7b1a0a4688145131be38cfd0c1342bde8125e136a6e6ee494e/websockets-17.4-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9ff89e36451a19775e7556d95ebfa4a0b24b84cc87565d6b5d0ec8ea82bf3f2c", size = 227237, upload-time = "2026-10-30T15:10:03.417Z" }, + { url = "https://files.pythonhosted.org/packages/44/41/c4e53f7ad63838d7eba6e82c5d743827e91dafe5e48c88a58f7e90043945/websockets-17.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:ee6c4e0085bff5f6621bf9c53452584dcb91ebd993ce841e1f4061ac12b6b556", size = 228348, upload-time = "2026-10-30T15:10:05.149Z" }, + { url = "https://files.pythonhosted.org/packages/ca/01/f6f78c3edeb8ad2b3c35a8c4117ec2cf9346215afaed8155af1e7933818b/websockets-17.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:1962f3bfde085af18878f1bb1aafb300c9a6ac33da886d0b0d97e33c9ce7a222", size = 226099, upload-time = "2026-10-30T15:10:06.588Z" }, + { url = "https://files.pythonhosted.org/packages/8d/01/d8c11740231b63d1aba6bad6b1d4e72e8384b26c5448801da238ebe82c92/websockets-17.4-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:42d7a6e818214336cf7af9a3aae5c6923f94f09fa07ac5aab98268ba2a98a6d5", size = 226956, upload-time = "2026-10-30T15:10:08.141Z" }, + { url = "https://files.pythonhosted.org/packages/99/87/dbfd43ae01ea8fdb7478a1b3d58b32aca83bb9c4aa61ebe187d1e188ac8e/websockets-17.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:c9f8fdb7bbefc4907c2bb3593f810f2b67a2d5329e1d38724a1aa3d763cf63eb", size = 227253, upload-time = "2026-10-30T15:10:09.533Z" }, + { url = "https://files.pythonhosted.org/packages/bf/8e/fbd968a75428063560ada02d564de8d6c49ca34ec29dfb78e5d900f4b0ef/websockets-17.4-cp315-cp315t-win32.whl", hash = "sha256:506623128d7a55b726a5a46e4c9a8eae4c9dd0f04ff60b041fe7df85b9d034fe", size = 218877, upload-time = "2026-10-30T15:10:10.925Z" }, + { url = "https://files.pythonhosted.org/packages/f9/53/8f37a3943517bba77fc86f7c4162c455018c5b6d760c5e9c9a11de9e37f7/websockets-17.4-cp315-cp315t-win_amd64.whl", hash = "sha256:6e6558efbb256b532c9f06a21ba42bcac729718e365c505819f181f25e5c0eca", size = 219195, upload-time = "2026-10-30T15:10:12.336Z" }, + { url = "https://files.pythonhosted.org/packages/69/35/cf33cba7248fcd80cfe5911ffe67aa2637f50c2bfaada123b1e9d2aeca90/websockets-17.4-cp315-cp315t-win_arm64.whl", hash = "sha256:fcac44d917672ad6257ad64b80b5168306f168a78cab5c0612e4c699caed18cf", size = 219117, upload-time = "2026-10-30T15:10:13.771Z" }, + { url = "https://files.pythonhosted.org/packages/a0/80/78c580302991d229ac5ad0a00c361916f7f84deaf6dd76370034dd8e7383/websockets-17.4-pp311-pypy311_pp80-macosx_10_15_x86_64.whl", hash = "sha256:73b00645316121105274fd266ed54a20e6514650126d399cdea39876ab1e7b04", size = 216364, upload-time = "2026-10-30T15:10:15.472Z" }, + { url = "https://files.pythonhosted.org/packages/d9/27/7d18d381994c7c27a855131ae064ff43ec00ded636b7c6ead4abb4cec841/websockets-17.4-pp311-pypy311_pp80-macosx_11_0_arm64.whl", hash = "sha256:02f380df26de14999ecace203fe1396ac14d1c6132afc7924eb6f8c8b646c69d", size = 216642, upload-time = "2026-10-30T15:10:17.153Z" }, + { url = "https://files.pythonhosted.org/packages/fc/91/43e73997fbdc7ef3cb434148888329113a07b66d97a8ea6aa2f93e574028/websockets-17.4-pp311-pypy311_pp80-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f5b1d315a615cec81a79e2ce3a94221dc5c23e7fd4012897085d3b5e5a5638d0", size = 217587, upload-time = "2026-10-30T15:10:19.123Z" }, + { url = "https://files.pythonhosted.org/packages/a8/17/5e3e6be945512aff7351c9f60134803902ccb07cd7d6c9becdfa349a32d5/websockets-17.4-pp311-pypy311_pp80-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:046ed16d3d83d64594e4a40655fef061ccf36059d8c30a01feca8a9481fe13b8", size = 217478, upload-time = "2026-10-30T15:10:20.665Z" }, + { url = "https://files.pythonhosted.org/packages/7d/5f/0a1ee98aeff04c200492a479a386ff106d1ef6d5c9d6613959b3e3d79469/websockets-17.4-pp311-pypy311_pp80-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f772007dfba8941873dbd276b6a6845428cc740888b5c6c37bf483b1ea34b42", size = 218371, upload-time = "2026-10-30T15:10:22.35Z" }, + { url = "https://files.pythonhosted.org/packages/17/97/acb333fa9a54bb1ad616c1add65185f9ab580c3c76366a3d1abc1090979b/websockets-17.4-pp311-pypy311_pp80-win_amd64.whl", hash = "sha256:accb5e9492b9bc9c9aeec5b72ea8f2ddcbefc6143d1c626fba960ecbdc89807e", size = 306811, upload-time = "2026-10-30T15:10:23.76Z" }, + { url = "https://files.pythonhosted.org/packages/e9/a3/d8fbc72c5c0e78905caf2d6dcf806e532451e3f48e2a09a8ebe1de9ad412/websockets-17.4-pp312-pypy312_pp80-macosx_10_15_x86_64.whl", hash = "sha256:c7f66a53e9b7ec831abb15e3d9b6cee8f52d6a24cd0a374786bf46c3ec218bc6", size = 216397, upload-time = "2026-10-30T15:10:25.255Z" }, + { url = "https://files.pythonhosted.org/packages/d3/de/1bf313cd0f4662df4884a7602932cd13347090e59dd6047865eee2bb5aa5/websockets-17.4-pp312-pypy312_pp80-macosx_11_0_arm64.whl", hash = "sha256:4fb2db1f649b6464711846b5bb9c1611bd906ce939d9460cbd1fa419552cd6c3", size = 216664, upload-time = "2026-10-30T15:10:27.016Z" }, + { url = "https://files.pythonhosted.org/packages/30/e2/7912bd417511b54907853bd495aef2daee111062dbafd43d133a3f7253a7/websockets-17.4-pp312-pypy312_pp80-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:32110d954d9d0e51f36edb0396673bf4d35193a0a80ba7013bf7f7d58a33ca07", size = 217603, upload-time = "2026-10-30T15:10:28.475Z" }, + { url = "https://files.pythonhosted.org/packages/56/6f/2e8d5610f6184a2e1720bf8ce256402ed99ad30ea87c461fba5bc4d651d9/websockets-17.4-pp312-pypy312_pp80-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:88ba8a439b2bad97bb69c38db5bf0ec16a061ee834cf0f244089186ee803e899", size = 217489, upload-time = "2026-10-30T15:10:29.999Z" }, + { url = "https://files.pythonhosted.org/packages/29/3a/a05bc57eadcd7e8e072d917888128e6d22e1203984afb21a8da3198982fe/websockets-17.4-pp312-pypy312_pp80-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:868744c68e9342768888c7326604da2228c19bb6946aa46b5f9e1ac32ea8d40b", size = 218356, upload-time = "2026-10-30T15:10:31.432Z" }, + { url = "https://files.pythonhosted.org/packages/b2/49/eed86bfb8863093a82cbaa52c9159be1ce2374d5ace6fe1f8e8031567e7d/websockets-17.4-pp312-pypy312_pp80-win_amd64.whl", hash = "sha256:829bcaa90be8737c132d9515d6a466e8528e3b3d050d3f3466f36ea94d3beb48", size = 306838, upload-time = "2026-10-30T15:10:32.954Z" }, + { url = "https://files.pythonhosted.org/packages/eb/27/9db924cb0dbf22eade78d98fbae77790f9bf6bc729e6ab29aef9d68e4156/websockets-17.4-py3-none-any.whl", hash = "sha256:c6bd2c9781915592b209160d0f017d4c7c82ad53075e6b0c24d2a89299e7f9e9", size = 212900, upload-time = "2026-10-30T15:10:34.482Z" }, +] + +[[package]] +name = "wrapt" +version = "2.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9c/b0/f752d19e1e83ab8bd64aeccfde32ff086aee3ef08520f7340b69a8d0a4d2/wrapt-2.5.2.tar.gz", hash = "sha256:551cb49e88b3722faad780303833bc4fa70685fb1773270fb98b40d39d9fddbf", size = 186066, upload-time = "2026-10-29T23:06:39.868Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4d/c2/b4bbaabf73ea9ccc2e322a11455a95d7d9dcae5bbcc6fd836c5f676a082f/wrapt-2.5.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8b240a879405591da10e2d20c2d1ad29b978d40ec37e24801296cfee1d4c04f9", size = 105761, upload-time = "2026-10-29T23:04:28.866Z" }, + { url = "https://files.pythonhosted.org/packages/f7/d4/57db9384ffb339f29b6712cc1d7d4ace29d07670756becf9ad336728ca42/wrapt-2.5.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b632d90ac0d04e3ba8821b19954d6c36ea8f714b75db53c58015025fefccb1ac", size = 105933, upload-time = "2026-10-29T23:04:30.45Z" }, + { url = "https://files.pythonhosted.org/packages/98/00/a0effd5872aed3271b28b4740a71bc2d7406d33b4e03eac01ae099ac8569/wrapt-2.5.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0743950d3dda9940e56f81f5334ba051c4fe2e1421e4e4a4ef8eb8fb86a90894", size = 240286, upload-time = "2026-10-29T23:04:31.855Z" }, + { url = "https://files.pythonhosted.org/packages/69/22/8e9ef3a15115f3cc01f2460aaf9aeb04819704fefd218086642c7182be95/wrapt-2.5.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:594c6d10b9cfb951a09f7338531a41d31194e7eee9dee206c0a8992421682719", size = 241793, upload-time = "2026-10-29T23:04:33.501Z" }, + { url = "https://files.pythonhosted.org/packages/15/7f/b2912f3d045fd9a5f30d9d58f3b4df8921c87e902524a32d7eb0e0e315cb/wrapt-2.5.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e4362b3b4e4b050b8f1f518e0c71a09f2e938a9f62ee559ea1743a13b3c9e8f1", size = 226781, upload-time = "2026-10-29T23:04:34.862Z" }, + { url = "https://files.pythonhosted.org/packages/ab/06/cdd488014d5010b052fdd9c368d8598accd9eee766d98e698cc8510b364d/wrapt-2.5.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:81e685c7662fab9958a852b9c86f3b5b8eee45d047a2766d6c23b63ad1eee423", size = 239441, upload-time = "2026-10-29T23:04:36.296Z" }, + { url = "https://files.pythonhosted.org/packages/dd/b9/6605b2fd612ea1635d0a7cebbdc05cdb59c97a07ee9c418a5f43a49cee53/wrapt-2.5.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:c6b4bd8c662c333518a9aedb35bb9f4f7d1584fbef4bc1507a6c6a47357c628e", size = 224041, upload-time = "2026-10-29T23:04:38.008Z" }, + { url = "https://files.pythonhosted.org/packages/42/9b/6a8acfd407991b50b9bdbaaae5551cc12ba487a8a0973c87793dac621f1f/wrapt-2.5.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7a7efde469ad904b8e05f98c76d63b437f4756c30ec7b9136bef02bdb5d1b14c", size = 229602, upload-time = "2026-10-29T23:04:39.463Z" }, + { url = "https://files.pythonhosted.org/packages/81/6c/9a975e802393c74af9879ca938b298a00fd59074ee90abf4ec4bedcdd109/wrapt-2.5.2-cp311-cp311-win32.whl", hash = "sha256:73d432588d1e0a8fcb88d46ef2733e848ff0c3e14111a0420c77199fd2a8cd30", size = 100856, upload-time = "2026-10-29T23:04:40.884Z" }, + { url = "https://files.pythonhosted.org/packages/46/aa/196ab4e3584e547fcb6c4a622934aae14077c367b86f57a5ab5e76a47203/wrapt-2.5.2-cp311-cp311-win_amd64.whl", hash = "sha256:04703a2a4eea122c3a6b3af89e72bbbaa20779e5c7199c3d06e3fcb6601bc7d4", size = 106052, upload-time = "2026-10-29T23:04:42.232Z" }, + { url = "https://files.pythonhosted.org/packages/e0/5d/7a699446d344bc74bcd607a0cf09087285a253eefc6449048c0df7b5a3e5/wrapt-2.5.2-cp311-cp311-win_arm64.whl", hash = "sha256:53cf804402d49fa2c920a90dfab971a82bca67fb43e54adc7c3b24c054485b4d", size = 103001, upload-time = "2026-10-29T23:04:43.529Z" }, + { url = "https://files.pythonhosted.org/packages/4b/fe/9ccae0a147d0732397f54ff232b1a0da148a4099f17c1b156b9d3e79127e/wrapt-2.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bec3b6b1ae2f7ed763fb0ba1776b9b5f11283e6ff40c9cbe3a855ea652c326cf", size = 106628, upload-time = "2026-10-29T23:04:44.962Z" }, + { url = "https://files.pythonhosted.org/packages/d5/ca/a61d994df49fa422abd859e525e04b95ef2888e3818a0f451aa7d4d3527f/wrapt-2.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e57d79e3338b3cecee1dd80d6ef8f945f8ea7b92f0d8d5591f840ffa0afc14dc", size = 106264, upload-time = "2026-10-29T23:04:46.307Z" }, + { url = "https://files.pythonhosted.org/packages/dd/26/a6caa9a84ef5db4a273787949cea7ab51f6001d2548768af4c8e3c49debd/wrapt-2.5.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:092472b7b1494deef40dac5e9f6295013a9d51b112b5fbc4350f64dc2574e46a", size = 250614, upload-time = "2026-10-29T23:04:47.735Z" }, + { url = "https://files.pythonhosted.org/packages/c7/28/2189571e711ab31cb7f682c739d05f033ae0e83e12eb4d5d21473ca2cd1a/wrapt-2.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d108bd98ab2c5ccbf55cf2154e0a73341df930030df2e01ee35d71a44a99d3ad", size = 250770, upload-time = "2026-10-29T23:04:49.183Z" }, + { url = "https://files.pythonhosted.org/packages/80/8e/46a6cc2e8215df7fae292178a355df729547ff9b912686823201d38be269/wrapt-2.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:858511731d6ede4217960c5fecdb5ecbf90e306dfd93b837395658d61374a498", size = 230031, upload-time = "2026-10-29T23:04:50.641Z" }, + { url = "https://files.pythonhosted.org/packages/97/38/dff531d0125fe880e05fe5fcb89f144d25ffbe95aa9a2c50539eabde7567/wrapt-2.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3b6885250b809532a634acd56e360d57c201c1cdc75cbf2b5e106241ece6cbc3", size = 247325, upload-time = "2026-10-29T23:04:52.16Z" }, + { url = "https://files.pythonhosted.org/packages/f0/5b/f4a78df4c52175d53ff095f2f5a54206a2d16e542b1dd2cdcaed901fe432/wrapt-2.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:c60a5cd8b7b510056f2643d94f1c144533a568ade2891a9dd35733f5e0055777", size = 226900, upload-time = "2026-10-29T23:04:53.559Z" }, + { url = "https://files.pythonhosted.org/packages/20/6f/8eab144c717300f76f1337ba58091f4de5da0f4d772727c9f41135b325c1/wrapt-2.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:40e03506f09dbf4854fd69848e843dadd9b7fbbdd217837cb27b37fb8f0b5bc3", size = 239017, upload-time = "2026-10-29T23:04:55.293Z" }, + { url = "https://files.pythonhosted.org/packages/59/1a/98e278ef2f8952a34f847a91f75899f6385762b07577c51a5ef82c768dfb/wrapt-2.5.2-cp312-cp312-win32.whl", hash = "sha256:ac00ba7d22d55d3c8d085005ce4942ff3bb118d480f889b5984f1d3454052917", size = 100660, upload-time = "2026-10-29T23:04:56.703Z" }, + { url = "https://files.pythonhosted.org/packages/7d/0a/ab645f8b4c594cac2db49bbc805bff97a9d3f2944061b865f67e0351b6c8/wrapt-2.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:36021ef761856bdbc10d5f3da9a95af93ef60d6acf9c72c8f849937ba2b902aa", size = 106220, upload-time = "2026-10-29T23:04:58.081Z" }, + { url = "https://files.pythonhosted.org/packages/37/1e/232868b68b925ab29ca5acbec4ad54ee42a853fcd8f596bf7e0e0e3850f1/wrapt-2.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:81bdf0bd141d9b1706a0751b2ee068c7afe6be4042712d427b32b3072d5c40b9", size = 103377, upload-time = "2026-10-29T23:04:59.366Z" }, + { url = "https://files.pythonhosted.org/packages/1b/7a/38f08a89ca8faa9b788a857f109b5e4cd1f25671a5157e2218072f64aa76/wrapt-2.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:88f982c2bb306732271aa15cded4002ce28b5d9023de9d11e927da4dcf65e441", size = 106242, upload-time = "2026-10-29T23:05:00.746Z" }, + { url = "https://files.pythonhosted.org/packages/e9/8b/2fb9b2522b7e1e7534a72fec0040bbf3d273129ec0a98316e7d37b09aa35/wrapt-2.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:269321b17467a10997cc6e14793bf1816e6ce488f9711c74b72552466d206739", size = 106366, upload-time = "2026-10-29T23:05:02.191Z" }, + { url = "https://files.pythonhosted.org/packages/c2/1e/770d73e0cc82a41602cb2cb184769c28bdbaa9b998944d577a1097c18da3/wrapt-2.5.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8b039b3a296762db1908d6108365225393c4fb33c1dbc5f00aa36f8302eaeaa0", size = 248696, upload-time = "2026-10-29T23:05:03.593Z" }, + { url = "https://files.pythonhosted.org/packages/ac/2b/b4362e803d870451b5e701df5e30ded2d6fb1d9e0c01eec4dc7fa8332b57/wrapt-2.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1af6136ac5bcfab17190a70b25d8437eb8d8f9ca2b821a0655d39275a8cb7e7", size = 248663, upload-time = "2026-10-29T23:05:05.084Z" }, + { url = "https://files.pythonhosted.org/packages/87/15/244dbd2d86285857898be5f7632e8375161953e645f250ac9778c058ab9b/wrapt-2.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9d4e1cdf2efdc7181c8177f6090886e22278e70f7257df12863d2f52a9dcbbd7", size = 227568, upload-time = "2026-10-29T23:05:06.836Z" }, + { url = "https://files.pythonhosted.org/packages/62/0e/15ae5812d510fbfb65acb3a63aecbd8ffb4b944b2fd0131d968e31df89d6/wrapt-2.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e33578755e07edf3a70df3241f4cf376dad507e2cc73e737311bb00b5067f4d7", size = 245147, upload-time = "2026-10-29T23:05:08.322Z" }, + { url = "https://files.pythonhosted.org/packages/f6/c2/e611b881c05f7f2a5c88f9d89236afb091b8adba3ac89ff9040b6a837be4/wrapt-2.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2bf23cde96e0f771a6a2c68973c1ded45c9707f8bd519ede30ecf075f3c720f6", size = 225491, upload-time = "2026-10-29T23:05:10.102Z" }, + { url = "https://files.pythonhosted.org/packages/f3/f4/bdb253208ec907097809e34c25d199cd66686a7974257e08b57d96e3176c/wrapt-2.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eff91af619ad5d587f8855f6c02164e12d33d205c702eb73d487deb499520265", size = 237319, upload-time = "2026-10-29T23:05:11.625Z" }, + { url = "https://files.pythonhosted.org/packages/67/86/74205217834201f27bc73a76b4db67f488fd07787e12a045fb2b39f09c29/wrapt-2.5.2-cp313-cp313-win32.whl", hash = "sha256:11655df8e17658a67628cdc97fe95d6b263e023213cf18067f21e5ec0b0285f3", size = 100634, upload-time = "2026-10-29T23:05:13.073Z" }, + { url = "https://files.pythonhosted.org/packages/e0/56/7c732aed39116853d74485b4431a0ea37b05bd2bf250bdddc55ceb64f8c0/wrapt-2.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:5726faa7342ba473041bc1a276486d232b42e3927d35427729b266b1b5ecaa42", size = 106044, upload-time = "2026-10-29T23:05:14.372Z" }, + { url = "https://files.pythonhosted.org/packages/0c/a7/c4f7ae891bbfef566aa63effe846f6804dac4c0461601993f4c59deaf955/wrapt-2.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:e1fb4af8aac3573770ed3e64efc39d953342b12bcb6e6479512a945eb5557523", size = 103077, upload-time = "2026-10-29T23:05:15.718Z" }, + { url = "https://files.pythonhosted.org/packages/ac/dc/a259acf2b59eefe400b2a1c6b45bc19b0d0b583722426c9dabb276cc0d19/wrapt-2.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:229859aebfc909626ea6b5a3ae9523aba43c63fd828f876f2a813f4a5767726f", size = 106620, upload-time = "2026-10-29T23:05:17.256Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c5/b34ca079b7906eb043c53c06896b4e42f3ca9efa97ac10e4e254c88e2ca6/wrapt-2.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c1ea16d7dfe7d235d29435307b1539495b4925e88b135d532892973a04569245", size = 106555, upload-time = "2026-10-29T23:05:18.656Z" }, + { url = "https://files.pythonhosted.org/packages/e2/46/f66042c9ed3626cdcdf641105f091964f6d38cd406cec96479c4a3f70640/wrapt-2.5.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:59b7e6d1dea7c3f38bab21954f587499c27c16ea537058eee4add6e4da1780ea", size = 251681, upload-time = "2026-10-29T23:05:20.035Z" }, + { url = "https://files.pythonhosted.org/packages/70/95/1ebe33ff8053a94b3e1a0bafe31ea94b5e9296f9c5098cbcafc4ee2bcdc9/wrapt-2.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cfd508866c421687a99bed9ce5b7b4f26fd9b93d3753685d81947ab37d54c496", size = 250919, upload-time = "2026-10-29T23:05:21.501Z" }, + { url = "https://files.pythonhosted.org/packages/1c/bf/ee90a8674c8f2179ad7aeaf8c5b875fa33a12fec7bf1ccf6cbfcc31fbbf0/wrapt-2.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:459bb66cd4bc43e35cba1f1ab2bdfb9b507e0d8dc0ec40c93a060c9cb0c5415e", size = 231773, upload-time = "2026-10-29T23:05:22.996Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ee/610ef6bf4f35e4719a5edea6bd0c4d948921d028950bc9669d1fa9234af9/wrapt-2.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a8626135ecbb0b892ca79c388581ab0ef57e087f09dc0e51a2f34185d3682055", size = 248171, upload-time = "2026-10-29T23:05:24.481Z" }, + { url = "https://files.pythonhosted.org/packages/c6/10/6f12cf42bd9a34829c902c8a617c8151a4e16e7d7cb015289eede5813f39/wrapt-2.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:7ffa0be31f651da63ee51e5b74701339feac1860b561a985c7b4869d4600e800", size = 228970, upload-time = "2026-10-29T23:05:25.904Z" }, + { url = "https://files.pythonhosted.org/packages/b1/f1/79417514032b9015b772bf5bf006ca542937b5f6c483b9ab092f9ceff8e9/wrapt-2.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5ab31d929ca8b2b7bf9320ad2a927edfb1841609951a869a9b98723b285ffbc6", size = 239267, upload-time = "2026-10-29T23:05:27.502Z" }, + { url = "https://files.pythonhosted.org/packages/a1/ce/092f2723758586973c94afa8c38a206ce3720ec5cd3edb64ee9c8b27a1c4/wrapt-2.5.2-cp314-cp314-win32.whl", hash = "sha256:afd99530994449aaac9a58e1e268eb080bb1ffd758be43ab2f8a249ce8970c9c", size = 101091, upload-time = "2026-10-29T23:05:28.955Z" }, + { url = "https://files.pythonhosted.org/packages/23/86/201fb9180290373b7fdff18e8d600151694fdb0b10892cdee77c13eb7e6b/wrapt-2.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:fabc60720d1e4a36bbe8aaf1c32024f04c6674991313f5acaca5eeadb564c600", size = 106417, upload-time = "2026-10-29T23:05:30.395Z" }, + { url = "https://files.pythonhosted.org/packages/73/a8/cc313dc9230f4b5029e24867a1fc1dbcb929b792b02ac5fb2e0d79df7401/wrapt-2.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:1c17ca5ce83c7145eddaa20073398ec2192dad65c8d8ff4d9b78fd2917c46a75", size = 104145, upload-time = "2026-10-29T23:05:31.788Z" }, + { url = "https://files.pythonhosted.org/packages/62/04/15e0c465088fbfdab321a672c88739f68429a18aeb81ad7995a0a5cf2065/wrapt-2.5.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:a60863d874cc6ac917bbf44324e3f195564064dee15c84e83b19e1fbbccd3169", size = 109731, upload-time = "2026-10-29T23:05:33.131Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b6/91d6f77257afabafe19bca698b41d60dde7cf49b59b0126eb25ed6a3a90e/wrapt-2.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d41c45517912610de55546188695e2bd0fbcd70b585087cd759f85a96f47be7e", size = 110032, upload-time = "2026-10-29T23:05:34.589Z" }, + { url = "https://files.pythonhosted.org/packages/9c/84/40901e8ba08f6f18f213fea51daa41a8107ccaae4e0b6e13b842f02f5feb/wrapt-2.5.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:48fd5026977adb3e2fda292a6a796967b511935d23f97dc2ae1f127a3a8639d5", size = 284278, upload-time = "2026-10-29T23:05:36.033Z" }, + { url = "https://files.pythonhosted.org/packages/89/af/6bfdffc2688a78019762f0b14171ca47c73fae1421c3324c0850135b212c/wrapt-2.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0d7639c3287d4efcdc2c8837f1854d1ecf27aae761714ba3d95e61fe8eb48db3", size = 294060, upload-time = "2026-10-29T23:05:37.515Z" }, + { url = "https://files.pythonhosted.org/packages/56/d1/9a4e3aed00d6d877d2646072d9b6b4c9a558a8ad79a18d3abafc1079cd07/wrapt-2.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:eeaa40251c40e18c5c97ef11d5dbbad28a7b7b99fdd7a7469662799100d74dc7", size = 263272, upload-time = "2026-10-29T23:05:39.008Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6f/0086e02aae9144a0fa029fb0351a8b2f91fbd28eb191c8f2ced3831cb1ba/wrapt-2.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b9ce67ec8803e6c56e78c9ebf726f61116516212c28dfa3683d0962e15cf9a62", size = 289219, upload-time = "2026-10-29T23:05:40.459Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ac/e342f997166b7d433abc12720b6e30793fcf3a36c5457d22261558b61411/wrapt-2.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:4d5faf5c3e435207b3a51294ed5a00e5e17e3842442ccbbd864ee9bc0efc63fb", size = 260554, upload-time = "2026-10-29T23:05:41.815Z" }, + { url = "https://files.pythonhosted.org/packages/65/64/48ddff54611f6e08ba70adf1b3dbf36c7b08b7aa5dbf7c65a03672b0eed1/wrapt-2.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2861d50a4f330fa140ddc2a9ddee33f7e4f9bdb649a23dc9be8ed6310ffa47fc", size = 278921, upload-time = "2026-10-29T23:05:43.489Z" }, + { url = "https://files.pythonhosted.org/packages/c0/bf/0ca422495491f22656b401832184a87b1e67d1dfb7f31ac8d60525c572ce/wrapt-2.5.2-cp314-cp314t-win32.whl", hash = "sha256:46cee4400437c9f33e755522be9e7ce6ebd097273f464eb6f57bee09787f0c59", size = 103586, upload-time = "2026-10-29T23:05:45.046Z" }, + { url = "https://files.pythonhosted.org/packages/69/17/922d99009a228907cd0a5f5d590bbc176dd70527d3eb06f8b4d74889edf8/wrapt-2.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:1ad706a42b139ad7f03f32aed57da5e10fe8ed707e29849cfa94f1d49cba1405", size = 110111, upload-time = "2026-10-29T23:05:46.458Z" }, + { url = "https://files.pythonhosted.org/packages/68/45/d168c09643e3207c5618b33a5636137f298b9ded38b3a33fad67dc343403/wrapt-2.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:450cc93f5a2d58d4a74d384d52db4b41d5728065c0057c9bb4666c6115f2a2c9", size = 106384, upload-time = "2026-10-29T23:05:48.051Z" }, + { url = "https://files.pythonhosted.org/packages/67/8c/3b2b95cd60b78f9450d748854e421fcf48bc350d76ca9e0fe048b87ad796/wrapt-2.5.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:2c17ec4310cc06f864799a4c37c1c716d5dcf05ceead2e63ca992a9466903b73", size = 106621, upload-time = "2026-10-29T23:05:49.433Z" }, + { url = "https://files.pythonhosted.org/packages/16/12/c430cd1289711cdf2b6b1c469d5efa527f4815fabab32bff3249545344da/wrapt-2.5.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:430070776fb30d925a7a1e13d68086e4731b63eedf4c43ee62fc4c8108920cce", size = 106590, upload-time = "2026-10-29T23:05:50.967Z" }, + { url = "https://files.pythonhosted.org/packages/69/4b/d7230c57ca30023a5630bf5cc0e092ad1cfce4d999a309b8377a36b3c249/wrapt-2.5.2-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:99978d196df45c115273c6119e4d0dacbc67bc267a196506625bf7084b741f0b", size = 252192, upload-time = "2026-10-29T23:05:52.344Z" }, + { url = "https://files.pythonhosted.org/packages/fa/74/6dc841c96b9906e0c466aaeed7f51162129cc8745a91bb28168aa3b45194/wrapt-2.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:217798fb0cfb31479a264f841b0242bc1bed1ffc70d233e8444a876cec57928c", size = 251207, upload-time = "2026-10-29T23:05:54.011Z" }, + { url = "https://files.pythonhosted.org/packages/52/bb/25e710cc9d3bd25d81d46791dd25029d6f9b9d44b990e3d81755b549ff71/wrapt-2.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:62b339565cfdfcc0ba71c527b4ad13ac9de25504d474fa4ae5db95d1c7e4c6a2", size = 233048, upload-time = "2026-10-29T23:05:55.796Z" }, + { url = "https://files.pythonhosted.org/packages/4e/80/672640d799862a36abae740e778146dbe155ec8ffd6211b3a99240f599ca/wrapt-2.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:84619ca6b6f67a7dd53754ad402cafceb4ddc9d8981f144f62718b783f05786e", size = 248479, upload-time = "2026-10-29T23:05:57.346Z" }, + { url = "https://files.pythonhosted.org/packages/f6/34/91eb6724eb7cf64b77637d720ef71cad1ec6e4ce2d15eb548670c47078fa/wrapt-2.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:08d1d7bcb7dd277b7b976fd914455c3c1088f5c101ac7469ae5a5b8c03be0a0a", size = 230013, upload-time = "2026-10-29T23:05:58.745Z" }, + { url = "https://files.pythonhosted.org/packages/bf/f8/f1fc0c3394819c9a6a3c0d0055b06614a3bef7ad133cf18f9c09a2b2141f/wrapt-2.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:4e86f3543c67d72b4d4c08c3e351523c2d69cd05932df65937d79bc472e9d62f", size = 239808, upload-time = "2026-10-29T23:06:00.266Z" }, + { url = "https://files.pythonhosted.org/packages/56/d1/70f9e71674d7b6c21c8e8cafc3016f773dc3acb31a131f23ab4af8c1effb/wrapt-2.5.2-cp315-cp315-win32.whl", hash = "sha256:035cd71e2aadfc0ad366ab4785b49e62093370885ea4b527b61b308b7a92ff14", size = 101099, upload-time = "2026-10-29T23:06:01.777Z" }, + { url = "https://files.pythonhosted.org/packages/7c/e6/fdea9e35605a6e7fc71556068ea184fb3e9cc09d1e3be8ca8f26d16339c9/wrapt-2.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:b9f41029f9bc6ba80755b9c07f5e77e9e7aafb71c625b9f67614e4ebfb24302a", size = 106423, upload-time = "2026-10-29T23:06:03.076Z" }, + { url = "https://files.pythonhosted.org/packages/d5/50/8c41d8ba868cde9afd5b68e18f19b94300d091c409ef081b80c2aecda653/wrapt-2.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:ae84013e89ec1874415549a46cfea373e28ddecbb72e1f5456cddfa2b76a28e6", size = 104152, upload-time = "2026-10-29T23:06:04.356Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e7/b43d341b036e2862550eb7fffe2b4130015c39c861f30eb34014a2f032d2/wrapt-2.5.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:b680bef5200899524667f813fa34dcfde9313fef9f9fa432985d4bc7b4195ba3", size = 109711, upload-time = "2026-10-29T23:06:05.768Z" }, + { url = "https://files.pythonhosted.org/packages/be/52/8012aaf046264e27969f79bc94cd2afb4729338f5434b90edd3d4bb60b8f/wrapt-2.5.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:da51f5ac290f2e024ee842799c6592f68cd880c20f6b3a54305d1b6aeab459a4", size = 110047, upload-time = "2026-10-29T23:06:07.309Z" }, + { url = "https://files.pythonhosted.org/packages/54/a7/628c315d19c6027e8b0e700c0dd7d5c3fd662329c7aa1294315064b87cdd/wrapt-2.5.2-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3ebc07822649eda442382c1d20983bc6ec5aa2bf79a600da11b29ecb62a0fb2", size = 285041, upload-time = "2026-10-29T23:06:08.777Z" }, + { url = "https://files.pythonhosted.org/packages/7a/fd/4b418c9655bacb5ce8b0aed894f8355e12940bde74237ec45d9396e1f87f/wrapt-2.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bbb6e959c1e2c32bbad291f83af6320c8c46bb64e256801e85f55d88a09522d5", size = 295329, upload-time = "2026-10-29T23:06:10.489Z" }, + { url = "https://files.pythonhosted.org/packages/92/24/dbe9776fded6dd5f2bfa1446ec04a33afe5afac1d5fb89cd7f5e96fbc61d/wrapt-2.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a0541e62f7b9c0d42130e3469d6ac3b1767f019314ae795646a2850a75c64412", size = 265088, upload-time = "2026-10-29T23:06:11.963Z" }, + { url = "https://files.pythonhosted.org/packages/9d/ee/4103576d31bed902224fed8b1d06b94313491504d1d644e42bceba4de880/wrapt-2.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:18819c05409a161999be68da8e451636470c35f77e25c8201825a33a7d88c89c", size = 290413, upload-time = "2026-10-29T23:06:13.536Z" }, + { url = "https://files.pythonhosted.org/packages/bc/7c/944e95c25232a5805ea9f25cf2ce90386262db025ba04fbb61f451d9523f/wrapt-2.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:2594e0be4ee09b2f19828265a39df90e591def44215fe8c5b8d6b83aa4cc18b5", size = 262383, upload-time = "2026-10-29T23:06:14.887Z" }, + { url = "https://files.pythonhosted.org/packages/5d/b3/a4b66497e3bb63d2e94ea1605f4beaf5b6b5dafbb6ce41abd727a6fcb7b5/wrapt-2.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:32c0387872e67b9dfdd2b599bf31fe127e597ed8526c5f192cdaca57a491e9dc", size = 280180, upload-time = "2026-10-29T23:06:16.314Z" }, + { url = "https://files.pythonhosted.org/packages/91/bd/28d046dccfcade6ad62ad19f2f805e5b2e3f3463431307c3b8bd54e24e7f/wrapt-2.5.2-cp315-cp315t-win32.whl", hash = "sha256:9cb33f293e3aa04b36f7d165dc05b42db85e0a88e20a8fd81f60426d1f17d535", size = 103551, upload-time = "2026-10-29T23:06:17.732Z" }, + { url = "https://files.pythonhosted.org/packages/0d/d9/aef3035a3e3d918eb51e7db454af9e06919f0c5208fa0a9315548fef7734/wrapt-2.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:7f89423965b23aa62a90bf21c20353056a829ca9a60c01fde9aec9876c99392e", size = 110099, upload-time = "2026-10-29T23:06:19.293Z" }, + { url = "https://files.pythonhosted.org/packages/5f/ea/56eddba6249fae5361b53eb62e2e25ad86cabec4632d943d356aba8dea1b/wrapt-2.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:fa642d3781c061579cb138773add4a55b16f99de9ebc41603e89a756cf9e62c6", size = 106397, upload-time = "2026-10-29T23:06:20.826Z" }, + { url = "https://files.pythonhosted.org/packages/77/8b/1ea57b936b70f98e8e7620a352578096d778dbee95b262f73c066d210ffb/wrapt-2.5.2-py3-none-any.whl", hash = "sha256:61eb54e9540ea522c2c4752a57549a83d3c67e6704ed708403d28e067aaf90f0", size = 82025, upload-time = "2026-10-29T23:06:38.56Z" }, +]