diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index bb2b2b9..73c8ed8 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -12,24 +12,22 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: ["3.8", "3.9", "3.10", "3.11", "3.12", "3.13"] + python-version: ["3.11", "3.12", "3.13", "3.14", "3.15"] steps: - - uses: actions/checkout@v3 - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v4 + - uses: actions/checkout@v7 + - name: Set up uv with Python ${{ matrix.python-version }} + uses: astral-sh/setup-uv@v10.2.0 with: python-version: ${{ matrix.python-version }} - name: Install dependencies - run: | - pip install coverage coveralls pytest - pip install -e . + run: uv sync --locked - name: Run tests - run: coverage run --source=pyblnet -m pytest tests + run: uv run coverage run --source=pyblnet -m pytest tests - name: Coverage report run: | - coverage report - coveralls + uv run coverage report + uv run --with coveralls coveralls env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} COVERALLS_FLAG_NAME: ${{ matrix.python-version }} @@ -40,11 +38,13 @@ jobs: name: Indicate completion to coveralls.io needs: build runs-on: ubuntu-latest - container: python:3-slim steps: - - name: Install coveralls - run: pip3 install --upgrade coveralls + - uses: astral-sh/setup-uv@v10.2.0 + with: + # this job has no checkout + enable-cache: false + ignore-empty-workdir: true - name: Finished - run: coveralls --finish + run: uvx coveralls --finish env: GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} \ No newline at end of file diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index bc6573a..274d1e5 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,22 +1,27 @@ -name: Python package +name: Release on: push: tags: - "*.*.*" jobs: - build: + release: runs-on: ubuntu-latest + permissions: + contents: write steps: - - uses: actions/checkout@v4 - # If there isn't a release for this version, create a new one. + - uses: actions/checkout@v7 + + - uses: astral-sh/setup-uv@v10.2.0 + + - name: Build + run: uv build + + # If there isn't a release for this version, create a new one + # with the wheel and sdist attached - uses: ncipollo/release-action@v1 with: + artifacts: "dist/*" generateReleaseNotes: true makeLatest: true prerelease: false skipIfReleaseExists: true - - - name: To PyPI using Flit - uses: AsifArmanRahman/to-pypi-using-flit@v1 - with: - password: ${{ secrets.PYPI_TOKEN }} \ No newline at end of file diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..b47b4e6 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,49 @@ +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. + +## Project + +PyBLNET is a Python client for the BL-NET gateway by Technische Alternative, which sits in front of a UVR1611 heating controller. It reads analog/digital values and can set switches to ON/OFF/AUTO. Managed with uv: `uv_build` backend, dev tools in the `dev` dependency group, and `uv.lock` committed. The only runtime dependency is `requests`. CI tests Python 3.11–3.15 with `uv sync --locked`, so run `uv lock` after changing dependencies. Pushing a `*.*.*` tag triggers the release workflow: `uv build`, then a GitHub release with the wheel and sdist attached. This fork is not published to PyPI (the `PyBLNET` package there belongs to upstream); users install from GitHub. When releasing, bump the version in both `pyproject.toml` and `VERSION` in `pyblnet/__init__.py`. + +## Commands + +```bash +uv sync # create .venv with package + dev group +uv run pytest tests # full suite +uv run pytest tests/test_web.py::BLNETWebTest::test_blnet_fetch # single test +uv run coverage run --source=pyblnet -m pytest tests && uv run coverage report # what CI runs +uv run --isolated --python 3.11 pytest tests # oldest supported Python, leaves .venv alone +uv run ruff check pyblnet tests # ruff defaults + pyupgrade (UP); UP is clean, other default rules still report issues; CI does not run ruff +uv build # sdist + wheel into dist/ +``` + +## Architecture + +Two independent transports, plus a facade over both: + +- **`BLNETWeb`** (`blnet_web.py`) scrapes the device's German-language HTTP interface with `requests` and the standard library's `html.parser` (`_element_texts()` keeps entities like ` ` as written and turns `
` into newlines, which the value regexes rely on). Login POSTs to `/main.html` and stores the `TAID` cookie. `logged_in()` works by checking whether a restricted page sends back `Set-Cookie`. Use it as a context manager: `__enter__`/`__exit__` call `log_in`/`log_out`. Logging out matters because the device blocks all web access for about 150s after a session that wasn't logged out. The constructor calls `blnet_test()` and raises `ValueError` if no BL-NET answers. Switch values use the device's German strings `"EIN"`, `"AUS"`, `"AUTO"`. Only this transport can set switches, read manual/auto mode, and select a CAN node. +- **`BLNETDirect`** (`blnet_conn.py`) speaks TA's binary bootloader protocol over TCP (port 40000). It is a Python port of berwinter's PHP `blnet-connection.inc.php`. On construction it queries the device mode: `CAN_MODE`, `DL_MODE` or `DL2_MODE`. That mode decides frame counts, dataset sizes and how `_split_latest`/`_split_datasets` slice the response. The README still calls this transport buggy and discourages it. The `timeout` is set on each socket it opens, not process-wide. `get_latest()` lists frames that never arrived in `info["timeout"]` and raises `ConnectionError` if no frame arrived. Read paths (`get_latest`, `get_count`, `_get_data`, `_check_mode`) are wrapped in `_reset_on_error`: on any error the socket is closed and the read state is reset, so the next call reconnects; empty or malformed replies are raised as `ConnectionError`. Errors reaching callers are therefore `OSError` subclasses (`ConnectionError` or `TimeoutError`). A one-byte `0xAB` reply means the device has no new data yet (real devices say so for up to ~5 s after a read); `get_latest()` then waits `NO_DATA_WAIT` seconds before the next try. `_query_latest()` derives the reply length from its first byte and reads the reply completely, because BL-NETs sometimes send the first byte in a TCP segment of its own; reading only part of it shifted all following replies by one byte, and the weak sum checksum let some of those shifted datasets through as garbage values. After a reply with a bad checksum `get_latest()` reconnects so stray bytes can't reach the next reply. +- **`BLNETParser`** (`blnet_parser.py`) decodes one binary dataset (55 bytes, or 61 with a timestamp) into `{'analog','digital','speed','energy','power'}` dicts keyed by 1-based ID. Inactive values are `None`: unused inputs (type bits `000`), temperature inputs without sensor (raw `0x2FFF` = 409.5 °C, `TEMP_NO_SENSOR`), inactive speed controls and inactive heat meters. `analog_types` maps each input to `"temperature"`, `"volume_flow"`, `"radiation"`, `"digital"` or `None` (`ANALOG_TYPES`, units in `ANALOG_UNITS`). It is used only by `BLNETDirect`. +- **`BLNET`** (`blnet.py`) is the high-level facade, with each transport switched on by `use_web` (default on) and `use_ta` (default off). `fetch()` returns a dict with all five domains. The web transport supplies analog/digital entries as dicts (`id`, `name`, `value`, `mode`). Direct data then overwrites `value` on those entries. If web is disabled ("DL-only" mode), `fetch()` creates entries from direct data alone and skips `None` values; analog entries carry `type` and `unit_of_measurement`, digital ones only `value`. Web analog entries get `type` derived from their unit (`WEB_UNIT_TYPES`). `speed`/`energy`/`power` come only from direct, with `unit_of_measurement` `None` (speed is a level 0-30), `"kWh"` and `"kW"`. `get_value()` matches on `name` (when given) or on the id key, so it works for both entry shapes. + +## Device documentation + +- Official BL-NET manual (German, v2.19): https://www.ta.co.at/download/datei/416. Its "Zugriff per Browser" chapter describes the web interface that `BLNETWeb` scrapes. Facts from it that the code relies on: + - Only one user can be logged in at a time. + - A session ends after 2.5 minutes without traffic. If a session isn't logged out, nobody can log in for those 2.5 minutes. + - There are three access levels: Experte, Anwender and "nur ansehen". The login form field `blu=1` selects Experte. + - From the factory no password is set. Code passes `password=None` to skip login. + - The default ports are HTTP 80 and TA port 40000. + - For CAN data logging, one UVR1611 must be node 1. +- The binary protocol used by `BLNETDirect` isn't in that manual. TA's spec "Schnittstelle Winsol <> Bootloader" (2006) describes it. The haus-terra link in the README is dead (404); an archived copy is at http://web.archive.org/web/20160122124754/http://www.haus-terra.at:80/heizung/download/Schnittstelle/Schnittstelle_PC_Bootloader.pdf. The spec covers: + - The DL modes only: 1DL `0xA8` and 2DL `0xD1`. + - The commands `0x81` (mode), `0x82` (firmware), `0xAA` (header), `0xAB` (latest data), `0xAC` (read logged block), `0xAD` (end read) and `0xAF` (reset logged data). + - The dataset layouts. +- Not in the spec: CAN mode (`0xDC`), the `0xBA` "wait" response, and the frame-number byte sent after `0xAB`. These come from berwinter's reverse-engineered PHP code. In DL mode the spec's `0xAB` request is one byte, but the code sends two, and a real device accepts that. + +## Tests + +- `tests/test_parser.py` checks `BLNETParser` against raw byte fixtures. +- `tests/test_web.py` runs `BLNETWeb`/`BLNET` against a local mock HTTP server (`tests/test_structure/blnet_mock_server.py`, started in a thread by `server_control.py`). The mock serves the saved device pages in `tests/test_structure/*.htm` and emulates login cookies, password (`0123`), node switching and a "blocked" state. Expected parse results live in `tests/web_raw/web_state.py`. +- `tests/test_direct.py` runs `BLNET` in DL-only mode against a fake TCP BL-NET (`tests/test_structure/blnet_direct_mock_server.py`). The fake replays mode, header and latest-data responses recorded from a real device in DL mode. Only `GET_MODE`, `GET_HEADER`, `GET_LATEST` and `END_READ` are emulated; CAN/DL2 modes and reading stored data (`_get_data`) are untested. diff --git a/LICENSE.txt b/LICENSE.txt index 7836745..33ea135 100644 --- a/LICENSE.txt +++ b/LICENSE.txt @@ -1,4 +1,5 @@ Copyright (c) 2017 Niels Mündler +Copyright (c) 2026 Alexander Eisele Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in diff --git a/Pipfile b/Pipfile deleted file mode 100644 index 8c02134..0000000 --- a/Pipfile +++ /dev/null @@ -1,13 +0,0 @@ -[[source]] -url = "https://pypi.org/simple" -verify_ssl = true -name = "pypi" - -[packages] -htmldom = "*" -requests = "*" - -[dev-packages] - -[requires] -python_version = "3.7" diff --git a/README.md b/README.md index 2978b2d..9232075 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,6 @@ # PyBLNET - a very basic python BL-NET bridge -![PyPI - Version](https://img.shields.io/pypi/v/pyblnet) -![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyblnet) -[![Build status](https://github.com/nielstron/pyblnet/actions/workflows/build.yml/badge.svg)](https://github.com/nielstron/pyblnet/actions/workflows/build.yml) -[![Coverage Status](https://coveralls.io/repos/github/nielstron/pyblnet/badge.svg?branch=master)](https://coveralls.io/github/nielstron/pyblnet?branch=master) +[![Build status](https://github.com/dereisele/pyblnet/actions/workflows/build.yml/badge.svg)](https://github.com/dereisele/pyblnet/actions/workflows/build.yml) +[![Coverage Status](https://coveralls.io/repos/github/dereisele/pyblnet/badge.svg?branch=master)](https://coveralls.io/github/dereisele/pyblnet?branch=master) A package that connects to the BL-NET that is connected itself to a UVR1611 device by Technische Alternative. It is able to read digital and analog values as well as to set switches to ON/OFF/AUTO. @@ -13,14 +11,29 @@ Two interfaces to BLNet exist and both are supported: - Webinterface - Class BLnetWeb - BLNet-Direct protocol [1] - Class BLNETDirect -However, as of now, there is no testing on the BLNet-Direct protocol *of any kind*, so enabling it is discouraged until the interface is fixed. -Parsing the data via the web interface is the preferred way of accessing the BLNet for now. +BLNet-Direct is tested against responses recorded from a real BL-NET in DL mode (one UVR1611). +CAN and 2DL mode as well as reading logged data are still untested, so the web interface remains the safer choice there. The class BLNET is a wrapper around the two classes. When initializing the class, the two interfaces can be activated/deactivated. BLNetDirect provides 'analog', 'digital', 'speed', 'energy', 'power', whereas BLnetWeb supports 'analog' and 'digital' only. If both are active, BLNetDirect has priority. Setting switches and reading their manual/auto state is only possible via the BLNetWeb interface. +### Installation + +This fork is not published on PyPI. The `PyBLNET` package on PyPI is released by the upstream project and doesn't contain the changes made here. +Install it from GitHub instead (Python 3.11 or newer): + +```bash +pip install git+https://github.com/dereisele/pyblnet.git +# or a specific release +pip install git+https://github.com/dereisele/pyblnet.git@0.11.0 +# or with uv +uv add git+https://github.com/dereisele/pyblnet.git +``` + +Each [release](https://github.com/dereisele/pyblnet/releases) also has the wheel and sdist attached. + ### Usage ```python @@ -67,4 +80,4 @@ print(blnet._get_data(1)) ``` -[1] https://www.haus-terra.at/heizung/download/Schnittstelle/Schnittstelle_PC_Bootloader.pdf +[1] Technische Alternative, "Schnittstelle Winsol <> Bootloader" (2006), archived copy: http://web.archive.org/web/20160122124754/http://www.haus-terra.at:80/heizung/download/Schnittstelle/Schnittstelle_PC_Bootloader.pdf diff --git a/pyblnet/__init__.py b/pyblnet/__init__.py index f1c98f6..c610dd0 100644 --- a/pyblnet/__init__.py +++ b/pyblnet/__init__.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- import warnings @@ -10,5 +9,5 @@ except ImportError as e: warnings.warn(ImportWarning(e)) -VERSION = (0, 10, 0) +VERSION = (0, 13, 1) diff --git a/pyblnet/blnet.py b/pyblnet/blnet.py index 11a23a5..9f2da11 100644 --- a/pyblnet/blnet.py +++ b/pyblnet/blnet.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- """ Created on 13.08.2018 @@ -12,11 +11,18 @@ """ from .blnet_web import BLNETWeb from .blnet_conn import BLNETDirect +from .blnet_parser import ANALOG_UNITS from urllib.parse import urlparse -class BLNET(object): +# Units of the values only available via BLNETDirect, speed is a level 0-30 +UNITS = {"speed": None, "energy": "kWh", "power": "kW"} +# Analog input type for the units shown by the web interface +WEB_UNIT_TYPES = {unit: input_type for input_type, unit in ANALOG_UNITS.items() if unit is not None} + + +class BLNET: """ General high-level BLNET interface. @@ -61,14 +67,14 @@ def __init__( self.blnet_direct = None if use_web: self.blnet_web = BLNETWeb( - "{}:{}".format(address, web_port), password, timeout + f"{address}:{web_port}", password, timeout ) if use_ta: # The address might not have a resulting hostname # especially not if not prefixed with http:// # see https://docs.python.org/3/library/urllib.parse.html#urllib.parse.urlparse host = urlparse(address).hostname or address - self.blnet_direct = BLNETDirect(host, ta_port) + self.blnet_direct = BLNETDirect(host, ta_port, timeout=timeout) def fetch(self, node=None): """ @@ -88,6 +94,8 @@ def fetch(self, node=None): blnet_session.set_node(node) data["analog"] = self._convert_web(blnet_session.read_analog_values()) data["digital"] = self._convert_web(blnet_session.read_digital_values()) + for entry in data["analog"].values(): + entry["type"] = WEB_UNIT_TYPES.get(entry.get("unit_of_measurement")) if self.blnet_direct: direct = self.blnet_direct.get_latest(self.max_retries)[0] # Override values for analog and digital as values are @@ -96,11 +104,20 @@ def fetch(self, node=None): for id, value in direct[domain].items(): if data[domain].get(id) is not None: data[domain][id]["value"] = value + elif not self.blnet_web: + if value is None: + continue + data[domain][id] = {"value": value} + if domain == "analog": + input_type = direct["analog_types"][id] + data[domain][id]["type"] = input_type + data[domain][id]["unit_of_measurement"] = ANALOG_UNITS.get(input_type) + for domain in ["speed", "energy", "power"]: for id, value in direct[domain].items(): if value is None: continue - data[domain][id] = {"value": value} + data[domain][id] = {"value": value, "unit_of_measurement": UNITS[domain]} return data def turn_on(self, digital_id, can_node=None): @@ -132,17 +149,15 @@ def _turn(self, digital_id, value, can_node=None): if can_node is not None: if not blnet_session.set_node(can_node): raise ConnectionError( - "Could not set can node to {}".format(can_node) + f"Could not set can node to {can_node}" ) if not blnet_session.set_digital_value(digital_id, value): raise ConnectionError( - "Failed to set digital switch {} to value {}".format( - digital_id, value - ) + f"Failed to set digital switch {digital_id} to value {value}" ) return True else: - raise EnvironmentError("Can't set values with blnet web disabled") + raise OSError("Can't set values with blnet web disabled") def get_value(self, name=None, id=None, type="digital", ret="value", cached=None): """ @@ -162,8 +177,11 @@ def get_value(self, name=None, id=None, type="digital", ret="value", cached=None if cached is None: cached = self.fetch() for key, v in cached[type].items(): - if str(v["name"]) == str(name) or str(v["id"]) == str(id): - val = v[ret] + # values fetched only via blnet_direct have no name + if (name is not None and str(v.get("name")) == str(name)) or ( + id is not None and str(key) == str(id) + ): + val = v.get(ret) dic = v return val, dic, cached diff --git a/pyblnet/blnet_conn.py b/pyblnet/blnet_conn.py index a76e6d7..ab49e05 100644 --- a/pyblnet/blnet_conn.py +++ b/pyblnet/blnet_conn.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- """ Created on 09.08.2018 @@ -8,8 +7,8 @@ @author: Niels """ -from builtins import str, int -from socket import socket, getaddrinfo, SOCK_STREAM, IPPROTO_TCP, setdefaulttimeout +from socket import socket, getaddrinfo, SOCK_STREAM, IPPROTO_TCP +import functools import struct from time import sleep from datetime import datetime @@ -27,12 +26,38 @@ END_READ = b"\xAD" RESET_DATA = b"\xAF" WAIT_TIME = 0xBA +# Seconds to wait when the BL-Net has no new data yet. Real devices answer +# GET_LATEST with "no data" for up to about 5 seconds after a read. +NO_DATA_WAIT = 2 MAX_RETRYS = 10 +# Length of a WAIT_TIME reply: 0xBA, seconds to wait, checksum +WAIT_SIZE = 3 DATASET_SIZE = 61 LATEST_SIZE = 56 -class BLNETDirect(object): +def _reset_on_error(method): + """ + Close the connection and forget the read state if a read fails, + so that the next call starts with a fresh connection. + Malformed replies are raised as ConnectionError. + """ + + @functools.wraps(method) + def wrapper(self, *args, **kwargs): + try: + return method(self, *args, **kwargs) + except (struct.error, IndexError, ValueError) as ex: + self._reset() + raise ConnectionError(f"Invalid reply from BL-Net: {ex}") from ex + except BaseException: + self._reset() + raise + + return wrapper + + +class BLNETDirect: """ A class for establishing a direct connection to the BLNET (rather than scraping the web interface) @@ -55,13 +80,14 @@ def __init__(self, address, port: int = 40000, reset: bool = False, timeout: flo self.address = address self.port = port self.reset = reset + # 0 would make the socket non-blocking, treat it like None (no timeout) + self._timeout = timeout or None self._mode = None self._socket = None self._count = None self._check_mode() - if timeout: - setdefaulttimeout(timeout) + @_reset_on_error def get_count(self): """ Get the number of datasets in the bootloader memory @@ -73,7 +99,7 @@ def get_count(self): if self._checksum(data): if self._mode == CAN_MODE: - frame_count = struct.unpack("<{}B".format(len(data)), data)[5] + frame_count = struct.unpack(f"<{len(data)}B", data)[5] ( type, version, @@ -83,14 +109,14 @@ def get_count(self): start_address, end_address, checksum, - ) = struct.unpack("= length: - break - return data - - self._disconnect() - raise ConnectionError("Error while querying command {}".format(command)) + self._socket.sendall(command) + data = b"" + # get response until length or less than 32 bytes + while True: + received = self._socket.recv(length) + if not received: + raise ConnectionError("BL-Net closed the connection") + data += received + if len(data) <= 32 or len(data) >= length: + break + return data + + def _recv_exact(self, length): + """ + Receive exactly length bytes + @throws ConnectionError BL-Net closed the connection + @return Binary: byte string + """ + data = b"" + while len(data) < length: + received = self._socket.recv(length - len(data)) + if not received: + raise ConnectionError("BL-Net closed the connection") + data += received + return data + + def _query_latest(self, command): + """ + Send a GET_LATEST command and receive the complete reply. + The BL-Net may send a reply in several TCP segments, so the length + is derived from its first byte and the reply is read completely. + Reading only part of it would leave the rest in the socket and + shift every following reply by some bytes. + @return Binary: byte string, a "no data", "wait" or data reply + """ + self._socket.sendall(command) + first = self._recv_exact(1) + if first[0] == GET_LATEST: + # no new data available yet + return first + if first[0] == WAIT_TIME: + return first + self._recv_exact(WAIT_SIZE - 1) + return first + self._recv_exact(self._actual_size - 1) def _start_read(self): """ @@ -215,7 +282,7 @@ def _checksum(self, data): @param byte string $data Binary string to check @return boolean """ - binary = struct.unpack("<{}B".format(len(data)), data) + binary = struct.unpack(f"<{len(data)}B", data) checksum = binary[-1] sum = 0 @@ -308,6 +375,7 @@ def _end_read(self, success=True): self._address = None self._disconnect() + @_reset_on_error def get_latest(self, max_retries=MAX_RETRYS): """ Fetch latest (current) data from the BLNet @@ -318,7 +386,7 @@ def get_latest(self, max_retries=MAX_RETRYS): self._connect() self.get_count() frames = {} - info = {"sleep": {}, "got": {}} + info = {"sleep": {}, "got": {}, "timeout": []} # for all frames for frame in range(0, self._can_frames): @@ -327,9 +395,12 @@ def get_latest(self, max_retries=MAX_RETRYS): # try 4 times sleeps = [] for n in range(0, max_retries): - data = self._query(command, self._actual_size) + data = self._query_latest(command) - if self._checksum(data): + if data == bytes([GET_LATEST]): + # no new data available yet ("Synchronisation" in TA's spec) + sleep(NO_DATA_WAIT) + elif self._checksum(data): binary = struct.unpack("<{}".format("B" * len(data)), data) if binary[0] == WAIT_TIME: @@ -342,9 +413,14 @@ def get_latest(self, max_retries=MAX_RETRYS): info["got"][frame] = n frames.update(self._split_latest(data, frame)) break - # TODO this looks suspicious - if n == max_retries - 1: - frames[frame] = "timeout" + else: + # Unexpected bytes may still be on their way, reconnect + # so that they can't end up in the next reply + self._disconnect() + self._connect() + else: + # BL-Net did not send data for this frame within max_retries + info["timeout"].append(frame) info["sleep"][frame] = sleeps self._end_read(True) if len(frames) > 0: diff --git a/pyblnet/blnet_parser.py b/pyblnet/blnet_parser.py index e8f2616..91b71a2 100644 --- a/pyblnet/blnet_parser.py +++ b/pyblnet/blnet_parser.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- """ Created on 09.08.2018 @@ -30,10 +29,28 @@ TYPE_RADIATION = 0x4000 TYPE_RAS = 0x7000 RAS_POSITIVE_MASK = 0x01FF +# Temperature input without sensor (or with a broken wire): all value bits set, 409.5 °C +TEMP_NO_SENSOR = TYPE_TEMP | POSITIVE_VALUE_MASK # 32 bit INT32_MASK = 0xFFFFFFFF INT32_SIGN = 0x80000000 +# Names of the analog input types, unused and undocumented types have none +ANALOG_TYPES = { + TYPE_DIGITAL: "digital", + TYPE_TEMP: "temperature", + TYPE_VOLUME: "volume_flow", + TYPE_RADIATION: "radiation", + TYPE_RAS: "temperature", +} +# Units of the analog input types, as the web interface shows them +ANALOG_UNITS = { + "digital": None, + "temperature": "°C", + "volume_flow": "l/h", + "radiation": "W/m²", +} + class BLNETParser: def __init__(self, data): @@ -71,8 +88,11 @@ def __init__(self, data): analog = struct.unpack("<{}{}".format("H" * 16, "x" * (len(data) - 32)), data) self.analog = {} + self.analog_types = {} for channel in range(0, 16): - self.analog[channel + 1] = round(self._convert_analog(analog[channel]), 3) + self.analog_types[channel + 1] = ANALOG_TYPES.get(analog[channel] & TYPE_MASK) + value = self._convert_analog(analog[channel]) + self.analog[channel + 1] = None if value is None else round(value, 3) self.digital = {} for channel in range(0, 16): @@ -107,7 +127,12 @@ def _convert_analog(self, value): """ mask = value & TYPE_MASK - if mask == TYPE_TEMP: + if mask == TYPE_NONE: + # input is unused + return None + elif value == TEMP_NO_SENSOR: + return None + elif mask == TYPE_TEMP: return self._calculate_value(value, 0.1) elif mask == TYPE_VOLUME: return self._calculate_value(value, 4) @@ -118,7 +143,8 @@ def _convert_analog(self, value): return 0 elif mask == TYPE_RAS: return self._calculate_value(value, 0.1, RAS_POSITIVE_MASK) - elif mask in [TYPE_RADIATION, TYPE_NONE] or True: + else: + # TYPE_RADIATION and types not covered by the interface spec return self._calculate_value(value) def _convert_digital(self, value, position): @@ -144,7 +170,7 @@ def _convert_energy(self, mwh, kwh, active, position): Check if heat meter is activated on a given position @return its energy """ - if active & position: + if active & (1 << position): kwh = self._calculate_value(kwh, 0.1, INT16_POSITIVE_MASK) return round(mwh * 1000 + kwh, 3) else: @@ -155,7 +181,7 @@ def _convert_power(self, value, active, position): checks if heat meter is activated at given position @return its power """ - if active & position: + if active & (1 << position): value = self._calculate_value(value, 1 / 2560, INT32_MASK, INT32_SIGN) value = round(value, 3) return value diff --git a/pyblnet/blnet_web.py b/pyblnet/blnet_web.py index ed22e97..27f8346 100644 --- a/pyblnet/blnet_web.py +++ b/pyblnet/blnet_web.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- """ Created on 26.09.2017 @@ -10,10 +9,73 @@ """ import requests -from htmldom import htmldom import html import re -from builtins import int +from html.parser import HTMLParser + + +class _ElementTextParser(HTMLParser): + """ + Collects the text of all elements with the given tag and class or id. + Entities like   are kept as written and
becomes a newline, + which is what the regular expressions below expect. + """ + + def __init__(self, tag, cls=None, id=None): + super().__init__(convert_charrefs=False) + self.tag = tag + self.cls = cls + self.id = id + # text of each matching element, in document order + self.texts = [] + # for each open element with self.tag: its index in self.texts, + # or None if it doesn't match. Matching elements can be nested. + self._open = [] + + def _matches(self, attrs): + attrs = dict(attrs) + return (self.cls is None or self.cls in (attrs.get("class") or "").split()) and ( + self.id is None or attrs.get("id") == self.id + ) + + def handle_starttag(self, tag, attrs): + if tag == self.tag: + if self._matches(attrs): + self.texts.append("") + self._open.append(len(self.texts) - 1) + else: + self._open.append(None) + elif tag == "br": + self.handle_data("\n") + + def handle_endtag(self, tag): + if tag == self.tag and self._open: + self._open.pop() + + def handle_data(self, data): + for index in self._open: + if index is not None: + self.texts[index] += data + + def handle_entityref(self, name): + self.handle_data(f"&{name};") + + def handle_charref(self, name): + self.handle_data(f"&#{name};") + + +def _element_texts(page, tag, cls=None, id=None): + """Texts of all elements in page with the given tag and class or id""" + parser = _ElementTextParser(tag, cls, id) + parser.feed(page) + parser.close() + return parser.texts + + +def _element_text(page, tag, cls=None, id=None): + """Text of the first such element, empty if there is none""" + texts = _element_texts(page, tag, cls, id) + return texts[0] if texts else "" def blnet_test(ip, timeout=5, id=0): @@ -28,18 +90,16 @@ def blnet_test(ip, timeout=5, id=0): r = requests.get(ip, timeout=timeout) except requests.exceptions.RequestException: return False - # Parse DOM object from HTMLCode - dom = htmldom.HtmlDom().createDom(r.text) # either a 'Zugriff verweigert' message is shown - if "BL-Net".lower() in dom.find("title").text().lower(): + if "BL-Net".lower() in _element_text(r.text, "title").lower(): return True # or (more often) the BL-NET Menü - if "BL-NET" in dom.find("div#head").text(): + if "BL-NET" in _element_text(r.text, "div", id="head"): return True return False -class BLNETWeb(object): +class BLNETWeb: """ Interface for connecting with, collecting data from and controlling the BLNet via it's HTTP-interface @@ -64,7 +124,7 @@ def __init__(self, ip, password=_def_password, timeout=5): if not ip.startswith("http://") and not ip.startswith("https://"): ip = "http://" + ip if not blnet_test(ip): - raise ValueError("No BLNET found under given address: {}".format(ip)) + raise ValueError(f"No BLNET found under given address: {ip}") self.ip = ip self.password = password self._timeout = timeout @@ -183,18 +243,12 @@ def read_analog_values(self): ) except requests.exceptions.RequestException: return None - # Parse DOM object from HTMLCode - dom = htmldom.HtmlDom().createDom(r.text) - # Check if we didn't fail in access - # if 'BL-Net Zugang verweigert' in dom.find('title').text(): - # return None # get the element containing the interesting information - dom = dom.find("div.c")[1] + texts = _element_texts(r.text, "div", cls="c") # in case of access denied or other errors, return None - if dom is None: - return dom - # filter out the text - data_raw = dom.text() + if len(texts) < 2: + return None + data_raw = texts[1] # collect data in an array data = list() @@ -234,18 +288,14 @@ def read_digital_values(self): ) except requests.exceptions.RequestException: return None - # Parse DOM object from HTMLCode - dom = htmldom.HtmlDom().createDom(r.text) # Check if we didn't fail in access - if "BL-Net Zugang verweigert" in dom.find("title").text(): + if "BL-Net Zugang verweigert" in _element_text(r.text, "title"): return None # get the element containing the interesting information - dom = dom.find("div.c")[1] - if dom is None: + texts = _element_texts(r.text, "div", cls="c") + if len(texts) < 2: return None - - # filter out the text - data_raw = dom.text() + data_raw = texts[1] # collect data in an array data = list() @@ -282,11 +332,11 @@ def set_digital_value(self, digital_id, value): # throw error for wrong id's if digital_id < 1: raise ValueError( - "Device id can't be smaller than 1, was {}".format(digital_id) + f"Device id can't be smaller than 1, was {digital_id}" ) if digital_id > 15: raise ValueError( - "Device id can't be larger than 15, was {}".format(digital_id) + f"Device id can't be larger than 15, was {digital_id}" ) # transform input value to 'EIN' or 'AUS' if isinstance(value, str): @@ -305,14 +355,14 @@ def set_digital_value(self, digital_id, value): ): value = "1" # 1 means turn off else: - raise ValueError("Illegal input string {}".format(value)) + raise ValueError(f"Illegal input string {value}") elif isinstance(value, int) and not isinstance(value, bool): if value in (1, 2, 3): value = str(value) elif value == 0: value = "1" else: - raise ValueError("Illegal input integer {}".format(value)) + raise ValueError(f"Illegal input integer {value}") else: # value can be interpreted as a true value if value: @@ -329,7 +379,7 @@ def set_digital_value(self, digital_id, value): # submit data to website try: r = requests.get( - "{}/580600.htm?blw91A1200{}={}".format(self.ip, digital_id, value), + f"{self.ip}/580600.htm?blw91A1200{digital_id}={value}", headers=self.cookie_header(), timeout=self._timeout, ) diff --git a/pyproject.toml b/pyproject.toml index 0edb73b..bfe6ae5 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,44 +1,48 @@ -[ build-system ] -requires = ["flit_core >=3.2,<4"] -build-backend = "flit_core.buildapi" +[build-system] +requires = ["uv_build>=0.12.8,<0.13"] +build-backend = "uv_build" -[ project ] +[project] name = "PyBLNET" -version = "0.10.0" +version = "0.13.1" description = "Automate wireless communication to UVR1611 via BL-NET" readme = "README.md" -readme-content-type = "text/markdown" -requires-python = ">=3" -license = {text = "MIT"} +requires-python = ">=3.11" +license = "MIT" +license-files = ["LICENSE.txt"] authors = [ - {name = "nielstron", email = "n.muendler@posteo.de"} + {name = "nielstron", email = "n.muendler@posteo.de"}, + {name = "Alexander Eisele", email = "alexander@eiselecloud.de"}, ] -homepage = "https://github.com/nielstron/pyblnet/" keywords = ["python", "uvr1611", "blnet", "technische alternative", "home automation", "iot"] classifiers = [ "Development Status :: 4 - Beta", "Intended Audience :: Developers", "Topic :: Software Development :: Object Brokering", - "License :: OSI Approved :: MIT License", - "Programming Language :: Python :: 3.8", - "Programming Language :: Python :: 3.9", - "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", - "Programming Language :: Python :: 3.13" + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: 3.15" ] dependencies = [ - "htmldom", "requests", ] -[project.optional-dependencies] -test = [ +[project.urls] +"Homepage" = "https://github.com/dereisele/pyblnet/" +"Upstream" = "https://github.com/nielstron/pyblnet/" + +[dependency-groups] +dev = [ + "coverage", "pytest", + "ruff", ] -[ project.urls ] -"Homepage" = "https://github.com/nielstron/pyblnet/" +[tool.uv.build-backend] +module-name = "pyblnet" +module-root = "" -[ tool.flit.module ] -name = "pyblnet" \ No newline at end of file +[tool.ruff.lint] +extend-select = ["UP"] diff --git a/tests/test_direct.py b/tests/test_direct.py new file mode 100644 index 0000000..f46dc33 --- /dev/null +++ b/tests/test_direct.py @@ -0,0 +1,173 @@ +#!/usr/bin/env python + +import gc +import socket +import threading +import time +import unittest +import warnings +from unittest import mock + +from pyblnet import BLNET, BLNETDirect +from tests.test_structure.blnet_direct_mock_server import ( + BLNETDirectServer, + DL_LATEST_RESPONSE, + GET_HEADER, + GET_LATEST, + READ_DATA, + WAIT_RESPONSE, +) + +ADDRESS = "localhost" + + +class BLNETDirectOnlyTest(unittest.TestCase): + """Test the high level interface with only the direct (DL mode) connection enabled""" + + def setUp(self): + self.server = BLNETDirectServer((ADDRESS, 0)) + threading.Thread(target=self.server.serve_forever, daemon=True).start() + self.port = self.server.server_address[1] + + def tearDown(self): + self.server.shutdown() + self.server.server_close() + + def blnet(self, max_retries=5, timeout=5): + return BLNET( + ADDRESS, + ta_port=self.port, + timeout=timeout, + use_web=False, + use_ta=True, + max_retries=max_retries, + ) + + def test_fetch(self): + data = self.blnet().fetch() + self.assertEqual( + data["analog"][6], + {"value": 53.9, "type": "temperature", "unit_of_measurement": "°C"}, + ) + self.assertEqual( + data["analog"][16], + {"value": 0, "type": "volume_flow", "unit_of_measurement": "l/h"}, + ) + self.assertEqual(data["digital"][1], {"value": 1}) + # speed level 0-30, no unit + self.assertEqual(data["speed"][1], {"value": 24, "unit_of_measurement": None}) + self.assertEqual(data["energy"], {1: {"value": 362847.4, "unit_of_measurement": "kWh"}}) + self.assertEqual(data["power"], {1: {"value": 0.0, "unit_of_measurement": "kW"}}) + + def test_fetch_leaves_out_inputs_without_sensor(self): + # inputs 1-5 and 15 of the recorded BL-NET have no sensor connected + data = self.blnet().fetch() + self.assertEqual(sorted(data["analog"]), [6, 7, 8, 9, 10, 11, 12, 13, 14, 16]) + + def test_get_value_by_id(self): + value, entry, _ = self.blnet().get_analog_value(id=6) + self.assertEqual(value, 53.9) + self.assertEqual(entry["value"], 53.9) + + def test_fetch_succeeds_on_last_retry(self): + self.server.latest_responses = [WAIT_RESPONSE, WAIT_RESPONSE, DL_LATEST_RESPONSE] + data = self.blnet(max_retries=3).fetch() + self.assertEqual(data["analog"][6]["value"], 53.9) + + def test_fetch_reads_replies_split_into_segments(self): + self.server.split_latest = True + blnet = self.blnet() + for _ in range(3): + data = blnet.fetch() + self.assertEqual(data["analog"][6]["value"], 53.9) + self.assertEqual(data["energy"][1]["value"], 362847.4) + + def test_fetch_reconnects_after_invalid_reply(self): + # a stray byte ahead of the reply must not shift the following replies + self.server.latest_responses = [b"\x00" + DL_LATEST_RESPONSE, DL_LATEST_RESPONSE] + data = self.blnet().fetch() + self.assertEqual(data["analog"][6]["value"], 53.9) + self.assertEqual(data["energy"][1]["value"], 362847.4) + + def test_timeout_does_not_change_global_socket_timeout(self): + BLNETDirect(ADDRESS, self.port, timeout=7) + self.assertIsNone(socket.getdefaulttimeout()) + + def test_failed_connection_attempt_closes_socket(self): + # Port that refuses connections: bind it, then free it again + with socket.socket() as s: + s.bind((ADDRESS, 0)) + refused_port = s.getsockname()[1] + # The first address refuses the connection, the second one is the BL-NET + addresses = [ + (socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP, "", ("127.0.0.1", port)) + for port in (refused_port, self.port) + ] + with mock.patch("pyblnet.blnet_conn.getaddrinfo", return_value=addresses): + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always", ResourceWarning) + BLNETDirect(ADDRESS, self.port, timeout=7) + gc.collect() + self.assertEqual([w for w in caught if w.category is ResourceWarning], []) + + def test_timeout_is_used_for_direct_connection(self): + self.server.silent = True + start = time.monotonic() + with self.assertRaises(TimeoutError): + BLNET(ADDRESS, ta_port=self.port, timeout=1, use_web=False, use_ta=True) + self.assertLess(time.monotonic() - start, 5) + + def test_fetch_recovers_after_timeout(self): + blnet = self.blnet(timeout=1) + self.server.silent = True + with self.assertRaises(TimeoutError): + blnet.fetch() + # BL-NET answers again, but the old connection is gone + self.server.silent = False + self.server.drop_connections() + self.assertEqual(blnet.fetch()["analog"][6]["value"], 53.9) + + def test_fetch_raises_connection_error_when_blnet_hangs_up(self): + blnet = self.blnet(timeout=1) + self.server.close_on = GET_HEADER + with self.assertRaises(ConnectionError): + blnet.fetch() + + def test_fetch_recovers_after_blnet_hung_up(self): + blnet = self.blnet(timeout=1) + self.server.close_on = GET_LATEST + with self.assertRaises(ConnectionError): + blnet.fetch() + self.server.close_on = None + self.assertEqual(blnet.fetch()["analog"][6]["value"], 53.9) + + def test_constructor_closes_socket_on_timeout(self): + self.server.silent = True + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always", ResourceWarning) + with self.assertRaises(TimeoutError): + BLNETDirect(ADDRESS, self.port, timeout=1) + gc.collect() + self.assertEqual([w for w in caught if w.category is ResourceWarning], []) + + def test_read_logged_data_raises_when_blnet_hangs_up(self): + blnet_direct = BLNETDirect(ADDRESS, self.port, timeout=1) + self.server.close_on = READ_DATA + with self.assertRaises(ConnectionError): + blnet_direct._get_data(1) + + def test_read_logged_data_raises_on_invalid_reply(self): + blnet_direct = BLNETDirect(ADDRESS, self.port, timeout=1) + with self.assertRaises(ConnectionError): + blnet_direct._get_data(1) + + def test_fetch_waits_while_blnet_has_no_new_data(self): + # Real BL-NETs answer "no data" for up to a few seconds after a read + blnet = self.blnet(max_retries=3) + self.server.no_data_until = time.monotonic() + 1 + self.assertEqual(blnet.fetch()["analog"][6]["value"], 53.9) + + def test_fetch_raises_when_blnet_keeps_waiting(self): + self.server.latest_responses = [WAIT_RESPONSE] + with self.assertRaises(ConnectionError): + self.blnet(max_retries=3).fetch() diff --git a/tests/test_parser.py b/tests/test_parser.py index 2e9bc3e..c90e12a 100644 --- a/tests/test_parser.py +++ b/tests/test_parser.py @@ -1,3 +1,4 @@ +import struct from pyblnet.blnet_parser import BLNETParser import unittest @@ -9,7 +10,7 @@ def test_parser_ok(self): parser = BLNETParser(data) parsed_values = parser.to_dict() expected_values = { - 'analog': {1: 12.5, 2: 69.3, 3: 61.4, 4: 51.5, 5: 38.2, 6: 65.4, 7: 27.8, 8: 22.4, 9: 25.5, 10: 24.3, 11: 24.8, 12: 0, 13: 31.7, 14: 1, 15: 0, 16: 48.2}, + 'analog': {1: 12.5, 2: 69.3, 3: 61.4, 4: 51.5, 5: 38.2, 6: 65.4, 7: 27.8, 8: 22.4, 9: 25.5, 10: 24.3, 11: 24.8, 12: None, 13: 31.7, 14: None, 15: 0, 16: 48.2}, 'digital': {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, 15: 0, 16: 0}, 'speed': {1: None, 2: 0, 3: 0, 4: 0}, 'energy': {1: None, 2: None}, @@ -22,6 +23,52 @@ def test_parser_ok(self): assert parsed_values['energy'] == expected_values['energy'] assert parsed_values['power'] == expected_values['power'] + def test_parser_unused_inputs_are_none(self): + # Input type bits 000 mean "Eingang unbenutzt", regardless of the other bits + inputs = [0x0000, 0x0001, 0x8005] + [0x2000] * 13 + data = struct.pack('<16H', *inputs) + bytes(55 - 32) + parsed_values = BLNETParser(data).to_dict() + + assert parsed_values['analog'][1] is None + assert parsed_values['analog'][2] is None + assert parsed_values['analog'][3] is None + assert parsed_values['analog'][4] == 0 + + def test_parser_disconnected_temperature_sensor_is_none(self): + # A temperature input without sensor reads all value bits set (409.5 °C) + inputs = [0x2FFF, 0x2FFE] + [0x2000] * 14 + data = struct.pack('<16H', *inputs) + bytes(55 - 32) + parsed_values = BLNETParser(data).to_dict() + + assert parsed_values['analog'][1] is None + assert parsed_values['analog'][2] == 409.4 + + def test_parser_input_types(self): + # temperature, volume flow, radiation, digital, unused, room sensor, undocumented type 101 + inputs = [0x2000, 0x3000, 0x4000, 0x1000, 0x0000, 0x7000, 0x5000] + [0x2000] * 9 + data = struct.pack('<16H', *inputs) + bytes(55 - 32) + parsed_values = BLNETParser(data).to_dict() + + expected_types = {1: 'temperature', 2: 'volume_flow', 3: 'radiation', 4: 'digital', 5: None, 6: 'temperature', 7: None} + expected_types.update({channel: 'temperature' for channel in range(8, 17)}) + assert parsed_values['analog_types'] == expected_types + + def test_parser_heat_meter_1_active(self): + # Latest data of a real UVR1611 in DL mode (header and checksum stripped), + # only heat meter 1 is active (active byte = 0x01) + data = bytes.fromhex( + 'ff2fff2fff2fff2fff2f1b224d210522e92110216e2032210322' + '6f21ff2f00306102' + '18000a12' + '01' + '000000001a216a01' + '0b010a3c0001000c' + ) + parsed_values = BLNETParser(data).to_dict() + + assert parsed_values['energy'] == {1: 362847.4, 2: None} + assert parsed_values['power'] == {1: 0, 2: None} + def test_parser_not_ok(self): data = b'broken} \xb5"f"\x03"~!\x8e"\x16!\xe0 \xff \xf3 \xf8 \x00\x00=!\x01\x00\x00`\xe2!\x00\x00\x80\x00\x00\x00\x00,\x00\xa4(\x06\x00DhI\x82\x1d\x04Ce\xc0\x00' with self.assertRaises(ValueError): diff --git a/tests/test_structure/blnet_direct_mock_server.py b/tests/test_structure/blnet_direct_mock_server.py new file mode 100644 index 0000000..6618ce7 --- /dev/null +++ b/tests/test_structure/blnet_direct_mock_server.py @@ -0,0 +1,98 @@ +import socket +import time +from socketserver import BaseRequestHandler, ThreadingTCPServer + +# Responses recorded from a real BL-NET with one UVR1611 in DL mode +DL_MODE_RESPONSE = bytes.fromhex("a8") +DL_HEADER_RESPONSE = bytes.fromhex("0fa85e6b1d76809204409204ff") +DL_LATEST_RESPONSE = bytes.fromhex( + "80ff2fff2fff2fff2fff2f1b224d210522e92110216e20322103226f21ff2f003061" + "0218000a1201000000001a216a010b010a3c0001000c04" +) +# Asks the client to wait the given amount of seconds before trying again +WAIT_RESPONSE = bytes.fromhex("ba00ba") +# No new data available yet ("Synchronisation" in TA's interface spec) +NO_DATA_RESPONSE = bytes.fromhex("ab") + +GET_MODE = 0x81 +GET_HEADER = 0xAA +GET_LATEST = 0xAB +READ_DATA = 0xAC +END_READ = 0xAD + + +class BLNETDirectServer(ThreadingTCPServer): + + daemon_threads = True + allow_reuse_address = True + + def __init__(self, server_address): + super().__init__(server_address, BLNETDirectRequestHandler) + # Responses to GET_LATEST, the last one is repeated forever + self.latest_responses = [DL_LATEST_RESPONSE] + # Accept connections but never answer + self.silent = False + # Close the connection when receiving this command + self.close_on = None + # Answer GET_LATEST with NO_DATA_RESPONSE until this time.monotonic() value + self.no_data_until = None + # Response to READ_DATA, by default one with a wrong checksum + self.read_data_response = bytes.fromhex("0001") + # Send the first byte of GET_LATEST replies in a TCP segment of its own, + # like real BL-NETs sometimes do + self.split_latest = False + # Currently open client connections + self.connections = set() + + def drop_connections(self): + """Close all open client connections, like a BL-NET that restarts""" + for connection in list(self.connections): + connection.shutdown(socket.SHUT_RDWR) + + +class BLNETDirectRequestHandler(BaseRequestHandler): + def handle(self): + self.server.connections.add(self.request) + try: + self._handle_commands() + except OSError: + # connection was dropped + pass + finally: + self.server.connections.discard(self.request) + + def _handle_commands(self): + while True: + command = self.request.recv(1) + if not command: + return + command = command[0] + if command == self.server.close_on: + return + if self.server.silent: + continue + if command == GET_MODE: + self.request.sendall(DL_MODE_RESPONSE) + elif command == GET_HEADER: + self.request.sendall(DL_HEADER_RESPONSE) + elif command == GET_LATEST: + # frame number + self.request.recv(1) + no_data_until = self.server.no_data_until + if no_data_until is not None and time.monotonic() < no_data_until: + self.request.sendall(NO_DATA_RESPONSE) + continue + responses = self.server.latest_responses + response = responses.pop(0) if len(responses) > 1 else responses[0] + if self.server.split_latest and len(response) > 1: + self.request.sendall(response[:1]) + time.sleep(0.05) + self.request.sendall(response[1:]) + else: + self.request.sendall(response) + elif command == READ_DATA: + # address, number of frames, checksum + self.request.recv(5) + self.request.sendall(self.server.read_data_response) + elif command == END_READ: + self.request.sendall(bytes([END_READ])) diff --git a/tests/test_structure/blnet_mock_server.py b/tests/test_structure/blnet_mock_server.py index 4323781..601bcf8 100644 --- a/tests/test_structure/blnet_mock_server.py +++ b/tests/test_structure/blnet_mock_server.py @@ -121,7 +121,7 @@ def do_POST(self): if query.startswith("blu"): if query.split("=")[1] != "1": self.send_error( - 403, "Wrong user set: expected blu=1, got {}".format(query) + 403, f"Wrong user set: expected blu=1, got {query}" ) return blu = True @@ -129,9 +129,7 @@ def do_POST(self): if query.split("=")[1] != self.server.password: self.send_error( 403, - "Wrong password: expected blp={}, got {}".format( - self.server.password, query - ), + f"Wrong password: expected blp={self.server.password}, got {query}", ) return blp = True @@ -139,14 +137,12 @@ def do_POST(self): if query.split("=")[1] != "Login": self.send_error( 403, - "Wrong bll spec, expected bll=Login, got {}".format( - request_string - ), + f"Wrong bll spec, expected bll=Login, got {request_string}", ) return bll = True if not (blu and blp and bll): - self.send_error(403, "Missing query param in {}".format(request_string)) + self.send_error(403, f"Missing query param in {request_string}") return # Check for content type if not self.headers.get("Content-Type") == "application/x-www-form-urlencoded": diff --git a/tests/test_structure/server_control.py b/tests/test_structure/server_control.py index 4998408..b17a41d 100644 --- a/tests/test_structure/server_control.py +++ b/tests/test_structure/server_control.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- import threading @@ -15,7 +14,7 @@ def __init__(self, server): def _run_server(self): - print("Server started, serving on port {}".format(self.get_port())) + print(f"Server started, serving on port {self.get_port()}") # notify about start self._server_started_event.set() diff --git a/tests/test_web.py b/tests/test_web.py index 6af25aa..beb15e8 100644 --- a/tests/test_web.py +++ b/tests/test_web.py @@ -1,5 +1,4 @@ #!/usr/bin/env python -# -*- coding: utf-8 -*- # general requirements import unittest @@ -60,7 +59,7 @@ def setUp(self): self.server_control = Server(self.server) self.server.set_password(PASSWORD) self.port = self.server_control.get_port() - self.url = "http://{}:{}".format(ADDRESS, self.port) + self.url = f"http://{ADDRESS}:{self.port}" # Start test server before running any tests self.server_control.start_server() @@ -79,7 +78,7 @@ def test_blnet_web_log_in(self): self.assertTrue(blnet.logged_in()) # test without http blnet = BLNETWeb( - "{}:{}".format(ADDRESS, self.port), password=PASSWORD, timeout=10 + f"{ADDRESS}:{self.port}", password=PASSWORD, timeout=10 ) with blnet as blnet: self.assertTrue(blnet.logged_in()) diff --git a/tests/test_web_pages.py b/tests/test_web_pages.py new file mode 100644 index 0000000..f533dae --- /dev/null +++ b/tests/test_web_pages.py @@ -0,0 +1,61 @@ +"""Parsing of saved BL-NET web pages, independent of the mock HTTP server""" + +import unittest +from pathlib import Path +from unittest import mock + +from pyblnet import BLNETWeb, blnet_test + +PAGES = Path(__file__).parent / "test_structure" + + +def page(name): + """Response serving a saved page, decoded like requests does for the BL-NET""" + return mock.Mock(text=(PAGES / name).read_bytes().decode("latin-1")) + + +def serve(name): + return mock.patch("pyblnet.blnet_web.requests.get", return_value=page(name)) + + +class BLNETWebPagesTest(unittest.TestCase): + def setUp(self): + with serve("main.htm"): + self.web = BLNETWeb("blnet", password=None) + + def test_blnet_test_recognizes_main_page(self): + with serve("main.htm"): + self.assertTrue(blnet_test("blnet")) + + def test_blnet_test_recognizes_access_denied_page(self): + with serve(".error.html"): + self.assertTrue(blnet_test("blnet")) + + def test_blnet_test_rejects_other_pages(self): + with serve("580500.htm"): + self.assertFalse(blnet_test("blnet")) + + def test_read_analog_values_with_negative_value(self): + with serve("580500.alternative.htm"): + values = self.web.read_analog_values() + self.assertEqual( + values, + [ + {"id": "1", "name": "TKollektor", "value": "-0.1", "unit_of_measurement": "°C"}, + {"id": "2", "name": "TSP.oben", "value": "47.1", "unit_of_measurement": "°C"}, + {"id": "3", "name": "TSP.unten", "value": "57.8", "unit_of_measurement": "°C"}, + {"id": "4", "name": "THeizkr.VL", "value": "45.8", "unit_of_measurement": "°C"}, + {"id": "5", "name": "Temp.Aussen", "value": "1.1", "unit_of_measurement": "°C"}, + {"id": "6", "name": "Temp.Raum", "value": "24.1", "unit_of_measurement": "°C"}, + {"id": "7", "name": "T Kaminofen", "value": "55.8", "unit_of_measurement": "°C"}, + {"id": "9", "name": "TZirku.RL", "value": "22.4", "unit_of_measurement": "°C"}, + ], + ) + + def test_read_analog_values_access_denied(self): + with serve(".error.html"): + self.assertIsNone(self.web.read_analog_values()) + + def test_read_digital_values_access_denied(self): + with serve(".error.html"): + self.assertIsNone(self.web.read_digital_values()) diff --git a/tests/web_raw/web_state.py b/tests/web_raw/web_state.py index fea4126..ea1b382 100644 --- a/tests/web_raw/web_state.py +++ b/tests/web_raw/web_state.py @@ -3,48 +3,56 @@ 1: { "id": "1", "name": "TKollektor", + "type": "temperature", "unit_of_measurement": "°C", "value": "5.3", }, 2: { "id": "2", "name": "TSP.oben", + "type": "temperature", "unit_of_measurement": "°C", "value": "46.3", }, 3: { "id": "3", "name": "TSP.unten", + "type": "temperature", "unit_of_measurement": "°C", "value": "53.1", }, 4: { "id": "4", "name": "THeizkr.VL", + "type": "temperature", "unit_of_measurement": "°C", "value": "44.8", }, 5: { "id": "5", "name": "Temp.Aussen", + "type": "temperature", "unit_of_measurement": "°C", "value": "-72.3", }, 6: { "id": "6", "name": "Temp.Raum", + "type": "temperature", "unit_of_measurement": "°C", "value": "24.6", }, 7: { "id": "7", "name": "T Kaminofen", + "type": "temperature", "unit_of_measurement": "°C", "value": "20.9", }, 9: { "id": "9", "name": "TZirku.RL", + "type": "temperature", "unit_of_measurement": "°C", "value": "36.6", }, @@ -68,42 +76,49 @@ "id": "2", "name": "TSP.oben", "value": "47.1", + "type": "temperature", "unit_of_measurement": "°C", }, 3: { "id": "3", "name": "TSP.unten", "value": "57.8", + "type": "temperature", "unit_of_measurement": "°C", }, 4: { "id": "4", "name": "THeizkr.VL", "value": "45.8", + "type": "temperature", "unit_of_measurement": "°C", }, 5: { "id": "5", "name": "Temp.Aussen", "value": "1.1", + "type": "temperature", "unit_of_measurement": "°C", }, 6: { "id": "6", "name": "Temp.Raum", "value": "24.1", + "type": "temperature", "unit_of_measurement": "°C", }, 7: { "id": "7", "name": "T Kaminofen", "value": "55.8", + "type": "temperature", "unit_of_measurement": "°C", }, 9: { "id": "9", "name": "TZirku.RL", "value": "22.4", + "type": "temperature", "unit_of_measurement": "°C", }, }, diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..d48f7d7 --- /dev/null +++ b/uv.lock @@ -0,0 +1,343 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" + +[[package]] +name = "certifi" +version = "2026.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/2d/a891ca51311197f6ad14a7ef42e2399f36cf2f9bd44752b3dc4eab60fdc5/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120", size = 154268, upload-time = "2026-01-04T02:42:41.825Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e6/ad/3cc14f097111b4de0040c83a525973216457bbeeb63739ef1ed275c1c021/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c", size = 152900, upload-time = "2026-01-04T02:42:40.15Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/13/69/33ddede1939fdd074bce5434295f38fae7136463422fe4fd3e0e89b98062/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a", size = 129418, upload-time = "2025-10-14T04:42:32.879Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ed/27/c6491ff4954e58a10f69ad90aca8a1b6fe9c5d3c6f380907af3c37435b59/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8", size = 206988, upload-time = "2025-10-14T04:40:33.79Z" }, + { url = "https://files.pythonhosted.org/packages/94/59/2e87300fe67ab820b5428580a53cad894272dbb97f38a7a814a2a1ac1011/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0", size = 147324, upload-time = "2025-10-14T04:40:34.961Z" }, + { url = "https://files.pythonhosted.org/packages/07/fb/0cf61dc84b2b088391830f6274cb57c82e4da8bbc2efeac8c025edb88772/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3", size = 142742, upload-time = "2025-10-14T04:40:36.105Z" }, + { url = "https://files.pythonhosted.org/packages/62/8b/171935adf2312cd745d290ed93cf16cf0dfe320863ab7cbeeae1dcd6535f/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc", size = 160863, upload-time = "2025-10-14T04:40:37.188Z" }, + { url = "https://files.pythonhosted.org/packages/09/73/ad875b192bda14f2173bfc1bc9a55e009808484a4b256748d931b6948442/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897", size = 157837, upload-time = "2025-10-14T04:40:38.435Z" }, + { url = "https://files.pythonhosted.org/packages/6d/fc/de9cce525b2c5b94b47c70a4b4fb19f871b24995c728e957ee68ab1671ea/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381", size = 151550, upload-time = "2025-10-14T04:40:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/55/c2/43edd615fdfba8c6f2dfbd459b25a6b3b551f24ea21981e23fb768503ce1/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815", size = 149162, upload-time = "2025-10-14T04:40:41.163Z" }, + { url = "https://files.pythonhosted.org/packages/03/86/bde4ad8b4d0e9429a4e82c1e8f5c659993a9a863ad62c7df05cf7b678d75/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0", size = 150019, upload-time = "2025-10-14T04:40:42.276Z" }, + { url = "https://files.pythonhosted.org/packages/1f/86/a151eb2af293a7e7bac3a739b81072585ce36ccfb4493039f49f1d3cae8c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161", size = 143310, upload-time = "2025-10-14T04:40:43.439Z" }, + { url = "https://files.pythonhosted.org/packages/b5/fe/43dae6144a7e07b87478fdfc4dbe9efd5defb0e7ec29f5f58a55aeef7bf7/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4", size = 162022, upload-time = "2025-10-14T04:40:44.547Z" }, + { url = "https://files.pythonhosted.org/packages/80/e6/7aab83774f5d2bca81f42ac58d04caf44f0cc2b65fc6db2b3b2e8a05f3b3/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89", size = 149383, upload-time = "2025-10-14T04:40:46.018Z" }, + { url = "https://files.pythonhosted.org/packages/4f/e8/b289173b4edae05c0dde07f69f8db476a0b511eac556dfe0d6bda3c43384/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569", size = 159098, upload-time = "2025-10-14T04:40:47.081Z" }, + { url = "https://files.pythonhosted.org/packages/d8/df/fe699727754cae3f8478493c7f45f777b17c3ef0600e28abfec8619eb49c/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224", size = 152991, upload-time = "2025-10-14T04:40:48.246Z" }, + { url = "https://files.pythonhosted.org/packages/1a/86/584869fe4ddb6ffa3bd9f491b87a01568797fb9bd8933f557dba9771beaf/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a", size = 99456, upload-time = "2025-10-14T04:40:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/65/f6/62fdd5feb60530f50f7e38b4f6a1d5203f4d16ff4f9f0952962c044e919a/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016", size = 106978, upload-time = "2025-10-14T04:40:50.844Z" }, + { url = "https://files.pythonhosted.org/packages/7a/9d/0710916e6c82948b3be62d9d398cb4fcf4e97b56d6a6aeccd66c4b2f2bd5/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1", size = 99969, upload-time = "2025-10-14T04:40:52.272Z" }, + { url = "https://files.pythonhosted.org/packages/f3/85/1637cd4af66fa687396e757dec650f28025f2a2f5a5531a3208dc0ec43f2/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394", size = 208425, upload-time = "2025-10-14T04:40:53.353Z" }, + { url = "https://files.pythonhosted.org/packages/9d/6a/04130023fef2a0d9c62d0bae2649b69f7b7d8d24ea5536feef50551029df/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25", size = 148162, upload-time = "2025-10-14T04:40:54.558Z" }, + { url = "https://files.pythonhosted.org/packages/78/29/62328d79aa60da22c9e0b9a66539feae06ca0f5a4171ac4f7dc285b83688/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef", size = 144558, upload-time = "2025-10-14T04:40:55.677Z" }, + { url = "https://files.pythonhosted.org/packages/86/bb/b32194a4bf15b88403537c2e120b817c61cd4ecffa9b6876e941c3ee38fe/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d", size = 161497, upload-time = "2025-10-14T04:40:57.217Z" }, + { url = "https://files.pythonhosted.org/packages/19/89/a54c82b253d5b9b111dc74aca196ba5ccfcca8242d0fb64146d4d3183ff1/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8", size = 159240, upload-time = "2025-10-14T04:40:58.358Z" }, + { url = "https://files.pythonhosted.org/packages/c0/10/d20b513afe03acc89ec33948320a5544d31f21b05368436d580dec4e234d/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86", size = 153471, upload-time = "2025-10-14T04:40:59.468Z" }, + { url = "https://files.pythonhosted.org/packages/61/fa/fbf177b55bdd727010f9c0a3c49eefa1d10f960e5f09d1d887bf93c2e698/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a", size = 150864, upload-time = "2025-10-14T04:41:00.623Z" }, + { url = "https://files.pythonhosted.org/packages/05/12/9fbc6a4d39c0198adeebbde20b619790e9236557ca59fc40e0e3cebe6f40/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f", size = 150647, upload-time = "2025-10-14T04:41:01.754Z" }, + { url = "https://files.pythonhosted.org/packages/ad/1f/6a9a593d52e3e8c5d2b167daf8c6b968808efb57ef4c210acb907c365bc4/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc", size = 145110, upload-time = "2025-10-14T04:41:03.231Z" }, + { url = "https://files.pythonhosted.org/packages/30/42/9a52c609e72471b0fc54386dc63c3781a387bb4fe61c20231a4ebcd58bdd/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf", size = 162839, upload-time = "2025-10-14T04:41:04.715Z" }, + { url = "https://files.pythonhosted.org/packages/c4/5b/c0682bbf9f11597073052628ddd38344a3d673fda35a36773f7d19344b23/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15", size = 150667, upload-time = "2025-10-14T04:41:05.827Z" }, + { url = "https://files.pythonhosted.org/packages/e4/24/a41afeab6f990cf2daf6cb8c67419b63b48cf518e4f56022230840c9bfb2/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9", size = 160535, upload-time = "2025-10-14T04:41:06.938Z" }, + { url = "https://files.pythonhosted.org/packages/2a/e5/6a4ce77ed243c4a50a1fecca6aaaab419628c818a49434be428fe24c9957/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0", size = 154816, upload-time = "2025-10-14T04:41:08.101Z" }, + { url = "https://files.pythonhosted.org/packages/a8/ef/89297262b8092b312d29cdb2517cb1237e51db8ecef2e9af5edbe7b683b1/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26", size = 99694, upload-time = "2025-10-14T04:41:09.23Z" }, + { url = "https://files.pythonhosted.org/packages/3d/2d/1e5ed9dd3b3803994c155cd9aacb60c82c331bad84daf75bcb9c91b3295e/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525", size = 107131, upload-time = "2025-10-14T04:41:10.467Z" }, + { url = "https://files.pythonhosted.org/packages/d0/d9/0ed4c7098a861482a7b6a95603edce4c0d9db2311af23da1fb2b75ec26fc/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3", size = 100390, upload-time = "2025-10-14T04:41:11.915Z" }, + { url = "https://files.pythonhosted.org/packages/97/45/4b3a1239bbacd321068ea6e7ac28875b03ab8bc0aa0966452db17cd36714/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794", size = 208091, upload-time = "2025-10-14T04:41:13.346Z" }, + { url = "https://files.pythonhosted.org/packages/7d/62/73a6d7450829655a35bb88a88fca7d736f9882a27eacdca2c6d505b57e2e/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed", size = 147936, upload-time = "2025-10-14T04:41:14.461Z" }, + { url = "https://files.pythonhosted.org/packages/89/c5/adb8c8b3d6625bef6d88b251bbb0d95f8205831b987631ab0c8bb5d937c2/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72", size = 144180, upload-time = "2025-10-14T04:41:15.588Z" }, + { url = "https://files.pythonhosted.org/packages/91/ed/9706e4070682d1cc219050b6048bfd293ccf67b3d4f5a4f39207453d4b99/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328", size = 161346, upload-time = "2025-10-14T04:41:16.738Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0d/031f0d95e4972901a2f6f09ef055751805ff541511dc1252ba3ca1f80cf5/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede", size = 158874, upload-time = "2025-10-14T04:41:17.923Z" }, + { url = "https://files.pythonhosted.org/packages/f5/83/6ab5883f57c9c801ce5e5677242328aa45592be8a00644310a008d04f922/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894", size = 153076, upload-time = "2025-10-14T04:41:19.106Z" }, + { url = "https://files.pythonhosted.org/packages/75/1e/5ff781ddf5260e387d6419959ee89ef13878229732732ee73cdae01800f2/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1", size = 150601, upload-time = "2025-10-14T04:41:20.245Z" }, + { url = "https://files.pythonhosted.org/packages/d7/57/71be810965493d3510a6ca79b90c19e48696fb1ff964da319334b12677f0/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490", size = 150376, upload-time = "2025-10-14T04:41:21.398Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d5/c3d057a78c181d007014feb7e9f2e65905a6c4ef182c0ddf0de2924edd65/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44", size = 144825, upload-time = "2025-10-14T04:41:22.583Z" }, + { url = "https://files.pythonhosted.org/packages/e6/8c/d0406294828d4976f275ffbe66f00266c4b3136b7506941d87c00cab5272/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133", size = 162583, upload-time = "2025-10-14T04:41:23.754Z" }, + { url = "https://files.pythonhosted.org/packages/d7/24/e2aa1f18c8f15c4c0e932d9287b8609dd30ad56dbe41d926bd846e22fb8d/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3", size = 150366, upload-time = "2025-10-14T04:41:25.27Z" }, + { url = "https://files.pythonhosted.org/packages/e4/5b/1e6160c7739aad1e2df054300cc618b06bf784a7a164b0f238360721ab86/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e", size = 160300, upload-time = "2025-10-14T04:41:26.725Z" }, + { url = "https://files.pythonhosted.org/packages/7a/10/f882167cd207fbdd743e55534d5d9620e095089d176d55cb22d5322f2afd/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc", size = 154465, upload-time = "2025-10-14T04:41:28.322Z" }, + { url = "https://files.pythonhosted.org/packages/89/66/c7a9e1b7429be72123441bfdbaf2bc13faab3f90b933f664db506dea5915/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac", size = 99404, upload-time = "2025-10-14T04:41:29.95Z" }, + { url = "https://files.pythonhosted.org/packages/c4/26/b9924fa27db384bdcd97ab83b4f0a8058d96ad9626ead570674d5e737d90/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14", size = 107092, upload-time = "2025-10-14T04:41:31.188Z" }, + { url = "https://files.pythonhosted.org/packages/af/8f/3ed4bfa0c0c72a7ca17f0380cd9e4dd842b09f664e780c13cff1dcf2ef1b/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2", size = 100408, upload-time = "2025-10-14T04:41:32.624Z" }, + { url = "https://files.pythonhosted.org/packages/2a/35/7051599bd493e62411d6ede36fd5af83a38f37c4767b92884df7301db25d/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd", size = 207746, upload-time = "2025-10-14T04:41:33.773Z" }, + { url = "https://files.pythonhosted.org/packages/10/9a/97c8d48ef10d6cd4fcead2415523221624bf58bcf68a802721a6bc807c8f/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb", size = 147889, upload-time = "2025-10-14T04:41:34.897Z" }, + { url = "https://files.pythonhosted.org/packages/10/bf/979224a919a1b606c82bd2c5fa49b5c6d5727aa47b4312bb27b1734f53cd/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e", size = 143641, upload-time = "2025-10-14T04:41:36.116Z" }, + { url = "https://files.pythonhosted.org/packages/ba/33/0ad65587441fc730dc7bd90e9716b30b4702dc7b617e6ba4997dc8651495/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14", size = 160779, upload-time = "2025-10-14T04:41:37.229Z" }, + { url = "https://files.pythonhosted.org/packages/67/ed/331d6b249259ee71ddea93f6f2f0a56cfebd46938bde6fcc6f7b9a3d0e09/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191", size = 159035, upload-time = "2025-10-14T04:41:38.368Z" }, + { url = "https://files.pythonhosted.org/packages/67/ff/f6b948ca32e4f2a4576aa129d8bed61f2e0543bf9f5f2b7fc3758ed005c9/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838", size = 152542, upload-time = "2025-10-14T04:41:39.862Z" }, + { url = "https://files.pythonhosted.org/packages/16/85/276033dcbcc369eb176594de22728541a925b2632f9716428c851b149e83/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6", size = 149524, upload-time = "2025-10-14T04:41:41.319Z" }, + { url = "https://files.pythonhosted.org/packages/9e/f2/6a2a1f722b6aba37050e626530a46a68f74e63683947a8acff92569f979a/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e", size = 150395, upload-time = "2025-10-14T04:41:42.539Z" }, + { url = "https://files.pythonhosted.org/packages/60/bb/2186cb2f2bbaea6338cad15ce23a67f9b0672929744381e28b0592676824/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c", size = 143680, upload-time = "2025-10-14T04:41:43.661Z" }, + { url = "https://files.pythonhosted.org/packages/7d/a5/bf6f13b772fbb2a90360eb620d52ed8f796f3c5caee8398c3b2eb7b1c60d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090", size = 162045, upload-time = "2025-10-14T04:41:44.821Z" }, + { url = "https://files.pythonhosted.org/packages/df/c5/d1be898bf0dc3ef9030c3825e5d3b83f2c528d207d246cbabe245966808d/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152", size = 149687, upload-time = "2025-10-14T04:41:46.442Z" }, + { url = "https://files.pythonhosted.org/packages/a5/42/90c1f7b9341eef50c8a1cb3f098ac43b0508413f33affd762855f67a410e/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828", size = 160014, upload-time = "2025-10-14T04:41:47.631Z" }, + { url = "https://files.pythonhosted.org/packages/76/be/4d3ee471e8145d12795ab655ece37baed0929462a86e72372fd25859047c/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec", size = 154044, upload-time = "2025-10-14T04:41:48.81Z" }, + { url = "https://files.pythonhosted.org/packages/b0/6f/8f7af07237c34a1defe7defc565a9bc1807762f672c0fde711a4b22bf9c0/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9", size = 99940, upload-time = "2025-10-14T04:41:49.946Z" }, + { url = "https://files.pythonhosted.org/packages/4b/51/8ade005e5ca5b0d80fb4aff72a3775b325bdc3d27408c8113811a7cbe640/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c", size = 107104, upload-time = "2025-10-14T04:41:51.051Z" }, + { url = "https://files.pythonhosted.org/packages/da/5f/6b8f83a55bb8278772c5ae54a577f3099025f9ade59d0136ac24a0df4bde/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2", size = 100743, upload-time = "2025-10-14T04:41:52.122Z" }, + { url = "https://files.pythonhosted.org/packages/0a/4c/925909008ed5a988ccbb72dcc897407e5d6d3bd72410d69e051fc0c14647/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f", size = 53402, upload-time = "2025-10-14T04:42:31.76Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "coverage" +version = "7.16.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2f/55/d1eaf3e73781174340a00dc1ba2aee8a65f82fadb18e2797b192b6b3925b/coverage-7.16.2.tar.gz", hash = "sha256:ca64d9f1f384f151b9511bec01126072acd2f313439f8ed015a22d8790aab6fa", size = 971999, upload-time = "2026-09-27T12:29:01.118Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/fa/ce3baf63d85b730398d92a7162f486f3a5e4e2cc3382a02488b3943725ba/coverage-7.16.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:732d950e51f3ba4fb6209c73250f3e8924fefca42953ee04a9e65d8c02414d7d", size = 223797, upload-time = "2026-09-27T12:25:54.756Z" }, + { url = "https://files.pythonhosted.org/packages/7a/57/9ba29c2aac7f756d479f03d45762120060f0f988788001001bf36e0e6fca/coverage-7.16.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5dca0bb66b4c3d624ba047887bf70270030c150692d543cb501293dc38a9f4b5", size = 224303, upload-time = "2026-09-27T12:25:56.214Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/0d6d60906dca7d28cc1e3fce12a9861801c4fbb6cbf220ad78cd059c9467/coverage-7.16.2-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:af2a2a8c7c74de0559e0c368d94c8def9e16c58faaee33a0bf081057c4227e3b", size = 254715, upload-time = "2026-09-27T12:25:57.755Z" }, + { url = "https://files.pythonhosted.org/packages/cd/b8/9198b865679379fb165c689c64f6e11105ef380f6bd1c7673e83f73d9f5c/coverage-7.16.2-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:db5f8394e17f877a625b257f2ba0ce8e728a499c2c1579ad66220272cd3df510", size = 256627, upload-time = "2026-09-27T12:25:59.131Z" }, + { url = "https://files.pythonhosted.org/packages/98/79/9521462cb6072fe394701bc8974b74afd576c9c9355156c7844e1a86a42b/coverage-7.16.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5b3146d2317c75f70df2509066d979dadd941f7021cdf9b5db4bcd8568258e25", size = 258724, upload-time = "2026-09-27T12:26:00.691Z" }, + { url = "https://files.pythonhosted.org/packages/a6/76/8d7d5d633db9fe0f3182fedc731bf09f9bcf2366055735152504ad614677/coverage-7.16.2-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e1d0ced76318bab499693ff25f64faa343415187cb2e4d7befdfdd391a1cf6a", size = 260692, upload-time = "2026-09-27T12:26:02.083Z" }, + { url = "https://files.pythonhosted.org/packages/4e/a7/76cb09c89ba46d74d37428bf93251fc14fb0bbe9e05cc2a5ef61773d318a/coverage-7.16.2-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:af98ad5ed9d6daaca956201e00bb429a7eb2b080426686f70a20353e0f9839f5", size = 254800, upload-time = "2026-09-27T12:26:03.369Z" }, + { url = "https://files.pythonhosted.org/packages/72/b6/2351c1979aaeb5b4a8091a75b90ca997ad60de36e181ddba267cf61dac97/coverage-7.16.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d56e4d21c56d2046447733f8b118409597db48c01efe898ee9ac24e858ec2d6", size = 256423, upload-time = "2026-09-27T12:26:04.751Z" }, + { url = "https://files.pythonhosted.org/packages/0f/f4/ad9a4f8b5cb2d494fa9452b546fe742ed2f9d3847cc14c05e36279a3e649/coverage-7.16.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1d5d0e3b660506fb84f995814e3118a21efdc0c8eb80127da1be627d90093c17", size = 254487, upload-time = "2026-09-27T12:26:06.082Z" }, + { url = "https://files.pythonhosted.org/packages/6c/1f/a520470472f3e8b01169bf42162b1470c9ba992230432f62ca36269bf3a0/coverage-7.16.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:17228fbca0f22976f797be94e975dcd237799c657d49551c7de1e0654d1202e9", size = 258259, upload-time = "2026-09-27T12:26:07.513Z" }, + { url = "https://files.pythonhosted.org/packages/09/d2/ff26d5938274745855fa61cfcba0245c88ccc10d98d2cbd96064f16cd5a7/coverage-7.16.2-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:bc0b0ac781d489304b741269857f1f8338b7a26b1b89c06c0344658001ec0035", size = 254216, upload-time = "2026-09-27T12:26:08.982Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1d/5d832d3b06785d9f53267e4f2724a9f60c312eee6ebed9063a461d0d3b45/coverage-7.16.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bf1bd822ec4e387ed245bed0d71151582cf7be9e5309bc4145eefe36083d5878", size = 255125, upload-time = "2026-09-27T12:26:10.35Z" }, + { url = "https://files.pythonhosted.org/packages/55/4d/1d33edbc2fcf7d99e384e393e712aa5a2ebbbd8409825357815982207976/coverage-7.16.2-cp311-cp311-win32.whl", hash = "sha256:7ed238d227e23cc300c3d464babdaf9f6ddc740aa1b15a77ae96136e6a7c4516", size = 225898, upload-time = "2026-09-27T12:26:11.7Z" }, + { url = "https://files.pythonhosted.org/packages/6f/7c/676df4882118756c4f8f560c954eddb93e166d84dda8c5f0b6a829689bde/coverage-7.16.2-cp311-cp311-win_amd64.whl", hash = "sha256:a90700f743e29aa3d75a6ff5f01953176a889c00e526194bc4d281731b88d99d", size = 226369, upload-time = "2026-09-27T12:26:13.375Z" }, + { url = "https://files.pythonhosted.org/packages/7a/0e/a457f4a461b3c5610d845137fdd45fa465e011a64c25af440518ab1f4e41/coverage-7.16.2-cp311-cp311-win_arm64.whl", hash = "sha256:a336eec40e3520d369b8a6cdabb4f596e69a8b42927ca074aa1452fed943238a", size = 226344, upload-time = "2026-09-27T12:26:15.127Z" }, + { url = "https://files.pythonhosted.org/packages/5e/2c/f8296c63c5d542f3d21aed685e56b7031a419037d155bb3382fc0940d249/coverage-7.16.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:218d742afca2b5ad5ca759e93eddedfbcc6eadf8322f080dcefc40b7bd4e2d48", size = 223969, upload-time = "2026-09-27T12:26:16.753Z" }, + { url = "https://files.pythonhosted.org/packages/90/23/6f3dcb1423a0d43216e402ea1746e4a7c7c44f38896b97dd573790f56a40/coverage-7.16.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9a638be322a8d76a41cdb17781c7f82aaee6a66493d8ffb7e2c09ee22423d99", size = 224328, upload-time = "2026-09-27T12:26:18.15Z" }, + { url = "https://files.pythonhosted.org/packages/ac/7d/8f3b6dc920e3fc6732f7678785a2091db439f186afbec30dbf2214d9b1f7/coverage-7.16.2-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:724bd0f1e81856b35e59fc98cf7b4e544a3cb662e4e0864dca73d4326ee9d808", size = 255832, upload-time = "2026-09-27T12:26:19.799Z" }, + { url = "https://files.pythonhosted.org/packages/d1/36/6c45f15be4eca4ac1062c6a55a323286494c99726a7e58951fe85967ac08/coverage-7.16.2-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5375ebd99038021b35e99dc88255022912c06565d316212f4a576e4b08d30f5d", size = 258571, upload-time = "2026-09-27T12:26:21.199Z" }, + { url = "https://files.pythonhosted.org/packages/34/fb/b54cbeba3ad89082c2e441278681859e538322cc34b84b2af7ebff00080f/coverage-7.16.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a076277ca9f5750cc230f0f578ebd2620cec60255b25707361699fef6fb465c", size = 259680, upload-time = "2026-09-27T12:26:22.822Z" }, + { url = "https://files.pythonhosted.org/packages/6e/a2/0dc65ec3d61930e1e4c2e371763b15eb4290896eb343a12d5d3091308116/coverage-7.16.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:58d4a54c6ea672afef66d49be922a2c69826c5ae1a42a9cd94f0c9c2bacdf800", size = 261945, upload-time = "2026-09-27T12:26:24.336Z" }, + { url = "https://files.pythonhosted.org/packages/d6/93/5fad7a61f2c14e08e98946fc31c1c7ffc1195061bf3fdc351db3be77a863/coverage-7.16.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcbcfcc059117284c603ff8cb61a65872512882f84a8cf0339241f7f7c2f148", size = 256191, upload-time = "2026-09-27T12:26:25.89Z" }, + { url = "https://files.pythonhosted.org/packages/2d/47/74e5de9227b939ece9f64e729645ddc4296bea10dbfa98721c1333c8be2e/coverage-7.16.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:afdf43b72ef3876c1fe66423b91466e37877c9e81e8cec70542b7e8525b9d1b7", size = 257610, upload-time = "2026-09-27T12:26:27.35Z" }, + { url = "https://files.pythonhosted.org/packages/13/fe/2cf28d40b43645d1b72388fe3ee7f7c747533a6a9557bb8c24a7ae74fe1a/coverage-7.16.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:9acc7f7ec4a1b5f89bd929fde5b8a714f6fafdc6cc18725413d510aa082b47ad", size = 255757, upload-time = "2026-09-27T12:26:28.949Z" }, + { url = "https://files.pythonhosted.org/packages/d7/3d/7c149fd99fc8bbc39c80db5e688d1d39fd040be2ecb78b8335a51a55b9c0/coverage-7.16.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:80d3f7b48d43ee8fc5e8707a8adb43d743a5a1a85256c25a24f9d6d0e2238fa6", size = 259822, upload-time = "2026-09-27T12:26:30.515Z" }, + { url = "https://files.pythonhosted.org/packages/e6/3f/b283fce09d5995e227bd8e513358dd7471bedc0f78abc85a925ebdb0a2f6/coverage-7.16.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:126d1af8804d7224421fe991ff65d3ce649081560df7a98b1a5ffff07f9923bd", size = 255325, upload-time = "2026-09-27T12:26:32.037Z" }, + { url = "https://files.pythonhosted.org/packages/bf/91/f3325edf0c4223fb1fe1532b8dbef2a1d2f729459a9a7d1a44d073bae534/coverage-7.16.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c19cd6d025c1673f22afcd22c7df8a662d779e05d8e3fa6820c22afb895b0206", size = 257191, upload-time = "2026-09-27T12:26:33.525Z" }, + { url = "https://files.pythonhosted.org/packages/c4/89/21eb5e83ecf2eed523c4eb3d65ae513cd082c8fd1b6deb34c4cb6c332f97/coverage-7.16.2-cp312-cp312-win32.whl", hash = "sha256:152877cdc8a07264882cfcd503ba56a3ef6cba56a70e8c70f6eb8ffd7384789a", size = 226034, upload-time = "2026-09-27T12:26:35.021Z" }, + { url = "https://files.pythonhosted.org/packages/db/de/e3ad6d864c0833624b4f1f9b53f9e58e116c945e5e965c3f1e172c5e84cd/coverage-7.16.2-cp312-cp312-win_amd64.whl", hash = "sha256:e6c52d3307824ff93b39efd99e4185d557db40bd841452abfb32e5d9151ca162", size = 226569, upload-time = "2026-09-27T12:26:36.604Z" }, + { url = "https://files.pythonhosted.org/packages/3e/c1/bccc58ebe5489cc70628f635c1932fd371f5d7da850dbcf960f95f4c4afc/coverage-7.16.2-cp312-cp312-win_arm64.whl", hash = "sha256:a678c0b6b22086ec2427359d22e37445d4a792f5fdbbc744112c7dade65cad02", size = 226372, upload-time = "2026-09-27T12:26:38.406Z" }, + { url = "https://files.pythonhosted.org/packages/f0/f6/8eb4f220ef24f84fb27d852d4f9bf83e0c73ec1a4a08dd9a87e3f4529739/coverage-7.16.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1a37c6e478cf687e1aa30a593d19c92c02fad9d122b51ab73f51b8dc7a0c0fc9", size = 223993, upload-time = "2026-09-27T12:26:40.164Z" }, + { url = "https://files.pythonhosted.org/packages/40/23/d4bbaf0c154e0b0c2b5264890dbf6ef098dcb50ec8f2469be9490d191660/coverage-7.16.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0993d0e90858c03943d3cb152e068a20dd4707924deec84dd2230261baae3b1b", size = 224368, upload-time = "2026-09-27T12:26:41.762Z" }, + { url = "https://files.pythonhosted.org/packages/7f/48/fc1e88fd571ec5cb38150b7f89f7696ca1bdf9920e01432febb69774cc85/coverage-7.16.2-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bb2fc905bbf4e6b7f40806ea79e31515abf6349594cdf0adf27c4215f0463204", size = 255358, upload-time = "2026-09-27T12:26:43.442Z" }, + { url = "https://files.pythonhosted.org/packages/1d/56/6785397d07c29c8e70fbb9a07e97d062b43c21ffc5f12385917847f09f63/coverage-7.16.2-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:4358b9c8c0125b460407f3017c6cce8156e904b32772c5630d27112f52bdbfe5", size = 257955, upload-time = "2026-09-27T12:26:45.725Z" }, + { url = "https://files.pythonhosted.org/packages/27/3b/c8cdd07721e5f99abd81cea970d971997f99bf158c0b85f51bd284179c8b/coverage-7.16.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f15254427c9b33eedac4f198eaf9e356eb4f6214551afb43da6194a2c088ad7", size = 259183, upload-time = "2026-09-27T12:26:47.208Z" }, + { url = "https://files.pythonhosted.org/packages/9b/11/606b192fe43d32574ec6238549d48de588fdcc18485682a5ec0a8ac357f2/coverage-7.16.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9a75a4704ff640e46170042eec1f984385a121227c505d5a16ad8e495f452541", size = 261325, upload-time = "2026-09-27T12:26:49.084Z" }, + { url = "https://files.pythonhosted.org/packages/67/90/eea481f8b0305ceeb33f081a5f47e298391dbd1b589de0c4b3b3aa50d3f2/coverage-7.16.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:14253fc7bb15749b849795a06f5d3b6d8bc3fb8a4b5ddc341faf7a89dce205fc", size = 255531, upload-time = "2026-09-27T12:26:50.509Z" }, + { url = "https://files.pythonhosted.org/packages/6b/be/dedbf9aea1457b120c27ac10b8fc2a357f37fa2b54c3e7286d42980a0a2a/coverage-7.16.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:921415102a90637fcc2e3f169f61dad7699ecf690e8639fc21b813acbedc0967", size = 257329, upload-time = "2026-09-27T12:26:52.005Z" }, + { url = "https://files.pythonhosted.org/packages/fa/cb/b25c19d5bb2bd0f2e4e27fe8e2ffcae80c7a91ae181c0dc749ed60e9b1a4/coverage-7.16.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cce2bc991293f15cc4084ca116827b5900c5f34e1a54dfe83f10ab5c43162eb7", size = 255294, upload-time = "2026-09-27T12:26:53.634Z" }, + { url = "https://files.pythonhosted.org/packages/5f/a2/892c5c5f4ad44b7b2ca009aee705191f3f268f15052244f2f9e3539b2e35/coverage-7.16.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:e1fa594c887365b69745f25a416806e61085dd07b94c9eae68a6e20730629b23", size = 259444, upload-time = "2026-09-27T12:26:55.243Z" }, + { url = "https://files.pythonhosted.org/packages/ed/99/a562537deba0a3e370182ae71c149be796c39d8087365f17a09188f27145/coverage-7.16.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:11e597173af1dc33d5f8a7332ada544199269a223af1ee1770ddd5e245ad0fe8", size = 255111, upload-time = "2026-09-27T12:26:56.851Z" }, + { url = "https://files.pythonhosted.org/packages/2d/20/854ec68641a9b3362ff068a32dfa41637299761617ef253791dbade6fc76/coverage-7.16.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3e7f99698ba3a7d13988bdd984b7ebf13af4dbe2166dc8502eef90d77603b0a4", size = 256882, upload-time = "2026-09-27T12:26:58.41Z" }, + { url = "https://files.pythonhosted.org/packages/db/0d/748e4518b0ac0f9ff2687c248a6e5f8c0737306e709372632a2556f84443/coverage-7.16.2-cp313-cp313-win32.whl", hash = "sha256:f80bd9f9633eafc73d0a913ba2645c96ba58bba1befc30590f7c0fbfde59d865", size = 226045, upload-time = "2026-09-27T12:26:59.983Z" }, + { url = "https://files.pythonhosted.org/packages/31/fa/6e46edba66a183fe4d99d4bb52c173287e9b8dddabe0888d24cb8210e580/coverage-7.16.2-cp313-cp313-win_amd64.whl", hash = "sha256:8be099e979fc42559328a21828281b4578304191ae46ed4e80a407048a82eee6", size = 226581, upload-time = "2026-09-27T12:27:01.494Z" }, + { url = "https://files.pythonhosted.org/packages/1b/d9/9ef6845367600b336ff75d000444a0d32497d6972c833141bd39356abf68/coverage-7.16.2-cp313-cp313-win_arm64.whl", hash = "sha256:28ff850182a67d117990fa2ce5ea1032836d8c9630dae867e8bdd3bff4533b79", size = 226409, upload-time = "2026-09-27T12:27:03.116Z" }, + { url = "https://files.pythonhosted.org/packages/59/4c/577fc0803dab4155dcf808faffbdd7b159256781c0874a8586e17b81b149/coverage-7.16.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4ee546b9e4872ffa194bf07ac87bfa1202ebb824d0795dc1ef22f175545ca90a", size = 224138, upload-time = "2026-09-27T12:27:05.141Z" }, + { url = "https://files.pythonhosted.org/packages/75/9e/e3785ba3ecba2bd11efc74bfe2801ca4b78c4480b15a375648d809a59da3/coverage-7.16.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a2fac6895eb299a2e52d7bbb8fb3903502b9da8d3f5309ceb16ec40c646b58ee", size = 224445, upload-time = "2026-09-27T12:27:06.805Z" }, + { url = "https://files.pythonhosted.org/packages/f0/d0/963ff22d3fd27117da3b8cc442f5bdc91196f783321e1a8ff0ec43476772/coverage-7.16.2-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:57ff3783f99d75a1e81dd56a9737eb5665e6736a5d93258ba596b6dcad8fd05b", size = 256112, upload-time = "2026-09-27T12:27:08.43Z" }, + { url = "https://files.pythonhosted.org/packages/a8/d4/a306940c81c6ae759e82fff27d20b7fdc6896e422b821f51313cce212b6c/coverage-7.16.2-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:35f37886699cb9abd29958247d718628d5bc6f39e623dff66a09e546c42a7e03", size = 258727, upload-time = "2026-09-27T12:27:09.927Z" }, + { url = "https://files.pythonhosted.org/packages/b9/a3/d3d99d93b02517087aa05bc0cf2d04d372956b849e5443e059079901429b/coverage-7.16.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0fd7a86fdda7cb6d616d178654bd0ad6bc0f3f33c2e478aa598500a1a9e34eda", size = 259909, upload-time = "2026-09-27T12:27:11.55Z" }, + { url = "https://files.pythonhosted.org/packages/08/44/39dd599181726758dd185ae4dc0c0ab3aeabf7ca70e68e145060feeaaa16/coverage-7.16.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ac0f3b379c94acc2f7dce5f5f0b24d44fa1cc6a509717ef83dfee07450c2117c", size = 262481, upload-time = "2026-09-27T12:27:13.17Z" }, + { url = "https://files.pythonhosted.org/packages/99/e8/91ee43f6ded411460c359d7e1aebde4d6fd8f00a2e5394182d9d212eb23c/coverage-7.16.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7d0732c83746bc24123c581a85d9dd96b70ddb538c9076020aa1a041790361e9", size = 256012, upload-time = "2026-09-27T12:27:14.91Z" }, + { url = "https://files.pythonhosted.org/packages/11/8c/e9499ddc33197bd7eabcb1118ca81756fc874457b324e2b479a4804b2ad2/coverage-7.16.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b451c68218c150f616bc9649783ec8de76a59792c759b43aa0c9c0466a465e4", size = 257898, upload-time = "2026-09-27T12:27:16.588Z" }, + { url = "https://files.pythonhosted.org/packages/5f/6e/c081cb5991a0afba99f9c4ad6c74a5fce9513a38ddc64e3e6680c6fed9af/coverage-7.16.2-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a56ac4fa5a75c7e182e8f62600cfb4aff43c5ed7356a034f3557659c3bec1d90", size = 255938, upload-time = "2026-09-27T12:27:18.19Z" }, + { url = "https://files.pythonhosted.org/packages/b2/42/1c3d819e8f9b6eb01c2fe90874d67a8882adb9507e0bbb09361ed131ea89/coverage-7.16.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:4cc4f73aa3fabc36e32046d6cd2971405948d8a903636508a3d3b2f9128b3a95", size = 260368, upload-time = "2026-09-27T12:27:19.903Z" }, + { url = "https://files.pythonhosted.org/packages/19/4f/d70eac07901fd587b6ab05e659b52afe13959992aa5113bf6cce059cc572/coverage-7.16.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:723dcdab91357159b722935b500ee8abc0a66c8c432e1e9fabf4cc7598952de8", size = 255620, upload-time = "2026-09-27T12:27:21.621Z" }, + { url = "https://files.pythonhosted.org/packages/34/5e/6d87af88317d3d9a9b18a9ca1bc1673eb516917f296e579d0d4a55cb3490/coverage-7.16.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5397e21a90dde0e9c6896b77ded8f0be26b66f8b22b33aed41f6043ed95d55e6", size = 257521, upload-time = "2026-09-27T12:27:23.358Z" }, + { url = "https://files.pythonhosted.org/packages/79/bb/90c2641170d2fa1a6757b3f8450ba2740197317b0ddd749e9604b914e886/coverage-7.16.2-cp314-cp314-win32.whl", hash = "sha256:848893e1d361448c113dc2f0913503522a6f7be231d0e38333d2a22d9698a011", size = 226248, upload-time = "2026-09-27T12:27:25.153Z" }, + { url = "https://files.pythonhosted.org/packages/30/08/d8d0478bb02c8eb0ae20a496fc80c40fcf4d3450bd184300d682ba2d28a6/coverage-7.16.2-cp314-cp314-win_amd64.whl", hash = "sha256:5a27b731c171e43dc8b5f32b76a5051dde2ec9b9366c87028f08a7088ebc2c7b", size = 226732, upload-time = "2026-09-27T12:27:26.907Z" }, + { url = "https://files.pythonhosted.org/packages/32/3f/0001da22155b0a8ce063ec0f7e64ecbe17b373f306e7a74435f6d6accb72/coverage-7.16.2-cp314-cp314-win_arm64.whl", hash = "sha256:1c569a9fd25505f1cd6bea90588818f90373ce90e2632e2cacf19ddbd6e14fdb", size = 226645, upload-time = "2026-09-27T12:27:28.588Z" }, + { url = "https://files.pythonhosted.org/packages/d7/85/6d8813aff9b8b8586691a9d33c43c5604f7227622574da7cdc3d91a86861/coverage-7.16.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d93db87adb6b1c1b408dce4763314b55d76a9f589e96783a84ac9e7689e48bdf", size = 224871, upload-time = "2026-09-27T12:27:30.32Z" }, + { url = "https://files.pythonhosted.org/packages/5c/70/444f3a4981ac2cda40fdcf4cc9b56a4e1a33c222abeb33e51ed3e3eb2a6b/coverage-7.16.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:aa62c85046473959c13ba9edca9dc90a77d5c1095b1ba313556314d77fe5b036", size = 225123, upload-time = "2026-09-27T12:27:32.33Z" }, + { url = "https://files.pythonhosted.org/packages/d0/c1/980681cd7b33eb66ac835044116ef0a92e11fcc7bdd866cc89d10b1130b9/coverage-7.16.2-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:db76506aa5416081f3e8974ae0f7965c58ada0bb0ef7339ac86099588dbb20d3", size = 265049, upload-time = "2026-09-27T12:27:34.085Z" }, + { url = "https://files.pythonhosted.org/packages/b2/e3/87679875c33bb2191f0f05544a1cc9adcc940fe0c35443a10f2df753dde5/coverage-7.16.2-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a0f2285329dac10ab08f79cb11f5692c497018e6c7c511f95e6fd63a70b8f831", size = 267717, upload-time = "2026-09-27T12:27:36.025Z" }, + { url = "https://files.pythonhosted.org/packages/76/64/5d372776d6eb523d4e93bafba2253f96984e3b18261c4cc56a50863c6d0d/coverage-7.16.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:382d3346d56b0eec1b793d53a4c88799c8053f516aa3a8d7c44315696954bacf", size = 270047, upload-time = "2026-09-27T12:27:37.96Z" }, + { url = "https://files.pythonhosted.org/packages/be/c1/44082ff0cbf9f97d0043f57970a71204097ec7ba606361a9fd2065393669/coverage-7.16.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:648352b94507179d82637292e7ae8802508d95f78e2f00a705a50b6c48011681", size = 271360, upload-time = "2026-09-27T12:27:39.766Z" }, + { url = "https://files.pythonhosted.org/packages/b8/17/9a215efe25b5e0ecc87c89dbe525c4a87d14d87c8c0c7316ef140a5f6f3e/coverage-7.16.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fb2bde05838fffae1a1bf75e5d411a6cac3e4e9bb97e6640fed8cd47888b33f0", size = 264736, upload-time = "2026-09-27T12:27:42.072Z" }, + { url = "https://files.pythonhosted.org/packages/a2/da/7f0a31af8e448107d4d32844bd684757f51ea907bc0c68c8fd537b2123ff/coverage-7.16.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:6a75180829efb8ae62b4aded25be6ddca1c888d138d2d82e21d93bfbd88f41cb", size = 267600, upload-time = "2026-09-27T12:27:43.85Z" }, + { url = "https://files.pythonhosted.org/packages/dd/a4/3bfecbd3366b775bacdcb3330394d356cf384b5d8f5b2146ac4b14b252b5/coverage-7.16.2-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:99704f73721e23859112072d522076e11c31744fc96b5652e5dd2018aa4359f7", size = 264767, upload-time = "2026-09-27T12:27:45.768Z" }, + { url = "https://files.pythonhosted.org/packages/b8/3f/5d62163732d87e4a0c4710a0eab30f0fd6a2d480112abe2029f014fe8c9d/coverage-7.16.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:29309ccc86b7f33df7db12813c299f215bbbc470ed6292d0bedd63ffae1ebf64", size = 269026, upload-time = "2026-09-27T12:27:47.787Z" }, + { url = "https://files.pythonhosted.org/packages/49/4d/8e4579f225426535085a9be371cc75e3b026d058d679b80affbdfb4c3ef0/coverage-7.16.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:30c1b65d529e46569899fadca59e4a87c1faf2886923f1307ba61e654d4f3c20", size = 264147, upload-time = "2026-09-27T12:27:49.681Z" }, + { url = "https://files.pythonhosted.org/packages/d1/36/ef1f77e2c3f7bb03c2b13b9a2006f88700fdd75535ef158d70049f425c1c/coverage-7.16.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dcf4bc2aab4e16b1c4c0c2005918f23a7dd5d7821ddae82caed9e3342dc2fcce", size = 266376, upload-time = "2026-09-27T12:27:51.551Z" }, + { url = "https://files.pythonhosted.org/packages/be/79/0cb2bf4428830dec971c718c2c841a039c084415c99e67281f5a72841aab/coverage-7.16.2-cp314-cp314t-win32.whl", hash = "sha256:a9cd3de0a5bfe7b0e21ee10e1a14e3d61bf52efc88217ab1d95d6ace6970bd46", size = 226585, upload-time = "2026-09-27T12:27:53.945Z" }, + { url = "https://files.pythonhosted.org/packages/3c/f9/da17121c16667fd84998e972200ae226a41540f6ea4795776c6d99e8976f/coverage-7.16.2-cp314-cp314t-win_amd64.whl", hash = "sha256:611a44e5229a59d7483ce830160e1a0e85f700562c7a5651c7c63fb8f4eb528c", size = 227378, upload-time = "2026-09-27T12:27:55.778Z" }, + { url = "https://files.pythonhosted.org/packages/74/89/01179c62d1b7e6e33bd5001566b02d7f778cf33d3ec1e81e94ca170c517f/coverage-7.16.2-cp314-cp314t-win_arm64.whl", hash = "sha256:22957cef43ce038641de78ba995de7568d2d6a37c6ddbf7fa0fd7d1ae2344d91", size = 227064, upload-time = "2026-09-27T12:27:57.496Z" }, + { url = "https://files.pythonhosted.org/packages/4c/57/52935003c3f627ba6e5203d7179aad32448c10899663a30336aba8e81a2c/coverage-7.16.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:414c26dfdb96aac2d570a54e03008f001e32eb2d413705365503648c6bd361d8", size = 224140, upload-time = "2026-09-27T12:27:59.343Z" }, + { url = "https://files.pythonhosted.org/packages/31/38/df472520f3e626524d7e2fc9d6da0afe7895a2f1489d36b48af8ca40bb41/coverage-7.16.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:00d3eb96e9988c45f50cccd1f1496571ac5c1f91386ac02c4d55516eeda19a24", size = 224449, upload-time = "2026-09-27T12:28:01.299Z" }, + { url = "https://files.pythonhosted.org/packages/0c/aa/3be084d5b82e63ccdad4ed751e4acbae294673573e30481d29f8b7402eec/coverage-7.16.2-cp315-cp315-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:4dbbd1155ca46e6e0b6b89d204428c56ef6a459af21333f365d135a2820e5a09", size = 256060, upload-time = "2026-09-27T12:28:03.185Z" }, + { url = "https://files.pythonhosted.org/packages/de/29/48fca82a7ebf7ff7b2e35019cc9537e7f65e4d2aa1215cc5a8792c989251/coverage-7.16.2-cp315-cp315-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:8fc15cc8d0d06e873c00ef18e1372d605f9aaf3de27d8c24e50782e75bc8b843", size = 259106, upload-time = "2026-09-27T12:28:05.15Z" }, + { url = "https://files.pythonhosted.org/packages/06/3d/b2d5986f2dd53fe201aa1be2e4ab204fa1aed5101e67c0dbbb419b850aee/coverage-7.16.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c6afdd69218202bc1758c9a14b86b8cf1084f37ed2ca143e567a103772b16d1", size = 260674, upload-time = "2026-09-27T12:28:06.868Z" }, + { url = "https://files.pythonhosted.org/packages/ce/7e/b50160be3506ead12e6480d14279af7f0f17627694300a2d1fd2c42d2ff5/coverage-7.16.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:aba5c63b7afdc749cc9eae943d5b868cba2b261a176378fa1c5a30bc8bc89982", size = 263139, upload-time = "2026-09-27T12:28:08.771Z" }, + { url = "https://files.pythonhosted.org/packages/14/5e/7c805ac9a32606de1399bd7e9bd375aa2f973dc61b12680d9e6403c2e891/coverage-7.16.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9174f0af24e5eff248b9dbfe76ec5275a3d19d37edbc2810543f12cf97347a34", size = 256591, upload-time = "2026-09-27T12:28:10.842Z" }, + { url = "https://files.pythonhosted.org/packages/ab/9e/76f1ed129a2daf658a3ea17122824cf2e3b91fea0460d8d3664fc5a61018/coverage-7.16.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:80e9fdb4c3d926b6ba721d4bf7435bdb869c3527ae7803290361d0ab73db13b6", size = 258708, upload-time = "2026-09-27T12:28:12.962Z" }, + { url = "https://files.pythonhosted.org/packages/5a/b7/8d62e75f48b527619239a65294f842d4b7fd02a0839d43ae1de80184e2df/coverage-7.16.2-cp315-cp315-musllinux_1_2_i686.whl", hash = "sha256:7b3bce4a0d05401d70b7d0d5ca783e686bc9d30e81dbd7d980d532609bf809e4", size = 256562, upload-time = "2026-09-27T12:28:14.934Z" }, + { url = "https://files.pythonhosted.org/packages/b8/8d/0a15f95c3afb78e947c52644786ba4bc9de259905687dd720d5e6fae2e76/coverage-7.16.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:44f21e407b278efdfc1ee5e481e00518bd1d500310a30a5fbf2bcbedfef4aaf0", size = 261077, upload-time = "2026-09-27T12:28:17.215Z" }, + { url = "https://files.pythonhosted.org/packages/25/00/88389987305a47d732866c07c8a500000ab574df9505e3114ac69c8d027f/coverage-7.16.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:59c3926585e1cd1f2190f4b2ac9014de1bbeaf0d5d0587b0dc6b0aa90d17896a", size = 256034, upload-time = "2026-09-27T12:28:19.08Z" }, + { url = "https://files.pythonhosted.org/packages/92/02/34d079d4952ad461bde037d353f9a6e037a7edc45fe0f9ee8781ff73f028/coverage-7.16.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:066429634299e14dd2d511e1e85f8f9cecc500781f6b41907c0dd6f1baea7e63", size = 258034, upload-time = "2026-09-27T12:28:21.242Z" }, + { url = "https://files.pythonhosted.org/packages/f6/d8/3e59a62879285b464ec1b10fd824fbc1af9ce66e842cd39974f80a0becc4/coverage-7.16.2-cp315-cp315-win32.whl", hash = "sha256:893ea9cf86cb8d2546812ac93d973aaf2ee1fb45110a873b014214fd23e3725e", size = 226252, upload-time = "2026-09-27T12:28:23.102Z" }, + { url = "https://files.pythonhosted.org/packages/f4/e1/128026e1b2836e9ad6b219207ba9edf1c5e0088a7869e23088aee7fbbe7a/coverage-7.16.2-cp315-cp315-win_amd64.whl", hash = "sha256:01c6908bc613b420c26c818fe948e1b97dfd041a53c98b01c63bd8321f5c9aae", size = 226728, upload-time = "2026-09-27T12:28:25.21Z" }, + { url = "https://files.pythonhosted.org/packages/a8/f4/c9fa8e7cf525ca7748ac52b0ee89331d13fe09808e45c679830708782e90/coverage-7.16.2-cp315-cp315-win_arm64.whl", hash = "sha256:967d72c835d7a8cf0af99ec813a2d06e3db6df706402f1fe85b31b437645f495", size = 226648, upload-time = "2026-09-27T12:28:27.136Z" }, + { url = "https://files.pythonhosted.org/packages/a2/13/e96b045447a856666f36f9c653e2a80bdaa732aaaf72412b19aa2c26a473/coverage-7.16.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:98d9c97f51b334b0adce7b964442a9af33c1a00c6ac856984cc5dc8d18f81c75", size = 224858, upload-time = "2026-09-27T12:28:29.169Z" }, + { url = "https://files.pythonhosted.org/packages/23/90/087f6ad1bd3df059632ca3407a4e6552ed1053ee35354de0a771acf35423/coverage-7.16.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:3e861f1071dcc2fec1e88bef0920f6b1eaa66a143555b4f8ab79ba2b0f30ef55", size = 225139, upload-time = "2026-09-27T12:28:31.131Z" }, + { url = "https://files.pythonhosted.org/packages/7e/8e/285dcef0184358044e7cbcd810a1bdc9566bc620f54702d605477155df4a/coverage-7.16.2-cp315-cp315t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:fb9d92ecfe2d5b494367c67f7446f8b75b68d8d0c8cf3bc3e6997478be25d9e2", size = 265090, upload-time = "2026-09-27T12:28:33.04Z" }, + { url = "https://files.pythonhosted.org/packages/06/b2/cc83f3a6e5789a4e89059c69555bc641c2efcde568405a1c06fc702951ab/coverage-7.16.2-cp315-cp315t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:eb57acff4a74246ae513c142d4b36e18c389c3aed8661914a53f7cd0071031b2", size = 268254, upload-time = "2026-09-27T12:28:35.135Z" }, + { url = "https://files.pythonhosted.org/packages/ac/41/f548c19530f5d66ac6e3c92bbcbc49da7261de3a458b9f3e54a3efb1a0b2/coverage-7.16.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:444889f7f66b74e4455c0a97e0e166dd41177f1dca8c0239a47cff25e05ba7e1", size = 270695, upload-time = "2026-09-27T12:28:36.959Z" }, + { url = "https://files.pythonhosted.org/packages/94/61/4dc27cf82ef96434d2874110ad0cc10ea4621025705dc5049862bd3bd181/coverage-7.16.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a740ea6f083c6db7b926534d159508f80ba275ab35e722522de0d18d0f56e55f", size = 271853, upload-time = "2026-09-27T12:28:38.821Z" }, + { url = "https://files.pythonhosted.org/packages/38/29/bf8072b1b8bd5f2de8b21460a404460b1a2b97e80a9464c78ec0271f6199/coverage-7.16.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:8e209591f7c41ae4a9171335cf6156afda0b21de73b02f73f5aa95b2d5fbb08d", size = 265644, upload-time = "2026-09-27T12:28:40.815Z" }, + { url = "https://files.pythonhosted.org/packages/7c/2f/0aecb8721be5cdeb8afd9d6d9f6b463f074e4d8d37f00f4c42442522709f/coverage-7.16.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:396bb16e04ce04efbb3df91456ae4e3da918e69ecdf67fb711b0a0fdf35ccce0", size = 268530, upload-time = "2026-09-27T12:28:42.725Z" }, + { url = "https://files.pythonhosted.org/packages/ab/0b/92b4b7628268ee711249958e68fc0328779bd3d9a7ab4715379465aedb84/coverage-7.16.2-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:9cdf19874e0d247f32f03609200370343c3c7aa260b191d8c2bb251d36198283", size = 265154, upload-time = "2026-09-27T12:28:44.684Z" }, + { url = "https://files.pythonhosted.org/packages/7b/d9/41c95c1ab29b3dcd357cd1227181d1c98185632aca41ce670ce671b23a43/coverage-7.16.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:fd3d72233eb8b48acc94fa57d44e2d32ce8e7abed02882ccb6d855ccc4ed33ec", size = 269799, upload-time = "2026-09-27T12:28:46.672Z" }, + { url = "https://files.pythonhosted.org/packages/80/07/ebeb259aa5362b033a137b86d7274ff4b109d59be8cc9913889b783bf75a/coverage-7.16.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:bb4ffe96aa663cee727659db5a2afeb38c95f8677b747d447b90d6d4874ea2c5", size = 265196, upload-time = "2026-09-27T12:28:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/b2/18/8437620f90d023680a072eee02f968055f3658bbfb7d386d0ea34cfb7f30/coverage-7.16.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:dba2edfb054f6d4a08df9d1637c39a5aa3865bca6617c13c86be21e45658a59c", size = 267266, upload-time = "2026-09-27T12:28:51.361Z" }, + { url = "https://files.pythonhosted.org/packages/28/6c/f08e8ee4293e6434035424180bef4d45e028e8ecc006c61bf9453e74405e/coverage-7.16.2-cp315-cp315t-win32.whl", hash = "sha256:251aed777c47c77aba047096d4542889db089227655711dfc2b9c54ef0e15e35", size = 226583, upload-time = "2026-09-27T12:28:53.33Z" }, + { url = "https://files.pythonhosted.org/packages/f7/fd/3f939c2847f4a72c20cff8b1ac33da78ea91a2d38d9b43336e60db719103/coverage-7.16.2-cp315-cp315t-win_amd64.whl", hash = "sha256:2aca0bdfa9e91621d5b09d815357bf63def4fc0e9cb66da67bf2cf93f3b1a6f5", size = 227374, upload-time = "2026-09-27T12:28:55.158Z" }, + { url = "https://files.pythonhosted.org/packages/5a/35/b98cdc354c952402132e675a87f2cc3227fb68f959c84aaa491fbe15933d/coverage-7.16.2-cp315-cp315t-win_arm64.whl", hash = "sha256:b88841e654f09732804809e435b3e005a929ffd9998b872b7b213957b8759cb8", size = 227064, upload-time = "2026-09-27T12:28:57.075Z" }, + { url = "https://files.pythonhosted.org/packages/3f/0c/7a64e1ac90541a8edf50daef0914848011fb057a5bf55284a4811e21939a/coverage-7.16.2-py3-none-any.whl", hash = "sha256:11d28e9123a9156cb405d8d27b44256c9a58fb5decc2073a8f17862057e3aa0f", size = 215754, upload-time = "2026-09-27T12:28:59.075Z" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "packaging" +version = "26.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/65/ee/299d360cdc32edc7d2cf530f3accf79c4fca01e96ffc950d8a52213bd8e4/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4", size = 143416, upload-time = "2026-01-21T20:50:39.064Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/b9/c538f279a4e237a006a2c98387d081e9eb060d203d8ed34467cc0f0b9b53/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529", size = 74366, upload-time = "2026-01-21T20:50:37.788Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "pyblnet" +version = "0.13.1" +source = { editable = "." } +dependencies = [ + { name = "requests" }, +] + +[package.dev-dependencies] +dev = [ + { name = "coverage" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [{ name = "requests" }] + +[package.metadata.requires-dev] +dev = [ + { name = "coverage" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.2" +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/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c9/74/b3ff8e6c8446842c3f5c837e9c3dfcfe2018ea6ecef224c710c85ef728f4/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf", size = 134517, upload-time = "2025-08-18T20:46:02.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/db/4254e3eabe8020b458f1a747140d32277ec7a271daf1d235b70dc0b4e6e3/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6", size = 64738, upload-time = "2025-08-18T20:46:00.542Z" }, +] + +[[package]] +name = "ruff" +version = "0.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e9/a7/70debb024dfacda67b8e560cc7511f52b34b9348a8cc8c1ec23036dcd51d/ruff-0.17.0.tar.gz", hash = "sha256:5cd03240d8208a557c2a9655a5cb07ebe36aa6bb35065f97d48c1f6adef5a322", size = 5320554, upload-time = "2026-10-09T19:47:29.248Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bc/f8/ee5ab9da6089eae2a33e6008b01deb1eda19992c1c8e10661e98cee1640f/ruff-0.17.0-py3-none-linux_armv6l.whl", hash = "sha256:0e271826af9a20d18c6cfae8c51e82959167c24859686ddd3eb9a7f0842ce81e", size = 10148907, upload-time = "2026-10-09T19:46:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/9f/d9/2f81fb5a9d580afbb11b1c8ff915233a11f2a1b27405d7991f183c5e1976/ruff-0.17.0-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:5f0ca4a40f81403689c04f12966e22f44e329ae362072d8f1587b7bda87f603b", size = 10224208, upload-time = "2026-10-09T19:46:41.711Z" }, + { url = "https://files.pythonhosted.org/packages/a7/20/643f3c8f75594f937b2bf74801241c56a2e2b8e139d24dff8b66b28cdd7f/ruff-0.17.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:cbf7149e0927dc3295d5d64679a4765576eef71b00782b2ae969ef82274d6bb9", size = 9273324, upload-time = "2026-10-09T19:46:44.323Z" }, + { url = "https://files.pythonhosted.org/packages/ec/91/627700b233d367736cb274f1bd0b47d1f2b12f68878192812bd875adadc3/ruff-0.17.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:13ee90156522998c3037059d8f66885c8adeeaf7643bdce2caceee196ecd23e0", size = 9953190, upload-time = "2026-10-09T19:46:47.155Z" }, + { url = "https://files.pythonhosted.org/packages/cd/92/91f7b5ed39490f89d6cbf56e1f543c383667a725efa8e2c2dee0f01f5591/ruff-0.17.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3d8e4a002a94cd9d0dc48b51dc69d807a172b5b9bf2b668e656424dc5b55ead1", size = 9961746, upload-time = "2026-10-09T19:46:50.098Z" }, + { url = "https://files.pythonhosted.org/packages/87/c5/7310f9fc63ce11ff6394edbd5e85433dfb0e14c9fbf6ccc97f1538491bc7/ruff-0.17.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c0b8a60c06a218c337e1161638d34757f83449243e2db161483ddf948e53ad14", size = 10625483, upload-time = "2026-10-09T19:46:53.379Z" }, + { url = "https://files.pythonhosted.org/packages/a5/8d/97443f0dca4a03a0bc7629fd396fd494a1cb6666121e38c5075acb217d8f/ruff-0.17.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a330178bdffc4205dbf3bda11d93e059e388fd6546f8cdd304501a9160363c0d", size = 11350129, upload-time = "2026-10-09T19:46:56.486Z" }, + { url = "https://files.pythonhosted.org/packages/9c/0a/c525efd9777be4b6b012e6969a3012648468e7e6c4b3e5b46af69f46e8eb/ruff-0.17.0-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7bb08489e234876fa2da67ae3ea938e9a2156da80293e0e4365abd6973d98329", size = 10906223, upload-time = "2026-10-09T19:47:00.263Z" }, + { url = "https://files.pythonhosted.org/packages/2c/3c/4a01195d93420cad1175bedad13a515dc8a56f95a6e39789b92e582682f5/ruff-0.17.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc73e7c133e82d55b5f15897b2a442d72c0cb4a0c886c46801ce3c247150b60c", size = 10386314, upload-time = "2026-10-09T19:47:03.057Z" }, + { url = "https://files.pythonhosted.org/packages/c7/72/1a3951665485a921f6375f91e754a1854d5a645d41acc3642668064ff64d/ruff-0.17.0-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:db4f74c533403ab70fe4007873f6ae0c9f94a8b03158cf48d78788e47cdbe399", size = 10565464, upload-time = "2026-10-09T19:47:05.831Z" }, + { url = "https://files.pythonhosted.org/packages/90/8c/539b4d8c082f57e18db8ae2be85a460d77861c79dcd5798e32b536a6a06f/ruff-0.17.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3d8cc360e666d1914e47b0777c6906d70cf18891a55532bd0a16844195d70859", size = 10079468, upload-time = "2026-10-09T19:47:08.617Z" }, + { url = "https://files.pythonhosted.org/packages/e0/b8/84286966db79434e8c26b585b0a0f6897cb3ab1c51a4aa4df10c28488b62/ruff-0.17.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d66de796b726c4801e05fa99a2a8d7a780e107be222486c304ab61765561e866", size = 9958556, upload-time = "2026-10-09T19:47:11.324Z" }, + { url = "https://files.pythonhosted.org/packages/69/50/27b6eed27b83fcdd5bfa0d52b83231e29094754374698da404d094487ae3/ruff-0.17.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:c3f268baf004aea944f040623327119527ea231af15f7fb7890e82cea0679589", size = 10352173, upload-time = "2026-10-09T19:47:14.188Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/955399fd13044cd827862044117d784a59e3196f6cce7424908ac9a7f914/ruff-0.17.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:864b6c1acb6b0bccf94b5a3938a1531fd09aaca5e5659a2e7bf0f3cf2a685540", size = 10791761, upload-time = "2026-10-09T19:47:16.931Z" }, + { url = "https://files.pythonhosted.org/packages/ae/bf/024e01e1f6aec87768696725e648ed5b438941341eea8f8100beb681961f/ruff-0.17.0-py3-none-win32.whl", hash = "sha256:5e50aa5b84decd9fe5b0bb0e6f71c3b592f1767ed09faa4b7207d933961e35cd", size = 9904112, upload-time = "2026-10-09T19:47:19.75Z" }, + { url = "https://files.pythonhosted.org/packages/cc/77/1ee73df41dcc8d1cdb686ee4bc46ea29704ea175feb6b95c78420f631ab8/ruff-0.17.0-py3-none-win_amd64.whl", hash = "sha256:8ab76bcda86dfd28e13776cb5de3c7bcdcf1ae3d37ed761113d1a5a415dc134c", size = 10115585, upload-time = "2026-10-09T19:47:22.698Z" }, + { url = "https://files.pythonhosted.org/packages/fd/71/eb4f0ccc844aece56963e8578df9c95d4c00f580547d52329d4035d3af18/ruff-0.17.0-py3-none-win_arm64.whl", hash = "sha256:c154c73ff43f9854395e24cac507af13078962e53d2b511605058d22af1fdb88", size = 9872035, upload-time = "2026-10-09T19:47:26.306Z" }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" }, +]