diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index bbbc4c8..9d96a64 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,79 +1,161 @@ -name: Build and upload to PyPI +name: Build and Test on: + push: + branches: [main, develop] + pull_request: + branches: [main] release: types: [published] + workflow_dispatch: + +# Least privilege: nothing here needs to write to the repo. The upload_pypi +# job re-declares its own permissions (id-token) for trusted publishing. +permissions: + contents: read + +# Cancel superseded runs of the same branch/PR (a stuck queued job would +# otherwise hold a stale run open for hours). +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true jobs: - build_wheels: - name: Build whells on ${{ matrix.os }} + # -------------------------------------------------------------------------- + # Source build + FULL pytest (incl. the ASGI/uvicorn/TLS integration suite) + # on the three platforms (tech design section 12.4 gate). + # -------------------------------------------------------------------------- + test: + name: "Source build & pytest (${{ matrix.os }}, py${{ matrix.python-version }})" runs-on: ${{ matrix.os }} strategy: + fail-fast: false matrix: - os: [ubuntu-18.04, windows-2019, macos-10.15] - + os: [ubuntu-latest, macos-latest, windows-latest] + python-version: ["3.10", "3.14"] # oldest + newest supported steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 with: - submodules: true - - uses: actions/setup-python@v2 + submodules: recursive + persist-credentials: false + + - uses: actions/setup-python@v5 with: - python-version: "3.8" - - name: Install dependencies - run: | - pip install -U pip wheel - pip install cibuildwheel + python-version: ${{ matrix.python-version }} - - name: Build wheels + - name: Build and install (with test extras) run: | - cibuildwheel --output-dir wheelhouse + python -m pip install -U pip + python -m pip install -e ".[test]" -v + + - name: Run full test suite + run: python -m pytest tests/ -v + + # -------------------------------------------------------------------------- + # Wheels: cibuildwheel matrix (tech design section 11). + # CPython 3.10-3.14 x manylinux2014 x86_64/aarch64 + musllinux x86_64 + # + macOS arm64 & x86_64 + Windows AMD64. + # Version selection / images / test command live in pyproject.toml + # ([tool.cibuildwheel]); this matrix only picks runner+arch. Linux aarch64 + # uses the native arm64 runner (no QEMU), so wheel tests run everywhere. + # -------------------------------------------------------------------------- + build_wheels: + name: "Wheels: ${{ matrix.name }}" + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - name: linux-x86_64 # manylinux2014 + musllinux x86_64 + os: ubuntu-latest + archs: x86_64 + - name: linux-aarch64 # manylinux2014 aarch64 (native runner) + os: ubuntu-24.04-arm + archs: aarch64 + - name: macos-x86_64 + # Intel (macos-13) runners are retired — jobs queue forever. Build + # x86_64 wheels by cross-compiling on the arm64 runner instead; + # cibuildwheel runs their tests under Rosetta 2. + os: macos-latest + archs: x86_64 + - name: macos-arm64 + os: macos-latest + archs: arm64 + - name: windows-amd64 + os: windows-latest + archs: AMD64 + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + persist-credentials: false + + - uses: actions/setup-python@v5 + with: + python-version: "3.12" + + - name: Install cibuildwheel + run: python -m pip install "cibuildwheel>=3.2,<4" + + - name: Build and test wheels + run: python -m cibuildwheel --output-dir wheelhouse env: - CIBW_BUILD: cp3?-* - CIBW_SKIP: "*-win32 *-manylinux_i686 cp35-*" - CIBW_BEFORE_BUILD: "pip install -U cython cmake" + CIBW_ARCHS: ${{ matrix.archs }} - - name: Show files + - name: Show wheels run: ls -lh wheelhouse shell: bash - - uses: actions/upload-artifact@v2 + - uses: actions/upload-artifact@v4 with: - path: ./wheelhouse/*.whl + name: wheels-${{ matrix.name }} + path: wheelhouse/*.whl + # -------------------------------------------------------------------------- + # sdist (built once, on Linux) + import smoke from the sdist itself. + # -------------------------------------------------------------------------- build_sdist: - name: Build source distribution - runs-on: ubuntu-18.04 + name: Build sdist + runs-on: ubuntu-latest steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 with: - submodules: true + submodules: recursive + persist-credentials: false - - uses: actions/setup-python@v2 - name: Install Python + - uses: actions/setup-python@v5 with: - python-version: '3.8' + python-version: "3.12" - name: Build sdist - run: python setup.py sdist + run: pipx run build --sdist - - uses: actions/upload-artifact@v2 + - name: Smoke-test sdist (build + import) + run: | + python -m pip install dist/*.tar.gz -v + python -c "import hvloop; loop = hvloop.new_event_loop(); loop.close(); print('hvloop', hvloop.__version__, 'ok')" + + - uses: actions/upload-artifact@v4 with: + name: sdist path: dist/*.tar.gz + # -------------------------------------------------------------------------- + # PyPI upload on GitHub release (trusted publishing; configure the project + # as a trusted publisher on PyPI before the first release). + # -------------------------------------------------------------------------- upload_pypi: - needs: [ build_wheels, build_sdist ] - runs-on: ubuntu-18.04 - # upload to PyPI on every tag starting with 'v' -# if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v') - # alternatively, to publish when a GitHub Release is created, use the following rule: - # if: github.event_name == 'release' && github.event.action == 'published' + name: Upload to PyPI + needs: [test, build_wheels, build_sdist] + runs-on: ubuntu-latest + if: github.event_name == 'release' && github.event.action == 'published' + environment: pypi + permissions: + id-token: write steps: - - uses: actions/download-artifact@v2 + - uses: actions/download-artifact@v4 with: - name: artifact path: dist + merge-multiple: true - - uses: pypa/gh-action-pypi-publish@master - with: - user: __token__ - password: ${{ secrets.pypi_password }} + - uses: pypa/gh-action-pypi-publish@release/v1 diff --git a/.gitignore b/.gitignore index 21200c8..d26ab25 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,8 @@ # Created by .ignore support plugin (hsz.mobi) ### Python template +# macOS +.DS_Store + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..a33f876 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,160 @@ +# CLAUDE.md + +Guidance for working in the hvloop repository. + +## What this is + +hvloop is a drop-in asyncio event loop (like uvloop) implemented as a **Cython +extension** on top of the vendored C library **libhv** (`vendor/libhv`, a git +submodule). Target use case: web servers — it runs FastAPI/ASGI under uvicorn, +including WebSocket and TLS. Cross-platform: Linux (epoll), macOS (kqueue), +Windows (wepoll). + +The authoritative design is `docs/plans/2026-06-13-hvloop-tech-design.md`. Read +it before making non-trivial changes — it explains *why* the loop is driven the +way it is. + +## Layout + +- `src/hvloop/_core.pyx` — **everything native lives here in one compilation + unit** (the loop, `TCPTransport`, `Server`, `_TCPListener`, `_FDWatcher`, + TLS wiring, `sock_*`, signals, and all libhv C callbacks). ~3000 lines. +- `src/hvloop/includes/hv.pxd` — libhv C API declarations (subset we use). + Truth source for the C API is `vendor/libhv/event/hloop.h`. +- `src/hvloop/hvloop_shim.h` — small `static inline` C helpers for things the + public libhv API doesn't expose (reaching private struct fields, etc.). +- `src/hvloop/__init__.py` — Python-level public API: `Loop`, + `EventLoopPolicy`, `install()`/`uninstall()`, `new_event_loop()`, `run()`. +- `tests/` — pytest suite (synchronous test functions that build their own + loop; `tests/certs/` holds committed self-signed certs for TLS tests). +- `benchmarks/`, `examples/fastapi_app.py` — runnable perf scripts and a demo. +- `CMakeLists.txt` + `pyproject.toml` — scikit-build-core + cython-cmake build; + libhv is compiled as a static lib with only its core event engine enabled. + +## Build & test + +```shell +# Editable install (rebuilds the extension). Run after any .pyx/.pxd/.h change. +uv pip install -e . + +# Full suite (expect 149 passing). +.venv/bin/python -m pytest tests/ -q + +# Faster inner loop without reinstalling: build + install the target directly. +cmake -S . -B build -DCMAKE_BUILD_TYPE=Debug -DSKBUILD_PROJECT_NAME=hvloop \ + -DSKBUILD_PROJECT_VERSION=0.2.0 -DPython_EXECUTABLE=$PWD/.venv/bin/python +cmake --build build --target _core -j +cmake --install build --component python_modules --prefix src +PYTHONPATH=src .venv/bin/python -m pytest + +# Wheel/sdist. +uv build +``` + +Environment here: macOS arm64, venv at `.venv` (Python 3.14). Editing a `.pyx` +and re-running pytest **without rebuilding tests stale code** — always rebuild +first. + +## Core invariants — do not break these + +These were hard-won during development; violating them causes crashes, leaks, +or busy-spins that tests may not immediately catch. + +1. **The loop is self-driven; we do NOT call `hloop_run`.** `run_forever()` + loops manually: run a snapshot of the `_ready` deque, then + `hloop_process_events(timeout)` with `timeout=0` when ready is non-empty + else a large cap. libhv clamps the poll to the nearest timer internally. + +2. **libhv's loop status must be forced to RUNNING while we drive it.** + `hloop_process_events` returns early (skipping pending-event dispatch) when + status is `STOP`, which is the initial value since we never call + `hloop_run`. `run_forever()` calls `hvloop_set_status_running()` on entry and + `hvloop_set_status_stop()` on exit (in `hvloop_shim.h`). Without this the + wakeup fd never drains and the loop busy-spins at 100% CPU. + +3. **Create the wakeup eventfd before the first poll.** `run_forever()` calls + `hloop_wakeup()` once up front; otherwise libhv sleeps in an un-wakeable + `hv_msleep` when there are no ios and `call_soon_threadsafe` can't interrupt. + +4. **`hloop_new(0)`** — pass 0 explicitly so `HLOOP_FLAG_AUTO_FREE` is off, + else libhv double-frees against our `hloop_free()` in `close()`. + +5. **Every libhv C callback is `noexcept nogil` + `with gil` + full try/except.** + No Python exception may propagate back into C. KeyboardInterrupt/SystemExit + raised inside a callback are stashed on `loop._pending_exc` and re-raised by + `run_forever` after the poll returns (they can't cross the `noexcept` frame). + +6. **Reference discipline for anything registered with libhv.** Objects handed + to libhv (timers, transports, listeners, fd watchers) do `Py_INCREF` at + registration and are tracked in a loop-level set (`_timer_handles`, + `_hio_objs`, `_fd_watchers`). There is exactly **one** release path per + object — the close/cancel dispatch and `loop.close()` teardown are mutually + exclusive and each nulls the C pointer before `Py_DECREF`. `loop.close()` + must tear all of these down *before* `hloop_free`. Getting this wrong = UAF + or leak (both happened and were fixed; regression tests guard them). + +7. **libhv's read buffer is loop-level shared memory.** In a read callback, + copy the bytes immediately (`PyBytes_FromStringAndSize`) before handing to + the protocol — the buffer is reused as soon as the callback returns. + +8. **fd ownership.** fds we create (`create_connection`, host/port + `create_server`) are handed to libhv via `sock.detach()` and libhv closes + them. Caller-owned fds (`create_server(sock=)`, `add_reader/writer`, signal + socketpair read end) are never closed by us — teardown uses + `hvloop_hio_release_external` (resets io type so `hio_close` skips the fd). + +## Gotchas / decisions worth knowing + +- **uvicorn ≥ 0.36 ignores the asyncio policy.** `loop="asyncio"` maps straight + to `SelectorEventLoop`; `hvloop.install()` has no effect there. Wire uvicorn + with `loop="hvloop:new_event_loop"` (recommended) or `loop="none"` + + `hvloop.install()`. See the README for all three wirings. +- **TLS reuses stdlib `asyncio.sslproto.SSLProtocol`** (MemoryBIO), *not* + libhv's OpenSSL. This keeps any `ssl.SSLContext` working and avoids an + OpenSSL link/distribution dependency. libhv is built with `WITH_OPENSSL=OFF`. + Code is version-gated (`_PY311`) for the 3.10 vs 3.11+ sslproto differences. +- **`add_reader`/`add_writer` replace libhv's io callback.** We `hio_add` our + own raw callback (libhv then won't read/write the fd itself) and translate + `hio_revents` into the reader/writer handles, clearing revents afterward + (mirrors `nio.c`'s `hio_handle_events`). A watched fd must not also be a + transport, and high-level `hio_read`/`hio_write` must not be used on it. +- **No half-close.** libhv closes on EOF, so `eof_received()` returning True + can't keep the transport open; `connection_lost` always follows. Fine for + HTTP/WebSocket. Documented deviation from asyncio. +- **Signals (Unix only):** `set_wakeup_fd` + a socketpair registered as an + internal reader. Windows raises `NotImplementedError` (uvicorn falls back to + `signal.signal`, same as asyncio's Proactor loop). + +## Known Windows limitations + +CI runs the full matrix (Linux/macOS/Windows × py3.10/3.14). Windows-specific +notes: + +- **Signals are Unix-only** — `add_signal_handler`/`remove_signal_handler` raise + `NotImplementedError`; those tests are skipped on Windows (uvicorn falls back + to `signal.signal`, same as asyncio's Proactor loop). +- **Write-buffer backpressure is unverified on Windows.** Two flow-control + tests (`test_write_flow_control`, `test_close_flushes_pending_writes`) assert + that a large `write()` to a paused/slow peer leaves data in libhv's write + queue (`get_write_buffer_size() > 0`). On Windows loopback the payload is + absorbed by the larger default socket buffers (and/or libhv's Windows + write-queue accounting differs), so the buffer reads 0 and `pause_writing` + doesn't fire in the test. These are marked `xfail(strict=False)` on Windows. + **Open question for a Windows maintainer:** does watermark flow control + actually engage under real backpressure on Windows, or is this a genuine gap? + Needs verification on real hardware (shrinking SO_SNDBUF/SO_RCVBUF in the test + is the likely fix if it's just buffer sizing). +- `os.fstat()` does **not** work on Windows socket handles (they aren't CRT + fds) — use `sock.getsockname()` for "is this socket still open" checks in + tests. + +## Conventions + +- `vendor/libhv/` is **read-only** — never modify it. It's a submodule pinned + to a specific commit. Reach private internals via `hvloop_shim.h`. +- Don't edit `docs/plans/` design docs unless changing the design deliberately. +- Match the existing code style in `_core.pyx` (dense comments explaining *why* + at every non-obvious libhv interaction; module-level aliases for hot-path + attribute lookups). +- New native features generally include their own pytest coverage; the test + suite is the acceptance bar. diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..07b9324 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,102 @@ +cmake_minimum_required(VERSION 3.25) +project(${SKBUILD_PROJECT_NAME} LANGUAGES C) + +# Find Python and Cython-cmake +find_package(Python COMPONENTS Interpreter Development.Module REQUIRED) + +# When invoked directly (not through scikit-build-core), the cython-cmake CMake +# helpers (UseCython / FindCython) are not on the module path. Locate them via +# the configured Python interpreter so the documented standalone +# `cmake -S . -B build ...` workflow works out of the box. +if(NOT cython-cmake_FOUND) + execute_process( + COMMAND "${Python_EXECUTABLE}" -c + "import cython_cmake, os; print(os.path.join(os.path.dirname(cython_cmake.__file__), 'cmake'))" + OUTPUT_VARIABLE _cython_cmake_dir + OUTPUT_STRIP_TRAILING_WHITESPACE + RESULT_VARIABLE _cython_cmake_rc + ) + if(_cython_cmake_rc EQUAL 0 AND EXISTS "${_cython_cmake_dir}") + # Normalize to forward slashes. On Windows the interpreter prints a path + # with backslashes; once it lands in CMAKE_MODULE_PATH it gets forwarded + # into the compiler-ABI try_compile scratch project (re-triggered by + # libhv's own project() in add_subdirectory below) as a set() argument, + # where the backslashes are invalid escapes -> "Syntax error in cmake + # code ... (set)". file(TO_CMAKE_PATH) fixes that. + file(TO_CMAKE_PATH "${_cython_cmake_dir}" _cython_cmake_dir) + list(PREPEND CMAKE_MODULE_PATH "${_cython_cmake_dir}") + endif() +endif() + +# libhv is built as a static library and linked into the _core Python extension +# (a shared object). On Linux (GNU ld) a static lib linked into a .so must be +# position-independent, else: "ld: final link failed: bad value". macOS/clang +# doesn't require this, which is why it only surfaced on Linux CI. Set globally +# BEFORE add_subdirectory so the hv_static target inherits it. +set(CMAKE_POSITION_INDEPENDENT_CODE ON) + +# ============================================================================ +# libhv Configuration +# ============================================================================ +# Configure libhv build options (must be set before add_subdirectory) +set(BUILD_SHARED OFF CACHE BOOL "build shared library" FORCE) +set(BUILD_STATIC ON CACHE BOOL "build static library" FORCE) +set(BUILD_EXAMPLES OFF CACHE BOOL "build examples" FORCE) +set(BUILD_UNITTEST OFF CACHE BOOL "build unittest" FORCE) + +# libhv feature flags - only enable what we need +set(WITH_EVPP OFF CACHE BOOL "compile evpp" FORCE) +set(WITH_HTTP OFF CACHE BOOL "compile http" FORCE) +set(WITH_HTTP_SERVER OFF CACHE BOOL "compile http/server" FORCE) +set(WITH_HTTP_CLIENT OFF CACHE BOOL "compile http/client" FORCE) +set(WITH_OPENSSL OFF CACHE BOOL "with openssl library" FORCE) +set(WITH_MQTT OFF CACHE BOOL "compile mqtt" FORCE) +set(WITH_PROTOCOL OFF CACHE BOOL "compile protocol" FORCE) +# Windows: the wepoll reactor backend is what makes add_reader/add_writer +# (and thus sock_*) work on Windows. libhv defaults it to ON; FORCE it so a +# cache/default drift can never silently disable it (tech design section 11). +if(WIN32) + set(WITH_WEPOLL ON CACHE BOOL "compile event/wepoll -> use iocp" FORCE) +endif() + +# Add libhv subdirectory. EXCLUDE_FROM_ALL keeps libhv's own install() rules +# (headers under include/hv, libhv.a, cmake config) OUT of the wheel; the +# hv_static target is still built as a link dependency of _core. +add_subdirectory(vendor/libhv EXCLUDE_FROM_ALL) + +# ============================================================================ +# Build Cython Module +# ============================================================================ +include(UseCython) + +# Transpile the thin Cython/libhv binding to C. +cython_transpile(src/hvloop/_core.pyx LANGUAGE C OUTPUT_VARIABLE core_c_source) + +# WITH_SOABI adds ABI tag (e.g., module.cpython-311-darwin.so). +python_add_library(_core MODULE "${core_c_source}" WITH_SOABI) + +target_link_libraries(_core PRIVATE hv_static) + +target_include_directories(_core PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/src/hvloop + ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libhv/include + ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libhv/include/hv + ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libhv/base + ${CMAKE_CURRENT_SOURCE_DIR}/vendor/libhv/event + ${CMAKE_CURRENT_BINARY_DIR}/vendor/libhv/include + ${CMAKE_CURRENT_BINARY_DIR}/vendor/libhv/include/hv +) + +target_compile_definitions(_core PRIVATE HV_STATICLIB) + +# ============================================================================ +# Installation +# ============================================================================ +# Install Python extension modules +# scikit-build-core automatically handles the correct installation paths +install( + TARGETS _core + COMPONENT python_modules + LIBRARY DESTINATION hvloop + RUNTIME DESTINATION hvloop +) diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index 0f631fa..0000000 --- a/MANIFEST.in +++ /dev/null @@ -1,4 +0,0 @@ -recursive-include hvloop *.pyx *.pxd *.pxi *.py *.c *.h -recursive-include vendor/libhv * -recursive-include tests *.py -include README.md diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..5505056 --- /dev/null +++ b/Makefile @@ -0,0 +1,110 @@ +.PHONY: help install dev-install test test-cov lint format clean build \ + configure build-ext install-ext dev-ext watch ci + +# Default target +help: + @echo "Available targets:" + @echo " install Install hvloop" + @echo " dev-install Install with development dependencies" + @echo " test Run tests" + @echo " test-cov Run tests with coverage" + @echo " lint Run linting" + @echo " format Format code" + @echo " clean Clean build artifacts" + @echo " build Build package" + @echo " configure Configure CMake build (for incremental dev builds)" + @echo " build-ext Build Cython extension via CMake (target: _core)" + @echo " install-ext Install built extension into src/ for import" + @echo " dev-ext Configure+Build+Install extension for local dev" + @echo " watch Auto-rebuild on .pyx/.pxd/.pxi changes (needs entr)" + +# Incremental CMake build settings (developer friendly) +CMAKE ?= cmake +BUILD_DIR ?= build +# Debug for faster builds; change to Release for perf validation +BUILD_TYPE ?= Debug + +# Required by CMakeLists.txt which expects scikit-build variables +SKBUILD_PROJECT_NAME ?= hvloop +SKBUILD_PROJECT_VERSION ?= 0.2.0 + +# Install prefix so that LIBRARY DESTINATION hvloop installs to src/hvloop/ +DEV_PREFIX ?= $(PWD)/src + +# Install hvloop +install: + uv pip install -e . + +# Install with development dependencies +dev-install: + uv pip install -e .[dev] + pre-commit install + +# Run tests +test: + uv run pytest tests/ -v + +# Run tests with coverage +test-cov: + uv run pytest tests/ --cov=hvloop --cov-report=html --cov-report=term + +# Run linting +lint: + uv run ruff check . + uv run mypy src/hvloop + +# Format code +format: + uv run black . + uv run ruff check --fix . + +# Clean build artifacts +clean: + rm -rf build/ + rm -rf dist/ + rm -rf *.egg-info/ + rm -rf .pytest_cache/ + rm -rf htmlcov/ + find . -type d -name __pycache__ -exec rm -rf {} + + find . -type f -name "*.pyc" -delete + +# Build package +build: clean + python -m build + +# Configure CMake (run once, or when CMake cache is missing) +configure: + $(CMAKE) -S . -B $(BUILD_DIR) \ + -DCMAKE_BUILD_TYPE=$(BUILD_TYPE) \ + -DSKBUILD_PROJECT_NAME=$(SKBUILD_PROJECT_NAME) \ + -DSKBUILD_PROJECT_VERSION=$(SKBUILD_PROJECT_VERSION) + +# Build only the Cython extension target (_core) +build-ext: + @if [ ! -f "$(BUILD_DIR)/CMakeCache.txt" ]; then \ + $(MAKE) configure; \ + fi + $(CMAKE) --build $(BUILD_DIR) --config $(BUILD_TYPE) --target _core -j + +# Install the built extension into src/hvloop/ for immediate import +install-ext: + $(CMAKE) --install $(BUILD_DIR) --config $(BUILD_TYPE) \ + --component python_modules --prefix $(DEV_PREFIX) + +# One-shot developer command: configure + build + install +dev-ext: + @if [ ! -f "$(BUILD_DIR)/CMakeCache.txt" ]; then \ + $(MAKE) configure; \ + fi + $(MAKE) build-ext + $(MAKE) install-ext + +# Auto-rebuild on Cython include changes (requires: brew install entr) +watch: + @command -v entr >/dev/null 2>&1 || { echo "entr not found. Install via 'brew install entr'"; exit 1; } + find src/hvloop -type f \( -name "*.pyx" -o -name "*.pxd" -o -name "*.pxi" \) | \ + dirname -z - | sort -zu | xargs -0 -I {} find {} -type f \( -name "*.pyx" -o -name "*.pxd" -o -name "*.pxi" \) | \ + entr -c sh -c '$(MAKE) dev-ext' + +# Build and test in CI +ci: dev-install test lint \ No newline at end of file diff --git a/README.md b/README.md index 32c9853..a52e3a8 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,192 @@ # hvloop [![PyPI](https://img.shields.io/pypi/v/hvloop.svg)](https://pypi.python.org/pypi/hvloop) -hvloop is a asyncio event loop like [uvloop](https://github.com/MagicStack/uvloop), based on [libhv](https://github.com/ithewei/libhv). +hvloop is a drop-in asyncio event loop — like [uvloop](https://github.com/MagicStack/uvloop), +but built on [libhv](https://github.com/ithewei/libhv) instead of libuv. It is a +Cython extension that drives libhv's cross-platform event engine (epoll on Linux, +kqueue on macOS, wepoll/IOCP on Windows) and exposes the asyncio loop API, aimed +at web-server workloads: it runs FastAPI/ASGI apps under uvicorn, including +WebSocket and TLS. -Note: hvloop stil in dev, DON"T use for production +> **Status:** alpha. The full test suite passes on macOS/Linux and hvloop runs +> real uvicorn + FastAPI workloads, but it has not been battle-tested in +> production yet. Windows is covered by CI but less exercised. UDP, subprocess +> and pipe transports are not implemented. ## Installation -hvloop requires python3.6 or greater +hvloop requires Python 3.10 or greater. ```shell $ pip install hvloop ``` ## Quickstart -```shell + +Install hvloop as the global asyncio event loop policy, then use asyncio as usual: + +```python +import asyncio import hvloop + hvloop.install() +async def main(): + await asyncio.sleep(1) + print("hello from hvloop") + +asyncio.run(main()) +``` + +Or run a coroutine directly on a fresh hvloop loop (no global policy change): + +```python +import asyncio +import hvloop + +async def main(): + await asyncio.sleep(1) + +hvloop.run(main()) # like asyncio.run(), but on hvloop + +# equivalently, on Python 3.11+: +with asyncio.Runner(loop_factory=hvloop.new_event_loop) as runner: + runner.run(main()) +``` + +## Running uvicorn + FastAPI on hvloop + +hvloop implements the asyncio TCP transport / server / signal APIs that uvicorn +needs, so a FastAPI app (HTTP **and** WebSocket) runs on it unchanged. There are +three supported ways to wire it up. + +> **Heads-up (uvicorn >= 0.36):** uvicorn no longer consults the asyncio +> event-loop *policy* — `Config.get_loop_factory()` maps `loop="asyncio"` +> straight to `asyncio.SelectorEventLoop`. The classic +> `hvloop.install()` + `uvicorn.run(app, loop="asyncio")` recipe therefore +> **silently runs on stock asyncio, not hvloop**. Use one of the wirings below. + +### 1. Recommended: `loop="hvloop:new_event_loop"` + +uvicorn accepts any `"module:callable"` string as a loop *factory*. +`hvloop.new_event_loop` is exactly that — no glue code needed: + +```python +import uvicorn +from fastapi import FastAPI + +app = FastAPI() + +@app.get("/") +async def root(): + return {"hello": "hvloop"} + +if __name__ == "__main__": + uvicorn.run(app, host="127.0.0.1", port=8000, loop="hvloop:new_event_loop") ``` +Same thing from the uvicorn CLI: + +```shell +$ uvicorn examples.fastapi_app:app --loop hvloop:new_event_loop +``` + +### 2. Policy-based: `hvloop.install()` + `loop="none"` + +`loop="none"` makes uvicorn use no explicit loop factory, so its runner falls +back to `asyncio.new_event_loop()` — which *does* consult the event-loop +policy that `hvloop.install()` sets: + +```python +import hvloop +import uvicorn + +hvloop.install() # asyncio.new_event_loop() now returns hvloop loops +uvicorn.run(app, host="127.0.0.1", port=8000, loop="none") +``` + +Note: the asyncio policy system is deprecated (Python 3.14 warns; removal is +slated for 3.16), so `hvloop.install()` emits a `DeprecationWarning` on 3.14. +Prefer wiring 1 for new code. + +### 3. Run `Server.serve()` on an hvloop loop you own + +Useful when you drive the loop yourself (e.g. a client and server on the same +loop, as the test suite does). `server.serve()` runs on whatever loop awaits +it — uvicorn's `loop=` setting is never used to create one in this mode: + +```python +import asyncio +import hvloop +import uvicorn +from fastapi import FastAPI + +app = FastAPI() + +@app.get("/") +async def root(): + return {"hello": "hvloop"} + +async def main(): + config = uvicorn.Config(app, host="127.0.0.1", port=8000) + server = uvicorn.Server(config) + await server.serve() # runs on the current (hvloop) loop + +hvloop.run(main()) +``` + +A complete runnable example (HTTP endpoints, a streaming response, lifespan +events and a WebSocket echo endpoint) lives in +[`examples/fastapi_app.py`](examples/fastapi_app.py): + +```shell +$ python examples/fastapi_app.py +``` + +## Implemented features + +hvloop currently implements: + +- the full loop lifecycle, scheduling (`call_soon`/`call_later`/`call_at`/ + `call_soon_threadsafe`), timers, executors and `getaddrinfo`/`getnameinfo`; +- TCP: `create_connection`, `create_server` (host/port and `sock=`), the + `asyncio.Transport` surface, and `Server` (`close`/`wait_closed`/ + `serve_forever`/`sockets`); +- TLS: `create_server(ssl=...)` and `create_connection(ssl=..., + server_hostname=...)` including `ssl_handshake_timeout` / + `ssl_shutdown_timeout` (3.11+), built on the stdlib + `asyncio.sslproto.SSLProtocol` (MemoryBIO), so any `ssl.SSLContext` + works unchanged — `uvicorn --ssl-certfile/--ssl-keyfile` included; +- `sock_recv` / `sock_recv_into` / `sock_sendall` / `sock_connect` / + `sock_accept`; +- `add_reader`/`add_writer`/`remove_reader`/`remove_writer`; +- Unix signal handling (`add_signal_handler`/`remove_signal_handler`). + +UDP (`create_datagram_endpoint`), subprocess and pipe APIs are not +implemented yet. + +## Benchmarks + +Numbers from a single machine — treat them as loop-vs-loop comparisons, +not absolute capacity. Environment: macOS 26.5 (arm64, Apple Silicon), +CPython 3.14.0, hvloop 0.2.0, uvloop 0.22.1, uvicorn 0.49 (h11); +server and load generator share the machine. Reproduce with the scripts +in [`benchmarks/`](benchmarks/). + +**TCP echo** — `benchmarks/bench_tcp_echo.py --rounds 500`: one loop runs +the echo server plus 100 client connections, each doing 500 sequential +10 KiB round trips (best of 3): + +| loop | roundtrips/s | MiB/s | vs asyncio | +|---------|-------------:|-------:|-----------:| +| asyncio | 129,812 | 2535.4 | 1.00x | +| hvloop | 126,985 | 2480.2 | 0.98x | +| uvloop | 169,331 | 3307.3 | 1.30x | + +**uvicorn hello-world RPS** — `benchmarks/bench_http.py`: raw-ASGI +hello-world served by `uvicorn.run(loop=...)` in a subprocess, loaded by a +self-contained keep-alive HTTP client (50 connections, 5 s window): + +| loop | RPS | vs asyncio | +|---------|-------:|-----------:| +| asyncio | 23,068 | 1.00x | +| hvloop | 24,785 | 1.07x | +| uvloop | 29,969 | 1.30x | diff --git a/benchmarks/bench_http.py b/benchmarks/bench_http.py new file mode 100644 index 0000000..e5ceb86 --- /dev/null +++ b/benchmarks/bench_http.py @@ -0,0 +1,175 @@ +#!/usr/bin/env python3 +"""uvicorn hello-world RPS: hvloop vs asyncio (vs uvloop when installed). + +Methodology (tech design section 12.4) +-------------------------------------- +For each loop implementation, a *subprocess* runs +``uvicorn.run(app, loop=)`` with a minimal raw-ASGI hello-world app +(no framework overhead), so each server owns a clean process and its own +loop built through uvicorn's real loop-factory path. The load generator is +self-contained (no wrk/oha dependency): it runs in the parent process on a +plain asyncio loop, opening N keep-alive connections that issue +pipelined-sequential ``GET /`` requests for D seconds; completed responses +are parsed (status line + content-length body) and counted. + +Client and server share the machine, so treat the numbers as *relative* +loop-vs-loop comparisons, not absolute capacity. + +Usage: + python benchmarks/bench_http.py [--concurrency 50] [--duration 5] +""" + +from __future__ import annotations + +import argparse +import asyncio +import platform +import socket +import subprocess +import sys +import time + +REQUEST = (b"GET / HTTP/1.1\r\n" + b"Host: 127.0.0.1\r\n" + b"Connection: keep-alive\r\n\r\n") + + +# --------------------------------------------------------------------------- +# server subprocess: `python bench_http.py --serve --loop --port

` +# --------------------------------------------------------------------------- +async def app(scope, receive, send): + if scope["type"] != "http": + return + await send({ + "type": "http.response.start", + "status": 200, + "headers": [(b"content-type", b"text/plain"), + (b"content-length", b"13")], + }) + await send({"type": "http.response.body", "body": b"Hello, world!"}) + + +def serve(loop_spec: str, port: int): + import uvicorn + uvicorn.run( + "bench_http:app", + host="127.0.0.1", + port=port, + loop=loop_spec, # "asyncio" | "uvloop" | "hvloop:new_event_loop" + http="h11", # same HTTP impl for every loop under test + lifespan="off", + log_level="error", + access_log=False, + ) + + +# --------------------------------------------------------------------------- +# load generator (parent process, stock asyncio loop) +# --------------------------------------------------------------------------- +async def _worker(port: int, stop_at: float, counter: list): + reader, writer = await asyncio.open_connection("127.0.0.1", port) + try: + while time.perf_counter() < stop_at: + writer.write(REQUEST) + await writer.drain() + # status + headers + headers = await reader.readuntil(b"\r\n\r\n") + if not headers.startswith(b"HTTP/1.1 200"): + raise RuntimeError(f"bad response: {headers[:40]!r}") + # fixed 13-byte hello-world body + await reader.readexactly(13) + counter[0] += 1 + finally: + writer.close() + try: + await writer.wait_closed() + except (ConnectionError, OSError): + pass + + +async def _load(port: int, concurrency: int, duration: float) -> int: + counter = [0] + stop_at = time.perf_counter() + duration + await asyncio.gather( + *(_worker(port, stop_at, counter) for _ in range(concurrency))) + return counter[0] + + +def _free_port() -> int: + with socket.socket() as s: + s.bind(("127.0.0.1", 0)) + return s.getsockname()[1] + + +def _wait_listening(port: int, proc, timeout=15.0): + deadline = time.monotonic() + timeout + while time.monotonic() < deadline: + if proc.poll() is not None: + raise RuntimeError(f"server exited early (rc={proc.returncode})") + try: + with socket.create_connection(("127.0.0.1", port), timeout=0.2): + return + except OSError: + time.sleep(0.05) + raise TimeoutError("server did not start listening") + + +def bench_target(name: str, loop_spec: str, args) -> dict: + port = _free_port() + proc = subprocess.Popen( + [sys.executable, __file__, "--serve", "--loop", loop_spec, + "--port", str(port)], + cwd=str(__import__("pathlib").Path(__file__).parent), + ) + try: + _wait_listening(port, proc) + # short warmup, then the measured window + asyncio.run(_load(port, args.concurrency, 0.5)) + n = asyncio.run(_load(port, args.concurrency, args.duration)) + finally: + proc.terminate() + try: + proc.wait(timeout=10) + except subprocess.TimeoutExpired: + proc.kill() + proc.wait() + return {"name": name, "rps": n / args.duration} + + +def main(): + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("--serve", action="store_true") + p.add_argument("--loop", default="asyncio") + p.add_argument("--port", type=int, default=8000) + p.add_argument("--concurrency", type=int, default=50) + p.add_argument("--duration", type=float, default=5.0) + args = p.parse_args() + + if args.serve: + serve(args.loop, args.port) + return + + targets = [("asyncio", "asyncio"), ("hvloop", "hvloop:new_event_loop")] + try: + import uvloop # noqa: F401 + targets.append(("uvloop", "uvloop")) + except ImportError: + print("uvloop not installed; skipping", file=sys.stderr) + + print(f"uvicorn hello-world (h11): {args.concurrency} keep-alive conns, " + f"{args.duration:.0f}s measured window") + print(f"python {sys.version.split()[0]} on {platform.platform()}\n") + + results = [bench_target(name, spec, args) for name, spec in targets] + base = next(r for r in results if r["name"] == "asyncio") + + hdr = f"{'loop':<10}{'RPS':>12}{'vs asyncio':>12}" + print(hdr) + print("-" * len(hdr)) + for r in results: + print(f"{r['name']:<10}{r['rps']:>12,.0f}" + f"{r['rps'] / base['rps']:>11.2f}x") + + +if __name__ == "__main__": + main() diff --git a/benchmarks/bench_tcp_echo.py b/benchmarks/bench_tcp_echo.py new file mode 100644 index 0000000..b13931f --- /dev/null +++ b/benchmarks/bench_tcp_echo.py @@ -0,0 +1,157 @@ +#!/usr/bin/env python3 +"""TCP echo throughput: hvloop vs asyncio (vs uvloop when installed). + +Methodology (tech design section 12.4) +-------------------------------------- +For each event loop implementation, ONE fresh loop runs both an echo server +(``loop.create_server``) and N concurrent client connections +(``loop.create_connection``) over real TCP on 127.0.0.1. Every client +performs R sequential round trips of an S-byte message (a write, then read +until S bytes came back), so one run moves N*R*S bytes each way. Server and +clients sharing a loop measures the *loop's* protocol/transport hot path +(read/write dispatch, flow control bookkeeping), not the kernel; all +implementations are measured under identical conditions. + +Usage: + python benchmarks/bench_tcp_echo.py [--connections 100] [--size 10240] + [--rounds 50] [--repeat 3] +""" + +from __future__ import annotations + +import argparse +import asyncio +import gc +import platform +import sys +import time + + +# --------------------------------------------------------------------------- +# protocols +# --------------------------------------------------------------------------- +class EchoServerProtocol(asyncio.Protocol): + def connection_made(self, transport): + self.transport = transport + + def data_received(self, data): + self.transport.write(data) + + +class EchoClientProtocol(asyncio.Protocol): + def __init__(self, loop, payload: bytes, rounds: int): + self.payload = payload + self.size = len(payload) + self.rounds = rounds + self.received = 0 + self.done = loop.create_future() + + def connection_made(self, transport): + self.transport = transport + transport.write(self.payload) + + def data_received(self, data): + self.received += len(data) + if self.received >= self.size: + self.received -= self.size + self.rounds -= 1 + if self.rounds <= 0: + if not self.done.done(): + self.done.set_result(None) + self.transport.close() + else: + self.transport.write(self.payload) + + def connection_lost(self, exc): + if not self.done.done(): + self.done.set_exception( + exc or ConnectionError("connection lost early")) + + +# --------------------------------------------------------------------------- +# one benchmark run +# --------------------------------------------------------------------------- +async def _run(loop, connections: int, size: int, rounds: int) -> float: + payload = b"\x55" * size + server = await loop.create_server(EchoServerProtocol, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + + clients = [] + t0 = time.perf_counter() + for _ in range(connections): + proto = EchoClientProtocol(loop, payload, rounds) + await loop.create_connection(lambda p=proto: p, "127.0.0.1", port) + clients.append(proto) + await asyncio.gather(*(c.done for c in clients)) + elapsed = time.perf_counter() - t0 + + server.close() + await server.wait_closed() + return elapsed + + +def bench_loop_factory(name, factory, args): + best = None + for _ in range(args.repeat): + loop = factory() + gc.collect() + try: + elapsed = loop.run_until_complete( + _run(loop, args.connections, args.size, args.rounds)) + finally: + loop.close() + best = elapsed if best is None else min(best, elapsed) + total_msgs = args.connections * args.rounds + total_bytes = total_msgs * args.size * 2 # payload travels both ways + return { + "name": name, + "time": best, + "rps": total_msgs / best, + "mbps": total_bytes / best / (1024 * 1024), + } + + +def main(): + p = argparse.ArgumentParser(description=__doc__) + p.add_argument("--connections", type=int, default=100) + p.add_argument("--size", type=int, default=10240) + p.add_argument("--rounds", type=int, default=50) + p.add_argument("--repeat", type=int, default=3, + help="runs per loop; best-of is reported") + args = p.parse_args() + + targets = [] + + def asyncio_loop(): + return asyncio.new_event_loop() + + targets.append(("asyncio", asyncio_loop)) + + import hvloop + targets.append(("hvloop", hvloop.new_event_loop)) + + try: + import uvloop + targets.append(("uvloop", uvloop.new_event_loop)) + except ImportError: + print("uvloop not installed; skipping", file=sys.stderr) + + print(f"TCP echo: {args.connections} conns x {args.rounds} rounds x " + f"{args.size}B (best of {args.repeat})") + print(f"python {sys.version.split()[0]} on {platform.platform()}\n") + + results = [bench_loop_factory(name, factory, args) + for name, factory in targets] + base = next(r for r in results if r["name"] == "asyncio") + + hdr = f"{'loop':<10}{'time (s)':>10}{'roundtrips/s':>14}{'MiB/s':>10}{'vs asyncio':>12}" + print(hdr) + print("-" * len(hdr)) + for r in results: + rel = base["time"] / r["time"] + print(f"{r['name']:<10}{r['time']:>10.3f}{r['rps']:>14,.0f}" + f"{r['mbps']:>10.1f}{rel:>11.2f}x") + + +if __name__ == "__main__": + main() diff --git a/docs/plans/2026-06-13-hvloop-tech-design.md b/docs/plans/2026-06-13-hvloop-tech-design.md new file mode 100644 index 0000000..4438c36 --- /dev/null +++ b/docs/plans/2026-06-13-hvloop-tech-design.md @@ -0,0 +1,198 @@ +# hvloop 技术方案：基于 libhv 的 asyncio 事件循环 + +日期：2026-06-13 +分支：`codex/refactor-native-io` +状态：待评审 + +## 1. 目标与范围 + +**目标**：用 Cython 实现一个 asyncio 兼容的事件循环扩展（定位类似 uvloop），底层复用 vendor/libhv 的跨平台事件引擎，面向 web server 场景。 + +**验收标准**（按优先级）： + +1. uvicorn + FastAPI 能以 `--loop hvloop`（或 `hvloop.install()`）正常运行 HTTP 服务； +2. FastAPI WebSocket 端点正常工作（uvicorn 的 `websockets` / `wsproto` 实现均基于 asyncio Protocol/Transport，不需要额外协议层）； +3. Linux（epoll）、macOS（kqueue）、Windows（wepoll）三平台构建并通过 CI 测试； +4. 常见异步客户端（httpx、asyncpg、redis-py async 等基于 `create_connection` 的库）可用。 + +**非目标**（明确不做或降级）： + +- `subprocess_exec` / `subprocess_shell`、`connect_read_pipe` / `connect_write_pipe`：抛 `NotImplementedError`（uvicorn/FastAPI 不依赖）； +- `sendfile`：回退到 asyncio 的 fallback 实现（`SendfileNotAvailableError` 路径）； +- Proactor 风格 API； +- 实现 asyncio 全部方法 —— 只做 web server 场景所需子集（见 §5）。 + +## 2. 现状 + +- 上一版实现（`loop.pyx` / `transport.pyx` / `server.pyx` / `handle.pyx`）已在 HEAD 提交中删除，CMakeLists 改为编译单一入口 `src/hvloop/_core.pyx`（待创建），即本分支是**推倒重写**。 +- 构建链已就绪：scikit-build-core + cython-cmake + CMake，libhv 以静态库（`hv_static`）链入，HTTP/MQTT/evpp/OpenSSL 等模块全部关闭，只编 core event。 +- 旧实现的主要教训（重写动机）： + - 用 `hloop_run` + `hidle` 驱动：libhv 的 idle 回调**只在本轮没有 IO/定时器事件时执行**（`hloop.c:180`），且 `hloop_run` 每轮最多阻塞 `HLOOP_MAX_BLOCK_TIME = 100ms`（`hloop.c:18`）——`call_soon` 排队的回调最坏要等 100ms，繁忙时还会被 IO 事件挤占，语义与 asyncio 不符； + - hio userdata 持有 Python 对象裸指针，没有配套的 INCREF/DECREF 纪律，存在 use-after-free 风险； + - 多 `.pyx` 独立编译单元之间 cimport，跨模块内联与构建依赖都比较脆。 + +## 3. 总体架构 + +### 3.1 模块布局 + +采用 uvloop 模式：**单编译单元** `_core.pyx`，子模块通过 Cython `include` 进同一翻译单元（拿到跨"模块"内联与 cdef class 直接访问，也匹配现有 CMake 只 transpile `_core.pyx` 的设定）： + +``` +src/hvloop/ + __init__.py # install() / new_event_loop() / run() / EventLoopPolicy + includes/ + hv.pxd # libhv C API 声明（hloop/hio/htimer/hevent） + consts.pxi # 常量 + python.pxd # CPython 内部 API 声明 + _core.pyx # 入口：include 下列文件 + loop.pyx / loop.pxd # Loop：驱动循环、call_soon/timer/threadsafe、executor、signal + handles.pyx # Handle / TimerHandle + tcp.pyx # TCPTransport（hio 封装）+ create_connection + server.pyx # Server + create_server + dns.pyx # getaddrinfo/getnameinfo（线程池） +``` + +M1 阶段可以先全部写在 `_core.pyx` 一个文件里，跑通后再按上面拆 include 文件。注意：CMake 需把 include 的文件列入 `cython_transpile` 的依赖（cython-cmake 的 depfile 支持；若不生效则在 CMake 里显式 `CMAKE_CONFIGURE_DEPENDS`），否则改子文件不触发重编。 + +### 3.2 与 libhv 的职责划分 + +| 职责 | 承担方 | +|---|---| +| IO 多路复用（epoll/kqueue/wepoll）| libhv `hloop_process_events` | +| 定时器堆 | libhv `htimer`（monotonic hrtime）| +| socket 读写缓冲、写流控水位 | libhv `hio`（内部写缓冲 + `hio_write_bufsize`）| +| 跨线程唤醒 | libhv `hloop_post_event`（线程安全，内置 eventfd/socketpair）| +| ready 回调队列、asyncio 语义、Future/Task、协议/传输对象 | hvloop（Cython）| +| DNS 解析、executor | hvloop（Python 线程池，同 asyncio 做法）| + +## 4. 核心设计：循环驱动模型 + +**不使用 `hloop_run`，由 hvloop 自驱**（uvloop 驱动 libuv 的同款思路）： + +```text +run_forever(): + 强制创建 wakeup eventfd（见下） + while not _stopping: + ntodo = len(_ready) + 逐个执行本轮快照内的 ready 回调（新入队的留到下一轮，防饿死） + if _stopping: break + timeout = 0 if _ready else INFINITE_OR_CAP + with nogil: + hloop_process_events(hvloop, timeout) # 内部会按最近 htimer 截断阻塞时间 +``` + +关键点： + +1. **`hloop_process_events` 自带定时器截断**：阻塞时间会取 `timeout` 与最近 htimer 到期时间的最小值（`hloop.c:140-161`），所以 hvloop 不需要自己算定时器超时，只需在 ready 队列非空时传 0。 +2. **wakeup fd 必须在进入循环前创建**：`hloop_process_events` 在 `nios == 0` 时直接 `hv_msleep(blocktime)`，**不可被唤醒**。而 wakeup eventfd 是 `hloop_run`/首次 `hloop_post_event` 惰性创建的。对策：`run_forever` 开头先 `hloop_post_event` 一个 no-op 事件，确保 eventfd 注册为 io（`nios >= 1`），此后循环始终阻塞在可中断的 poll 上。 +3. **`call_soon`**：append 到 `_ready`（Python deque）。因为只在 loop 线程调用，无需加锁；由于 ready 非空时 poll timeout 为 0，延迟为零。 +4. **`call_soon_threadsafe`**：append 到 `_ready`（CPython deque 的 append 在 GIL 下原子）+ `hloop_post_event(loop, no-op)` 打断 poll。不用 `hloop_wakeup` 之外的额外管道。 +5. **`stop()`**：置 `_stopping`；跨线程时经 `call_soon_threadsafe` 路径唤醒。 +6. **GIL 纪律**：poll 期间 `nogil` 释放；所有 libhv C 回调声明为 `noexcept`，体内 `with gil` 并整体 try/except，异常一律送 `call_exception_handler`，绝不穿透回 C。 +7. **KeyboardInterrupt**：SIGINT 到达会 EINTR 打断 poll，回到 Python 字节码层后由解释器抛出 —— 与 asyncio 行为一致；Windows 下 uvicorn 自行用 `signal.signal` 处理，不依赖 loop。 + +**定时器**：`call_later`/`call_at` → `htimer_add(cb, delay_ms, repeat=1)`，`TimerHandle` 持有 `htimer_t*`；cancel → `htimer_del`。注册期间对 Handle `Py_INCREF`，触发或取消后 `DECREF`。`loop.time()` = `hloop_now_us(hvloop) / 1e6`（monotonic，与 htimer 同时间源，保证 `call_at` 语义自洽）。 + +## 5. asyncio API 实现清单 + +**必须实现（M1–M3）**： + +- 生命周期：`run_forever` / `run_until_complete` / `stop` / `close` / `is_running` / `is_closed`、`shutdown_asyncgens`、`shutdown_default_executor` +- 调度：`call_soon` / `call_later` / `call_at` / `call_soon_threadsafe` / `time` / `create_future` / `create_task`、`set_task_factory` / `get_task_factory` +- 网络：`create_server`（host/port 多地址、`sock=`、backlog、reuse_address/reuse_port、start_serving，含 `Server` 对象全套：`close/wait_closed/serve_forever/sockets`）、`create_connection`（host/port、`sock=`、local_addr） +- fd 监视：`add_reader` / `remove_reader` / `add_writer` / `remove_writer`（基于 `hio_get` + `hio_add(HV_READ/HV_WRITE)`；得益于 Windows 用 wepoll 反应器后端，**三平台都可用**——这点优于 asyncio 的 ProactorEventLoop） +- DNS/executor：`getaddrinfo` / `getnameinfo`（默认线程池执行，同 asyncio）、`run_in_executor` / `set_default_executor` +- 信号：`add_signal_handler` / `remove_signal_handler`（仅 Unix；Windows 抛 `NotImplementedError`，与 asyncio Proactor 一致，uvicorn 会自动回退） +- 异常处理：`default_exception_handler` / `call_exception_handler` / `set_exception_handler`、`set_debug` / `get_debug` + +**Phase 2（M4，可选）**：`create_datagram_endpoint`、`sock_recv/sock_sendall/sock_accept/sock_connect`（基于 add_reader/writer 的简单实现）、TLS（见 §8）。 + +**不实现**（抛 `NotImplementedError`）：subprocess 系、pipe 系、`sendfile`（走 fallback）。 + +## 6. TCP Transport 设计 + +`TCPTransport`（实现 `asyncio.Transport` 接口）封装一个 `hio_t*`： + +- **读**：`hio_setcb_read` + `hio_read_start`。⚠️ libhv 的 readbuf 是 **loop 级共享缓冲**，回调返回后即被复用——回调内必须立刻 `PyBytes_FromStringAndSize` 拷贝再交给 `protocol.data_received`。`pause_reading` → `hio_read_stop`；`resume_reading` → `hio_read_start`。 +- **写**：`write(data)` → `hio_write`（libhv 先尝试直写，未写完部分进内部写缓冲并自动注册 HV_WRITE）。写流控：每次 write 后查 `hio_write_bufsize`，超过 high-water → `protocol.pause_writing()`；在 `hwrite_cb` 中检查降到 low-water 以下 → `resume_writing()`。`set_write_buffer_limits` 调整水位；`get_write_buffer_size` = `hio_write_bufsize`。 +- **关闭**：`close()` = 优雅关闭（停止读，待写缓冲清空后 `hio_close`，libhv 的 close 本身会 flush 残余写缓冲）；`abort()` = 直接 `hio_close`。`hclose_cb` → `protocol.connection_lost(exc)`，exc 由 `hio_error` 推断（0 → None）。 +- **write_eof**：libhv 无半关闭 API，在写缓冲清空后对 fd 直接调 `shutdown(SHUT_WR)`；`can_write_eof()` 返回 True。 +- **EOF 语义（已知偏差）**：libhv 收到对端 EOF 时不回调 read(0) 而是直接走 close 流程，拿不到"半关闭后继续写"的窗口。即 `protocol.eof_received()` 之后连接即关闭。对 HTTP/WebSocket（h11、httptools、websockets 均不依赖半关闭）无影响；如未来需要，可给 vendored libhv 打小 patch。 +- **生命周期**：`hio_set_context(io, transport)` + 注册时 `Py_INCREF(transport)`，`hclose_cb` 末尾 `Py_DECREF`。Transport 关闭后将 `_hio` 置 NULL，所有方法判 NULL 防悬挂。 +- **extra_info**：`socket`（用 `socket.socket(fileno=...)` 复制时注意所有权，提供 `dup` 视图）、`sockname` / `peername`（`hio_localaddr` / `hio_peeraddr`）。 + +`create_connection`：用 Python socket + `getaddrinfo` 做地址解析与多地址尝试（happy-eyeballs 不做，顺序尝试），连接用 `hio_get(fd)` + `hio_setcb_connect` + `hio_connect`（非阻塞 connect 交给 libhv），成功后构造 Transport。这样把 socket 创建/绑定细节留在 Python 侧（行为与 asyncio 一致），libhv 只管事件。 + +## 7. Server / create_server + +- **host/port 路径**：hvloop 用 Python `socket` 自建监听 socket（getaddrinfo 多地址、`SO_REUSEADDR`/`SO_REUSEPORT`、IPv6 dualstack），`listen(backlog)` 后交给 libhv：`hio_get(loop, fd)` + `hio_setcb_accept` + `hio_accept`。 +- **sock= 路径**：uvicorn 多 worker/reload 模式会传现成 socket，直接取 `fileno()` 走同样流程；Python socket 对象由 Server 持有保活（fd 所有权仍归 Python socket，关闭时先 `hio_del` 再由 socket 对象 close）。 +- **accept 回调**：libhv 已完成 accept，回调里拿到新连接的 `hio_t*` → `protocol_factory()` → 构造 `TCPTransport` → `connection_made`。`Server._attach/_detach` 计数维持 `wait_closed` 语义。 +- Windows 注意：Python 的 `fileno()` 返回 SOCKET 句柄（uintptr），libhv API 是 `int`——实践中句柄值在 int 范围内（libhv 全库即此假设，wepoll 同），跟随该约定，入口处加断言。 + +## 8. TLS 策略 + +- **Phase 1 不支持**：`create_server(ssl=...)` / `create_connection(ssl=...)` 抛 `NotImplementedError`。Web 部署中 TLS 终止通常在 nginx/Caddy/LB 层，不阻塞 FastAPI 验收目标。 +- **Phase 2**：复用 stdlib `asyncio.sslproto.SSLProtocol`（MemoryBIO 方案，uvloop 同源做法）：hvloop 的 TCPTransport 之上套 SSLProtocol，即可直接吃 Python 的 `ssl.SSLContext`。 +- **明确不用 libhv 的 OpenSSL 集成**：它与 Python `ssl.SSLContext`（证书、ALPN、SNI 配置）不互通，且会让 wheel 背上 OpenSSL 链接/分发负担。CMake 维持 `WITH_OPENSSL=OFF`。 + +## 9. 信号处理（Unix） + +不用 libhv 的 `hsignal_add`（其实现语义与 asyncio 要求不符），照搬 CPython unix_events 方案： + +- `signal.set_wakeup_fd(write_end)`，socketpair 读端注册进 hloop（`add_reader`）； +- 信号到达 → 字节写入 wakeup fd → loop 醒来 → 读出 signo → 调度已注册 handler 到 ready 队列； +- `signal.signal(sig, _noop)` 保证 C 层 handler 存在。 + +Windows：`add_signal_handler` 抛 `NotImplementedError`（uvicorn 检测后回退到 `signal.signal`，行为与其在 ProactorEventLoop 上一致）。 + +## 10. Python 包装层 + +```python +import hvloop + +hvloop.install() # asyncio.set_event_loop_policy(hvloop.EventLoopPolicy()) +loop = hvloop.new_event_loop() # 直接构造 Loop +hvloop.run(main()) # 3.11+: asyncio.Runner(loop_factory=...)；3.10: 自管理等价实现 +``` + +uvicorn 接入方式（两种都验证）：`hvloop.install()` 后 `uvicorn.run(app, loop="asyncio")`，以及为 uvicorn 注册自定义 loop setup（文档给出示例）。 + +## 11. 构建与发布 + +- 构建链不变：scikit-build-core + cython-cmake，CMake `cython_transpile(_core.pyx)` → C → 链 `hv_static`。 +- libhv 选项维持现状（只编 core event）；确认 Windows 下 `WITH_WEPOLL=ON`（libhv 默认 ON，CMake 中显式 FORCE 一次防漂移）。 +- Wheel 矩阵（cibuildwheel）：manylinux2014 x86_64/aarch64、musllinux、macOS x86_64 + arm64、Windows AMD64；CPython 3.10–3.13（3.14 进 CI 验证后加 classifier）。 +- CI：GitHub Actions 三平台 build + pytest + FastAPI/WebSocket 集成冒烟（现有 build.yml 改造）。 + +## 12. 测试与验收 + +1. **单元**：call_soon FIFO 顺序、call_later/call_at 精度与取消、call_soon_threadsafe 跨线程唤醒延迟、stop/close 语义、异常处理器、run_until_complete 嵌套错误、shutdown_asyncgens。 +2. **Transport**：echo client/server、1MB+ 大包、读暂停/恢复、写水位 pause_writing/resume_writing、对端半关/RST、abort、`sock=` 传入路径。 +3. **集成（验收门槛）**： + - uvicorn + FastAPI：JSON 端点、路径/查询参数、`def`（线程池）端点、流式响应、lifespan 启停、Ctrl-C 优雅退出； + - FastAPI WebSocket echo + 并发广播（websockets 客户端）； + - httpx AsyncClient 走 hvloop 的 `create_connection` 出站请求。 +4. **三平台 CI** 跑 1–3；**基准**（Linux）：oha/wrk 对比 asyncio、uvloop 的 RPS/延迟，写进 README。 + +## 13. 里程碑 + +| 里程碑 | 内容 | 完成标志 | +|---|---|---| +| M1 Loop 核心 | 自驱循环、call_soon/timer/threadsafe、executor、异常处理、生命周期 | 单元测试组 1 全绿（三平台）| +| M2 TCP | TCPTransport、create_connection、create_server/Server、add_reader/writer、Unix 信号 | echo + transport 测试组 2 全绿 | +| M3 ASGI 验收 | uvicorn + FastAPI HTTP & WebSocket、文档、uvicorn 接入示例 | 集成测试组 3 三平台全绿 | +| M4 打磨 | TLS（sslproto）、UDP（可选）、sock_* 系、wheel 发布流水线、benchmark | PyPI 可装、README 含基准 | + +## 14. 关键风险与对策 + +| 风险 | 影响 | 对策 | +|---|---|---| +| libhv readbuf 为 loop 级共享缓冲 | 数据被覆盖 | read 回调内立即拷贝为 bytes（§6）| +| `nios==0` 时 `hv_msleep` 不可唤醒 | threadsafe 唤醒失效 | 启动即 post no-op 事件创建 eventfd（§4.2）| +| libhv EOF 即关闭，无半关闭窗口 | `eof_received` 语义不完整 | HTTP/WS 不受影响；记录偏差，必要时 patch vendored libhv | +| Python 对象与 hio 生命周期错配 | use-after-free / 泄漏 | 统一 INCREF-on-register / DECREF-on-close 纪律，close 后指针置 NULL | +| C 回调中 Python 异常穿透 | 进程崩溃 | 所有回调 `noexcept` + `with gil` + 全量 try/except → exception handler | +| Windows SOCKET(uintptr) vs libhv int fd | 句柄截断（理论）| 跟随 libhv 全库约定，入口断言；wepoll 同假设 | +| cython include 文件改动不触发重编 | 开发体验 | CMake 依赖声明 / depfile 验证（§3.1）| +| uvicorn 对 loop 私有行为的隐性依赖 | 集成翻车 | M3 用 uvicorn 真实跑而非模拟；遇到缺口按需补 API | diff --git a/examples/fastapi_app.py b/examples/fastapi_app.py new file mode 100644 index 0000000..3b23cbf --- /dev/null +++ b/examples/fastapi_app.py @@ -0,0 +1,108 @@ +"""Runnable FastAPI + WebSocket example served on hvloop. + +Two ways to run it (both use hvloop as the event loop): + +1. Directly: + + python examples/fastapi_app.py + + ``main()`` calls ``uvicorn.run(app, loop="hvloop:new_event_loop")``. + uvicorn (>= 0.36) treats any ``"module:callable"`` string as an event-loop + *factory*, so it builds its loop by calling ``hvloop.new_event_loop()``. + +2. Via the uvicorn CLI, passing the same loop factory: + + uvicorn examples.fastapi_app:app --loop hvloop:new_event_loop + +NOTE: with uvicorn >= 0.36, ``hvloop.install()`` + ``--loop asyncio`` does NOT +work: uvicorn maps ``asyncio`` directly to ``asyncio.SelectorEventLoop`` and +never consults the (deprecated) asyncio event-loop policy, so that recipe +silently runs on stock asyncio. Use ``--loop hvloop:new_event_loop`` (or +``hvloop.install()`` + ``--loop none``). See README "Running uvicorn + FastAPI +on hvloop". + +Then try it out:: + + curl http://127.0.0.1:8000/ + curl http://127.0.0.1:8000/loopinfo # proves which loop class is running + curl http://127.0.0.1:8000/items/42?q=hi + # WebSocket echo (needs the `websockets` package): + python -m websockets ws://127.0.0.1:8000/ws + +Requires: ``pip install hvloop fastapi uvicorn`` (plus ``websockets`` for /ws). +""" + +from __future__ import annotations + +import asyncio +import contextlib + +from fastapi import FastAPI, WebSocket, WebSocketDisconnect +from fastapi.responses import StreamingResponse + + +@contextlib.asynccontextmanager +async def lifespan(_app: FastAPI): + print("hvloop example: startup") + yield + print("hvloop example: shutdown") + + +app = FastAPI(lifespan=lifespan) + + +@app.get("/") +async def root(): + return {"hello": "hvloop", "server": "uvicorn+fastapi"} + + +@app.get("/loopinfo") +async def loopinfo(): + # Sanity probe: shows the event-loop class actually serving this request. + # Expect "hvloop.Loop" when wired correctly (see module docstring). + cls = type(asyncio.get_running_loop()) + return {"loop_class": f"{cls.__module__}.{cls.__qualname__}"} + + +@app.get("/items/{item_id}") +async def read_item(item_id: int, q: str | None = None): + return {"item_id": item_id, "q": q} + + +@app.get("/sync") +def sync_endpoint(): + # Plain ``def`` endpoints run in Starlette's thread pool. + return {"mode": "sync"} + + +@app.get("/stream") +async def stream(): + async def gen(): + for i in range(5): + yield f"chunk {i}\n".encode() + + return StreamingResponse(gen(), media_type="text/plain") + + +@app.websocket("/ws") +async def ws_echo(ws: WebSocket): + await ws.accept() + try: + while True: + message = await ws.receive_text() + await ws.send_text(f"echo: {message}") + except WebSocketDisconnect: + pass + + +def main() -> None: + import uvicorn + + # loop="hvloop:new_event_loop" hands uvicorn the hvloop loop factory + # directly -- the only wiring that works with uvicorn >= 0.36 without + # touching the deprecated asyncio policy system. + uvicorn.run(app, host="127.0.0.1", port=8000, loop="hvloop:new_event_loop") + + +if __name__ == "__main__": + main() diff --git a/hvloop/__init__.py b/hvloop/__init__.py deleted file mode 100644 index 9d11d3f..0000000 --- a/hvloop/__init__.py +++ /dev/null @@ -1,25 +0,0 @@ -import asyncio as __asyncio -from asyncio.events import BaseDefaultEventLoopPolicy as __BasePolicy - -from .loop import Loop as __BaseLoop - -__all__ = ('new_event_loop', 'install', 'EventLoopPolicy') - - -class Loop(__BaseLoop, __asyncio.AbstractEventLoop): - pass - - -def new_event_loop(): - """Return a new event loop.""" - return Loop() - - -def install(): - __asyncio.set_event_loop_policy(EventLoopPolicy()) - - -class EventLoopPolicy(__BasePolicy): - - def _loop_factory(self): - return new_event_loop() diff --git a/hvloop/handle.pxd b/hvloop/handle.pxd deleted file mode 100644 index 8b5c0b8..0000000 --- a/hvloop/handle.pxd +++ /dev/null @@ -1,15 +0,0 @@ - -cdef class TimerHandle: - cdef: - object callback - tuple args - bint _cancelled - hv.htimer_t* timer - Loop loop - object context - tuple _debug_info - object __weakref__ - - cdef _run(self) - cdef _cancel(self) - cdef inline _clear(self) diff --git a/hvloop/handle.pyx b/hvloop/handle.pyx deleted file mode 100644 index a76a30c..0000000 --- a/hvloop/handle.pyx +++ /dev/null @@ -1,166 +0,0 @@ - -cdef void on_timer(hv.htimer_t* timer) with gil: - cdef: - TimerHandle handle = (timer).userdata - handle._run() - - -@cython.no_gc_clear -@cython.freelist(250) -cdef class TimerHandle: - def __cinit__(self, Loop loop, object callback, object args, - uint32_t delay, object context): - - self.loop = loop - self.callback = callback - self.args = args - self._cancelled = 0 - - if PY37: - pass - # if context is None: - # context = Context_CopyCurrent() - # self.context = context - else: - if context is not None: - raise NotImplementedError( - '"context" argument requires Python 3.7') - self.context = None - - self._debug_info = None - - self.timer = hv.htimer_add(self.loop.hvloop, on_timer, delay, 1) - hv.hevent_set_userdata(self.timer, self) - - - - # self.timer.start() - - # Only add to loop._timers when `self.timer` is successfully created - # add self ref to disable self and self.callback release - loop._timers.add(self) - - property _source_traceback: - def __get__(self): - if self._debug_info is not None: - return self._debug_info[1] - - def __dealloc__(self): - if not self.timer == NULL: - raise RuntimeError('active TimerHandle is deallacating') - - cdef _cancel(self): - if self._cancelled == 1: - return - self._cancelled = 1 - self._clear() - - cdef inline _clear(self): - if self.timer == NULL: - return - - self.callback = None - self.args = None - try: - self.loop._timers.remove(self) - finally: - hv.htimer_del(self.timer) - self.timer = NULL # let the UVTimer handle GC - - cdef _run(self): - if self._cancelled == 1: - return - - if self.callback is None: - raise RuntimeError('cannot run TimerHandle; callback is not set') - - - callback = self.callback - args = self.args - - - # Since _run is a cdef and there's no BoundMethod, - # we guard 'self' manually. - Py_INCREF(self) - - # if self.loop._debug: - # started = time_monotonic() - try: - # if PY37: - # assert self.context is not None - # Context_Enter(self.context) - - if args is not None: - callback(*args) - else: - callback() - except (KeyboardInterrupt, SystemExit): - raise - except BaseException as ex: - context = { - 'message': 'Exception in callback {}'.format(callback), - 'exception': ex, - 'handle': self, - } - - # if self._debug_info is not None: - # context['source_traceback'] = self._debug_info[1] - - self.loop.call_exception_handler(context) - else: - pass - # if self.loop._debug: - # pass - # delta = time_monotonic() - started - # if delta > self.loop.slow_callback_duration: - # aio_logger.warning( - # 'Executing %r took %.3f seconds', - # self, delta) - finally: - context = self.context - Py_DECREF(self) - # if PY37: - # Context_Exit(context) - self._clear() - - # Public API - - def __repr__(self): - info = [self.__class__.__name__] - - if self._cancelled: - info.append('cancelled') - - if self._debug_info is not None: - callback_name = self._debug_info[0] - source_traceback = self._debug_info[1] - else: - callback_name = None - source_traceback = None - - if callback_name is not None: - info.append(callback_name) - elif self.callback is not None: - info.append(format_callback_name(self.callback)) - - if source_traceback is not None: - frame = source_traceback[-1] - info.append('created at {}:{}'.format(frame[0], frame[1])) - - return '<' + ' '.join(info) + '>' - - def cancelled(self): - return self._cancelled - - def cancel(self): - self._cancel() - - -cdef format_callback_name(func): - if hasattr(func, '__qualname__'): - cb_name = getattr(func, '__qualname__') - elif hasattr(func, '__name__'): - cb_name = getattr(func, '__name__') - else: - cb_name = repr(func) - return cb_name diff --git a/hvloop/includes/hv.pxd b/hvloop/includes/hv.pxd deleted file mode 100644 index 4afbf55..0000000 --- a/hvloop/includes/hv.pxd +++ /dev/null @@ -1,194 +0,0 @@ -from libc.stdint cimport uint32_t, uint64_t -from posix.types cimport gid_t, uid_t - - -cdef extern from "hloop.h" nogil: - cdef int AF_INET - cdef int AF_INET6 - cdef int AF_UNIX - cdef int IPPROTO_IPV6 - cdef int SOCK_STREAM - cdef int SOCK_DGRAM - cdef int SOL_SOCKET - cdef int SO_REUSEADDR - - ctypedef enum hio_type_e: - HIO_TYPE_UNKNOWN = 0 - HIO_TYPE_STDIN = 0x00000001 - HIO_TYPE_STDOUT = 0x00000002 - HIO_TYPE_STDERR = 0x00000004 - HIO_TYPE_STDIO = 0x0000000F - - HIO_TYPE_FILE = 0x00000010 - - HIO_TYPE_IP = 0x00000100 - HIO_TYPE_UDP = 0x00001000 - HIO_TYPE_TCP = 0x00010000 - HIO_TYPE_SSL = 0x00020000 - HIO_TYPE_SOCKET = 0x00FFFF00 - - - ctypedef struct hloop_t - - ctypedef struct hevent_t: - hloop_t* loop - void* userdata - uint64_t event_id - int priority - - ctypedef struct hidle_t - ctypedef struct htimer_t - ctypedef struct htimeout_t - ctypedef struct hperiod_t - ctypedef struct hio_t: - hio_type_e io_type - sockaddr* localaddr - sockaddr* peeraddr - - ctypedef void (*hevent_cb) (hevent_t* ev) - ctypedef void (*hidle_cb) (hidle_t* idle) - ctypedef void (*htimer_cb) (htimer_t* timer) - ctypedef void (*hio_cb) (hio_t* io) - - ctypedef void (*haccept_cb) (hio_t* io) - ctypedef void (*hconnect_cb) (hio_t* io) - ctypedef void (*hread_cb) (hio_t* io, void* buf, int readbytes) - ctypedef void (*hwrite_cb) (hio_t* io, const void* buf, int writebytes) - ctypedef void (*hclose_cb) (hio_t* io) - - - hloop_t* hloop_new(int flags) - - void hloop_free(hloop_t** pp) - - int hloop_run(hloop_t* loop) - int hloop_stop(hloop_t* loop) - - void hloop_update_time(hloop_t* loop) - uint64_t hloop_now_us(hloop_t* loop) - - hidle_t* hidle_add(hloop_t* loop, hidle_cb cb, uint32_t repeat) - void hidle_del(hidle_t* idle) - - htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, uint32_t timeout, uint32_t repeat) - void htimer_del(htimer_t* timer) - - void htimer_del(htimer_t* timer) - void htimer_reset(htimer_t* timer) - - hio_t* hloop_create_tcp_client(hloop_t* loop, const char* host, int port, hconnect_cb connect_cb) - hio_t* hloop_create_tcp_server(hloop_t* loop, const char* host, int port, haccept_cb accept_cb) - - hio_t* hloop_create_udp_server(hloop_t* loop, const char* host, int port) - hio_t* hloop_create_udp_client(hloop_t* loop, const char* host, int port) - - # Nonblocking, poll IO events in the loop to call corresponding callback. - int HV_READ - int HV_WRITE - int HV_RDWR - - void hloop_post_event(hloop_t* loop, hevent_t* ev) - - hio_t * hio_get(hloop_t* loop, int fd) - int hio_add(hio_t* io, hio_cb cb, int events) - int hio_del(hio_t* io, int events) - - # hio_t fields - int hio_fd(hio_t* io) - int hio_error(hio_t* io) - hio_type_e hio_type(hio_t* io) - sockaddr* hio_localaddr(hio_t* io) - sockaddr* hio_peeraddr(hio_t* io) - void hio_set_peeraddr(hio_t* io, sockaddr* addr, int addrlen) - - # set callbacks - void hio_setcb_read(hio_t* io, hread_cb read_cb) - void hio_setcb_write(hio_t* io, hwrite_cb write_cb) - void hio_setcb_accept(hio_t* io, haccept_cb accept_cb) - void hio_setcb_connect(hio_t* io, hconnect_cb connect_cb) - void hio_setcb_close(hio_t* io, hclose_cb close_cb) - - # hio_add(io, HV_READ) => accept => haccept_cb - int hio_accept (hio_t* io) - # connect => hio_add(io, HV_WRITE) => hconnect_cb - int hio_connect(hio_t* io) - # hio_add(io, HV_READ) => read => hread_cb - int hio_read (hio_t* io) - # hio_try_write => hio_add(io, HV_WRITE) => write => hwrite_cb - int hio_write (hio_t* io, const void* buf, size_t len) - # hio_del(io, HV_RDWR) => close => hclose_cb - int hio_close (hio_t* io) - - int hio_read_start(hio_t* io) # same as hio_read - - - - - #------------------high-level apis------------------------------------------- - # hio_get -> hio_set_readbuf -> hio_setcb_read -> hio_read - hio_t* hread (hloop_t* loop, int fd, void* buf, size_t len, hread_cb read_cb) - # hio_get -> hio_setcb_write -> hio_write - hio_t* hwrite (hloop_t* loop, int fd, const void* buf, size_t len, hwrite_cb write_cb) - # hio_get -> hio_close - void hclose (hloop_t* loop, int fd) - - # tcp - # hio_get -> hio_setcb_accept -> hio_accept - hio_t* haccept (hloop_t* loop, int listenfd, haccept_cb accept_cb) - # hio_get -> hio_setcb_connect -> hio_connect - hio_t* hconnect (hloop_t* loop, int connfd, hconnect_cb connect_cb) - # hio_get -> hio_set_readbuf -> hio_setcb_read -> hio_read - hio_t* hrecv (hloop_t* loop, int connfd, void* buf, size_t len, hread_cb read_cb) - # hio_get -> hio_setcb_write -> hio_write - hio_t* hsend (hloop_t* loop, int connfd, const void* buf, size_t len, hwrite_cb write_cb) - - - #hevent.h - # void hio_init(hio_t* io) - # int hio_read(hio_t* io) - # void hio_done(hio_t* io) - # void hio_free(hio_t* io) - - -ctypedef enum hv_run_flag: - HV_RUN_ONCE = 1 - HV_AUTO_FREE = 2 - HV_QUIT_WHEN_NO_ACTIVE_EVENTS = 4 - - -cdef inline void hevent_set_userdata(hevent_t* ev, void* udata): - (ev).userdata = udata - - -cdef extern from "hsocket.h" nogil: - ctypedef int socklen_t - struct sockaddr: - unsigned short sa_family - char sa_data[14] - - struct sockaddr_in: - unsigned short sin_family - unsigned short sin_port - # ... - - struct sockaddr_in6: - unsigned short sin6_family - unsigned short sin6_port - unsigned long sin6_flowinfo - # ... - unsigned long sin6_scope_id - - ctypedef union sockaddr_u: - sockaddr sa - sockaddr_in sin - sockaddr_in6 sin6 - - int ntohs(int) - int htonl(int) - int ntohl(int) - - int sockaddr_set_ipport(sockaddr_u* addr, const char* host, int port) - socklen_t sockaddr_len(sockaddr_u* addr) - const char* sockaddr_str(sockaddr_u* addr, char* buf, int len) - - diff --git a/hvloop/includes/python.pxd b/hvloop/includes/python.pxd deleted file mode 100644 index 0bcd1c6..0000000 --- a/hvloop/includes/python.pxd +++ /dev/null @@ -1,21 +0,0 @@ -cdef extern from "Python.h": - int PY_VERSION_HEX - - unicode PyUnicode_FromString(const char *) - - void* PyMem_RawMalloc(size_t n) nogil - void* PyMem_RawRealloc(void *p, size_t n) nogil - void* PyMem_RawCalloc(size_t nelem, size_t elsize) nogil - void PyMem_RawFree(void *p) nogil - - object PyUnicode_EncodeFSDefault(object) - void PyErr_SetInterrupt() nogil - - void _Py_RestoreSignals() - - object PyMemoryView_FromMemory(char *mem, ssize_t size, int flags) - object PyMemoryView_FromObject(object obj) - int PyMemoryView_Check(object obj) - - cdef enum: - PyBUF_WRITE diff --git a/hvloop/loop.pxd b/hvloop/loop.pxd deleted file mode 100644 index e930997..0000000 --- a/hvloop/loop.pxd +++ /dev/null @@ -1,42 +0,0 @@ -from .includes cimport hv -from libc.stdint cimport uint32_t, uint64_t - -# cdef extern from *: -# ctypedef int vint "volatile int" - -cdef class Loop: - cdef: - hv.hloop_t* hvloop - - bint _debug - bint _closed - bint _stopping - - int _conn_lost - - uint64_t _thread_id - - object _task_factory - object _exception_handler - object _default_executor - object _ready # collections.deque - - set _timers - bint _eof - - char _recv_buffer[8192] - - cdef _run(self, int flags) - cdef inline _call_soon(self, object callback, object args, object context) - cdef _make_socket_transport(self, object sock, object protocol, object waiter, object extra, object server) - cdef _make_datagram_transport(self, object sock, object protocol, object address, object waiter, object extra) - cdef _make_hio_transport(self, hv.hio_t* hio, protocol, waiter, extra, server) - cdef uint64_t _time(self) - cdef _wake_up(self) - - - -include "server.pxd" -include "transport.pxd" -include "handle.pxd" - diff --git a/hvloop/loop.pyx b/hvloop/loop.pyx deleted file mode 100644 index 7615d88..0000000 --- a/hvloop/loop.pyx +++ /dev/null @@ -1,758 +0,0 @@ -# cython: language_level=3, embedsignature=True -import os -import stat -import sys -import asyncio -import concurrent.futures -import collections -import traceback -import socket -import itertools -import warnings - -cimport cython -from cython.operator cimport dereference as deref -from libc.stdint cimport uint32_t, uint64_t -from libc.string cimport memset -from cpython cimport PyObject -from cpython cimport ( - Py_INCREF, Py_DECREF, Py_XDECREF, Py_XINCREF, - PyBytes_AS_STRING, Py_SIZE, PyThread_get_thread_ident -) - -from .includes.python cimport ( - PY_VERSION_HEX, - PyMem_RawMalloc, - PyMem_RawFree, - PyUnicode_FromString, - Context_CopyCurrent, - Context_Enter, - Context_Exit, -) - -cdef os_environ = os.environ -cdef os_name = os.name -cdef sys_platform = sys.platform -cdef sys_getframe = sys._getframe -cdef sys_ignore_environment = sys.flags.ignore_environment -cdef aio_logger = asyncio.log.logger -cdef aio_Future = asyncio.Future -cdef aio_Task = asyncio.Task -cdef aio_ensure_future = asyncio.ensure_future -cdef aio_isfuture = asyncio.isfuture -cdef aio_Handle = asyncio.Handle -cdef aio_TimerHandle = asyncio.TimerHandle -cdef aio_wrap_future = asyncio.wrap_future -cdef aio_gather = asyncio.gather -cdef aio_set_running_loop = asyncio._set_running_loop -cdef aio_get_running_loop = asyncio._get_running_loop -cdef cc_ThreadPoolExecutor = concurrent.futures.ThreadPoolExecutor -cdef future_set_result_unless_cancelled = asyncio.futures._set_result_unless_cancelled - -cdef int has_IPV6_V6ONLY = hasattr(socket, 'IPV6_V6ONLY') -cdef int IPV6_V6ONLY = getattr(socket, 'IPV6_V6ONLY', -1) -cdef int has_SO_REUSEPORT = hasattr(socket, 'SO_REUSEPORT') -cdef int SO_REUSEPORT = getattr(socket, 'SO_REUSEPORT', 0) -cdef socket_getaddrinfo = socket.getaddrinfo -cdef socket_getnameinfo = socket.getnameinfo -cdef socket_socket = socket.socket -cdef socket_error = socket_error - -cdef col_deque = collections.deque -cdef col_Iterable = collections.abc.Iterable -cdef warnings_warn = warnings.warn - -cdef tb_StackSummary = traceback.StackSummary -cdef tb_walk_stack = traceback.walk_stack -cdef tb_format_list = traceback.format_list - -cdef chain_from_iterable = itertools.chain.from_iterable - -include "includes/consts.pxi" - -cdef: - int PY37 = PY_VERSION_HEX >= 0x03070000 - int PY36 = PY_VERSION_HEX >= 0x03060000 - uint64_t MAX_SLEEP = 3600 * 24 * 365 * 100 - uint32_t INFINITE = -1 - - -cdef void on_idle(hv.hidle_t* idle) with gil: - cdef: - Loop loop = (idle).userdata - ntodo = len(loop._ready) - for i in range(ntodo): - handle = loop._ready.popleft() - if handle._cancelled: - continue - handle._run() - handle = None - # time.sleep(2) - - if loop._stopping: - hv.hloop_stop(loop.hvloop) - - -_unset = object() - - -@cython.no_gc_clear -cdef class Loop: - """ - https://www.python.org/dev/peps/pep-3156/#event-loop-methods-overview - """ - - def __cinit__(self): - self.hvloop = hv.hloop_new(0) - - self._debug = 0 - self._thread_id = 0 - self._closed = 0 - self._stopping = 0 - - self._timers = set() - - self._task_factory = None - self._exception_handler = None - self._default_executor = None - self._ready = col_deque() - - def __init__(self): - self.set_debug((not sys_ignore_environment - and bool(os_environ.get('PYTHONASYNCIODEBUG')))) - - def __dealloc__(self): - # if self._closed == 0: - # aio_logger.warning("unclosed event loop") - # not self.is_running() - # if self._thread_id != 0: - # self.close() - - hv.hloop_free(&self.hvloop) - - def __repr__(self): - return '<{} running={} closed={} debug={}>'.format( - 'hvloop.Loop', self.is_running(), self.is_closed(), self.get_debug() - ) - - # starting, stopping and closing - cdef _run(self, int flags): - Py_INCREF(self) - aio_set_running_loop(self) - self._thread_id = PyThread_get_thread_ident() - - with nogil: - err = hv.hloop_run(self.hvloop) - Py_DECREF(self) - - self._stopping = 0 - self._thread_id = 0 - if err < 0: - raise ValueError("loop run error") - - def run_forever(self): - cdef hv.hidle_t* idle - idle = hv.hidle_add(self.hvloop, on_idle, INFINITE) - hv.hevent_set_userdata(idle, self) - return self._run(1) - - def run_until_complete(self, future): - new_task = not aio_isfuture(future) - - future = aio_ensure_future(future, loop=self) - if new_task: - # An exception is raised if the future didn't complete, so there - # is no need to log the "destroy pending task" message - future._log_destroy_pending = False - - def _run_until_complete_cb(fut): - if not fut.cancelled(): - exc = fut.exception() - if isinstance(exc, (SystemExit, KeyboardInterrupt)): - # Issue #22429: run_forever() already finished, no need to - # stop it. - return - self.stop() - - stop_cb = lambda :self.stop() - future.add_done_callback(_run_until_complete_cb) - try: - self.run_forever() - except: - if new_task and future.done() and not future.cancelled(): - # The coroutine raised a BaseException. Consume the exception - # to not log a warning, the caller doesn't have access to the - # local task. - future.exception() - raise - finally: - future.remove_done_callback(_run_until_complete_cb) - - if not future.done(): - raise RuntimeError('Event loop stopped before Future completed.') - - return future.result() - - - def stop(self): - """Stop running the event loop. - - Every callback already scheduled will still run. This simply informs - run_forever to stop looping after a complete iteration. - """ - self._stopping = 1 - - def is_running(self): - return (self._thread_id != 0) - - def close(self): - """Close the event loop. - - This clears the queues and shuts down the executor, - but does not wait for the executor to finish. - - The event loop must not be running. - """ - if self.is_running(): - raise RuntimeError("Cannot close a running event loop") - if self._closed: - return - if self._debug: - aio_logger.debug("Close %r", self) - self._closed = 1 - self._ready.clear() - # self._scheduled.clear() - executor = self._default_executor - if executor is not None: - self._default_executor = None - executor.shutdown(wait=False) - - def is_closed(self): - return self._closed - - # basic and timed callbacks - def call_soon(self, callback, *args, context=None): - handle = self._call_soon(callback, args, context) - return handle - - cdef inline _call_soon(self, object callback, object args, object context): - handle = aio_Handle(callback, args, self, context) - self._ready.append(handle) - return handle - - - def call_later(self, delay, callback, *args, context=None): - if delay < 0: - delay = 0 - if not args: - args = None - # s -> ms - when = round(delay * 1000) - return TimerHandle(self, callback, args, when, context) - - def call_at(self, when, callback, *args, context=None): - return self.call_later(when - self.time(), callback, *args, context=context) - - cdef uint64_t _time(self): - hv.hloop_update_time(self.hvloop) - return hv.hloop_now_us(self.hvloop) - - def time(self): - return self._time() / 1000 - - - # thread interaction - cdef _wake_up(self): - cdef hv.hevent_t ev - memset(&ev, 0, sizeof(ev)) - hv.hloop_post_event(self.hvloop, &ev) - - def call_soon_threadsafe(self, callback, *args, context=None): - handle = self._call_soon(callback, args, context) - #hvloop has inner socketpair, use it - self._wake_up() - return handle - - def run_in_executor(self, executor, func, *args): - if executor is None: - executor = self._default_executor - if executor is None: - executor = cc_ThreadPoolExecutor() - self.set_default_executor = executor - return aio_wrap_future( - executor.submit(func, *args), loop=self - ) - - def set_default_executor(self, executor): - self._default_executor = executor - - # internet name lookups - cdef _make_socket_transport(self, sock, protocol, waiter, extra, server): - cdef hv.hio_t* hio = hv.hio_get(self.hvloop, sock) - tr = self._make_hio_transport(hio, protocol, waiter, extra, server) - tr._attach_fileobj(sock) - return tr - - cdef _make_hio_transport(self, hv.hio_t* hio, protocol, waiter, extra, server): - tr = HVSocketTransport(self, protocol, waiter, extra, server) - tr._init_hio(hio) - tr._on_connect() - return tr - - @cython.iterable_coroutine - async def getaddrinfo(self, host, port, *, - family=0, type=0, proto=0, flags=0): - return await self.run_in_executor( - None, socket_getaddrinfo, host, port, family, type, proto, flags - ) - - @cython.iterable_coroutine - async def getnameinfo(self, sockaddr, flags=0): - return await self.run_in_executor( - None, socket_getnameinfo, sockaddr, flags - ) - - #internet connections - @cython.iterable_coroutine - async def create_connection( - self, protocol_factory, host=None, port=None, - *, ssl=None, family=0, - proto=0, flags=0, sock=None, - local_addr=None, server_hostname=None, - ssl_handshake_timeout=None, - happy_eyeballs_delay=None, interleave=None): - protocol = protocol_factory() - waiter = self.create_future() - if ssl: - raise ValueError("not support now") - - if host is not None and port is not None: - try: - host = host.encode('ascii') - except UnicodeError: - host = host.encode('idna') - try: - transport = HVSocketTransport.connect( - self, host, port, protocol, waiter, None, None - ) - # transport.connect(host, port) - await waiter - except: - aio_logger.error("transport connect error") - # transport.close() - raise - pass - else: - if sock is None: - raise ValueError('host and port was not specified and no sock specified') - transport = self._make_socket_transport(sock, protocol, waiter, None, None) - await waiter - - return transport, protocol - - - async def create_server( - self, protocol_factory, host=None, port=None, - *, - family=socket.AF_UNSPEC, - flags=socket.AI_PASSIVE, - sock=None, - backlog=100, - ssl=None, - reuse_address=None, - reuse_port=None, - ssl_handshake_timeout=None, - start_serving=True): - """Create a TCP server. - - The host parameter can be a string, in that case the TCP server is - bound to host and port. - - The host parameter can also be a sequence of strings and in that case - the TCP server is bound to all hosts of the sequence. If a host - appears multiple times (possibly indirectly e.g. when hostnames - resolve to the same IP address), the server is only bound once to that - host. - - Return a Server object which can be used to stop the service. - - This method is a coroutine. - """ - if isinstance(ssl, bool): - raise TypeError('ssl argument must be an SSLContext or None') - - if ssl_handshake_timeout is not None and ssl is None: - raise ValueError( - 'ssl_handshake_timeout is only meaningful with ssl') - - if host is not None or port is not None: - if sock is not None: - raise ValueError( - 'host/port and sock can not be specified at the same time') - - if reuse_address is None: - reuse_address = os_name == 'posix' and sys_platform != 'cygwin' - - if reuse_port and not has_SO_REUSEPORT: - raise ValueError('reuse_port not supported by socket module') - - sockets = [] - if host == '': - hosts = [None] - elif (isinstance(host, str) or - not isinstance(host, col_Iterable)): - hosts = [host] - else: - hosts = host - - fs = [self.getaddrinfo(host, port, family=family, type=hv.SOCK_STREAM, flags=flags) - for host in hosts] - infos = await aio_gather(*fs, loop=self) - infos = set(chain_from_iterable(infos)) - - completed = False - try: - for res in infos: - af, socktype, proto, canonname, sa = res - try: - sock = socket_socket(af, socktype, proto) - except socket.error: - # Assume it's a bad family/type/protocol combination. - if self._debug: - aio_logger.warning('create_server() failed to create ' - 'socket.socket(%r, %r, %r)', - af, socktype, proto, exc_info=True) - continue - sockets.append(sock) - if reuse_address: - sock.setsockopt( - hv.SOL_SOCKET, hv.SO_REUSEADDR, True) - if reuse_port: - sock.setsockopt(hv.SOL_SOCKET, SO_REUSEPORT, 1) - # Disable IPv4/IPv6 dual stack support (enabled by - # default on Linux) which makes a single socket - # listen on both address families. - if af == hv.AF_INET6 and has_IPV6_V6ONLY: - - sock.setsockopt(hv.IPPROTO_IPV6, - IPV6_V6ONLY, - True) - try: - sock.bind(sa) - except OSError as err: - raise OSError(err.errno, 'error while attempting ' - 'to bind on address %r: %s' - % (sa, err.strerror.lower())) from None - completed = True - finally: - if not completed: - for sock in sockets: - sock.close() - else: - if sock is None: - raise ValueError('Neither host/port nor sock were specified') - if sock.type != socket.SOCK_STREAM: - raise ValueError(f'A Stream Socket was expected, got {sock!r}') - sockets = [sock] - - for sock in sockets: - sock.setblocking(False) - - server = Server(self, sockets, protocol_factory, - ssl, backlog, ssl_handshake_timeout) - - if start_serving: - server._start_serving() - # Skip one loop iteration so that all 'loop.add_reader' - # go through. - # await tasks.sleep(0, loop=self) - - if self._debug: - aio_logger.info("%r is serving", server) - return server - - cdef _make_datagram_transport(self, object sock, protocol, - address, waiter, extra): - - tr = DatagramTransport(self, protocol, address, waiter, extra) - cdef hv.hio_t* hio - hio = hv.hio_get(self.hvloop, sock.fileno()) - cdef hv.sockaddr_u peeraddr - memset(&peeraddr, 0, sizeof(peeraddr)) - if address: - hv.sockaddr_set_ipport(&peeraddr, address[0].encode("ascii"), address[1]) - hv.hio_set_peeraddr(hio, &peeraddr.sa, hv.sockaddr_len(&peeraddr)) - - tr._init_hio(hio) - tr._on_connect() - tr._attach_fileobj(sock) - return tr - - async def create_datagram_endpoint(self, protocol_factory, - local_addr=None, remote_addr=None, *, - family=0, proto=0, flags=0, - reuse_address=_unset, reuse_port=None, - allow_broadcast=None, sock=None): - if sock is not None: - if sock.type != socket.SOCK_DGRAM: - raise ValueError( - f'A UDP Socket was expected, got {sock!r}') - if (local_addr or remote_addr or - family or proto or flags or - reuse_port or allow_broadcast): - # show the problematic kwargs in exception msg - opts = dict(local_addr=local_addr, remote_addr=remote_addr, - family=family, proto=proto, flags=flags, - reuse_address=reuse_address, reuse_port=reuse_port, - allow_broadcast=allow_broadcast) - problems = ', '.join(f'{k}={v}' for k, v in opts.items() if v) - raise ValueError( - f'socket modifier keyword arguments can not be used ' - f'when sock is specified. ({problems})') - sock.setblocking(False) - r_addr = None - else: - if not (local_addr or remote_addr): - if family == 0: - raise ValueError('unexpected address family') - addr_pairs_info = (((family, proto), (None, None)),) - elif hasattr(socket, 'AF_UNIX') and family == socket.AF_UNIX: - for addr in (local_addr, remote_addr): - if addr is not None and not isinstance(addr, str): - raise TypeError('string is expected') - - if local_addr and local_addr[0] not in (0, '\x00'): - try: - if stat.S_ISSOCK(os.stat(local_addr).st_mode): - os.remove(local_addr) - except FileNotFoundError: - pass - except OSError as err: - # Directory may have permissions only to create socket. - aio_logger.error('Unable to check or remove stale UNIX ' - 'socket %r: %r', - local_addr, err) - - addr_pairs_info = (((family, proto), - (local_addr, remote_addr)),) - else: - # join address by (family, protocol) - addr_infos = {} # Using order preserving dict - for idx, addr in ((0, local_addr), (1, remote_addr)): - if addr is not None: - assert isinstance(addr, tuple) and len(addr) == 2, ( - '2-tuple is expected') - - infos = await self.getaddrinfo( - addr[0], addr[1], family=family, type=socket.SOCK_DGRAM, - proto=proto, flags=flags) - if not infos: - raise OSError('getaddrinfo() returned empty list') - - for fam, _, pro, _, address in infos: - key = (fam, pro) - if key not in addr_infos: - addr_infos[key] = [None, None] - addr_infos[key][idx] = address - - # each addr has to have info for each (family, proto) pair - addr_pairs_info = [ - (key, addr_pair) for key, addr_pair in addr_infos.items() - if not ((local_addr and addr_pair[0] is None) or - (remote_addr and addr_pair[1] is None))] - - if not addr_pairs_info: - raise ValueError('can not get address information') - - exceptions = [] - - # bpo-37228 - if reuse_address is not _unset: - if reuse_address: - raise ValueError("Passing `reuse_address=True` is no " - "longer supported, as the usage of " - "SO_REUSEPORT in UDP poses a significant " - "security concern.") - else: - warnings_warn("The *reuse_address* parameter has been " - "deprecated as of 3.5.10 and is scheduled " - "for removal in 3.11.", DeprecationWarning, - stacklevel=2) - - if reuse_port and not has_SO_REUSEPORT: - raise ValueError('reuse_port not supported by socket module') - - for ((family, proto), - (local_address, remote_address)) in addr_pairs_info: - sock = None - r_addr = None - try: - sock = socket.socket( - family=family, type=socket.SOCK_DGRAM, proto=proto) - if reuse_port: - sock.setsockopt(hv.SOL_SOCKET, SO_REUSEPORT, 1) - if allow_broadcast: - sock.setsockopt( - socket.SOL_SOCKET, socket.SO_BROADCAST, 1) - sock.setblocking(False) - - if local_addr: - sock.bind(local_address) - if remote_addr: - if not allow_broadcast: - sock.connect(remote_address) - r_addr = remote_address - except OSError as exc: - if sock is not None: - sock.close() - exceptions.append(exc) - except: - if sock is not None: - sock.close() - raise - else: - break - else: - raise exceptions[0] - - protocol = protocol_factory() - waiter = self.create_future() - transport = self._make_datagram_transport( - sock, protocol, r_addr, waiter, None) - if self._debug: - if local_addr: - aio_logger.info("Datagram endpoint local_addr=%r remote_addr=%r " - "created: (%r, %r)", - local_addr, remote_addr, transport, protocol) - else: - aio_logger.debug("Datagram endpoint remote_addr=%r created: " - "(%r, %r)", - remote_addr, transport, protocol) - - try: - await waiter - except: - transport.close() - raise - - return transport, protocol - - # tasks and futures support - def create_future(self): - return aio_Future(loop=self) - - def create_task(self, coro, *, name=None): - if self._task_factory is None: - task = aio_Task(coro, loop=self, name=name) - else: - task = self._task_factory(self, coro) - return task - - def set_task_factory(self, factory): - self._task_factory = factory - - def get_task_factory(self): - return self._task_factory - - # error handling - def get_exception_handler(self): - return self._exception_handler - - def set_exception_handler(self, handler): - if handler is not None and not callable(handler): - return TypeError("A callable object or None is expected, ", - "got {!r}".format(handler)) - self._exception_handler = handler - - def default_exception_handler(self, context): - """Default exception handler. - - This is called when an exception occurs and no exception - handler is set, and can be called by a custom exception - handler that wants to defer to the default behavior. - - The context parameter has the same meaning as in - `call_exception_handler()`. - """ - message = context.get('message') - if not message: - message = 'Unhandled exception in event loop' - - exception = context.get('exception') - if exception is not None: - exc_info = (type(exception), exception, exception.__traceback__) - else: - exc_info = False - - log_lines = [message] - for key in sorted(context): - if key in {'message', 'exception'}: - continue - value = context[key] - if key == 'source_traceback': - tb = ''.join(tb_format_list(value)) - value = 'Object created at (most recent call last):\n' - value += tb.rstrip() - else: - try: - value = repr(value) - except (KeyboardInterrupt, SystemExit): - raise - except BaseException as ex: - value = ('Exception in __repr__ {!r}; ' - 'value type: {!r}'.format(ex, type(value))) - log_lines.append('{}: {}'.format(key, value)) - - aio_logger.error('\n'.join(log_lines), exc_info=exc_info) - - def call_exception_handler(self, context): - if self._exception_handler is None: - try: - self.default_exception_handler(context) - except (KeyboardInterrupt, SystemExit): - raise - except BaseException: - # Second protection layer for unexpected errors - # in the default implementation, as well as for subclassed - # event loops with overloaded "default_exception_handler". - aio_logger.error('Exception in default exception handler', exc_info=True) - else: - try: - self._exception_handler(self, context) - except (KeyboardInterrupt, SystemExit): - raise - except BaseException as exc: - # Exception in the user set custom exception handler. - try: - # Let's try default handler. - self.default_exception_handler({ - 'message': 'Unhandled error in exception handler', - 'exception': exc, - 'context': context, - }) - except (KeyboardInterrupt, SystemExit): - raise - except BaseException: - # Guard 'default_exception_handler' in case it is - # overloaded. - aio_logger.error('Exception in default exception handler ' - 'while handling an unexpected error ' - 'in custom exception handler', - exc_info=True) - - - # debug mode todo: - def get_debug(self): - return self._debug - - def set_debug(self, enabled): - self._debug = bool(enabled) - - if self.is_running(): - pass - - -include "server.pyx" -include "transport.pyx" -include "handle.pyx" - diff --git a/hvloop/requests.pyx b/hvloop/requests.pyx deleted file mode 100644 index 2828674..0000000 --- a/hvloop/requests.pyx +++ /dev/null @@ -1,90 +0,0 @@ -from libcpp.string cimport string -from libcpp cimport bool as bool_t -from libcpp.memory cimport shared_ptr - - -cdef extern from "http_client.h": - ctypedef struct http_client_t - - http_client_t* http_client_new(const char* host, int port, int https) - -cdef extern from "hstring.h": - cdef cppclass StringCaseLess - -cdef extern from "hmap.h" namespace "hv" nogil: - ctypedef map[string, string] KeyValue - -cdef extern from "http_content.h": - ctypedef KeyValue QueryParams - - -cdef extern from "httpdef.h": - cdef enum http_status: - HTTP_STATUS_CONTINUE = 100 - HTTP_STATUS_SWITCHING_PROTOCOLS = 101 - HTTP_STATUS_PROCESSING = 102 - HTTP_STATUS_OK = 200 - HTTP_STATUS_CREATED = 201 - HTTP_STATUS_ACCEPTED = 202 - HTTP_STATUS_NON_AUTHORITATIVE_INFORMATION = 203 - HTTP_STATUS_NO_CONTENT = 204 - HTTP_STATUS_RESET_CONTENT = 205 - HTTP_STATUS_PARTIAL_CONTENT = 206 - HTTP_STATUS_MULTI_STATUS = 207 - HTTP_STATUS_ALREADY_REPORTED = 208 - - cdef enum http_method: - HTTP_DELETE = 0 - HTTP_GET = 1 - HTTP_HEAD = 2 - HTTP_POST = 3 - HTTP_PUT = 4 - HTTP_CONNECT = 5 - HTTP_OPTIONS = 6 - - -ctypedef map[string, string, StringCaseLess] http_headers -ctypedef string http_body - - -cdef extern from "HttpMessage.h": - ctypedef struct HNetAddr: - string ip - int port - - cdef cppclass HttpMessage: - int type - unsigned short http_major - unsigned short http_minor - - http_headers headers - http_body body - void * content - int content_length - - cdef cppclass HttpResponse: - http_status status_code - const char* status_message() - - cdef cppclass HttpRequest: - http_method method - string url - bool_t https - string host - int port - string path - QueryParams query_params - - HNetAddr client_addr - -cdef extern from "requests.h" namespace "requests": - ctypedef shared_ptr[HttpRequest] Request - ctypedef shared_ptr[HttpResponse] Response - - Response request(http_method method, const char* url, const http_body& body, const http_headers& headers) - - -def crequest(int method, str url, ): - py_byte_string = url.encode("utf-8") - resp = request(HTTP_GET, py_byte_string) - print("%d %s\r\n" % (resp.get().status_code, resp.get().status_message())) diff --git a/hvloop/server.pxd b/hvloop/server.pxd deleted file mode 100644 index a4db12c..0000000 --- a/hvloop/server.pxd +++ /dev/null @@ -1,19 +0,0 @@ -cdef class Server: - cdef: - Loop _loop - list _sockets - int _backlog - object _protocol_factory - object _ssl_context - object _serving_forever_fut - - object ssl_handshake_timeout - object ssl_shutdown_timeout - bint _serving - int _active_count - hv.hio_t** _server_io_list - - list _waiters - - cdef _start_serving(self) - cdef _on_accept(self, hv.hio_t* io) diff --git a/hvloop/server.pyx b/hvloop/server.pyx deleted file mode 100644 index 7085cd0..0000000 --- a/hvloop/server.pyx +++ /dev/null @@ -1,137 +0,0 @@ - -@cython.no_gc_clear -cdef class Server: - """ - events.AbstractServer - """ - def __cinit__(self, Loop loop, list sockets, object protocol_factory, - object ssl, int backlog, object ssl_handshake_timeout): - - self._loop = loop - self._sockets = sockets - self._protocol_factory = protocol_factory - self._backlog = backlog - self._ssl_context = ssl - self._serving_forever_fut = None - self._serving = 0 - self.ssl_handshake_timeout = None - self.ssl_shutdown_timeout = None - self._active_count = 0 - self._waiters = [] - - self._server_io_list = PyMem_RawMalloc( - len(self._sockets) * sizeof(hv.hio_t*) - ) - - def __dealloc__(self): - PyMem_RawFree(self._server_io_list) - self._server_io_list = NULL - - def __repr__(self): - return "<{} sockets={}>".format(self.__class__.__name__, self._sockets) - - def _wakeup(self): - waiters = self._waiters - self._waiters = None - for waiter in waiters: - if not waiter.done(): - waiter.set_result(waiter) - - def close(self): - cdef int idx = 0 - while idx < len(self._sockets): - hv.hio_close(self._server_io_list[idx]) - idx += 1 - - self._serving = 0 - - if (self._serving_forever_fut is not None and not - self._serving_forever_fut.done()): - self._serving_forever_fut.cancel() - self._serving_forever_fut = None - - if self._active_count == 0: - self._wakeup() - - @cython.iterable_coroutine - async def wait_closed(self): - if self._sockets is None or self._waiters is None: - return - waiter = self._loop.create_future() - self._waiters.append(waiter) - await waiter - - def get_loop(self): - return self._loop - - def is_serving(self): - return self._serving - - cdef _on_accept(self, hv.hio_t* io): - protocol = self._protocol_factory() - self._loop._make_hio_transport(io, protocol, None, None, self) - - cdef _start_serving(self): - if self._serving == 1: - return - self._serving = 1 - cdef: - hv.hio_t* io - int idx = 0 - - for sock in self._sockets: - sock.listen(self._backlog) - io = hv.haccept(self._loop.hvloop, sock.fileno(), on_accept) - hv.hevent_set_userdata( io, self) - - self._server_io_list[idx] = io - idx += 1 - - @cython.iterable_coroutine - async def start_serving(self): - self._start_serving() - - async def serve_forever(self): - if self._serving_forever_fut is not None: - raise RuntimeError( - f'server {self!r} is already being awaited on serve_forever()') - if self._sockets is None: - raise RuntimeError(f'server {self!r} is closed') - - - self._start_serving() - self._serving_forever_fut = self._loop.create_future() - - try: - await self._serving_forever_fut - except asyncio.CancelledError: - try: - self.close() - await self.wait_closed() - finally: - raise - finally: - self._serving_forever_fut = None - - def _attach(self): - """will call when init a transport""" - self._active_count += 1 - - def _detach(self): - """call when transport closed""" - self._active_count -= 1 - if self._active_count == 0 and self._sockets is None: - self._wakeup() - - async def __aenter__(self): - return self - - async def __aexit__(self, exc_type, exc_val, exc_tb): - self.close() - await self.wait_closed() - -cdef void on_accept(hv.hio_t* io) with gil: - cdef: - Server server = ( io).userdata - - server._on_accept(io) diff --git a/hvloop/transport.pxd b/hvloop/transport.pxd deleted file mode 100644 index 75bc118..0000000 --- a/hvloop/transport.pxd +++ /dev/null @@ -1,94 +0,0 @@ - -cdef class HVSocketTransport: - cdef: - object _protocol - object _waiter - object _server - - dict _extra_info - Loop _loop - hv.hio_t* _hio - size_t _buffer_size - size_t _high_water - size_t _low_water - - # _SelectorSocketTransport - bint _eof - - # _SelectorTransport - size_t _conn_lost - bint _closing - bint _protocol_connected - bint _protocol_paused - - object _fileobj - - # cdef void connect(self, const char* host, int port) - # cdef _accept(self, hv.hio_t* io, object server) - - cdef _init_hio(self, hv.hio_t* hio) - - cdef inline _attach_fileobj(self, object file) - @staticmethod - cdef HVSocketTransport connect(Loop loop, const char* host, int port, object protocol, object waiter, - object extra, object server) - cdef _set_server(self, Server server) - # cdef _call_connection_made(self) - cdef _schedule_call_connection_lost(self, exc) - # cdef _call_connection_lost(self, exc) - cdef _on_connect(self) - cdef _on_recv(self, void* buf, int n) - - cdef size_t _get_write_buffer_size(self) - - # cdef _write(self, object data) - cdef inline _maybe_pause_protocol(self) - cdef inline _maybe_resume_protocol(self) - - cdef _start_reading(self) - cdef _stop_reading(self) - - -cdef class DatagramTransport: - cdef: - object _protocol - object _waiter - object _address - - dict _extra_info - Loop _loop - hv.hio_t* _hio - size_t _buffer_size - size_t _high_water - size_t _low_water - - # _SelectorSocketTransport - bint _eof - - # _SelectorTransport - size_t _conn_lost - bint _closing - bint _protocol_connected - bint _protocol_paused - object _fileobj - - # cdef void connect(self, const char* host, int port) - # cdef _accept(self, hv.hio_t* io, object server) - - cdef _init_hio(self, hv.hio_t* hio) - - cdef inline _attach_fileobj(self, object file) - # cdef _call_connection_made(self) - cdef _schedule_call_connection_lost(self, exc) - # cdef _call_connection_lost(self, exc) - cdef _on_connect(self) - cdef _on_datagram_recv(self, void* buf, int n, object addr) - - cdef size_t _get_write_buffer_size(self) - - # cdef _write(self, object data) - cdef inline _maybe_pause_protocol(self) - cdef inline _maybe_resume_protocol(self) - - cdef _start_reading(self) - cdef _stop_reading(self) diff --git a/hvloop/transport.pyx b/hvloop/transport.pyx deleted file mode 100644 index 8ecfd6e..0000000 --- a/hvloop/transport.pyx +++ /dev/null @@ -1,615 +0,0 @@ - -cdef void on_connect(hv.hio_t* io) with gil: - cdef: - HVSocketTransport transport = (io).userdata - transport._on_connect() - - -cdef void on_recv(hv.hio_t* io, void* buf, int readbytes) with gil: - cdef: - HVSocketTransport transport = (io).userdata - transport._on_recv(buf, readbytes) - - -@cython.no_gc_clear -cdef class HVSocketTransport: - """ - client socket - or server accept socket - """ - - def __cinit__(self, Loop loop, protocol, waiter=None, - extra=None, server=None): - self._loop = loop - self._protocol = None - self._server = server - self._waiter = waiter - self._extra_info = dict() - self._hio = NULL - self._eof = 0 - # no need buffer, use hio_write intern buf - self._buffer_size = 0 - - # flow control - self._high_water = 64 * 1024 - self._low_water = 64 // 4 - - self.set_protocol(protocol) - if server is not None: - self._set_server(server) - self._conn_lost = 0 - self._closing = 0 - - self._protocol_connected = 0 - self._protocol_paused = 0 - - - def __repr__(self): - return '<{} closed=1 {:#x}>'.format( - self.__class__.__name__, - id(self) - ) - - def __dealloc__(self): - pass - - cdef _init_hio(self, hv.hio_t* hio): - self._hio = hio - hv.hevent_set_userdata(self._hio, self) - - def get_extra_info(self, name, default=None): - return self._extra_info.get(name, default) - - cdef _set_server(self, Server server): - self._server = server - self._server._attach() - - cdef inline _attach_fileobj(self, object file): - file._io_refs += 1 - self._fileobj = file - - @staticmethod - cdef HVSocketTransport connect(Loop loop, const char* host, int port, object protocol, object waiter, - object extra, object server): - cdef: - HVSocketTransport tr - hv.hio_t* hio - # todo: libhv 怎么处理连接超时的问题， 其内部 调用 hio_connect 失败的问题 - # waiter set exception ? - hio = hv.hloop_create_tcp_client(loop.hvloop, host, port, on_connect) - if hio == NULL: - raise ValueError("connect error") - tr = HVSocketTransport(loop, protocol, waiter, extra, server) - tr._init_hio(hio) - return tr - - - cdef _start_reading(self): - hv.hio_setcb_read(self._hio, on_recv) - hv.hio_read(self._hio) - # hv.hio_set_readbuf(self._io, self.loop._recv_buf, 8192) - - cdef _stop_reading(self): - hv.hio_del(self._hio, hv.HV_READ) - - - cdef _on_connect(self): - # 填写 sockanme 和 peername - self._extra_info["sockname"] = convert_sockaddr_to_pyaddr(hv.hio_localaddr(self._hio)) - self._extra_info["peername"] = convert_sockaddr_to_pyaddr(hv.hio_peeraddr(self._hio)) - self._loop.call_soon(self._call_connection_made) - - - def _call_connection_made(self): - self._protocol_connected = 1 - self._protocol.connection_made(self) - self._start_reading() - - if self._waiter is not None and not self._waiter.cancelled(): - self._waiter.set_result(None) - - - def _call_connection_lost(self, exc): - - try: - if self._protocol_connected: - self._protocol.connection_lost(exc) - finally: - self._protocol = None - # close socket - server = self._server - if server is not None: - server._detach() - self._server = None - - - cdef _on_recv(self, void *buf, int n): - cdef bytes py_bytes - try: - py_bytes = (buf)[:n] - self._protocol.data_received(py_bytes) - except BaseException as exc: - self._fatal_error(exc) - - - def write(self, object data): - if not isinstance(data, (bytes, bytearray, memoryview)): - raise TypeError('data argument must be a bytes-like object, not {}'.format(type(data).__name__)) - - if not data: - return - - cdef: - void* buf - size_t blen - - buf = PyBytes_AS_STRING(data) - blen = Py_SIZE(data) - self._buffer_size += blen - n = hv.hio_write(self._hio, buf, blen) - if n < 0: - exc = Exception() - self._fatal_error(exc, "hio_write error code: %d" % n) - raise exc - else: - self._buffer_size -= n - aio_logger.info("send: %s, buf: %s", n, blen) - if self._buffer_size > 0: - # todo: add io_close_cb, check io send error? - hv.hio_setcb_write(self._hio, on_data_write) - self._maybe_pause_protocol() - - def get_protocol(self): - return self._protocol - - def set_protocol(self, protocol): - self._protocol = protocol - - def writelines(self, list_of_data): - data = b''.join(list_of_data) - self.write(data) - - def write_eof(self): - self._eof = 1 - - def can_write_eof(self): - return True - - # flow control - cdef inline _maybe_pause_protocol(self): - cdef: - size_t size = self._get_write_buffer_size() - if size <= self._high_water: - return - - if not self._protocol_paused: - self._protocol_paused = 1 - try: - self._protocol.pause_writing() - except (SystemExit, KeyboardInterrupt): - raise - except BaseException as exc: - self._loop.call_exception_handler({ - 'message': 'protocol.pause_writing() failed', - 'exception': exc, - 'transport': self, - 'protocol': self._protocol, - }) - - cdef inline _maybe_resume_protocol(self): - cdef: - size_t size = self._get_write_buffer_size() - if (self._protocol_paused and - size <= self._low_water): - self._protocol_paused = 0 - try: - self._protocol.resume_writing() - except (SystemExit, KeyboardInterrupt): - raise - except BaseException as exc: - self._loop.call_exception_handler({ - 'message': 'protocol.resume_writing() failed', - 'exception': exc, - 'transport': self, - 'protocol': self._protocol, - }) - - cdef size_t _get_write_buffer_size(self): - return self._buffer_size - - def get_write_buffer_size(self): - return self._get_write_buffer_size() - - def _set_write_buffer_limits(self, high=None, low=None): - if high is None: - if low is None: - high = 64 * 1024 - else: - high = 4 * low - if low is None: - low = high // 4 - - if not high >= low >= 0: - raise ValueError('high ({}) must be >= low ({}) must be >= 0'.format(high, low)) - self._high_water = high - self._low_water = low - - def set_writer_buffer_limits(self, high=None, low=None): - self._set_write_buffer_limits(high, low) - self._maybe_pause_protocol() - - def get_writer_buffer_limits(self): - return (self._low_water, self._high_water) - - def pause_reading(self): - pass - - def resume_reading(self): - pass - - def is_closing(self): - return self._closing - - def close(self): - if self._closing == 1: - return - self._closing = 1 - - # stop reader event - self._stop_reading() - - # wait all data send out, timeout 60s - hv.hio_setcb_close(self._hio, on_hio_close) - hv.hio_close(self._hio) - - - def abort(self): - pass - - def _fatal_error(self, exc, message='Fatal error on transport'): - # Should be called from exception handler only. - if isinstance(exc, OSError): - pass - # if self._loop.get_debug(): - # logger.debug("%r: %s", self, message, exc_info=True) - else: - self._loop.call_exception_handler({ - 'message': message, - 'exception': exc, - 'transport': self, - 'protocol': self._protocol, - }) - self._force_close(exc) - - cdef _schedule_call_connection_lost(self, exc): - self._loop.call_soon(self._call_connection_lost, exc) - - def _force_close(self, exc): - if self._conn_lost: - return - # clear hio close cb - hv.hio_close(self._hio) - # self._loop._remove_writer(self._sock_fd) - if not self._closing: - self._closing = 1 - self._stop_reading() - self._conn_lost += 1 - self._schedule_call_connection_lost(exc) - - -cdef void on_hio_close(hv.hio_t* io) with gil: - cdef: - HVSocketTransport transport = (io).userdata - transport._schedule_call_connection_lost(None) - - -cdef void on_data_write(hv.hio_t* io, const void* buf, int writebytes) with gil: - cdef: - HVSocketTransport transport = (io).userdata - - transport._buffer_size -= writebytes - transport._maybe_resume_protocol() # May append to buffer. - if transport._buffer_size <= 0: - if transport._closing: - transport._call_connection_lost(None) - elif transport._eof: - hv.hio_close(io) - -cdef convert_sockaddr_to_pyaddr(hv.sockaddr* addr): - - cdef: - char buf[128] - hv.sockaddr_in *addr4 - hv.sockaddr_in6 *addr6 - - if addr.sa_family == hv.AF_INET: - addr4 = addr - - hv.sockaddr_str(addr4, buf, sizeof(buf)) - host, port = PyUnicode_FromString(buf).rsplit(':', 1) - return (host, int(port)) - elif addr.sa_family == hv.AF_INET6: - addr6 = addr - hv.sockaddr_str(addr6, buf, sizeof(buf)) - host, port = PyUnicode_FromString(buf).rsplit(':', 1) - return (host, port, hv.ntohl(addr6.sin6_flowinfo), addr6.sin6_scope_id) - - raise RuntimeError("cannot convert sockaddr into Python object") - - -@cython.no_gc_clear -cdef class DatagramTransport: - - def __cinit__(self, Loop loop, protocol, address=None, waiter=None, - extra=None): - self._loop = loop - self._protocol = None - self._address = address - self._waiter = waiter - self._extra_info = dict() - self._hio = NULL - self._eof = 0 - # no need buffer, use hio_write intern buf - self._buffer_size = 0 - - # flow control - self._high_water = 64 * 1024 - self._low_water = 64 // 4 - - self.set_protocol(protocol) - self._conn_lost = 0 - self._closing = 0 - - self._protocol_connected = 0 - self._protocol_paused = 0 - - def __repr__(self): - return '<{} closed=1 {:#x}>'.format( - self.__class__.__name__, - id(self) - ) - - def __dealloc__(self): - pass - - cdef inline _attach_fileobj(self, object file): - file._io_refs += 1 - self._fileobj = file - - cdef _init_hio(self, hv.hio_t* hio): - self._hio = hio - hv.hevent_set_userdata(self._hio, self) - - def get_extra_info(self, name, default=None): - return self._extra_info.get(name, default) - - - cdef _start_reading(self): - hv.hio_setcb_read(self._hio, on_recv2) - hv.hio_read(self._hio) - # hv.hio_set_readbuf(self._io, self.loop._recv_buf, 8192) - - cdef _stop_reading(self): - hv.hio_del(self._hio, hv.HV_READ) - - - cdef _on_connect(self): - # 填写 sockanme 和 peername - self._extra_info["sockname"] = convert_sockaddr_to_pyaddr(hv.hio_localaddr(self._hio)) - # self._extra_info["peername"] = convert_sockaddr_to_pyaddr(hv.hio_peeraddr(self._hio)) - self._loop.call_soon(self._call_connection_made) - - - def _call_connection_made(self): - self._protocol_connected = 1 - self._protocol.connection_made(self) - self._start_reading() - - if self._waiter is not None and not self._waiter.cancelled(): - self._waiter.set_result(None) - - - def _call_connection_lost(self, exc): - - try: - if self._protocol_connected: - self._protocol.connection_lost(exc) - finally: - self._protocol = None - # close socket - - - def sendto(self, object data, addr=None): - if not data: - return - if self._address: - if addr not in (None, self._address): - raise ValueError( - 'Invalid address: must be None or %s' % (self._address,) - ) - addr = None - - cdef: - void* buf - size_t blen - - buf = PyBytes_AS_STRING(data) - blen = Py_SIZE(data) - self._buffer_size += blen - n = hv.hio_write(self._hio, buf, blen) - if n < 0: - exc = Exception() - self._fatal_error(exc, "hio_write error code: %d" % n) - raise exc - else: - self._buffer_size -= n - aio_logger.info("send: %s, buf: %s", n, blen) - if self._buffer_size > 0: - # todo: add io_close_cb, check io send error? - hv.hio_setcb_write(self._hio, on_data_write2) - self._maybe_pause_protocol() - - def get_protocol(self): - return self._protocol - - def set_protocol(self, protocol): - self._protocol = protocol - - def write_eof(self): - self._eof = 1 - - def can_write_eof(self): - return True - - # flow control - cdef inline _maybe_pause_protocol(self): - cdef: - size_t size = self._get_write_buffer_size() - if size <= self._high_water: - return - - if not self._protocol_paused: - self._protocol_paused = 1 - try: - self._protocol.pause_writing() - except (SystemExit, KeyboardInterrupt): - raise - except BaseException as exc: - self._loop.call_exception_handler({ - 'message': 'protocol.pause_writing() failed', - 'exception': exc, - 'transport': self, - 'protocol': self._protocol, - }) - - cdef inline _maybe_resume_protocol(self): - cdef: - size_t size = self._get_write_buffer_size() - if (self._protocol_paused and - size <= self._low_water): - self._protocol_paused = 0 - try: - self._protocol.resume_writing() - except (SystemExit, KeyboardInterrupt): - raise - except BaseException as exc: - self._loop.call_exception_handler({ - 'message': 'protocol.resume_writing() failed', - 'exception': exc, - 'transport': self, - 'protocol': self._protocol, - }) - - cdef size_t _get_write_buffer_size(self): - return self._buffer_size - - def get_write_buffer_size(self): - return self._get_write_buffer_size() - - def _set_write_buffer_limits(self, high=None, low=None): - if high is None: - if low is None: - high = 64 * 1024 - else: - high = 4 * low - if low is None: - low = high // 4 - - if not high >= low >= 0: - raise ValueError('high ({}) must be >= low ({}) must be >= 0'.format(high, low)) - self._high_water = high - self._low_water = low - - def set_writer_buffer_limits(self, high=None, low=None): - self._set_write_buffer_limits(high, low) - self._maybe_pause_protocol() - - def get_writer_buffer_limits(self): - return (self._low_water, self._high_water) - - def pause_reading(self): - pass - - def resume_reading(self): - pass - - cdef _on_datagram_recv(self, void *buf, int n, object addr): - try: - py_bytes = ( buf)[:n] - self._protocol.datagram_received(py_bytes, addr) - except BaseException as exc: - self._fatal_error(exc) - - def is_closing(self): - return self._closing - - def close(self): - if self._closing == 1: - return - self._closing = 1 - - # stop reader event - self._stop_reading() - - # wait all data send out, timeout 60s - hv.hio_setcb_close(self._hio, on_hio_close2) - hv.hio_close(self._hio) - - - def abort(self): - pass - - def _fatal_error(self, exc, message='Fatal error on transport'): - # Should be called from exception handler only. - if isinstance(exc, OSError): - pass - # if self._loop.get_debug(): - # logger.debug("%r: %s", self, message, exc_info=True) - else: - self._loop.call_exception_handler({ - 'message': message, - 'exception': exc, - 'transport': self, - 'protocol': self._protocol, - }) - self._force_close(exc) - - cdef _schedule_call_connection_lost(self, exc): - self._loop.call_soon(self._call_connection_lost, exc) - - def _force_close(self, exc): - if self._conn_lost: - return - # clear hio close cb - hv.hio_close(self._hio) - # self._loop._remove_writer(self._sock_fd) - if not self._closing: - self._closing = 1 - self._stop_reading() - self._conn_lost += 1 - self._schedule_call_connection_lost(exc) - - -cdef void on_data_write2(hv.hio_t* io, const void* buf, int writebytes) with gil: - cdef: - DatagramTransport transport = (io).userdata - - transport._buffer_size -= writebytes - transport._maybe_resume_protocol() # May append to buffer. - if transport._buffer_size <= 0: - if transport._closing: - transport._call_connection_lost(None) - elif transport._eof: - hv.hio_close(io) - -cdef void on_recv2(hv.hio_t* io, void* buf, int readbytes) with gil: - cdef: - DatagramTransport transport = (io).userdata - object pyaddr - pyaddr = convert_sockaddr_to_pyaddr(hv.hio_peeraddr(io)) - transport._on_datagram_recv(buf, readbytes, pyaddr) - -cdef void on_hio_close2(hv.hio_t* io) with gil: - cdef: - DatagramTransport transport = (io).userdata - transport._schedule_call_connection_lost(None) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..f77636b --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,200 @@ +[build-system] +requires = [ + "scikit-build-core>=0.12.2", + "cython>=3.2.5", + "cython-cmake>=0.2.2", +] +build-backend = "scikit_build_core.build" + +[project] +name = "hvloop" +version = "0.2.0" +description = "asyncio event loop based on libhv" +requires-python = ">=3.10" +dependencies = [] +readme = "README.md" +license = {text = "MIT"} +authors = [ + {name = "xiispace", email = "xiispace@163.com"} +] +keywords = ["asyncio", "event-loop", "libhv", "network"] +classifiers = [ + "Development Status :: 3 - Alpha", + "Framework :: AsyncIO", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "License :: OSI Approved :: MIT License", + "Intended Audience :: Developers", + "Topic :: Software Development :: Libraries :: Python Modules", + "Topic :: System :: Networking", +] + +[project.optional-dependencies] +dev = [ + "pytest>=8.0", + "pytest-asyncio>=0.23", + "pytest-cov", + "pre-commit", + "black", + "ruff", + "mypy", + "build", # For building wheels/sdist +] +test = [ + "pytest>=8.0", + "pytest-asyncio>=0.23", + "pytest-cov", + # M3 ASGI acceptance suite (tests/test_asgi.py). httptools is optional: + # its HTTP path is covered too when installed, otherwise only h11 runs. + "fastapi", + "uvicorn", + "httpx", + "websockets", + "httptools", +] + +[project.urls] +Homepage = "https://github.com/xiispace/hvloop" +Repository = "https://github.com/xiispace/hvloop" +Documentation = "https://github.com/xiispace/hvloop#readme" + +[tool.scikit-build] +# Build optimization settings +build.verbose = true +# build-dir = "build/{wheel_tag}" + +# Parallel build configuration +#ninja.make-fallback = true + +# Caching configuration +editable.mode = "redirect" +install.strip = false + +# Keep the wheel lean: only the package (__init__.py + compiled _core) ships. +# Cython sources/headers are build-time inputs (present in the sdist), and +# libhv's own install artifacts are suppressed via EXCLUDE_FROM_ALL in +# CMakeLists.txt -- the excludes below are the second line of defense. +wheel.exclude = [ + "**.pyx", + "**.pxd", + "**.pxi", + "hvloop/hvloop_shim.h", + "include/**", + "lib/**", +] + +# Note: All CMake options (including libhv options) are configured in CMakeLists.txt + +# Source distribution configuration +# scikit-build-core automatically includes: README, LICENSE, pyproject.toml, etc. +sdist.include = [ + "src/hvloop/**/*.py", # Python files + "src/hvloop/**/*.pyx", # Cython implementation + "src/hvloop/**/*.pxd", # Cython definitions + "src/hvloop/**/*.pxi", # Cython includes + "src/hvloop/**/*.h", # C shims (hvloop_shim.h) + "vendor/libhv/**", # libhv source code (git submodule) + "tests/**/*.py", # test suite + "tests/certs/**", # committed TLS test certificates + + "CMakeLists.txt", # Build configuration + "Makefile", # Convenience targets +] +sdist.exclude = [ + "vendor/libhv/examples/**", + "vendor/libhv/unittest/**", + "vendor/libhv/echo-servers/**", + "vendor/libhv/evpp/**", + "vendor/libhv/docs/**", + "__pycache__", + "*.pyc", + ".DS_Store", +] + +# ---------------------------------------------------------------------------- +# cibuildwheel (M4 release pipeline, tech design section 11). +# Matrix: CPython 3.10-3.14 x {manylinux2014 x86_64/aarch64, musllinux x86_64, +# macOS arm64+x86_64, Windows AMD64}. The per-runner arch selection lives in +# .github/workflows/build.yml; everything version/image related lives here. +# ---------------------------------------------------------------------------- +[tool.cibuildwheel] +build = "cp310-* cp311-* cp312-* cp313-* cp314-*" +# Plan section 11 scope: no 32-bit, no PyPy, musllinux only on x86_64. +skip = "pp* *-win32 *_i686 *-musllinux_aarch64" +build-verbosity = 1 +# Wheel smoke tests: core suite only (pytest + pytest-asyncio). The optional +# ASGI/TLS-uvicorn integration tests importorskip their deps and skip cleanly +# here; the full [test] extra runs in the source-build CI job instead, keeping +# the 25-wheel matrix independent of fastapi/uvicorn/httptools wheel +# availability on every python/arch combination. +test-requires = ["pytest>=8.0", "pytest-asyncio>=0.23"] +test-command = "pytest {project}/tests -q" + +[tool.cibuildwheel.linux] +manylinux-x86_64-image = "manylinux2014" +manylinux-aarch64-image = "manylinux2014" + +[[tool.cibuildwheel.overrides]] +# The CentOS7-based manylinux2014 images are EOL and stopped growing new +# CPython versions; build the 3.14 wheels on manylinux_2_28 instead. +select = "cp314-*" +manylinux-x86_64-image = "manylinux_2_28" +manylinux-aarch64-image = "manylinux_2_28" + +[tool.black] +line-length = 88 +target-version = ['py310', 'py311', 'py312', 'py313'] + +[tool.ruff] +line-length = 88 +target-version = "py310" + +[tool.ruff.lint] +select = [ + "E", # pycodestyle errors + "W", # pycodestyle warnings + "F", # pyflakes + "I", # isort + "B", # flake8-bugbear + "C4", # flake8-comprehensions + "UP", # pyupgrade +] +ignore = [ + "E501", # line too long, handled by black + "B008", # do not perform function calls in argument defaults +] + +[tool.mypy] +python_version = "3.10" +warn_return_any = true +warn_unused_configs = true +ignore_missing_imports = true + +[tool.pytest.ini_options] +minversion = "8.0" +addopts = "-ra -q --strict-markers" +testpaths = ["tests"] +asyncio_mode = "auto" + +[tool.coverage.run] +source = ["src/hvloop"] +omit = [ + "*/tests/*", + "*/test_*", +] + +[tool.coverage.report] +exclude_lines = [ + "pragma: no cover", + "def __repr__", + "if self.debug:", + "if settings.DEBUG", + "raise AssertionError", + "raise NotImplementedError", + "if 0:", + "if __name__ == .__main__.:", +] diff --git a/requirements.dev.txt b/requirements.dev.txt deleted file mode 100644 index 002d1b9..0000000 --- a/requirements.dev.txt +++ /dev/null @@ -1 +0,0 @@ -Cython diff --git a/setup.py b/setup.py deleted file mode 100644 index c88bab1..0000000 --- a/setup.py +++ /dev/null @@ -1,99 +0,0 @@ -# coding:utf-8 -import os -import platform -import sys -import subprocess - -from setuptools.command.build_ext import build_ext -from distutils.core import setup, Extension - -from distutils import log as logger -import Cython -from Cython.Build import cythonize - -is_x64 = platform.architecture()[0] == '64bit' -is_win = sys.platform.startswith('win') -is_mac = sys.platform.startswith('darwin') -use_openssl = not (is_win or is_mac) - -LIBHV_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "vendor", "libhv")) - - -class hvloop_build_ext(build_ext): - - def build_libhv(self): - # cmake configure - cmake_args = [LIBHV_DIR, "-DCMAKE_POSITION_INDEPENDENT_CODE=ON"] - - if is_win: - cmake_args.append("-DCMAKE_GENERATOR_PLATFORM=x64") - cmake_args.append("-DCMAKE_GENERATOR_TOOLSET=host=x64") - - print(cmake_args) - - subprocess.check_call(["cmake"] + cmake_args, cwd=self.build_temp) - - # cmake build - subprocess.check_call([ - "cmake", "--build", ".", "--config", "Release", "--target", "libhv_static"], - cwd=self.build_temp) - - def build_extension(self, *args, **kwargs): - if not os.path.exists(self.build_temp): - os.makedirs(self.build_temp) - - build_dir = os.path.abspath(self.build_temp) - - self.build_libhv() - - if is_win: - libhv_lib = os.path.join(build_dir, "lib", "Release", "hv_static.lib") - else: - libhv_lib = os.path.join(build_dir, "lib", "libhv_static.a") - if not os.path.exists(libhv_lib): - raise RuntimeError("failed to build libhv") - self.extensions[-1].extra_objects.extend([libhv_lib]) - self.compiler.add_include_dir(os.path.join(build_dir, "include", "hv")) - - super().build_extension(*args, **kwargs) - - -ext_type = Extension( - "hvloop.loop", - sources=["hvloop/loop.pyx"], - language="c", - define_macros=[('HV_STATICLIB', '1'), ], -) - -with open("README.md", "r", encoding="utf-8") as f: - LONG_DESCRIPTION = f.read() - -setup( - name="hvloop", - version="0.0.2", - packages=['hvloop'], - license="MIT License", - author="xiispace", - author_email="xiispace@163.com", - description="asyncio event loop base on libhv", - long_description=LONG_DESCRIPTION, - long_description_content_type="text/markdown", - url="https://github.com/xiispace/hvloop", - classifiers=[ - 'Development Status :: 1 - Planning', - 'Framework :: AsyncIO', - 'Programming Language :: Python :: 3 :: Only', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'License :: OSI Approved :: Apache Software License', - 'License :: OSI Approved :: MIT License', - 'Intended Audience :: Developers', - ], - cmdclass={ - "build_ext": hvloop_build_ext - }, - python_requires=">=3.6", - include_package_data=True, - ext_modules=cythonize([ext_type], compiler_directives={'language_level': "3"}) -) diff --git a/src/hvloop/__init__.py b/src/hvloop/__init__.py new file mode 100644 index 0000000..b280a96 --- /dev/null +++ b/src/hvloop/__init__.py @@ -0,0 +1,137 @@ +"""hvloop: an asyncio-compatible event loop backed by libhv. + +Public API (M1): + + import hvloop + + hvloop.install() # set hvloop as the default policy + loop = hvloop.new_event_loop() # construct a Loop directly + hvloop.run(main()) # run a coroutine to completion +""" + +from __future__ import annotations + +import asyncio as _asyncio +import sys as _sys +import typing as _typing + +from ._core import Loop as _CoreLoop + +__all__ = ( + "Loop", + "EventLoopPolicy", + "new_event_loop", + "install", + "uninstall", + "run", +) + +__version__ = "0.2.0" + + +class Loop(_CoreLoop, _asyncio.AbstractEventLoop): + """The hvloop event loop. + + ``_core.Loop`` is a Cython ``cdef class`` and cannot directly inherit from + the pure-Python ``AbstractEventLoop`` ABC, so we compose them here (the + same pattern uvloop uses). The concrete C methods satisfy the abstract + interface; ABCMeta's ``__subclasshook__`` accepts the subclass because all + abstract methods are provided. + """ + + +def new_event_loop() -> Loop: + """Create and return a new hvloop event loop.""" + return Loop() + + +class EventLoopPolicy(_asyncio.DefaultEventLoopPolicy): + """An event loop policy whose ``new_event_loop`` returns an hvloop Loop. + + Mirrors uvloop.EventLoopPolicy: only the loop factory changes; child + watcher / loop bookkeeping is inherited from the default policy. + """ + + def _loop_factory(self) -> Loop: # type: ignore[override] + return new_event_loop() + + if _typing.TYPE_CHECKING: + # The base class declares these; keep type checkers happy without + # changing runtime behavior. + def get_event_loop(self) -> Loop: ... + + def new_event_loop(self) -> Loop: ... + + +def install() -> None: + """Set hvloop as the global asyncio event loop policy. + + Equivalent to ``asyncio.set_event_loop_policy(hvloop.EventLoopPolicy())``. + """ + _asyncio.set_event_loop_policy(EventLoopPolicy()) + + +def uninstall() -> None: + """Restore the default asyncio event loop policy.""" + _asyncio.set_event_loop_policy(None) + + +def run(main, *, debug: bool | None = None, loop_factory=None): + """Run a coroutine on a fresh hvloop event loop, then clean up. + + On Python 3.11+ this delegates to ``asyncio.Runner(loop_factory=...)`` so + that ``run_until_complete``, ``shutdown_asyncgens`` and + ``shutdown_default_executor`` semantics match the stdlib exactly. On 3.10 + a hand-rolled equivalent is used. + """ + if not _asyncio.iscoroutine(main): + raise ValueError(f"a coroutine was expected, got {main!r}") + + if loop_factory is None: + loop_factory = new_event_loop + + if _sys.version_info >= (3, 11): + with _asyncio.Runner(debug=debug, loop_factory=loop_factory) as runner: + return runner.run(main) + + # Python 3.10 fallback: replicate asyncio.run() against our loop factory. + if _asyncio.events._get_running_loop() is not None: + raise RuntimeError( + "hvloop.run() cannot be called from a running event loop" + ) + loop = loop_factory() + try: + _asyncio.set_event_loop(loop) + if debug is not None: + loop.set_debug(debug) + return loop.run_until_complete(main) + finally: + try: + _cancel_all_tasks(loop) + loop.run_until_complete(loop.shutdown_asyncgens()) + loop.run_until_complete(loop.shutdown_default_executor()) + finally: + _asyncio.set_event_loop(None) + loop.close() + + +def _cancel_all_tasks(loop) -> None: + to_cancel = _asyncio.all_tasks(loop) + if not to_cancel: + return + for task in to_cancel: + task.cancel() + loop.run_until_complete( + _asyncio.gather(*to_cancel, return_exceptions=True) + ) + for task in to_cancel: + if task.cancelled(): + continue + if task.exception() is not None: + loop.call_exception_handler( + { + "message": "unhandled exception during hvloop.run() shutdown", + "exception": task.exception(), + "task": task, + } + ) diff --git a/src/hvloop/_core.pyx b/src/hvloop/_core.pyx new file mode 100644 index 0000000..13803ae --- /dev/null +++ b/src/hvloop/_core.pyx @@ -0,0 +1,3028 @@ +# cython: language_level=3, embedsignature=True, binding=True +# +# hvloop M1 core: a self-driven asyncio-compatible event loop on top of +# libhv's hloop_process_events. See docs/plans/2026-06-13-hvloop-tech-design.md +# (sections 4 and 5, milestone M1). +# +# Design highlights (see plan section 4): +# * We do NOT use hloop_run. run_forever() drives the loop itself: each turn +# it runs a snapshot of the _ready deque, then calls hloop_process_events +# with timeout 0 (ready non-empty) or a large cap (idle). hloop_process_events +# internally clamps the poll to the nearest htimer, so timers need no manual +# timeout math. +# * Before entering the loop we force-create the wakeup eventfd via +# hloop_wakeup(); otherwise libhv would sleep in an un-wakeable hv_msleep +# when nios == 0, and call_soon_threadsafe could not interrupt it. +# * hloop_new(0): explicitly pass 0 so HLOOP_FLAG_AUTO_FREE is NOT set +# (the C default would double-free against our hloop_free in close()). +# * All libhv C callbacks are ``noexcept nogil`` and re-acquire the GIL with +# ``with gil``; their bodies are wrapped in try/except so no Python +# exception ever propagates back into C. + +import asyncio +import collections +import collections.abc +import concurrent.futures +import errno as errno_module +import os +import signal as signal_module +import socket as socket_module +import sys +import threading +import traceback + +cimport cython +from libc.math cimport ceil as libc_ceil +from libc.stdint cimport uint32_t, uint64_t +from libc.string cimport memset, memcpy +from cpython.object cimport PyObject +from cpython.ref cimport Py_INCREF, Py_DECREF +from cpython.buffer cimport (PyObject_GetBuffer, PyBuffer_Release, + PyBUF_WRITABLE) +from cpython.bytes cimport (PyBytes_FromStringAndSize, PyBytes_AS_STRING, + PyBytes_GET_SIZE) + +from .includes cimport hv +from .includes.python cimport PY_VERSION_HEX + +# Forward declarations: Loop's create_connection/create_server reference these +# extension types, which are defined further down in this file (single +# compilation unit, plan section 3.1). +cdef class TCPTransport +cdef class Server +cdef class _TCPListener +cdef class _FDWatcher + + +# --------------------------------------------------------------------------- +# Module-level aliases (avoid repeated attribute lookups on hot paths). +# --------------------------------------------------------------------------- +cdef object aio_Future = asyncio.Future +cdef object aio_Task = asyncio.Task +cdef object aio_ensure_future = asyncio.ensure_future +cdef object aio_isfuture = asyncio.isfuture +cdef object aio_iscoroutine = asyncio.iscoroutine +cdef object aio_set_running_loop = asyncio._set_running_loop +cdef object col_deque = collections.deque + +# A "very large" poll cap (ms). hloop_process_events clamps this to the next +# htimer anyway, so when there are timers we still wake on time; when there are +# none we block here until a wakeup eventfd write arrives. ~1 day. +cdef int _MAX_BLOCK_MS = 86400000 + +# Python version gate for create_task(context=...) (3.11+). +cdef int _PY311 = PY_VERSION_HEX >= 0x030b0000 + +# ----- TCP transport constants (plan section 6) ---------------------------- +# Default write flow-control watermarks, matching asyncio's +# FlowControlMixin._set_write_buffer_limits defaults. +cdef size_t _FLOW_CONTROL_HIGH_WATER = 64 * 1024 +# Mirrors asyncio.constants.LOG_THRESHOLD_FOR_CONNLOST_WRITES. +cdef int _LOG_THRESHOLD_FOR_CONNLOST_WRITES = 5 +# asyncio has no implicit connect timeout (the OS decides); suppress libhv's +# 10s HIO_DEFAULT_CONNECT_TIMEOUT with a ~24-day cap instead. +cdef int _HV_CONNECT_TIMEOUT_MS = 0x7fffffff +cdef int _ECONNABORTED = errno_module.ECONNABORTED +cdef int _AF_INET = socket_module.AF_INET +cdef int _AF_INET6 = socket_module.AF_INET6 + +# M2b: signal handling is Unix-only (plan section 9). Runtime check rather +# than conditional compilation so the code paths stay compiled everywhere. +cdef bint _IS_WINDOWS = sys.platform == 'win32' + + +# =========================================================================== +# Handles +# =========================================================================== +@cython.no_gc_clear +cdef class Handle: + """A callback scheduled via call_soon / call_soon_threadsafe. + + Mirrors asyncio.Handle's public surface closely enough for asyncio's + internals (e.g. Task step scheduling) to use it. + """ + cdef: + object _callback + tuple _args + Loop _loop + object _context + bint _cancelled + bint _repeat # persistent handle: _run keeps callback/args + object __weakref__ + + def __cinit__(self, object callback, tuple args, Loop loop, object context): + self._callback = callback + self._args = args + self._loop = loop + self._cancelled = False + self._repeat = False + if context is None: + context = copy_context() + self._context = context + + def cancel(self): + if not self._cancelled: + self._cancelled = True + self._callback = None + self._args = None + + def cancelled(self): + return self._cancelled + + def __repr__(self): + info = ['Handle'] + if self._cancelled: + info.append('cancelled') + if self._callback is not None: + info.append(_format_callback(self._callback, self._args)) + return '<' + ' '.join(info) + '>' + + cdef _run(self): + if self._cancelled: + return + cdef object cb = self._callback + cdef tuple args = self._args + if cb is None: + return + if not self._repeat: + # Drop references early (asyncio does the same) so the callback + # can be garbage collected promptly after running. Repeat handles + # (add_reader/add_writer/add_signal_handler slots, M2b) keep + # theirs: the same Handle runs once per readiness event / signal + # delivery until cancelled. + self._callback = None + self._args = None + try: + if args is not None: + self._context.run(cb, *args) + else: + self._context.run(cb) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as exc: + cb_repr = _format_callback(cb, args) + self._loop.call_exception_handler({ + 'message': 'Exception in callback {}'.format(cb_repr), + 'exception': exc, + 'handle': self, + }) + + +cdef void _on_timer(hv.htimer_t* timer) noexcept nogil: + # libhv invokes this from hloop_process_events with the GIL released. + with gil: + _timer_dispatch(timer) + + +cdef inline void _timer_dispatch(hv.htimer_t* timer): + cdef TimerHandle handle + cdef Loop loop + cdef void* udata = (timer).userdata + if udata == NULL: + return + handle = udata + loop = handle._loop + # repeat=1 timers are auto-destroyed by libhv AFTER this callback returns + # (hloop_process_pendings frees events flagged destroy). So from our side + # the htimer_t* is no longer valid once we return: mark it gone now. + handle._timer = NULL + # Drop from the loop's live-timer set: this path is mutually exclusive with + # cancel() (which removes there) and close() (which never runs while we are + # mid-poll), so the registration DECREF below happens exactly once. + loop._timer_handles.discard(handle) + try: + try: + handle._run() + except BaseException as exc: + # uvloop-style pending-exception pump: a KeyboardInterrupt / + # SystemExit raised by the callback would otherwise be swallowed by + # the ``noexcept`` _on_timer frame ("Exception ignored ..."). Stash + # it on the loop and stop the poll; run_forever re-raises it after + # hloop_process_events returns, so it propagates out of + # run_forever()/run_until_complete() per the asyncio contract. + # (Plain Exceptions are already routed to call_exception_handler by + # handle._run(); only KI/SE re-raise out of _run.) + loop._pending_exc = exc + if loop.hvloop is not NULL: + hv.hloop_stop(loop.hvloop) + finally: + # Release the registration reference taken in __cinit__. + Py_DECREF(handle) + + +@cython.no_gc_clear +@cython.freelist(64) +cdef class TimerHandle: + """A callback scheduled via call_later / call_at, backed by an htimer_t.""" + cdef: + object _callback + tuple _args + Loop _loop + object _context + bint _cancelled + hv.htimer_t* _timer + double _when + object __weakref__ + + def __cinit__(self, Loop loop, object callback, tuple args, + uint32_t delay_ms, double when, object context): + self._loop = loop + self._callback = callback + self._args = args + self._cancelled = False + self._when = when + self._timer = NULL + if context is None: + context = copy_context() + self._context = context + + if delay_ms == 0: + # libhv's htimer_add rejects a 0ms timeout. Per the plan, a + # non-positive delay schedules on the next loop turn via the ready + # queue while still returning a cancellable TimerHandle. + loop._ready.append(self) + return + + self._timer = hv.htimer_add(loop.hvloop, _on_timer, delay_ms, 1) + if self._timer is NULL: + raise RuntimeError('htimer_add failed') + hv.hevent_set_userdata(self._timer, self) + # Keep this handle alive while the timer is registered with libhv, and + # track it on the loop so close() can tear down un-fired timers (which + # libhv frees in hloop_free without invoking our callback) — otherwise + # the registration reference below would leak and a post-close cancel() + # would call htimer_del on a freed htimer_t* (use-after-free). + Py_INCREF(self) + loop._timer_handles.add(self) + + def __dealloc__(self): + # If we still own a live timer here something leaked a reference; the + # registration INCREF should have prevented dealloc while _timer != NULL. + pass + + def cancel(self): + if self._cancelled: + return + self._cancelled = True + self._callback = None + self._args = None + cdef hv.htimer_t* t = self._timer + if t is not NULL: + self._timer = NULL + hv.htimer_del(t) + # Drop from the loop's live-timer set and release the registration + # reference (mirrors _timer_dispatch). close() may have already + # torn this timer down (self._timer set to NULL there), in which + # case t is NULL and we do nothing — no double DECREF. + self._loop._timer_handles.discard(self) + Py_DECREF(self) + + def cancelled(self): + return self._cancelled + + def when(self): + return self._when + + def __repr__(self): + info = ['TimerHandle'] + if self._cancelled: + info.append('cancelled') + if self._callback is not None: + info.append(_format_callback(self._callback, self._args)) + info.append('when={!r}'.format(self._when)) + return '<' + ' '.join(info) + '>' + + cdef _run(self): + if self._cancelled: + return + cdef object cb = self._callback + cdef tuple args = self._args + self._callback = None + self._args = None + if cb is None: + return + try: + if args is not None: + self._context.run(cb, *args) + else: + self._context.run(cb) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as exc: + cb_repr = _format_callback(cb, args) + self._loop.call_exception_handler({ + 'message': 'Exception in callback {}'.format(cb_repr), + 'exception': exc, + 'handle': self, + }) + + +# =========================================================================== +# The Loop +# =========================================================================== +@cython.no_gc_clear +cdef class Loop: + """asyncio-compatible event loop driven by libhv's hloop_process_events.""" + + cdef: + hv.hloop_t* hvloop + object _ready # collections.deque[Handle] + set _timer_handles # live TimerHandles backed by an htimer_t + set _hio_objs # live hio wrappers (TCPTransport/_TCPListener/_FDWatcher) + dict _fd_watchers # {int fd: _FDWatcher} (add_reader/add_writer, M2b) + dict _signal_handlers # {int signum: Handle} (add_signal_handler, M2b) + object _signal_ssock # signal wakeup socketpair read end (loop-owned) + object _signal_csock # ... write end, installed via set_wakeup_fd + object _pending_exc # KI/SE raised inside a libhv C timer callback + bint _stopping + bint _closed + long _thread_id + bint _debug + object _exception_handler + object _default_executor + bint _executor_shutdown_called + object _task_factory + object _asyncgens # weakref.WeakSet of running async generators + bint _asyncgens_shutdown_called + bint _coroutine_origin_tracking_enabled + object _coroutine_origin_tracking_saved_depth + double _last_time # loop.time() snapshot taken at close() + dict __dict__ + object __weakref__ + + def __cinit__(self): + self.hvloop = hv.hloop_new(0) # explicit 0: no HLOOP_FLAG_AUTO_FREE + if self.hvloop is NULL: + raise RuntimeError('hloop_new failed') + self._ready = col_deque() + self._timer_handles = set() + self._hio_objs = set() + self._fd_watchers = {} + self._signal_handlers = {} + self._signal_ssock = None + self._signal_csock = None + self._pending_exc = None + self._stopping = False + self._closed = False + self._thread_id = 0 + self._debug = bool(sys.flags.dev_mode) + self._exception_handler = None + self._default_executor = None + self._executor_shutdown_called = False + self._task_factory = None + self._asyncgens = _weakset() + self._asyncgens_shutdown_called = False + self._coroutine_origin_tracking_enabled = False + self._coroutine_origin_tracking_saved_depth = None + self._last_time = 0.0 + + def __dealloc__(self): + if self.hvloop is not NULL: + hv.hloop_free(&self.hvloop) + self.hvloop = NULL + + def __repr__(self): + return '<{} running={} closed={} debug={}>'.format( + type(self).__name__, self.is_running(), self.is_closed(), + self.get_debug()) + + # ----- internal helpers ---------------------------------------------- + cdef inline _check_closed(self): + if self._closed: + raise RuntimeError('Event loop is closed') + + cdef inline _check_running(self): + if self.is_running(): + raise RuntimeError('This event loop is already running') + if aio_get_running_loop() is not None: + raise RuntimeError( + 'Cannot run the event loop while another loop is running') + + cdef inline _post_wakeup(self): + # Force/refresh the wakeup eventfd and interrupt any in-progress poll. + hv.hloop_wakeup(self.hvloop) + + cdef _run_ready(self): + # Run a snapshot of the ready queue; callbacks scheduled during this + # turn stay queued for the next turn (prevents starvation), matching + # asyncio.BaseEventLoop._run_once. The queue holds Handle (call_soon) + # and occasionally TimerHandle (call_later/call_at with delay <= 0). + cdef object ready = self._ready + cdef Py_ssize_t ntodo = len(ready) + cdef Py_ssize_t i + cdef object item + for i in range(ntodo): + item = ready.popleft() + if type(item) is Handle: + (item)._run() + else: + (item)._run() + + # ----- lifecycle ------------------------------------------------------ + def run_forever(self): + self._check_closed() + self._check_running() + + cdef int timeout_ms + old_agen_hooks = sys.get_asyncgen_hooks() + self._set_coroutine_origin_tracking(self._debug) + try: + self._thread_id = threading.get_ident() + sys.set_asyncgen_hooks( + firstiter=self._asyncgen_firstiter_hook, + finalizer=self._asyncgen_finalizer_hook) + aio_set_running_loop(self) + + # Plan section 4.2: create the wakeup eventfd BEFORE blocking, so a + # cross-thread call_soon_threadsafe can interrupt the very first poll. + self._post_wakeup() + + # We self-drive via hloop_process_events instead of hloop_run, so + # libhv never moves the loop out of its initial HLOOP_STATUS_STOP. + # In that state hloop_process_events returns right after the poll + # (hloop.c:170) and skips hloop_process_pendings, so IO callbacks + # (including the wakeup-fd reader that drains the eventfd) never + # run and the loop busy-spins. Mirror hloop_run: mark RUNNING here, + # and STOP again in the finally below. A KeyboardInterrupt/SystemExit + # path (_timer_dispatch -> hloop_stop) flips status back to STOP to + # break out promptly; re-entering run_forever() re-arms RUNNING here. + hv.hvloop_set_status_running(self.hvloop) + + while True: + self._run_ready() + if self._stopping: + break + if len(self._ready): + timeout_ms = 0 + else: + timeout_ms = _MAX_BLOCK_MS + with nogil: + hv.hloop_process_events(self.hvloop, timeout_ms) + # A timer callback running inside the poll above may have raised + # KeyboardInterrupt/SystemExit; _timer_dispatch stashes it here + # (it cannot propagate through the noexcept C callback frame). + # Re-raise so it leaves run_forever()/run_until_complete(). + if self._pending_exc is not None: + exc = self._pending_exc + self._pending_exc = None + raise exc + finally: + # Mirror hloop_run's exit: return the loop to STOP. Guard NULL in + # case close() (or a teardown path) already freed the loop. + if self.hvloop is not NULL: + hv.hvloop_set_status_stop(self.hvloop) + self._stopping = False + self._pending_exc = None + self._thread_id = 0 + aio_set_running_loop(None) + self._set_coroutine_origin_tracking(False) + sys.set_asyncgen_hooks(*old_agen_hooks) + + def run_until_complete(self, future): + self._check_closed() + self._check_running() + + new_task = not aio_isfuture(future) + future = aio_ensure_future(future, loop=self) + if new_task: + # The caller did not pass a Future/Task; if it raises we don't want + # an "exception never retrieved" warning. + future._log_destroy_pending = False + + future.add_done_callback(_run_until_complete_cb) + try: + self.run_forever() + except BaseException: + if new_task and future.done() and not future.cancelled(): + future.exception() + raise + finally: + future.remove_done_callback(_run_until_complete_cb) + if not future.done(): + raise RuntimeError('Event loop stopped before Future completed.') + return future.result() + + def stop(self): + self._stopping = True + # If stop() is called from another thread, wake the poll so the loop + # body re-checks _stopping promptly. + if self.hvloop is not NULL: + self._post_wakeup() + + def is_running(self): + return self._thread_id != 0 + + def is_closed(self): + return self._closed + + def close(self): + if self.is_running(): + raise RuntimeError('Cannot close a running event loop') + if self._closed: + return + self._closed = True + # Snapshot the clock so time() keeps returning a sane monotonic value + # after close instead of jumping back to 0.0 (see time()). + if self.hvloop is not NULL: + hv.hloop_update_time(self.hvloop) + self._last_time = hv.hloop_now_us(self.hvloop) / 1e6 + self._ready.clear() + # Tear down every still-registered htimer's TimerHandle BEFORE + # hloop_free. libhv frees the htimer_t* structs in hloop_free without + # invoking our _on_timer callback, so without this each un-fired timer + # would leak its registration reference (callback/args kept alive) and a + # later handle.cancel() would call htimer_del on freed memory. We null + # each handle's _timer first so a subsequent cancel() takes its t==NULL + # branch (no htimer_del, no second DECREF). This path is mutually + # exclusive with _timer_dispatch (loop not running) and cancel(). + cdef TimerHandle th + if self._timer_handles: + handles = list(self._timer_handles) + self._timer_handles.clear() + for th in handles: + th._timer = NULL + th._cancelled = True + th._callback = None + th._args = None + Py_DECREF(th) + # M2b signal teardown: unregister every signal handler (restoring the + # default dispositions, asyncio semantics), restore set_wakeup_fd(-1) + # (only if the installed wakeup fd is still our write end) and close + # both ends of the socketpair -- the pair is loop-owned. This runs + # BEFORE the _hio_objs teardown so the pair's read-end watcher is + # deregistered from the iowatcher while its fd is still open. + if self._signal_handlers and not sys.is_finalizing(): + for sig in list(self._signal_handlers): + try: + self.remove_signal_handler(sig) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as sig_exc: + self.call_exception_handler({ + 'message': 'error while removing signal handler {} ' + 'during loop.close()'.format(sig), + 'exception': sig_exc, + }) + self._teardown_signal_wakeup() + # Tear down every still-open hio wrapper (transports / server + # listeners / fd watchers) BEFORE hloop_free. Each teardown nulls the + # wrapper's hio_t* pointer, clears the C callbacks/context so + # hloop_free's own hio_close path cannot re-enter Python, releases the + # registration reference exactly once, and (for caller-owned fds: + # create_server(sock=..) listeners and add_reader/add_writer watchers) + # detaches the hio so the caller's fd is NOT closed. Self-owned + # fds are closed by hloop_free (hio_free -> hio_close -> closesocket). + # This path is mutually exclusive with the C close-callback dispatch + # (the loop is not running) and with Server.close()/transport.close() + # afterwards (they see a NULL hio and return safely). + if self._hio_objs: + objs = list(self._hio_objs) + self._hio_objs.clear() + for obj in objs: + try: + obj._loop_close_teardown() + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as teardown_exc: + self.call_exception_handler({ + 'message': 'error while tearing down a transport ' + 'during loop.close()', + 'exception': teardown_exc, + }) + if self._default_executor is not None: + executor = self._default_executor + self._default_executor = None + executor.shutdown(wait=False) + if self.hvloop is not NULL: + hv.hloop_free(&self.hvloop) + self.hvloop = NULL + + def __enter__(self): + return self + + def __exit__(self, *exc): + self.close() + + # ----- time ----------------------------------------------------------- + def time(self): + if self.hvloop is NULL: + # After close() the libhv loop is gone; return the monotonic value + # captured at close() rather than jumping back to 0.0, so time() + # never appears to run backwards across close. + return self._last_time + hv.hloop_update_time(self.hvloop) + return hv.hloop_now_us(self.hvloop) / 1e6 + + # ----- scheduling ----------------------------------------------------- + def call_soon(self, callback, *args, context=None): + self._check_closed() + if self._debug: + self._check_callback(callback, 'call_soon') + self._check_thread() + return self._call_soon(callback, args, context) + + cdef Handle _call_soon(self, object callback, tuple args, object context): + cdef Handle handle = Handle(callback, args, self, context) + self._ready.append(handle) + return handle + + def call_soon_threadsafe(self, callback, *args, context=None): + self._check_closed() + if self._debug: + self._check_callback(callback, 'call_soon_threadsafe') + cdef Handle handle = Handle(callback, args, self, context) + # deque.append is atomic under the GIL; safe from any thread. + self._ready.append(handle) + # Interrupt the loop's poll (plan section 4.4). + if self.hvloop is not NULL: + self._post_wakeup() + return handle + + def call_later(self, delay, callback, *args, context=None): + self._check_closed() + if self._debug: + self._check_callback(callback, 'call_later') + self._check_thread() + if delay is None: + raise TypeError('delay must not be None') + when = self.time() + delay + return self._call_at(when, delay, callback, args, context) + + def call_at(self, when, callback, *args, context=None): + self._check_closed() + if self._debug: + self._check_callback(callback, 'call_at') + self._check_thread() + if when is None: + raise TypeError('when must not be None') + delay = when - self.time() + return self._call_at(when, delay, callback, args, context) + + cdef object _call_at(self, double when, double delay, + object callback, tuple args, object context): + cdef uint32_t delay_ms + cdef double delay_ms_d + if delay <= 0: + # Non-positive delay: run on the next loop turn. TimerHandle handles + # delay_ms == 0 by enqueueing itself on the ready queue (libhv's + # htimer_add rejects 0ms anyway), while still returning a + # cancellable TimerHandle per the asyncio contract. + delay_ms = 0 + else: + # Round UP (ceil), not nearest: asyncio forbids running a callback + # before its ``when``. Nearest rounding (e.g. 10.4ms -> 10ms) could + # fire ~0.4ms early; ceil guarantees the htimer fires at or after + # ``when``. The precision tests assert actual run time >= when. + delay_ms_d = libc_ceil(delay * 1000.0) + # Clamp before the uint32_t cast: a huge delay (e.g. 1e9 s) overflows + # uint32 and the C cast is undefined behaviour. libhv's htimer caps + # out around 0xffffffff ms (~49.7 days), which is far longer than any + # real timeout, so clamping to 0xfffffffe is harmless. + if delay_ms_d >= 0xfffffffe: + delay_ms = 0xfffffffe + else: + delay_ms = delay_ms_d + if delay_ms == 0: + # ceil() of a tiny-but-positive delay can still be 0 only if + # delay*1000 == 0 exactly, which delay > 0 already excludes; + # guard anyway so a positive delay never degrades to "next turn". + delay_ms = 1 + return TimerHandle(self, callback, args, delay_ms, when, context) + + def create_future(self): + return aio_Future(loop=self) + + def create_task(self, coro, *, name=None, context=None): + self._check_closed() + if self._task_factory is None: + if _PY311: + task = aio_Task(coro, loop=self, name=name, context=context) + else: + if context is not None: + raise TypeError( + "'context' is only supported on Python 3.11+") + task = aio_Task(coro, loop=self, name=name) + if task._source_traceback: + del task._source_traceback[-1] + else: + if _PY311 and context is not None: + task = self._task_factory(self, coro, context=context) + else: + task = self._task_factory(self, coro) + try: + task.set_name(name) + except AttributeError: + pass + return task + + def set_task_factory(self, factory): + if factory is not None and not callable(factory): + raise TypeError('task factory must be a callable or None') + self._task_factory = factory + + def get_task_factory(self): + return self._task_factory + + # ----- executor / DNS ------------------------------------------------- + def run_in_executor(self, executor, func, *args): + self._check_closed() + if self._debug: + self._check_callback(func, 'run_in_executor') + if executor is None: + executor = self._default_executor + if executor is None: + if self._executor_shutdown_called: + raise RuntimeError('Executor shutdown has been called') + executor = concurrent.futures.ThreadPoolExecutor( + thread_name_prefix='hvloop') + self._default_executor = executor + return asyncio.futures.wrap_future( + executor.submit(func, *args), loop=self) + + def set_default_executor(self, executor): + if not isinstance(executor, concurrent.futures.ThreadPoolExecutor): + raise TypeError( + 'executor must be ThreadPoolExecutor instance') + self._default_executor = executor + + async def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, + flags=0): + getaddr_func = socket_module.getaddrinfo + return await self.run_in_executor( + None, getaddr_func, host, port, family, type, proto, flags) + + async def getnameinfo(self, sockaddr, flags=0): + return await self.run_in_executor( + None, socket_module.getnameinfo, sockaddr, flags) + + # ----- sock_* low-level socket operations (plan section 5, M4) ---------- + # + # Implemented on top of the M2b add_reader/add_writer machinery with the + # semantics of asyncio's *selector* event loop: the socket must be + # non-blocking (validated in debug mode, exactly like asyncio), the fd + # stays owned by the caller, and each pending operation registers a + # temporary reader/writer that is removed when its future completes + # (including cancellation). + # + # CONSTRAINTS (documented, not enforced -- same as add_reader/add_writer, + # see the fd-watching section): a socket used with sock_* must not + # simultaneously (a) be owned by a transport/server listener of this + # loop, or (b) carry a user add_reader/add_writer registration in the + # same direction -- the sock_* operation and the user callback would + # replace each other's registration (asyncio's selector loop raises for + # case (a) and silently replaces in case (b); we document both). Also + # note libhv flips watched socket fds to non-blocking mode. + + async def sock_recv(self, sock, n): + """Receive up to ``n`` bytes from ``sock`` (a non-blocking socket).""" + _check_ssl_socket(sock) + if self._debug and sock.gettimeout() != 0: + raise ValueError('the socket must be non-blocking') + try: + return sock.recv(n) + except (BlockingIOError, InterruptedError): + pass + fut = self.create_future() + fd = sock.fileno() + self.add_reader(fd, self._sock_recv_cb, fut, sock, n) + fut.add_done_callback(lambda f: self.remove_reader(fd)) + return await fut + + def _sock_recv_cb(self, fut, sock, n): + if fut.done(): + return + try: + data = sock.recv(n) + except (BlockingIOError, InterruptedError): + return # spurious readiness; wait for the next event + except (SystemExit, KeyboardInterrupt): + raise + except BaseException as exc: + fut.set_exception(exc) + else: + fut.set_result(data) + + async def sock_recv_into(self, sock, buf): + """Receive into ``buf``; returns the number of bytes received.""" + _check_ssl_socket(sock) + if self._debug and sock.gettimeout() != 0: + raise ValueError('the socket must be non-blocking') + try: + return sock.recv_into(buf) + except (BlockingIOError, InterruptedError): + pass + fut = self.create_future() + fd = sock.fileno() + self.add_reader(fd, self._sock_recv_into_cb, fut, sock, buf) + fut.add_done_callback(lambda f: self.remove_reader(fd)) + return await fut + + def _sock_recv_into_cb(self, fut, sock, buf): + if fut.done(): + return + try: + nbytes = sock.recv_into(buf) + except (BlockingIOError, InterruptedError): + return + except (SystemExit, KeyboardInterrupt): + raise + except BaseException as exc: + fut.set_exception(exc) + else: + fut.set_result(nbytes) + + async def sock_sendall(self, sock, data): + """Send ``data`` to ``sock``, retrying until everything is sent.""" + _check_ssl_socket(sock) + if self._debug and sock.gettimeout() != 0: + raise ValueError('the socket must be non-blocking') + try: + n = sock.send(data) + except (BlockingIOError, InterruptedError): + n = 0 + if n == len(data): + # Common case: everything went out in one non-blocking send. + return + fut = self.create_future() + fd = sock.fileno() + # pos is a 1-element list so the writer callback can advance it. + pos = [n] + self.add_writer(fd, self._sock_sendall_cb, fut, sock, + memoryview(data), pos) + fut.add_done_callback(lambda f: self.remove_writer(fd)) + return await fut + + def _sock_sendall_cb(self, fut, sock, view, pos): + if fut.done(): + return + start = pos[0] + try: + n = sock.send(view[start:]) + except (BlockingIOError, InterruptedError): + return + except (SystemExit, KeyboardInterrupt): + raise + except BaseException as exc: + fut.set_exception(exc) + return + start += n + if start == len(view): + fut.set_result(None) + else: + pos[0] = start + + async def sock_connect(self, sock, address): + """Connect ``sock`` (non-blocking) to ``address``.""" + _check_ssl_socket(sock) + if self._debug and sock.gettimeout() != 0: + raise ValueError('the socket must be non-blocking') + if (sock.family == _AF_INET or sock.family == _AF_INET6): + # Resolve the address first (asyncio's _ensure_resolved: + # numeric fast path, else getaddrinfo in the executor). + address = await self._sock_resolve(sock, address) + fut = self.create_future() + fd = sock.fileno() + try: + sock.connect(address) + except (BlockingIOError, InterruptedError): + # Connect in progress: the fd turns writable when it completes + # (level-triggered wepoll/epoll/kqueue all report this). + self.add_writer(fd, self._sock_connect_cb, fut, sock, address) + fut.add_done_callback(lambda f: self.remove_writer(fd)) + except (SystemExit, KeyboardInterrupt): + raise + except BaseException as exc: + fut.set_exception(exc) + else: + fut.set_result(None) + return await fut + + async def _sock_resolve(self, sock, address): + host, port = address[:2] + if _ipaddr_info is not None: + info = _ipaddr_info(host, port, sock.family, sock.type, + sock.proto, *address[2:]) + if info is not None: + return info[4] + infos = await self.getaddrinfo(host, port, family=sock.family, + type=sock.type, proto=sock.proto) + if not infos: + raise OSError('getaddrinfo() returned empty list') + return infos[0][4] + + def _sock_connect_cb(self, fut, sock, address): + if fut.done(): + return + try: + err = sock.getsockopt(socket_module.SOL_SOCKET, + socket_module.SO_ERROR) + if err != 0: + # Jump to the except clause below (mirrors asyncio). + raise OSError(err, 'Connect call failed {}'.format(address)) + except (BlockingIOError, InterruptedError): + pass # not connected yet; retry on the next writability + except (SystemExit, KeyboardInterrupt): + raise + except BaseException as exc: + fut.set_exception(exc) + else: + fut.set_result(None) + + async def sock_accept(self, sock): + """Accept a connection on listening ``sock`` (non-blocking). + + Returns (conn, address); ``conn`` is set non-blocking. + """ + _check_ssl_socket(sock) + if self._debug and sock.gettimeout() != 0: + raise ValueError('the socket must be non-blocking') + try: + conn, address = sock.accept() + except (BlockingIOError, InterruptedError): + pass + else: + conn.setblocking(False) + return conn, address + fut = self.create_future() + fd = sock.fileno() + self.add_reader(fd, self._sock_accept_cb, fut, sock) + fut.add_done_callback(lambda f: self.remove_reader(fd)) + return await fut + + def _sock_accept_cb(self, fut, sock): + if fut.done(): + return + try: + conn, address = sock.accept() + conn.setblocking(False) + except (BlockingIOError, InterruptedError): + return + except (SystemExit, KeyboardInterrupt): + raise + except BaseException as exc: + fut.set_exception(exc) + else: + fut.set_result((conn, address)) + + # ----- fd watching: add_reader / add_writer (plan section 5, M2b) ------ + # + # Implementation note: hio_add(io, cb, events) REPLACES the io's + # event-dispatch callback (hloop.c: io->cb = cb; the high-level API puts + # nio.c's hio_handle_events there), so with our raw __fd_watcher_cb libhv + # never reads/writes the fd itself -- we only translate level-triggered + # readiness into the registered callbacks. Constraints (documented, not + # enforced): an fd watched here must not simultaneously be owned by a + # transport/server listener of this loop, and libhv's high-level + # hio_read/hio_write API must not be used on a watched fd. + + def add_reader(self, fd, callback, *args): + """Start watching ``fd`` for readability. + + ``callback(*args)`` runs on every loop turn in which the fd is + readable (level-triggered), in a context captured at registration + time (contextvars.copy_context, asyncio semantics). ``fd`` is an int + or any object with a ``fileno()`` method. Re-registering an fd that + already has a reader replaces the previous callback. + + The fd stays owned by the caller: remove_reader()/loop.close() only + unregister it from libhv and never close it. NOTE: libhv flips + watched socket fds to non-blocking mode (hio_ready). + """ + self._check_closed() + self._fd_watch_add(_fileobj_to_fd(fd), hv.HV_READ, callback, args) + + def remove_reader(self, fd): + """Stop watching ``fd`` for readability. + + Returns True if a reader callback was registered, False otherwise. + The fd itself is never closed and remains usable by the caller. + """ + if self._closed: + return False + return self._fd_watch_remove(_fileobj_to_fd(fd), hv.HV_READ) + + def add_writer(self, fd, callback, *args): + """Start watching ``fd`` for writability. + + ``callback(*args)`` runs on every loop turn in which the fd is + writable; the libhv poll backends are level-triggered, so the + callback keeps firing while the fd stays writable (asyncio + semantics). See add_reader() for fd ownership and constraints. + """ + self._check_closed() + self._fd_watch_add(_fileobj_to_fd(fd), hv.HV_WRITE, callback, args) + + def remove_writer(self, fd): + """Stop watching ``fd`` for writability. + + Returns True if a writer callback was registered, False otherwise. + The fd itself is never closed and remains usable by the caller. + """ + if self._closed: + return False + return self._fd_watch_remove(_fileobj_to_fd(fd), hv.HV_WRITE) + + cdef _fd_watch_add(self, int fd, int events, object callback, tuple args): + cdef _FDWatcher w + cdef object existing = self._fd_watchers.get(fd) + if existing is None: + w = _FDWatcher.new(self, fd) + else: + w = <_FDWatcher>existing + try: + w._add(events, callback, args) + except BaseException: + # A freshly created (or now-empty) watcher must not stay + # registered without any callback slot. + if w._reader is None and w._writer is None: + w._teardown() + raise + + cdef bint _fd_watch_remove(self, int fd, int events): + cdef object existing = self._fd_watchers.get(fd) + if existing is None: + return False + return (<_FDWatcher>existing)._remove(events) + + # ----- Unix signals (plan section 9, M2b) ------------------------------- + # + # CPython's C-level signal handler writes the signal number to a + # non-blocking socketpair write end installed via signal.set_wakeup_fd(); + # the read end is watched with the M2b fd machinery above, and arriving + # signal numbers dispatch the registered (persistent) Handle onto the + # ready queue. A Python-level no-op handler keeps the C-level handler + # installed (SIG_DFL/SIG_IGN would bypass the wakeup-fd write entirely). + + def add_signal_handler(self, sig, callback, *args): + """Register ``callback(*args)`` to run on Unix signal ``sig``. + + Main thread only (a signal.set_wakeup_fd restriction, surfaced as + RuntimeError, same as asyncio). Windows: NotImplementedError. + """ + cdef Handle handle + if _IS_WINDOWS: + raise NotImplementedError( + 'add_signal_handler() is not supported on Windows') + if (aio_iscoroutine(callback) or + _iscoroutinefunction(callback)): + raise TypeError( + 'coroutines cannot be used with add_signal_handler()') + self._check_signal(sig) + self._check_closed() + # Installs (or refreshes) the wakeup fd; RuntimeError when not on the + # main thread. + self._ensure_signal_wakeup() + handle = Handle(callback, args, self, None) + handle._repeat = True # one Handle runs once per signal delivery + self._signal_handlers[sig] = handle + try: + signal_module.signal(sig, _sighandler_noop) + # Don't let the signal interrupt blocking syscalls (asyncio does + # the same; the wakeup fd already interrupts our poll). + signal_module.siginterrupt(sig, False) + except OSError as exc: + del self._signal_handlers[sig] + if not self._signal_handlers: + self._reset_wakeup_fd() + if exc.errno == errno_module.EINVAL: + raise RuntimeError( + 'sig {} cannot be caught'.format(sig)) from None + raise + + def remove_signal_handler(self, sig): + """Remove the handler for ``sig``; returns True if one was set. + + asyncio semantics: the disposition is restored to + signal.default_int_handler for SIGINT and signal.SIG_DFL otherwise. + """ + if _IS_WINDOWS: + raise NotImplementedError( + 'remove_signal_handler() is not supported on Windows') + self._check_signal(sig) + try: + del self._signal_handlers[sig] + except KeyError: + return False + if sig == signal_module.SIGINT: + handler = signal_module.default_int_handler + else: + handler = signal_module.SIG_DFL + try: + signal_module.signal(sig, handler) + except OSError as exc: + if exc.errno == errno_module.EINVAL: + raise RuntimeError( + 'sig {} cannot be caught'.format(sig)) from None + raise + if not self._signal_handlers: + self._reset_wakeup_fd() + return True + + cdef _check_signal(self, sig): + if not isinstance(sig, int): + raise TypeError('sig must be an int, not {!r}'.format(sig)) + if sig not in signal_module.valid_signals(): + raise ValueError('invalid signal number {}'.format(sig)) + + cdef _ensure_signal_wakeup(self): + # Lazily create the non-blocking wakeup socketpair, watch its read + # end with the fd machinery, and (re-)install its write end as the + # interpreter's signal wakeup fd. + cdef bint created = False + if self._signal_ssock is None: + ssock, csock = socket_module.socketpair() + ssock.setblocking(False) + csock.setblocking(False) + created = True + else: + ssock = self._signal_ssock + csock = self._signal_csock + try: + # ValueError when not on the main thread. + signal_module.set_wakeup_fd(csock.fileno()) + except (ValueError, OSError) as exc: + if created: + ssock.close() + csock.close() + raise RuntimeError(str(exc)) from None + if created: + self._signal_ssock = ssock + self._signal_csock = csock + try: + self._fd_watch_add(ssock.fileno(), hv.HV_READ, + self._on_signal_wakeup, ()) + except BaseException: + self._teardown_signal_wakeup() + raise + + cdef _reset_wakeup_fd(self): + # Restore set_wakeup_fd(-1), but only if the installed wakeup fd is + # still our write end; if someone else installed their own in the + # meantime, put theirs back untouched. + if self._signal_csock is None: + return + try: + fd = signal_module.set_wakeup_fd(-1) + if fd != -1 and fd != self._signal_csock.fileno(): + signal_module.set_wakeup_fd(fd) + except (ValueError, OSError) as exc: + aio_logger.info('set_wakeup_fd(-1) failed: %s', exc) + + cdef _teardown_signal_wakeup(self): + # Restore the wakeup fd, unwatch the read end and close both ends of + # the socketpair (the pair is loop-owned). The unwatch must happen + # while the read end is still open so the iowatcher deregistration + # (kqueue/epoll DEL on the fd) succeeds. + ssock = self._signal_ssock + csock = self._signal_csock + if ssock is None: + return + self._reset_wakeup_fd() + self._signal_ssock = None + self._signal_csock = None + self._fd_watch_remove(ssock.fileno(), hv.HV_READ) + ssock.close() + csock.close() + + def _on_signal_wakeup(self): + # Persistent reader callback on the wakeup socketpair's read end; + # runs in the loop thread. Drain the pair, dispatch per signo. + ssock = self._signal_ssock + if ssock is None: + return + while True: + try: + data = ssock.recv(4096) + except InterruptedError: + continue + except OSError: + # BlockingIOError: drained. Anything else: nothing useful to + # do from here; the loop keeps running. + return + if not data: + return + for signum in data: + if not signum: + continue + self._dispatch_signal(signum) + + cdef _dispatch_signal(self, int signum): + handle = self._signal_handlers.get(signum) + if handle is None: + return + if (handle)._cancelled: + self.remove_signal_handler(signum) + else: + # The Handle is persistent (_repeat): _run_ready executes it + # without consuming callback/args (plan section 9). + self._ready.append(handle) + + # ----- TCP: create_connection / create_server (plan sections 6 & 7) ---- + cdef TCPTransport _tcp_wrap_fd(self, int fd): + # Wrap an OS-level fd (already detached from any Python socket; libhv + # owns it from here on and hio_close will close it) in a TCPTransport. + cdef hv.hio_t* io = hv.hio_get(self.hvloop, fd) + if io is NULL: + try: + # socket.close(fd), not os.close(fd): on Windows the fd is a + # raw SOCKET handle, not a CRT fd (M4 Windows portability). + socket_module.close(fd) + except OSError: + pass + raise RuntimeError('hio_get() failed for fd {}'.format(fd)) + return TCPTransport.new(self, None, None, io) + + async def _tcp_connect(self, object sock, object address): + """Detach ``sock``, hand its fd to libhv and connect to ``address``. + + Returns a connected TCPTransport in pre-init state (no protocol yet). + Connect errors surface through the hio close callback (nio.c routes + failed connects to hio_close), which fails the waiter future. + """ + cdef int fd = sock.detach() + cdef TCPTransport tr = self._tcp_wrap_fd(fd) + cdef hv.sockaddr_u paddr + memset(&paddr, 0, sizeof(paddr)) + host = address[0] + port = address[1] + if hv.sockaddr_set_ipport(&paddr, host.encode('ascii'), port) != 0: + # Fresh self-owned fd: hio_close closes it (no callbacks set yet + # beyond ours, which tolerate the pre-protocol state). + tr._teardown_failed_connect() + raise OSError('invalid remote address {!r}'.format(address)) + hv.hio_set_peeraddr(tr._hio, &paddr, + hv.sockaddr_len(&paddr)) + waiter = self.create_future() + tr._waiter = waiter + hv.hio_setcb_connect(tr._hio, __tcp_connect_cb) + hv.hio_set_connect_timeout(tr._hio, _HV_CONNECT_TIMEOUT_MS) + # On immediate failure hio_connect schedules an async close; the close + # dispatch then fails the waiter, so we always just await it. + hv.hio_connect(tr._hio) + try: + await waiter + except BaseException: + # OSError from the close dispatch, or CancelledError from the + # caller. Tear down the half-open connection; there is no protocol + # yet, so the close dispatch only cleans up. + tr._teardown_failed_connect() + raise + return tr + + async def create_connection(self, protocol_factory, host=None, port=None, + *, ssl=None, family=0, proto=0, flags=0, + sock=None, local_addr=None, + server_hostname=None, + ssl_handshake_timeout=None, + ssl_shutdown_timeout=None, + happy_eyeballs_delay=None, interleave=None, + all_errors=False): + """Connect to a TCP server (plan section 6). + + Multiple resolved addresses are tried sequentially (no + happy-eyeballs), matching the plan. + + TLS (M4, plan section 8): ``ssl`` may be True (default client + context) or an ssl.SSLContext. The raw TCPTransport then carries the + ciphertext for a stdlib asyncio.sslproto.SSLProtocol and the caller + receives (ssl_app_transport, protocol) -- exactly the structure of + asyncio.BaseEventLoop._make_ssl_transport. + """ + self._check_closed() + if server_hostname is not None and not ssl: + raise ValueError( + 'server_hostname is only meaningful with ssl') + if server_hostname is None and ssl: + # asyncio semantics: default server_hostname to host; using + # ssl with sock= (no host) requires an explicit server_hostname. + if not host: + raise ValueError('You must set server_hostname ' + 'when using ssl without a host') + server_hostname = host + if ssl_handshake_timeout is not None and not ssl: + raise ValueError( + 'ssl_handshake_timeout is only meaningful with ssl') + if ssl_shutdown_timeout is not None and not ssl: + raise ValueError( + 'ssl_shutdown_timeout is only meaningful with ssl') + if ssl_shutdown_timeout is not None and not _PY311: + raise TypeError( + 'ssl_shutdown_timeout requires Python 3.11+ ' + '(pre-3.11 asyncio.sslproto has no such parameter)') + if sock is not None: + _check_ssl_socket(sock) + + cdef TCPTransport tr = None + + if host is not None or port is not None: + if sock is not None: + raise ValueError( + 'host/port and sock can not be specified at the ' + 'same time') + infos = await self.getaddrinfo( + host, port, family=family, type=socket_module.SOCK_STREAM, + proto=proto, flags=flags) + if not infos: + raise OSError('getaddrinfo() returned empty list') + laddr_infos = None + if local_addr is not None: + laddr_infos = await self.getaddrinfo( + *local_addr, family=family, + type=socket_module.SOCK_STREAM, proto=proto, flags=flags) + if not laddr_infos: + raise OSError('getaddrinfo() returned empty list') + + exceptions = [] + for af, socktype, protonum, _cname, address in infos: + try: + s = socket_module.socket(af, socktype, protonum) + except OSError as exc: + exceptions.append(exc) + continue + s.setblocking(False) + if laddr_infos is not None: + bound = False + for _, _, _, _, laddr in laddr_infos: + try: + s.bind(laddr) + bound = True + break + except OSError as exc: + msg = ('error while attempting to bind on ' + 'address {!r}: {}'.format( + laddr, exc.strerror.lower())) + exceptions.append(OSError(exc.errno, msg)) + if not bound: + s.close() + continue + try: + tr = await self._tcp_connect(s, address) + break + except OSError as exc: + exceptions.append(exc) + tr = None + if tr is None: + if all_errors: + raise ExceptionGroup('create_connection failed', + exceptions) + if len(exceptions) == 1: + raise exceptions[0] + model = str(exceptions[0]) + if all(str(exc) == model for exc in exceptions): + raise exceptions[0] + raise OSError('Multiple exceptions: {}'.format( + ', '.join(str(exc) for exc in exceptions))) + else: + if sock is None: + raise ValueError( + 'host and port was not specified and no sock specified') + if sock.type != socket_module.SOCK_STREAM: + raise ValueError( + 'A Stream Socket was expected, got {!r}'.format(sock)) + # asyncio semantics: the transport takes ownership of an + # already-connected sock; detach moves the fd to libhv, which + # closes it on transport close. + sock.setblocking(False) + tr = self._tcp_wrap_fd(sock.detach()) + + if tr._hio is NULL: + # The connection dropped between connect success and now. + raise ConnectionResetError( + errno_module.ECONNRESET, 'Connection lost during handshake') + try: + protocol = protocol_factory() + except BaseException: + tr._teardown_failed_connect() + raise + if ssl: + # Same structure as asyncio's _make_ssl_transport: SSLProtocol + # becomes the raw transport's protocol, the caller gets the + # SSL app-transport; the waiter completes when the handshake + # does (or fails). + sslcontext = None if isinstance(ssl, bool) else ssl + waiter = self.create_future() + try: + ssl_protocol = _make_ssl_protocol( + self, protocol, sslcontext, waiter, False, + server_hostname, ssl_handshake_timeout, + ssl_shutdown_timeout) + app_transport = _ssl_app_transport(ssl_protocol) + except BaseException: + tr._teardown_failed_connect() + raise + tr._protocol = ssl_protocol + tr._initialize() + try: + await waiter + except BaseException: + # Handshake failure/cancellation: SSLProtocol._fatal_error + # already force-closed the raw transport in the failure case; + # closing the (captured) app transport covers cancellation + # and is a no-op when the connection is already lost. + app_transport.close() + raise + return app_transport, protocol + tr._protocol = protocol + tr._initialize() + return tr, protocol + + async def create_server(self, protocol_factory, host=None, port=None, *, + family=socket_module.AF_UNSPEC, + flags=socket_module.AI_PASSIVE, + sock=None, backlog=100, ssl=None, + reuse_address=None, reuse_port=None, + keep_alive=None, + ssl_handshake_timeout=None, + ssl_shutdown_timeout=None, + start_serving=True): + """Create a TCP server (plan section 7). + + host/port path: hvloop builds the listen sockets in Python (multi + address getaddrinfo, SO_REUSEADDR/SO_REUSEPORT, IPV6_V6ONLY), then + sock.detach() hands each fd to libhv, which owns and closes it. + sock= path: the fd stays owned by the caller's socket object; + Server.close()/loop.close() only unregister it from libhv. + + ssl= (M4, plan section 8): an ssl.SSLContext wraps every accepted + connection in asyncio.sslproto.SSLProtocol; the application protocol + sees the SSL app-transport. + """ + self._check_closed() + if isinstance(ssl, bool): + raise TypeError('ssl argument must be an SSLContext or None') + if ssl_handshake_timeout is not None and ssl is None: + raise ValueError( + 'ssl_handshake_timeout is only meaningful with ssl') + if ssl_shutdown_timeout is not None and ssl is None: + raise ValueError( + 'ssl_shutdown_timeout is only meaningful with ssl') + if ssl_shutdown_timeout is not None and not _PY311: + raise TypeError( + 'ssl_shutdown_timeout requires Python 3.11+ ' + '(pre-3.11 asyncio.sslproto has no such parameter)') + if sock is not None: + _check_ssl_socket(sock) + + cdef Server server + cdef _TCPListener listener + + if host is not None or port is not None: + if sock is not None: + raise ValueError( + 'host/port and sock can not be specified at the ' + 'same time') + if reuse_address is None: + reuse_address = os.name == 'posix' and sys.platform != 'cygwin' + sockets = [] + if host == '': + hosts = [None] + elif (isinstance(host, str) or + not isinstance(host, collections.abc.Iterable)): + hosts = [host] + else: + hosts = list(host) + + infos = set() + for h in hosts: + infos.update(await self.getaddrinfo( + h, port, family=family, type=socket_module.SOCK_STREAM, + flags=flags)) + + completed = False + try: + for af, socktype, protonum, _cname, sa in infos: + try: + s = socket_module.socket(af, socktype, protonum) + except OSError: + # Assume it's a bad family/type/protocol combination. + continue + sockets.append(s) + if reuse_address: + s.setsockopt(socket_module.SOL_SOCKET, + socket_module.SO_REUSEADDR, True) + if reuse_port: + _set_reuseport(s) + if keep_alive: + s.setsockopt(socket_module.SOL_SOCKET, + socket_module.SO_KEEPALIVE, True) + # Disable IPv4/IPv6 dual stack support (enabled by + # default on Linux) which makes a single socket listen on + # both address families (same as asyncio). + if (af == socket_module.AF_INET6 and + hasattr(socket_module, 'IPV6_V6ONLY')): + s.setsockopt(socket_module.IPPROTO_IPV6, + socket_module.IPV6_V6ONLY, True) + try: + s.bind(sa) + except OSError as err: + msg = ('error while attempting to bind on address ' + '{!r}: {}'.format(sa, err.strerror.lower())) + raise OSError(err.errno, msg) from None + completed = True + finally: + if not completed: + for s in sockets: + s.close() + + server = Server.new(self, protocol_factory, backlog, + ssl, ssl_handshake_timeout, + ssl_shutdown_timeout) + for s in sockets: + # NOTE: deviation from asyncio: listen() happens here rather + # than in start_serving(), because the fd is detached to + # libhv right away and the Python socket object goes away. + # With start_serving=False the socket is therefore already + # listening (connections queue in the backlog) but no accept + # callbacks run until start_serving(). + s.setblocking(False) + s.listen(backlog) + listener = _TCPListener.new(self, server, s.detach(), None) + server._add_listener(listener) + else: + if sock is None: + raise ValueError( + 'Neither host/port nor sock were specified') + if sock.type != socket_module.SOCK_STREAM: + raise ValueError( + 'A Stream Socket was expected, got {!r}'.format(sock)) + sock.setblocking(False) + server = Server.new(self, protocol_factory, backlog, + ssl, ssl_handshake_timeout, + ssl_shutdown_timeout) + # Caller-owned fd: keep the Python socket object alive on the + # listener; teardown only unregisters from libhv (plan section 7). + listener = _TCPListener.new(self, server, sock.fileno(), sock) + server._add_listener(listener) + + if start_serving: + server._start_serving() + return server + + async def shutdown_default_executor(self, timeout=None): + self._executor_shutdown_called = True + if self._default_executor is None: + return + future = self.create_future() + thread = threading.Thread(target=self._do_shutdown, args=(future,)) + thread.start() + try: + await future + finally: + thread.join(timeout) + if thread.is_alive(): + import warnings + warnings.warn( + 'The executor did not finishing joining its threads ' + 'within %s seconds.' % timeout, + RuntimeWarning, stacklevel=2) + self._default_executor.shutdown(wait=False) + + def _do_shutdown(self, future): + try: + self._default_executor.shutdown(wait=True) + if not self.is_closed(): + self.call_soon_threadsafe(_set_result_unless_cancelled, + future, None) + except Exception as ex: # noqa: BLE001 + if not self.is_closed() and not future.cancelled(): + self.call_soon_threadsafe(future.set_exception, ex) + + # ----- async generators ---------------------------------------------- + def _asyncgen_firstiter_hook(self, agen): + if self._asyncgens_shutdown_called: + import warnings + warnings.warn( + 'asynchronous generator %r was scheduled after ' + 'loop.shutdown_asyncgens() call' % agen, + ResourceWarning, source=self) + self._asyncgens.add(agen) + + def _asyncgen_finalizer_hook(self, agen): + self._asyncgens.discard(agen) + if not self.is_closed(): + self.call_soon_threadsafe(self.create_task, agen.aclose()) + + async def shutdown_asyncgens(self): + self._asyncgens_shutdown_called = True + if not len(self._asyncgens): + return + closing_agens = list(self._asyncgens) + self._asyncgens.clear() + results = await asyncio.gather( + *[ag.aclose() for ag in closing_agens], + return_exceptions=True) + for result, agen in zip(results, closing_agens): + if isinstance(result, Exception): + self.call_exception_handler({ + 'message': 'an error occurred during closing of ' + 'asynchronous generator {!r}'.format(agen), + 'exception': result, + 'asyncgen': agen, + }) + + # ----- debug ---------------------------------------------------------- + def get_debug(self): + return self._debug + + def set_debug(self, enabled): + self._debug = bool(enabled) + + cdef _set_coroutine_origin_tracking(self, bint enabled): + if bool(enabled) == self._coroutine_origin_tracking_enabled: + return + if enabled: + self._coroutine_origin_tracking_saved_depth = ( + sys.get_coroutine_origin_tracking_depth()) + sys.set_coroutine_origin_tracking_depth( + constants_DEBUG_STACK_DEPTH) + else: + sys.set_coroutine_origin_tracking_depth( + self._coroutine_origin_tracking_saved_depth) + self._coroutine_origin_tracking_enabled = enabled + + cdef inline _check_callback(self, object callback, str method): + if (aio_iscoroutine(callback) or + _iscoroutinefunction(callback)): + raise TypeError( + "coroutines cannot be used with {}()".format(method)) + if not callable(callback): + raise TypeError( + 'a callable object was expected by {}(), got {!r}'.format( + method, callback)) + + cdef inline _check_thread(self): + if self._thread_id == 0: + return + cdef long thread_id = threading.get_ident() + if thread_id != self._thread_id: + raise RuntimeError( + 'Non-thread-safe operation invoked on an event loop other ' + 'than the current one') + + # ----- exception handling -------------------------------------------- + def get_exception_handler(self): + return self._exception_handler + + def set_exception_handler(self, handler): + if handler is not None and not callable(handler): + raise TypeError( + 'A callable object or None is expected, got {!r}'.format( + handler)) + self._exception_handler = handler + + def default_exception_handler(self, context): + message = context.get('message') + if not message: + message = 'Unhandled exception in event loop' + + exception = context.get('exception') + if exception is not None: + exc_info = (type(exception), exception, exception.__traceback__) + else: + exc_info = False + + log_lines = [message] + for key in sorted(context): + if key in {'message', 'exception'}: + continue + value = context[key] + if key == 'source_traceback': + tb = ''.join(traceback.format_list(value)) + value = 'Object created at (most recent call last):\n' + value += tb.rstrip() + elif key == 'handle_traceback': + tb = ''.join(traceback.format_list(value)) + value = 'Handle created at (most recent call last):\n' + value += tb.rstrip() + else: + try: + value = repr(value) + except Exception as ex: # noqa: BLE001 + value = ('Exception in __repr__ {!r}; ' + 'value type: {!r}'.format(ex, type(value))) + log_lines.append('{}: {}'.format(key, value)) + + logger = asyncio.log.logger + logger.error('\n'.join(log_lines), exc_info=exc_info) + + def call_exception_handler(self, context): + if self._exception_handler is None: + try: + self.default_exception_handler(context) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException: + asyncio.log.logger.error( + 'Exception in default exception handler', + exc_info=True) + return + try: + self._exception_handler(self, context) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as exc: + try: + self.default_exception_handler({ + 'message': 'Unhandled error in exception handler', + 'exception': exc, + 'context': context, + }) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException: + asyncio.log.logger.error( + 'Exception in default exception handler ' + 'while handling an unexpected error ' + 'in custom exception handler', + exc_info=True) + + # ----- asyncio infrastructure hooks ----------------------------------- + def _timer_handle_cancelled(self, handle): + # asyncio.Future/Task call this when a TimerHandle is cancelled. With + # libhv we delete the htimer eagerly in TimerHandle.cancel(), so this + # is a no-op (kept for interface compatibility). + pass + + +# =========================================================================== +# Module-level helpers +# =========================================================================== +cdef object _run_until_complete_cb(fut): + if not fut.cancelled(): + exc = fut.exception() + if isinstance(exc, (SystemExit, KeyboardInterrupt)): + # Don't stop the loop on these; let run_forever propagate them. + return + loop = fut.get_loop() + loop.stop() + + +cdef _set_result_unless_cancelled(fut, result): + if fut.cancelled(): + return + fut.set_result(result) + + +cdef object _format_callback(object cb, object args): + return _format_callback_source(cb, args) + + +# --------------------------------------------------------------------------- +# Imports / fallbacks resolved at import time (kept out of hot paths). +# --------------------------------------------------------------------------- +import contextvars as _contextvars +import weakref as _weakref_module +from asyncio import format_helpers as _format_helpers +from asyncio import coroutines as _aio_coroutines +from asyncio import constants as _aio_constants + +cdef object copy_context = _contextvars.copy_context +cdef object _weakset = _weakref_module.WeakSet +# Python 3.14 deprecated the public asyncio.coroutines.iscoroutinefunction +# (a DeprecationWarning per call); the stdlib's own event loops use the +# private _iscoroutinefunction instead. Prefer it when available. +cdef object _iscoroutinefunction = getattr( + _aio_coroutines, '_iscoroutinefunction', + _aio_coroutines.iscoroutinefunction) +cdef object _format_callback_source = _format_helpers._format_callback_source +cdef int constants_DEBUG_STACK_DEPTH = _aio_constants.DEBUG_STACK_DEPTH + + +cdef object aio_get_running_loop(): + try: + return asyncio.get_running_loop() + except RuntimeError: + return None + + +# =========================================================================== +# TCP transport / server (M2a, plan sections 6 & 7) +# =========================================================================== +cdef object aio_logger = asyncio.log.logger + + +# ----- TLS (M4, plan section 8) --------------------------------------------- +# Strategy: reuse the stdlib's asyncio.sslproto.SSLProtocol (MemoryBIO based, +# same approach as uvloop). Our TCPTransport carries the raw ciphertext and +# the SSLProtocol sits between it and the application protocol; the caller +# gets SSLProtocol's _app_transport. libhv's own OpenSSL integration stays +# disabled (WITH_OPENSSL=OFF): it cannot consume Python ssl.SSLContext +# objects and would burden the wheels with an OpenSSL link dependency. +import ssl as ssl_module +from asyncio import sslproto as aio_sslproto + +cdef object _SSLSocket = ssl_module.SSLSocket +cdef object _SSLProtocol = aio_sslproto.SSLProtocol +cdef object aio_BufferedProtocol = asyncio.BufferedProtocol + +# _ipaddr_info: asyncio-private fast path that skips getaddrinfo for numeric +# addresses (used by sock_connect, same as asyncio's _ensure_resolved). +from asyncio import base_events as _aio_base_events +cdef object _ipaddr_info = getattr(_aio_base_events, '_ipaddr_info', None) + + +cdef _check_ssl_socket(object sock): + # asyncio semantics: ssl.SSLSocket objects are never acceptable for + # transport/sock_* APIs (they wrap their own blocking state machine). + if isinstance(sock, _SSLSocket): + raise TypeError('Socket cannot be of type SSLSocket') + + +cdef object _make_ssl_protocol(Loop loop, object app_protocol, + object sslcontext, object waiter, + bint server_side, object server_hostname, + object ssl_handshake_timeout, + object ssl_shutdown_timeout): + # Version gate (plan section 8 / M4): Python 3.11 rewrote asyncio.sslproto + # (SSLProtocol became a BufferedProtocol with an explicit state machine) + # and added the ssl_shutdown_timeout parameter. The 3.10 SSLProtocol is a + # plain streaming Protocol without that parameter -- construct accordingly. + # Passing None for a timeout lets sslproto substitute its own defaults + # (constants.SSL_HANDSHAKE_TIMEOUT / SSL_SHUTDOWN_TIMEOUT) on every + # supported version. Both variants handle sslcontext=None client-side via + # _create_transport_context() (and reject it server-side). + if _PY311: + return _SSLProtocol( + loop, app_protocol, sslcontext, waiter, + server_side, server_hostname, + ssl_handshake_timeout=ssl_handshake_timeout, + ssl_shutdown_timeout=ssl_shutdown_timeout) + # Python 3.10 path (best effort: not locally verifiable on this 3.14 + # dev box, exercised by the CI matrix). + return _SSLProtocol( + loop, app_protocol, sslcontext, waiter, + server_side, server_hostname, + ssl_handshake_timeout=ssl_handshake_timeout) + + +cdef object _ssl_app_transport(object ssl_protocol): + # 3.12+ creates the app-side transport lazily via _get_app_transport(); + # 3.10/3.11 construct it eagerly in __init__. + get_app = getattr(ssl_protocol, '_get_app_transport', None) + if get_app is not None: + return get_app() + return ssl_protocol._app_transport + + +cdef inline void _pump_base_exc(Loop loop, object exc): + # uvloop-style pending-exception pump (same as _timer_dispatch): a + # KeyboardInterrupt/SystemExit raised by protocol code inside a libhv C + # callback cannot propagate through the noexcept frame; stash it on the + # loop and stop the poll so run_forever re-raises it. + loop._pending_exc = exc + if loop.hvloop is not NULL: + hv.hloop_stop(loop.hvloop) + + +cdef object _make_sock_oserror(int err): + try: + msg = os.strerror(err) + except (ValueError, OverflowError): + msg = 'unknown error {}'.format(err) + # OSError with (errno, msg) auto-selects the right subclass + # (ConnectionResetError, ConnectionRefusedError, TimeoutError, ...). + return OSError(err, msg) + + +cdef object _sockaddr_to_pyaddr(hv.sockaddr* sa): + cdef char ip[72] + cdef int port = 0 + cdef uint32_t flowinfo = 0 + cdef uint32_t scope_id = 0 + cdef int fam + ip[0] = 0 + fam = hv.hvloop_sockaddr_info(sa, ip, sizeof(ip), &port, + &flowinfo, &scope_id) + if fam < 0: + return None + ip_str = (ip).decode('ascii', 'replace') + if fam == _AF_INET: + return (ip_str, port) + if fam == _AF_INET6: + return (ip_str, port, flowinfo, scope_id) + return None + + +cdef object _dup_socket_view(int fd): + """Duplicate socket ``fd`` into an independent Python socket object. + + POSIX: plain os.dup -- the new descriptor shares the open file + description but closing it can never close libhv's fd, and no flag is + touched. + + Windows (M4 portability): os.dup() only handles CRT fds and libhv fds + are raw SOCKET handles, so duplicate via socket.socket(fileno=...).dup() + and detach the temporary wrapper so the original stays owned by libhv. + CAUTION: socket.dup() copies the temporary wrapper's *Python-level* + timeout (None == blocking!) onto the duplicate, and the blocking mode + lives on the underlying socket shared with libhv's handle -- restore + non-blocking immediately (libhv always operates non-blocking). + """ + if not _IS_WINDOWS: + return socket_module.socket(fileno=os.dup(fd)) + tmp = socket_module.socket(fileno=fd) + try: + view = tmp.dup() + finally: + tmp.detach() + view.setblocking(False) + return view + + +def _set_reuseport(sock): + if not hasattr(socket_module, 'SO_REUSEPORT'): + raise ValueError('reuse_port not supported by socket module') + try: + sock.setsockopt(socket_module.SOL_SOCKET, + socket_module.SO_REUSEPORT, True) + except OSError: + raise ValueError('reuse_port not supported by socket module, ' + 'SO_REUSEPORT defined but not implemented.') + + +# ----- libhv C callbacks ---------------------------------------------------- +# Each pair: a ``noexcept nogil`` trampoline handed to libhv plus a GIL-held +# dispatcher whose body is fully wrapped in try/except so no Python exception +# ever escapes back into C (plan section 4.6). + +cdef void __tcp_read_cb(hv.hio_t* io, void* buf, int readbytes) noexcept nogil: + with gil: + _tcp_dispatch_read(io, buf, readbytes) + + +cdef void _tcp_dispatch_read(hv.hio_t* io, void* buf, int nread): + cdef void* ctx = hv.hio_context(io) + cdef TCPTransport tr + if ctx is NULL: + return + tr = ctx + if tr._hio is NULL or nread <= 0: + # EOF and read errors never reach this callback: nio_read routes both + # straight to hio_close, i.e. our close callback (plan section 6). + return + try: + if tr._proto_buffered: + # BufferedProtocol path (asyncio.protocols.BufferedProtocol; + # notably the 3.11+ asyncio.sslproto.SSLProtocol): copy the libhv + # shared readbuf straight into the protocol's own buffer(s). + tr._deliver_buffered(buf, nread) + else: + # libhv's readbuf is a loop-level shared buffer that is reused as + # soon as this callback returns: copy IMMEDIATELY (plan section 6). + data = PyBytes_FromStringAndSize(buf, nread) + tr._protocol.data_received(data) + except (KeyboardInterrupt, SystemExit) as exc: + _pump_base_exc(tr._loop, exc) + except BaseException as exc: + tr._loop.call_exception_handler({ + 'message': 'Fatal error: protocol data delivery failed.', + 'exception': exc, + 'transport': tr, + 'protocol': tr._protocol, + }) + + +cdef void __tcp_write_cb(hv.hio_t* io, const void* buf, + int writebytes) noexcept nogil: + with gil: + _tcp_dispatch_write(io) + + +cdef void _tcp_dispatch_write(hv.hio_t* io): + # Fires on every (partial) write completion: drive write_eof completion + # and the low-water resume_writing side of the flow control protocol. + # NOTE: also fires synchronously from inside hio_write's direct-write + # path; in that case _protocol_paused is necessarily False (a paused + # transport always has a non-empty libhv write queue, which disables the + # direct-write path), so resume_writing never re-enters protocol.write(). + cdef void* ctx = hv.hio_context(io) + cdef TCPTransport tr + cdef size_t size + if ctx is NULL: + return + tr = ctx + if tr._hio is NULL: + return + try: + size = hv.hio_write_bufsize(tr._hio) + if size == 0 and tr._eof_pending and not tr._eof_written: + tr._do_write_eof() + if tr._protocol_paused and size <= tr._low_water: + tr._protocol_paused = False + tr._protocol.resume_writing() + except (KeyboardInterrupt, SystemExit) as exc: + _pump_base_exc(tr._loop, exc) + except BaseException as exc: + tr._loop.call_exception_handler({ + 'message': 'protocol.resume_writing() failed', + 'exception': exc, + 'transport': tr, + 'protocol': tr._protocol, + }) + + +cdef void __tcp_connect_cb(hv.hio_t* io) noexcept nogil: + with gil: + _tcp_dispatch_connect(io) + + +cdef void _tcp_dispatch_connect(hv.hio_t* io): + cdef void* ctx = hv.hio_context(io) + cdef TCPTransport tr + if ctx is NULL: + return + tr = ctx + try: + waiter = tr._waiter + tr._waiter = None + if waiter is not None and not waiter.done(): + waiter.set_result(None) + except (KeyboardInterrupt, SystemExit) as exc: + _pump_base_exc(tr._loop, exc) + except BaseException as exc: + tr._loop.call_exception_handler({ + 'message': 'error while completing a TCP connect', + 'exception': exc, + 'transport': tr, + }) + + +cdef void __tcp_close_cb(hv.hio_t* io) noexcept nogil: + with gil: + _tcp_dispatch_close(io) + + +cdef void _tcp_dispatch_close(hv.hio_t* io): + # Single funnel for every connection end: peer EOF, errors (incl. failed + # connects -- nio.c routes them all to hio_close) and our own + # close()/abort(). May fire from inside the poll OR synchronously from a + # Python-initiated hio_close. Releases the registration reference taken + # in TCPTransport.new exactly once; mutually exclusive with + # Loop.close()'s teardown (which clears the close callback first). + cdef void* ctx = hv.hio_context(io) + cdef TCPTransport tr + cdef int err + cdef bint was_closing + if ctx is NULL: + return + tr = ctx + if tr._hio is NULL: + return + err = hv.hio_error(io) + was_closing = tr._closing + hv.hio_set_context(io, NULL) + tr._hio = NULL + tr._closing = True + try: + tr._loop._hio_objs.discard(tr) + waiter = tr._waiter + if waiter is not None: + # Still connecting: a close here means the connect failed (or was + # cancelled). No protocol exists yet -- just fail the waiter. + # libhv detects failed connects via getpeername() and records ITS + # errno (EINVAL/ENOTCONN); recover the real connect error from + # SO_ERROR while the fd is still open (nio.c closes it only after + # this callback returns). + sock_err = hv.hvloop_sock_error(hv.hio_fd(io)) + if sock_err > 0: + err = sock_err + tr._waiter = None + if not waiter.done(): + if err != 0: + waiter.set_exception(_make_sock_oserror(err)) + else: + waiter.set_exception( + ConnectionError('connection closed before connect ' + 'completed')) + return + if not tr._protocol_connected: + # Never exposed to a protocol (e.g. torn down mid-handshake or a + # failed-connect cleanup): nothing to notify. + return + if tr._force_close_exc is not None: + # _force_close(exc) path (asyncio-private transport API used by + # asyncio.sslproto): deliver the caller-supplied exception. + exc = tr._force_close_exc + tr._force_close_exc = None + elif tr._aborted or err == 0: + exc = None + else: + exc = _make_sock_oserror(err) + # Peer-initiated clean shutdown: deliver best-effort eof_received() + # before connection_lost (plan section 6; see _call_connection_lost + # for the documented half-close deviation). + got_eof = err == 0 and not was_closing and not tr._aborted + tr._loop.call_soon(tr._call_connection_lost, exc, got_eof) + except (KeyboardInterrupt, SystemExit) as exc2: + _pump_base_exc(tr._loop, exc2) + except BaseException as exc2: + tr._loop.call_exception_handler({ + 'message': 'error while dispatching transport close', + 'exception': exc2, + 'transport': tr, + }) + finally: + Py_DECREF(tr) + + +cdef void __tcp_accept_cb(hv.hio_t* io) noexcept nogil: + with gil: + _tcp_dispatch_accept(io) + + +cdef void _tcp_dispatch_accept(hv.hio_t* io): + # ``io`` is the NEW connection's hio. nio_accept copies the listening + # io's hevent userdata onto it, which is where _TCPListener.new stored + # the listener backref. + cdef void* udata = hv.hevent_get_userdata(io) + cdef _TCPListener listener + cdef TCPTransport tr + cdef Loop loop + cdef Server server + # Never leave the borrowed listener pointer on the connection's hio. + hv.hevent_set_userdata(io, NULL) + if udata is NULL: + hv.hio_close(io) + return + listener = <_TCPListener>udata + server = listener._server + loop = listener._loop + if (loop._closed or listener._hio is NULL or server is None or + server._listeners is None or not server._serving): + hv.hio_close(io) + return + try: + protocol = server._protocol_factory() + if server._ssl_context is not None: + # TLS server (plan section 8): interpose the stdlib SSLProtocol. + # waiter=None -- handshake failures on the accept path are routed + # to the loop's exception handler by SSLProtocol._fatal_error + # (which force-closes the raw transport); the server keeps + # serving, same as asyncio. + protocol = _make_ssl_protocol( + loop, protocol, server._ssl_context, None, True, None, + server._ssl_handshake_timeout, server._ssl_shutdown_timeout) + tr = TCPTransport.new(loop, protocol, server, io) + except (KeyboardInterrupt, SystemExit) as exc: + _pump_base_exc(loop, exc) + hv.hio_close(io) + return + except BaseException as exc: + loop.call_exception_handler({ + 'message': 'Error in protocol_factory() while accepting a ' + 'new connection', + 'exception': exc, + }) + hv.hio_close(io) + return + server._attach() + # connection_made (and the read start) run via call_soon so protocol code + # never executes inside the libhv accept-callback stack (plan section 7). + loop.call_soon(tr._initialize) + + +# ----- Server / listener ---------------------------------------------------- +@cython.no_gc_clear +cdef class _TCPListener: + """One listening socket of a Server, wrapping a libhv accept hio. + + fd ownership (plan section 7): + * self-built sockets (host/port path): the fd was detach()ed from its + Python socket; libhv owns it and _close() -> hio_close closes it. + * caller sockets (create_server(sock=...)): the fd belongs to the + caller's Python socket; _close() only unregisters the hio + (hvloop_hio_release_external) and never closes the fd. + """ + cdef: + Loop _loop + Server _server + hv.hio_t* _hio + int _fd + object _sock # caller-owned Python socket, or None + bint _external + object _sockview # lazy dup()-based socket for Server.sockets + object __weakref__ + + @staticmethod + cdef _TCPListener new(Loop loop, Server server, int fd, object sock): + cdef _TCPListener self = _TCPListener.__new__(_TCPListener) + self._loop = loop + self._server = server + self._fd = fd + self._sock = sock + self._external = sock is not None + self._sockview = None + self._hio = hv.hio_get(loop.hvloop, fd) + if self._hio is NULL: + raise RuntimeError('hio_get() failed for listen fd {}'.format(fd)) + hv.hio_setcb_accept(self._hio, __tcp_accept_cb) + hv.hevent_set_userdata(self._hio, self) + # Registration reference (same discipline as TimerHandle): released + # exactly once, either in _close() or in the loop.close() teardown. + Py_INCREF(self) + loop._hio_objs.add(self) + return self + + cdef _start(self, int backlog): + if self._hio is NULL: + raise RuntimeError('server listener is already closed') + if self._external: + # asyncio also (re-)listens on caller sockets in start_serving. + self._sock.listen(backlog) + if hv.hio_accept(self._hio) != 0: + raise RuntimeError( + 'hio_accept() failed for listen fd {}'.format(self._fd)) + + cdef _close(self): + cdef hv.hio_t* io = self._hio + if io is NULL: + return + self._hio = NULL + self._loop._hio_objs.discard(self) + if self._external: + # Unregister from libhv without touching the caller's fd. + hv.hvloop_hio_release_external(io) + else: + hv.hio_setcb_accept(io, NULL) + hv.hevent_set_userdata(io, NULL) + # Self-owned fd: hio_close closes it (write queue is empty on a + # listen socket, so this is immediate). + hv.hio_close(io) + if self._sockview is not None: + try: + self._sockview.close() + except OSError: + pass + self._sockview = None + Py_DECREF(self) + + def _loop_close_teardown(self): + # Called by Loop.close() before hloop_free; _close() already does + # exactly what is needed (and is mutually exclusive with any later + # Server.close(), which will see _hio == NULL). + self._close() + + cdef _get_socket(self): + if self._external: + return self._sock + if self._sockview is None: + if self._hio is NULL: + return None + try: + # A dup()-based view: an independent descriptor on the same + # underlying socket, so getsockname/setsockopt work but + # closing it cannot close libhv's fd. + self._sockview = _dup_socket_view(self._fd) + except OSError: + return None + return self._sockview + + +@cython.no_gc_clear +cdef class Server: + """asyncio-compatible Server returned by loop.create_server (plan §7).""" + cdef: + Loop _loop + object _protocol_factory + list _listeners # None once close() was called + list _waiters # None once fully closed (wait_closed wakeup) + int _active_count + int _backlog + bint _serving + object _serving_forever_fut + object _ssl_context # ssl.SSLContext, or None (plain TCP) + object _ssl_handshake_timeout # float seconds, or None (default) + object _ssl_shutdown_timeout # float seconds, or None (default) + object __weakref__ + + @staticmethod + cdef Server new(Loop loop, object protocol_factory, int backlog, + object ssl_context, object ssl_handshake_timeout, + object ssl_shutdown_timeout): + cdef Server self = Server.__new__(Server) + self._loop = loop + self._protocol_factory = protocol_factory + self._listeners = [] + self._waiters = [] + self._active_count = 0 + self._backlog = backlog + self._serving = False + self._serving_forever_fut = None + self._ssl_context = ssl_context + self._ssl_handshake_timeout = ssl_handshake_timeout + self._ssl_shutdown_timeout = ssl_shutdown_timeout + return self + + cdef _add_listener(self, _TCPListener listener): + self._listeners.append(listener) + + # -- connection accounting (drives wait_closed) ------------------------- + cdef _attach(self): + self._active_count += 1 + + cdef _detach(self): + self._active_count -= 1 + if self._active_count == 0 and self._listeners is None: + self._wakeup() + + cdef _wakeup(self): + waiters = self._waiters + if waiters is None: + return + self._waiters = None + for waiter in waiters: + if not waiter.done(): + waiter.set_result(None) + + def _start_serving(self): + cdef _TCPListener listener + if self._serving: + return + if self._listeners is None: + raise RuntimeError('server {!r} is closed'.format(self)) + self._serving = True + for listener in self._listeners: + listener._start(self._backlog) + + # -- public API ---------------------------------------------------------- + def __repr__(self): + return '<{} sockets={!r}>'.format(type(self).__name__, self.sockets) + + def get_loop(self): + return self._loop + + def is_serving(self): + return self._serving + + @property + def sockets(self): + cdef _TCPListener listener + if self._listeners is None: + return () + result = [] + for listener in self._listeners: + s = listener._get_socket() + if s is not None: + result.append(s) + return tuple(result) + + def close(self): + cdef _TCPListener listener + if self._listeners is None: + return + listeners = self._listeners + self._listeners = None + for listener in listeners: + listener._close() + self._serving = False + if (self._serving_forever_fut is not None and + not self._serving_forever_fut.done()): + self._serving_forever_fut.cancel() + self._serving_forever_fut = None + if self._active_count == 0: + self._wakeup() + + async def start_serving(self): + self._start_serving() + + async def serve_forever(self): + if self._serving_forever_fut is not None: + raise RuntimeError( + 'server {!r} is already being awaited on ' + 'serve_forever()'.format(self)) + if self._listeners is None: + raise RuntimeError('server {!r} is closed'.format(self)) + self._start_serving() + self._serving_forever_fut = self._loop.create_future() + try: + await self._serving_forever_fut + except asyncio.CancelledError: + try: + self.close() + await self.wait_closed() + finally: + raise + finally: + self._serving_forever_fut = None + + async def wait_closed(self): + # Returns once close() was called AND all connections created from + # this server have had connection_lost delivered (_detach). + if self._waiters is None or (self._listeners is None and + self._active_count == 0): + return + waiter = self._loop.create_future() + self._waiters.append(waiter) + await waiter + + async def __aenter__(self): + return self + + async def __aexit__(self, *exc): + self.close() + await self.wait_closed() + + +# ----- TCPTransport ---------------------------------------------------------- +@cython.no_gc_clear +cdef class TCPTransport: + """asyncio.Transport implementation over a libhv hio (plan section 6). + + Lifecycle/reference discipline (mirrors TimerHandle): TCPTransport.new + registers the transport as the hio's context with a Py_INCREF and tracks + it in loop._hio_objs; the close dispatch and Loop.close() teardown are + mutually exclusive paths that each null the hio pointer, discard from the + tracking set and Py_DECREF exactly once. Every public method checks + _hio == NULL first, so calls after close/teardown are safe no-ops. + """ + cdef: + Loop _loop + hv.hio_t* _hio + object _protocol + Server _server # set for server-side connections, else None + dict _extra + object _waiter # create_connection connect waiter + object _sock_view # lazy dup()-based socket for extra_info + object _force_close_exc # exception passed to _force_close() + bint _protocol_connected # connection_made was delivered + bint _proto_buffered # protocol is an asyncio.BufferedProtocol + bint _closing + bint _paused # reading paused via pause_reading() + bint _protocol_paused # pause_writing() delivered + bint _eof_pending # write_eof() called, waiting for drain + bint _eof_written # shutdown(SHUT_WR) done + bint _aborted + size_t _high_water + size_t _low_water + unsigned int _conn_lost + object __weakref__ + + @staticmethod + cdef TCPTransport new(Loop loop, object protocol, Server server, + hv.hio_t* io): + cdef TCPTransport self = TCPTransport.__new__(TCPTransport) + self._loop = loop + self._protocol = protocol + self._server = server + self._hio = io + self._extra = {} + self._waiter = None + self._sock_view = None + self._force_close_exc = None + self._protocol_connected = False + self._proto_buffered = False + self._closing = False + self._paused = False + self._protocol_paused = False + self._eof_pending = False + self._eof_written = False + self._aborted = False + self._high_water = _FLOW_CONTROL_HIGH_WATER + self._low_water = _FLOW_CONTROL_HIGH_WATER // 4 + self._conn_lost = 0 + hv.hio_set_context(io, self) + hv.hio_setcb_read(io, __tcp_read_cb) + hv.hio_setcb_write(io, __tcp_write_cb) + hv.hio_setcb_close(io, __tcp_close_cb) + # Flow control is the protocol's job (pause_writing); never let libhv + # kill the connection on its internal 16MiB write-buffer cap. + hv.hio_set_max_write_bufsize(io, 0xffffffff) + # asyncio enables TCP_NODELAY on TCP transports by default. + hv.tcp_nodelay(hv.hio_fd(io), 1) + Py_INCREF(self) + loop._hio_objs.add(self) + return self + + def __repr__(self): + state = [] + if self._hio is NULL: + state.append('closed') + elif self._closing: + state.append('closing') + else: + state.append('open') + state.append('fd={}'.format(hv.hio_fd(self._hio))) + return ''.format(' '.join(state)) + + # -- initialization ------------------------------------------------------ + def _initialize(self): + # Runs via call_soon for accepted connections (never inside the libhv + # accept-callback stack, plan section 7) and directly from the + # create_connection coroutine for client connections. + if self._hio is NULL or self._closing: + return + self._init_extra() + self._proto_buffered = isinstance(self._protocol, + aio_BufferedProtocol) + try: + self._protocol_connected = True + self._protocol.connection_made(self) + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as exc: + self._loop.call_exception_handler({ + 'message': 'protocol.connection_made() failed', + 'exception': exc, + 'transport': self, + 'protocol': self._protocol, + }) + # connection_made may have closed/aborted the transport. + if self._hio is NULL or self._closing or self._paused: + return + hv.hio_read_start(self._hio) + + cdef _init_extra(self): + if self._hio is NULL: + return + if 'sockname' not in self._extra: + self._extra['sockname'] = _sockaddr_to_pyaddr( + hv.hio_localaddr(self._hio)) + if 'peername' not in self._extra: + self._extra['peername'] = _sockaddr_to_pyaddr( + hv.hio_peeraddr(self._hio)) + + cdef _deliver_buffered(self, char* buf, Py_ssize_t nread): + # asyncio.BufferedProtocol delivery (M4; used by the 3.11+ + # SSLProtocol): copy the libhv loop-shared readbuf into the buffer(s) + # the protocol exposes via get_buffer(). The protocol's buffer may be + # smaller than nread, so loop in chunks; every chunk is fully copied + # before buffer_updated() runs (which may consume/replace the buffer). + cdef Py_ssize_t offset = 0 + cdef Py_ssize_t n + cdef Py_buffer pybuf + while offset < nread: + if self._hio is NULL or self._protocol is None: + # buffer_updated() closed the transport mid-delivery; the + # remaining ciphertext belongs to a dead connection. + return + buf_obj = self._protocol.get_buffer(nread - offset) + PyObject_GetBuffer(buf_obj, &pybuf, PyBUF_WRITABLE) + try: + n = pybuf.len + if n <= 0: + raise RuntimeError( + 'get_buffer() returned an empty buffer') + if n > nread - offset: + n = nread - offset + memcpy(pybuf.buf, buf + offset, n) + finally: + PyBuffer_Release(&pybuf) + self._protocol.buffer_updated(n) + offset += n + + cdef _teardown_failed_connect(self): + # Close a never-exposed (still-connecting) transport. There is no + # protocol yet, so the close dispatch only cleans up bookkeeping. + cdef hv.hio_t* io = self._hio + if io is NULL: + return + self._closing = True + # Force the immediate-close path even if libhv buffered something. + hv.hvloop_hio_set_error(io, _ECONNABORTED) + hv.hio_close(io) + + # -- extra info ------------------------------------------------------------ + def get_extra_info(self, name, default=None): + if name == 'socket': + # Decision (plan section 6): expose a dup()-based socket.socket. + # It is a real socket object (uvicorn et al. call getsockname / + # setsockopt on it) on an independent descriptor, so user code + # closing or leaking it can never close the fd libhv owns. It is + # cached and closed together with the transport. + if self._sock_view is None: + if self._hio is NULL: + return default + try: + self._sock_view = _dup_socket_view(hv.hio_fd(self._hio)) + except OSError: + return default + return self._sock_view + if name in self._extra: + return self._extra[name] + if self._hio is not NULL and name in ('sockname', 'peername'): + self._init_extra() + return self._extra.get(name, default) + return default + + # -- protocol / state ------------------------------------------------------ + def set_protocol(self, protocol): + self._protocol = protocol + self._proto_buffered = isinstance(protocol, aio_BufferedProtocol) + + def get_protocol(self): + return self._protocol + + def is_closing(self): + return self._closing or self._hio is NULL + + # -- reading (plan section 6: hio_read_stop / hio_read_start) -------------- + def is_reading(self): + return (self._hio is not NULL and not self._closing and + not self._paused and self._protocol_connected) + + def pause_reading(self): + # asyncio semantics: idempotent, no-op while closing/closed. + if self._closing or self._hio is NULL or self._paused: + return + self._paused = True + hv.hio_read_stop(self._hio) + + def resume_reading(self): + if self._closing or self._hio is NULL or not self._paused: + return + self._paused = False + hv.hio_read_start(self._hio) + + # -- writing ---------------------------------------------------------------- + def write(self, object data): + cdef int rc + if not isinstance(data, (bytes, bytearray, memoryview)): + raise TypeError( + 'data argument must be a bytes-like object, not ' + '{!r}'.format(type(data).__name__)) + if self._eof_pending or self._eof_written: + raise RuntimeError('Cannot call write() after write_eof()') + if len(data) == 0: + return + if self._closing or self._hio is NULL: + # Same accounting/warning behaviour as asyncio's selector + # transport for writes after the connection was lost. + if self._conn_lost >= _LOG_THRESHOLD_FOR_CONNLOST_WRITES: + aio_logger.warning('socket.send() raised exception.') + self._conn_lost += 1 + return + if not isinstance(data, bytes): + data = bytes(data) + # hio_write either sends immediately or memcpy's the remainder into + # its own write queue before returning, so a temporary is fine. + rc = hv.hio_write(self._hio, PyBytes_AS_STRING(data), + PyBytes_GET_SIZE(data)) + if rc < 0: + # The connection broke; libhv has scheduled the close path, which + # delivers connection_lost with hio_error. + return + self._maybe_pause_protocol() + + def writelines(self, list_of_data): + self.write(b''.join(list_of_data)) + + cdef _maybe_pause_protocol(self): + if self._hio is NULL or self._protocol_paused: + return + if hv.hio_write_bufsize(self._hio) <= self._high_water: + return + self._protocol_paused = True + try: + self._protocol.pause_writing() + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as exc: + self._loop.call_exception_handler({ + 'message': 'protocol.pause_writing() failed', + 'exception': exc, + 'transport': self, + 'protocol': self._protocol, + }) + + def get_write_buffer_size(self): + if self._hio is NULL: + return 0 + return hv.hio_write_bufsize(self._hio) + + def get_write_buffer_limits(self): + return (self._low_water, self._high_water) + + def set_write_buffer_limits(self, high=None, low=None): + if high is None: + if low is None: + high = _FLOW_CONTROL_HIGH_WATER + else: + high = 4 * low + if low is None: + low = high // 4 + if not high >= low >= 0: + raise ValueError( + 'high ({!r}) must be >= low ({!r}) must be >= 0'.format( + high, low)) + self._high_water = high + self._low_water = low + self._maybe_pause_protocol() + + # -- EOF / closing ------------------------------------------------------------ + def can_write_eof(self): + return True + + def write_eof(self): + # Plan section 6: libhv has no half-close API; shutdown(SHUT_WR) on + # the raw fd once the libhv write buffer has drained. + if self._eof_pending or self._eof_written: + return + if self._closing or self._hio is NULL: + return + self._eof_pending = True + if hv.hio_write_bufsize(self._hio) == 0: + self._do_write_eof() + + cdef _do_write_eof(self): + self._eof_written = True + if self._hio is not NULL: + hv.hvloop_shutdown_wr(hv.hio_fd(self._hio)) + + def close(self): + # Graceful close: stop reading; libhv's hio_close itself defers the + # actual close until the write queue is flushed (nio.c), then fires + # the close callback -> connection_lost(None). + if self._closing or self._hio is NULL: + return + self._closing = True + hv.hio_read_stop(self._hio) + hv.hio_close(self._hio) + + def abort(self): + cdef hv.hio_t* io = self._hio + if io is NULL: + return + self._aborted = True + self._closing = True + # hio_close defers while the write queue is non-empty and error == 0; + # setting an error forces the immediate-close path (buffer discarded). + hv.hvloop_hio_set_error(io, _ECONNABORTED) + hv.hio_close(io) + + def _force_close(self, exc): + # asyncio-private transport API (called by asyncio.sslproto's + # _fatal_error, and by asyncio internals generally): close + # immediately, discarding buffered writes, and deliver ``exc`` to + # protocol.connection_lost. + cdef hv.hio_t* io = self._hio + if io is NULL: + return + self._force_close_exc = exc + self._aborted = True # suppress eof_received / hio_error mapping + self._closing = True + hv.hvloop_hio_set_error(io, _ECONNABORTED) + hv.hio_close(io) + + def _call_connection_lost(self, exc, eof): + # Scheduled via call_soon by the close dispatch, so protocol code runs + # outside the libhv callback stack and KI/SE propagate through + # Handle._run naturally. + protocol = self._protocol + if protocol is None: + return + try: + if eof: + try: + protocol.eof_received() + # Documented deviation (plan section 6): libhv closes the + # connection as soon as it sees EOF, so returning True + # from eof_received() cannot keep the transport open for + # writing; connection_lost always follows. + except (KeyboardInterrupt, SystemExit): + raise + except BaseException as eof_exc: + self._loop.call_exception_handler({ + 'message': 'protocol.eof_received() failed', + 'exception': eof_exc, + 'transport': self, + 'protocol': protocol, + }) + protocol.connection_lost(exc) + finally: + self._protocol = None + server = self._server + self._server = None + if server is not None: + server._detach() + if self._sock_view is not None: + try: + self._sock_view.close() + except OSError: + pass + self._sock_view = None + + def _loop_close_teardown(self): + # Called by Loop.close() right before hloop_free: detach this wrapper + # from the C structures so nothing re-enters Python while libhv frees + # (and, for our self-owned fds, closes) the ios. Mutually exclusive + # with the close dispatch: the loop is not running and we clear the + # close callback before hloop_free can invoke it. + cdef hv.hio_t* io = self._hio + if io is NULL: + return + self._hio = NULL + self._closing = True + hv.hio_setcb_read(io, NULL) + hv.hio_setcb_write(io, NULL) + hv.hio_setcb_close(io, NULL) + hv.hio_setcb_connect(io, NULL) + hv.hio_set_context(io, NULL) + waiter = self._waiter + self._waiter = None + if waiter is not None and not waiter.done(): + waiter.cancel() + if self._sock_view is not None: + try: + self._sock_view.close() + except OSError: + pass + self._sock_view = None + self._protocol = None + self._server = None + Py_DECREF(self) + + +# =========================================================================== +# fd watching & Unix signal support (M2b, plan sections 5 & 9) +# =========================================================================== + +def _sighandler_noop(signum, frame): + """Python-level no-op signal handler installed by add_signal_handler(). + + The real work happens in CPython's C-level handler, which writes the + signal number to the wakeup fd (signal.set_wakeup_fd); this stub merely + keeps a C-level handler installed (SIG_DFL/SIG_IGN would bypass the + wakeup-fd write entirely). + """ + pass + + +cdef int _fileobj_to_fd(object fileobj) except -1: + # asyncio/selectors semantics: an int fd, or any object with fileno(). + cdef int fd + if isinstance(fileobj, int): + fd = fileobj + else: + try: + fd = int(fileobj.fileno()) + except (AttributeError, TypeError, ValueError): + raise ValueError( + 'Invalid file object: {!r}'.format(fileobj)) from None + if fd < 0: + raise ValueError('Invalid file descriptor: {}'.format(fd)) + return fd + + +cdef void __fd_watcher_cb(hv.hio_t* io) noexcept nogil: + # Installed via hio_add as the io's raw event-dispatch callback, REPLACING + # nio.c's hio_handle_events (hloop.c: io->cb = cb): libhv therefore never + # reads/writes the fd itself for watched fds. + with gil: + _fd_watcher_dispatch(io) + + +cdef void _fd_watcher_dispatch(hv.hio_t* io): + cdef int revents = hv.hio_revents(io) + cdef void* ctx = hv.hio_context(io) + cdef _FDWatcher w + # Mirror the tail of nio.c's hio_handle_events: the iowatcher backends + # accumulate readiness with |= into io->revents, so it must be cleared + # after every dispatch or a stale HV_READ/HV_WRITE bit would mis-dispatch + # the wrong direction on this io's next wakeup. + hv.hvloop_io_clear_revents(io) + if ctx is NULL: + return + w = <_FDWatcher>ctx + if w._hio is not io: + return + try: + if (revents & hv.HV_READ) and w._reader is not None: + # Handle._run routes ordinary exceptions to the loop's exception + # handler itself; only KeyboardInterrupt/SystemExit re-raise. + w._reader._run() + # The reader callback may have removed the writer or torn the whole + # watcher down (w._hio nulled): re-check before the writer dispatch. + if (w._hio is io and (revents & hv.HV_WRITE) and + w._writer is not None): + w._writer._run() + except (KeyboardInterrupt, SystemExit) as exc: + _pump_base_exc(w._loop, exc) + + +@cython.no_gc_clear +cdef class _FDWatcher: + """Raw readiness watcher for one caller-owned fd (add_reader/add_writer). + + Design (M2b): hio_get(loop, fd) + hio_add(io, __fd_watcher_cb, events). + hio_add REPLACES the io's event-dispatch callback, so libhv's nio layer + never touches the fd; __fd_watcher_cb translates hio_revents() into the + reader/writer Handles and clears revents, exactly like the tail of + hio_handle_events. The poll backends are level-triggered, so a writer + keeps firing while the fd stays writable and a reader while data is + pending (asyncio semantics). + + fd ownership: always the caller's. Teardown (last remove_* or + loop.close()) unregisters via hvloop_hio_release_external, which never + closes the fd -- the fd must remain valid and usable afterwards. + + Reference discipline (mirrors TimerHandle/_TCPListener): Py_INCREF at + registration plus loop._hio_objs/_fd_watchers tracking; _teardown() is + the single release point (guarded by _hio == NULL), reachable from + _remove() and from Loop.close(). + + Constraints (documented, not enforced): a watched fd must not + simultaneously be owned by a transport/listener of the same loop (both + would fight over io->cb), and libhv's high-level hio_read/hio_write API + must not be used on a watched io. libhv also flips watched socket fds to + non-blocking mode (hio_ready -> hio_socket_init). + """ + + cdef: + Loop _loop + hv.hio_t* _hio + int _fd + Handle _reader # persistent (_repeat) Handle, or None + Handle _writer # persistent (_repeat) Handle, or None + object __weakref__ + + @staticmethod + cdef _FDWatcher new(Loop loop, int fd): + cdef _FDWatcher self = _FDWatcher.__new__(_FDWatcher) + self._loop = loop + self._fd = fd + self._reader = None + self._writer = None + self._hio = hv.hio_get(loop.hvloop, fd) + if self._hio is NULL: + raise RuntimeError('hio_get() failed for fd {}'.format(fd)) + hv.hio_set_context(self._hio, self) + # Registration reference (same discipline as TimerHandle): released + # exactly once in _teardown(). + Py_INCREF(self) + loop._hio_objs.add(self) + loop._fd_watchers[fd] = self + return self + + def __repr__(self): + return '<_FDWatcher fd={} reader={} writer={}>'.format( + self._fd, self._reader is not None, self._writer is not None) + + cdef _add(self, int events, object callback, tuple args): + # events is exactly HV_READ or HV_WRITE (enforced by the callers). + cdef Handle handle + cdef Handle old + if self._hio is NULL: + raise RuntimeError( + 'fd watcher for fd {} is already closed'.format(self._fd)) + if hv.hio_add(self._hio, __fd_watcher_cb, events) != 0: + raise OSError( + 'hio_add() failed for fd {} (events={})'.format( + self._fd, events)) + handle = Handle(callback, args, self._loop, None) + handle._repeat = True # runs once per readiness event, not consumed + if events == hv.HV_READ: + old = self._reader + self._reader = handle + else: + old = self._writer + self._writer = handle + if old is not None: + # add_reader/add_writer on an already-watched direction replaces + # the previous callback (asyncio semantics). + old.cancel() + + cdef bint _remove(self, int events): + cdef Handle old + if events == hv.HV_READ: + old = self._reader + self._reader = None + else: + old = self._writer + self._writer = None + if old is None: + return False + old.cancel() + if self._hio is not NULL: + if self._reader is None and self._writer is None: + # Last direction removed: fully unregister (this also + # deregisters both events) without closing the caller's fd. + self._teardown() + else: + hv.hio_del(self._hio, events) + return True + + cdef _teardown(self): + cdef hv.hio_t* io = self._hio + if io is NULL: + return + self._hio = NULL + self._loop._hio_objs.discard(self) + self._loop._fd_watchers.pop(self._fd, None) + if self._reader is not None: + self._reader.cancel() + self._reader = None + if self._writer is not None: + self._writer.cancel() + self._writer = None + # Caller-owned fd: unregister from libhv WITHOUT closing it (the + # io_type is reset so hio_close skips closesocket; the context and + # all C callbacks are cleared so nothing re-enters Python -- see + # hvloop_shim.h). Safe both mid-dispatch (a callback removing its own + # watcher) and from Loop.close(). + hv.hvloop_hio_release_external(io) + Py_DECREF(self) + + def _loop_close_teardown(self): + # Called by Loop.close() before hloop_free; the caller's fd stays + # open and usable afterwards (M2b requirement). + self._teardown() diff --git a/src/hvloop/hvloop_shim.h b/src/hvloop/hvloop_shim.h new file mode 100644 index 0000000..9d29a3b --- /dev/null +++ b/src/hvloop/hvloop_shim.h @@ -0,0 +1,121 @@ +#ifndef HVLOOP_SHIM_H +#define HVLOOP_SHIM_H +/* hloop_t is opaque in the public hloop.h; the struct definition lives in + * libhv's internal header event/hevent.h, which is already on our include + * path. Including the real header keeps field offsets correct for the + * vendored libhv version. */ +#include "hevent.h" + +static inline void hvloop_set_status_running(hloop_t* loop) { + loop->status = HLOOP_STATUS_RUNNING; +} +static inline void hvloop_set_status_stop(hloop_t* loop) { + loop->status = HLOOP_STATUS_STOP; +} + +/* --------------------------------------------------------------------------- + * TCP (M2a) helpers. + * ------------------------------------------------------------------------- */ + +/* hio_close() defers the actual close while the write queue is non-empty and + * io->error == 0 (graceful flush, nio.c). Setting an error first forces the + * immediate-close path; transport.abort() uses this to discard the buffer. */ +static inline void hvloop_hio_set_error(hio_t* io, int err) { + io->error = err; +} + +/* shutdown(SHUT_WR) for transport.write_eof(); libhv has no half-close API + * (tech design section 6). SD_SEND == SHUT_WR == 1, but spell both out. */ +static inline int hvloop_shutdown_wr(int fd) { +#ifdef OS_WIN + return shutdown(fd, SD_SEND); +#else + return shutdown(fd, SHUT_WR); +#endif +} + +/* Release an hio that wraps a *caller-owned* fd (create_server(sock=...)) + * WITHOUT closing the fd (tech design section 7: the fd stays owned by the + * Python socket object). + * - all callbacks/context are cleared so nothing re-enters Python; + * - io_type is reset to HIO_TYPE_UNKNOWN so hio_close() skips + * closesocket(io->fd) (nio.c only closes HIO_TYPE_SOCKET/PIPE fds); + * - hio_close() then unregisters the fd from the io watcher (hio_done -> + * hio_del) and clears any pending-event flags. + * The hio_t struct itself intentionally stays in loop->ios: freeing it here + * (hio_detach + hio_free) could leave a dangling pointer in the loop's + * pending-event queue if this runs from inside an io callback of the same + * poll iteration. libhv reuses the slot on the next hio_get(fd) and frees it + * in hloop_free. */ +static inline void hvloop_hio_release_external(hio_t* io) { + hio_setcb_accept(io, NULL); + hio_setcb_connect(io, NULL); + hio_setcb_read(io, NULL); + hio_setcb_write(io, NULL); + hio_setcb_close(io, NULL); + hio_set_context(io, NULL); + hevent_set_userdata(io, NULL); + hio_set_type(io, HIO_TYPE_UNKNOWN); + hio_close(io); +} + +/* --------------------------------------------------------------------------- + * fd watching (M2b) helpers. + * ------------------------------------------------------------------------- */ + +/* Clear io->revents after the raw fd-watcher callback dispatched the + * reader/writer handles. hio_add(io, cb, events) REPLACES the io's + * event-dispatch callback (hloop.c: io->cb = cb), so nio.c's + * hio_handle_events never runs for watched fds and its end-of-dispatch + * ``io->revents = 0`` must be mirrored here: the iowatcher backends + * accumulate readiness with |= (e.g. kqueue.c: io->revents |= HV_READ), so a + * stale bit would mis-dispatch the wrong direction on the io's next wakeup. */ +static inline void hvloop_io_clear_revents(hio_t* io) { + io->revents = 0; +} + +/* Pending socket error (SO_ERROR). libhv's nio_connect reports a failed + * connect via getpeername()'s errno (EINVAL on macOS, ENOTCONN on Linux) + * instead of the real connect error; the close dispatch for a connecting + * transport queries SO_ERROR to recover e.g. ECONNREFUSED. Returns the + * pending error, 0 if none, -1 if getsockopt itself failed. */ +static inline int hvloop_sock_error(int fd) { + int err = 0; + socklen_t len = (socklen_t)sizeof(err); + if (getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&err, &len) != 0) { + return -1; + } + return err; +} + +/* Decode a sockaddr into (family, ip, port, flowinfo, scope_id) for + * transport.get_extra_info('sockname'/'peername'). Returns the address + * family, or -1 if sa is NULL / undecodable. */ +static inline int hvloop_sockaddr_info(struct sockaddr* sa, + char* ip, int iplen, int* port, + uint32_t* flowinfo, uint32_t* scope_id) { + *port = 0; + *flowinfo = 0; + *scope_id = 0; + /* Families other than INET/INET6 return without writing ip; a caller that + * only checks for -1 must not read stale stack content as an address. */ + if (ip != NULL && iplen > 0) ip[0] = '\0'; + if (sa == NULL) return -1; + if (sa->sa_family == AF_INET) { + struct sockaddr_in* sin = (struct sockaddr_in*)sa; + if (inet_ntop(AF_INET, &sin->sin_addr, ip, iplen) == NULL) return -1; + *port = (int)ntohs(sin->sin_port); + return AF_INET; + } + if (sa->sa_family == AF_INET6) { + struct sockaddr_in6* sin6 = (struct sockaddr_in6*)sa; + if (inet_ntop(AF_INET6, &sin6->sin6_addr, ip, iplen) == NULL) return -1; + *port = (int)ntohs(sin6->sin6_port); + *flowinfo = ntohl(sin6->sin6_flowinfo); + *scope_id = (uint32_t)sin6->sin6_scope_id; + return AF_INET6; + } + return (int)sa->sa_family; +} + +#endif diff --git a/hvloop/includes/__init__.py b/src/hvloop/includes/__init__.py similarity index 100% rename from hvloop/includes/__init__.py rename to src/hvloop/includes/__init__.py diff --git a/src/hvloop/includes/hv.pxd b/src/hvloop/includes/hv.pxd new file mode 100644 index 0000000..04f7e1c --- /dev/null +++ b/src/hvloop/includes/hv.pxd @@ -0,0 +1,196 @@ +# cython: language_level=3 +# +# libhv C API declarations (subset needed for the M1 loop core). +# +# Truth source: vendor/libhv/event/hloop.h +# +# NOTE on GIL discipline: every C callback typedef below is invoked by libhv +# from inside ``hloop_process_events`` while we have released the GIL. The +# Cython functions we hand to these typedefs are therefore declared +# ``noexcept nogil`` and re-acquire the GIL with ``with gil`` internally. +# Functions that may block (``hloop_process_events``) are declared ``nogil`` +# so they can be called inside a ``with nogil:`` block. + +from libc.stdint cimport uint32_t, uint64_t + + +cdef extern from "hv/hloop.h" nogil: + # ----- opaque / event types ------------------------------------------- + ctypedef struct hloop_t + ctypedef struct htimer_t + ctypedef struct hidle_t + ctypedef struct hio_t + + # Opaque view of the C ``struct sockaddr`` (full definition comes from the + # platform headers pulled in by hloop.h -> hplatform.h). + cdef struct sockaddr: + pass + + ctypedef enum hevent_type_e: + HEVENT_TYPE_NONE = 0 + HEVENT_TYPE_IO = 0x00000001 + HEVENT_TYPE_TIMEOUT = 0x00000010 + HEVENT_TYPE_PERIOD = 0x00000020 + HEVENT_TYPE_TIMER = 0x00000030 + HEVENT_TYPE_IDLE = 0x00000100 + HEVENT_TYPE_SIGNAL = 0x00000200 + HEVENT_TYPE_CUSTOM = 0x00000400 + + ctypedef void (*hevent_cb) (hevent_t* ev) noexcept nogil + ctypedef void (*htimer_cb) (htimer_t* timer) noexcept nogil + ctypedef void (*hidle_cb) (hidle_t* idle) noexcept nogil + + # IO callbacks. libhv usually invokes these from hloop_process_events with + # the GIL released, but a few fire synchronously from a Python-held-GIL + # call (e.g. hio_write's direct-write completion, hio_close with an empty + # write queue). ``with gil`` handles both (PyGILState_Ensure is reentrant). + # Raw event-dispatch callback for hio_add. NOTE (M2b): hio_add REPLACES + # the io's event-dispatch callback (hloop.c: io->cb = (hevent_cb)cb); the + # high-level API installs nio.c's hio_handle_events there. Passing our own + # hio_cb means libhv never reads/writes the fd itself and we get raw + # readiness notifications (hio_revents) instead. + ctypedef void (*hio_cb) (hio_t* io) noexcept nogil + + ctypedef void (*haccept_cb) (hio_t* io) noexcept nogil + ctypedef void (*hconnect_cb)(hio_t* io) noexcept nogil + ctypedef void (*hread_cb) (hio_t* io, void* buf, int readbytes) noexcept nogil + ctypedef void (*hwrite_cb) (hio_t* io, const void* buf, int writebytes) noexcept nogil + ctypedef void (*hclose_cb) (hio_t* io) noexcept nogil + + # The public hevent_t struct. We only touch the fields we need; libhv lays + # the same header (HEVENT_FIELDS) at the start of htimer_t/hidle_t/hio_t, + # so casting those to hevent_t* to reach ``loop``/``userdata`` is valid. + ctypedef struct hevent_t: + hloop_t* loop + hevent_type_e event_type + uint64_t event_id + hevent_cb cb + void* userdata + void* privdata + int priority + + # ----- loop lifecycle ------------------------------------------------- + int HLOOP_FLAG_RUN_ONCE + int HLOOP_FLAG_AUTO_FREE + int HLOOP_FLAG_QUIT_WHEN_NO_ACTIVE_EVENTS + + hloop_t* hloop_new(int flags) + void hloop_free(hloop_t** pp) + + # Single iteration: poll ios (blocking up to timeout_ms, but clamped to the + # nearest htimer), then run timers/idles/pendings. Releases nothing on its + # own; we wrap calls in ``with nogil``. + int hloop_process_events(hloop_t* loop, int timeout_ms) nogil + + int hloop_stop(hloop_t* loop) + int hloop_wakeup(hloop_t* loop) + + # thread-safe; copies *ev into the loop's queue and writes the eventfd. + void hloop_post_event(hloop_t* loop, hevent_t* ev) + + void hloop_update_time(hloop_t* loop) + uint64_t hloop_now_us(hloop_t* loop) + + uint32_t hloop_nios(hloop_t* loop) + uint32_t hloop_ntimers(hloop_t* loop) + + # ----- timers --------------------------------------------------------- + htimer_t* htimer_add(hloop_t* loop, htimer_cb cb, + uint32_t timeout_ms, uint32_t repeat) + void htimer_del(htimer_t* timer) + + # ----- idle (unused in M1 but cheap to declare) ----------------------- + hidle_t* hidle_add(hloop_t* loop, hidle_cb cb, uint32_t repeat) + void hidle_del(hidle_t* idle) + + # ----- io (M2a: TCP transports / server) ------------------------------- + int HV_READ + int HV_WRITE + int HV_RDWR + + hio_t* hio_get(hloop_t* loop, int fd) + int hio_add(hio_t* io, hio_cb cb, int events) + int hio_del(hio_t* io, int events) + void hio_detach(hio_t* io) + + # Readiness bits (HV_READ/HV_WRITE) accumulated by the iowatcher for the + # current dispatch; cleared via hvloop_io_clear_revents (M2b fd watching). + int hio_revents(hio_t* io) + + uint32_t hio_id(hio_t* io) + int hio_fd(hio_t* io) + int hio_error(hio_t* io) + sockaddr* hio_localaddr(hio_t* io) + sockaddr* hio_peeraddr(hio_t* io) + void hio_set_context(hio_t* io, void* ctx) + void* hio_context(hio_t* io) + bint hio_is_opened(hio_t* io) + bint hio_is_closed(hio_t* io) + + void hio_setcb_accept (hio_t* io, haccept_cb accept_cb) + void hio_setcb_connect(hio_t* io, hconnect_cb connect_cb) + void hio_setcb_read (hio_t* io, hread_cb read_cb) + void hio_setcb_write (hio_t* io, hwrite_cb write_cb) + void hio_setcb_close (hio_t* io, hclose_cb close_cb) + + void hio_set_max_write_bufsize(hio_t* io, uint32_t size) + size_t hio_write_bufsize(hio_t* io) + void hio_set_connect_timeout(hio_t* io, int timeout_ms) + void hio_set_peeraddr(hio_t* io, sockaddr* addr, int addrlen) + + int hio_accept (hio_t* io) + int hio_connect(hio_t* io) + int hio_read (hio_t* io) + # These two are #define'd in hloop.h (hio_read / hio_del(io, HV_READ)); + # declaring them as functions lets the C preprocessor expand them. + int hio_read_start(hio_t* io) + int hio_read_stop (hio_t* io) + int hio_write (hio_t* io, const void* buf, size_t len) + int hio_close (hio_t* io) + + +# ----- hsocket helpers (linked into hv_static from libhv/base) ------------- +cdef extern from "hv/hsocket.h" nogil: + ctypedef union sockaddr_u: + sockaddr sa + + int sockaddr_set_ipport(sockaddr_u* addr, const char* host, int port) + int sockaddr_len(sockaddr_u* addr) + int tcp_nodelay(int sockfd, int on) + + +# Convenience setters mirroring the libhv macros (these are #defines in C, so +# we re-implement them as inline helpers here). +cdef inline void hevent_set_userdata(void* ev, void* udata) nogil: + (ev).userdata = udata + + +cdef inline void* hevent_get_userdata(void* ev) nogil: + return (ev).userdata + + +# --------------------------------------------------------------------------- +# Self-drive shim (src/hvloop/hvloop_shim.h). +# +# hvloop drives the loop via hloop_process_events rather than hloop_run, so the +# loop's status field stays at its initial HLOOP_STATUS_STOP. That makes +# hloop_process_events bail out right after the poll (hloop.c:170) and skip +# hloop_process_pendings, so IO callbacks (incl. the internal wakeup-fd reader) +# never run and the loop spins at 100% CPU. There is no public API to flip the +# status without entering hloop_run, so these helpers set it directly. We +# mirror hloop_run by setting RUNNING before the loop and STOP on exit. +# --------------------------------------------------------------------------- +cdef extern from "hvloop_shim.h" nogil: + void hvloop_set_status_running(hloop_t* loop) + void hvloop_set_status_stop(hloop_t* loop) + + # fd watching (M2b) helper; see hvloop_shim.h for rationale. + void hvloop_io_clear_revents(hio_t* io) + + # TCP (M2a) helpers; see hvloop_shim.h for rationale. + void hvloop_hio_set_error(hio_t* io, int err) + int hvloop_shutdown_wr(int fd) + int hvloop_sock_error(int fd) + void hvloop_hio_release_external(hio_t* io) + int hvloop_sockaddr_info(sockaddr* sa, char* ip, int iplen, int* port, + uint32_t* flowinfo, uint32_t* scope_id) diff --git a/src/hvloop/includes/python.pxd b/src/hvloop/includes/python.pxd new file mode 100644 index 0000000..f7d8786 --- /dev/null +++ b/src/hvloop/includes/python.pxd @@ -0,0 +1,6 @@ +# cython: language_level=3 +# +# Minimal CPython API surface used by the loop core. + +cdef extern from "Python.h": + int PY_VERSION_HEX diff --git a/tests/__init__.py b/tests/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/tests/certs/README.md b/tests/certs/README.md new file mode 100644 index 0000000..303e96d --- /dev/null +++ b/tests/certs/README.md @@ -0,0 +1,27 @@ +# hvloop test certificates + +Self-signed certificate + key used ONLY by the TLS test suite +(`tests/test_tls.py`). Do not use for anything real. + +Why not reuse `vendor/libhv/cert/server.crt`? That certificate carries **no +subjectAltName and no CN hostname**, so Python's `ssl` hostname verification +(which requires a SAN since 3.7) can never pass against it. A committed, +long-lived self-signed pair also avoids depending on an `openssl` CLI being +present at test time on every CI platform (notably Windows). + +Properties: + +* CN=localhost, SAN: DNS:localhost, IP:127.0.0.1, IP:::1 +* basicConstraints CA:TRUE (so the cert can act as its own trust anchor + when loaded via `SSLContext.load_verify_locations`) +* valid 20 years from 2026-07 + +Regenerate with: + +```sh +openssl req -x509 -newkey rsa:2048 -keyout server.key -out server.crt \ + -days 7300 -nodes -subj "/C=US/O=hvloop tests/CN=localhost" \ + -addext "subjectAltName=DNS:localhost,IP:127.0.0.1,IP:::1" \ + -addext "basicConstraints=critical,CA:TRUE" \ + -addext "keyUsage=critical,digitalSignature,keyEncipherment,keyCertSign" +``` diff --git a/tests/certs/server.crt b/tests/certs/server.crt new file mode 100644 index 0000000..161f036 --- /dev/null +++ b/tests/certs/server.crt @@ -0,0 +1,22 @@ +-----BEGIN CERTIFICATE----- +MIIDkTCCAnmgAwIBAgIUQFOcEcGMA7/OmzZtakptsz+c0aQwDQYJKoZIhvcNAQEL +BQAwODELMAkGA1UEBhMCVVMxFTATBgNVBAoMDGh2bG9vcCB0ZXN0czESMBAGA1UE +AwwJbG9jYWxob3N0MB4XDTI2MDcwMjAyMzM1M1oXDTQ2MDYyNzAyMzM1M1owODEL +MAkGA1UEBhMCVVMxFTATBgNVBAoMDGh2bG9vcCB0ZXN0czESMBAGA1UEAwwJbG9j +YWxob3N0MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwAmuCvU2KPnN +jRZ3l73NqI+avTvQaD9+YffXG1jTYo12CZTD9IrrTCF8o4e6d8naTfBd72NHBAHk +xVHmQp5+ctFo1W8NdRVLS70M4NWwI/BVg/1VcQ7ckBzs0wrnoDINgygnMni++Kmu +4kme8D9H1IsgXoWZDedRTO9zbg6t7HUv68rH8kVQYRLLtxhqbKT7L9cPoJSeryZm +4k6ezoTy+TdxvT3lvF5mLcdVM8y2eRXvRvSHSFKlPZOqCUkQBgN6pOb8gW8p7qQn +E66F4qTiZEfu17ieQzgYxiPUM70NsfR4od7XuivDYOc6y5NTd48lSSezDpzFPrSV +ENyjcD6hEQIDAQABo4GSMIGPMB0GA1UdDgQWBBQ27V8rmFmW7YB2PAzEQgimNq8e +YjAfBgNVHSMEGDAWgBQ27V8rmFmW7YB2PAzEQgimNq8eYjAsBgNVHREEJTAjggls +b2NhbGhvc3SHBH8AAAGHEAAAAAAAAAAAAAAAAAAAAAEwDwYDVR0TAQH/BAUwAwEB +/zAOBgNVHQ8BAf8EBAMCAqQwDQYJKoZIhvcNAQELBQADggEBABMe+jwgC09s3fVY +7G+BuyUIXYdXJ+AuP6Fvco53rp2W9JP/1v9128GP/4GFRxrKYCrzU2tNZFkEFvEp +nczm1puoS/67l+0xWXNRyxIOsB6Ks9mxIHivyXVc1o3giW/fkjmTx7wTmJ8Jd2B+ +lnjVYqFMN2CK4N097ID7GHetbHGGQUZJYNaOkgr7+9KtUZ9JR9vviO9t+YzWQ14i +lYFEetZI5X0mxVWCyvQ6vU6uK2Hi4y1CJktaGAWYoZfYR/IJ2TrBIuPz5PfWtqCs +Et9/CdMS7JCwcVTTEeO84UZZ1E5AwYpjiJIrhCdAOkPSHm88Nszbp4fjhayXGR2H +zZ3FSEg= +-----END CERTIFICATE----- diff --git a/tests/certs/server.key b/tests/certs/server.key new file mode 100644 index 0000000..b6b26ae --- /dev/null +++ b/tests/certs/server.key @@ -0,0 +1,28 @@ +-----BEGIN PRIVATE KEY----- +MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDACa4K9TYo+c2N +FneXvc2oj5q9O9BoP35h99cbWNNijXYJlMP0iutMIXyjh7p3ydpN8F3vY0cEAeTF +UeZCnn5y0WjVbw11FUtLvQzg1bAj8FWD/VVxDtyQHOzTCuegMg2DKCcyeL74qa7i +SZ7wP0fUiyBehZkN51FM73NuDq3sdS/rysfyRVBhEsu3GGpspPsv1w+glJ6vJmbi +Tp7OhPL5N3G9PeW8XmYtx1UzzLZ5Fe9G9IdIUqU9k6oJSRAGA3qk5vyBbynupCcT +roXipOJkR+7XuJ5DOBjGI9QzvQ2x9Hih3te6K8Ng5zrLk1N3jyVJJ7MOnMU+tJUQ +3KNwPqERAgMBAAECggEALiNFOuG+EOsvbOnMctsJqalS2osf36P9l8kFV88n/kIR +bWzeBYdIz+ItwVZPQQ9wkRAiaWzXN4nC7ntmUHQm2iwgvUKwn4QtsnUpvmzopEHO +MedwGzkgWclxRqUUkELmRzAi9rfW3gRafYiFlKAHgHOqo7sCUjpUqKDRAUyqkagM +3mQf4hbVueWqlttDG4rAKhWBbL7QCaVRbOqEIX7hKsGkOZ2xbAJOUsKg/a13hzcd +BrqTyiqIMIAF2llCZnsk/T5ZL32v9s5CPjMuPmPvkIJItgYpksqThksNxKer4Tgd +pSaEBbDgzUD9AWJC9XJl5DJDMXsc4qncd4wDeEJdTwKBgQD3Od5CoQktDa768rZ6 +fxwQ30srO3d95T6X6sL5n6T9j+Pd4Os0gqs55dtTG6Y9+zwh+TIkEoEZTqG/Xw3q +PO2sEJljKXcPtmMVRISp3ADIePQqYBNjJZOHWPdH7O/Sq3ERWcj73JWe/BzTwQzb +Zby3rj+MMUfXbAvkgu7/jQzIywKBgQDG2mhwgLkIEpGNG0VhKgb9Rl2k906wF8EL ++T7WuyVW8dQq0VNNJnyUS1puvuQj62H9AlNn69hBcas+K9ncMfHDGCvW0e9ptU2+ +C6epUoJIuHbwe4iGVkb8ilMONDHWmxvlKu5bEdGkA3hREdZZo2M/CfV0AftYoR1s +pMezT/3uEwKBgH67GFc5a5W/zPHxF1+l5wIzJLpNqoxLxpFjk30YvCAK8bkcghWR +4io0zQBGTSq6rfGQZ4acQbdyWnHaTSzE/OTWQXrWl6TjTtlpHURhdblOX4OVanrJ +mV2pWmFxcOKiZbyKNP/+7GfqPvDBplCVT28tEIBSBszEIziJcfBoIqSPAoGAGHup +ojhnD7RhkVMLPsRS6fow62+7k3jJPvUoJH4UQdkyezccn4Ieko+YicwdAMMpZGJV +7JSgIqahI914TGEl2BRwyVk9tfEpqj17HiDXg6aalk9PZuLWiJ9rTHNms3qTe6rG +gBX4js4SkUC1+IFiZc+PFgJsdOQZYFgFcnFl3VsCgYEAvF+jWQejmbQUARJVe5HO +n14T1ICfdzq9c8lJ5DOSWLP0NunwMr91sgnqAy3jdy2nvar/579YfleBLIxfhIUD +Ywy7TsVzADYKugLg0GmqteSOYMo4lnqC2TyGjIupi6nPaYqAT2/WNBY1JrQaqhq4 +j9iePuATqSKRd7SgjxrVkPo= +-----END PRIVATE KEY----- diff --git a/tests/conftest.py b/tests/conftest.py new file mode 100644 index 0000000..067fadc --- /dev/null +++ b/tests/conftest.py @@ -0,0 +1,25 @@ +"""Shared pytest configuration for the hvloop test suite. + +Most hvloop tests are *synchronous* functions that construct their own Loop and +drive it explicitly (run_forever / run_until_complete). The project-level +pytest config sets ``asyncio_mode = "auto"``, which would otherwise try to run +every ``async def`` test on the stdlib loop. We don't want that to interfere, +so async coroutine-style assertions in this suite are driven manually via +``hvloop.run(...)`` inside synchronous tests rather than relying on +pytest-asyncio's auto mode. +""" + +import pytest + +import hvloop + + +@pytest.fixture +def loop(): + """Provide a fresh hvloop event loop, closed on teardown.""" + lp = hvloop.new_event_loop() + try: + yield lp + finally: + if not lp.is_closed(): + lp.close() diff --git a/tests/test_asgi.py b/tests/test_asgi.py new file mode 100644 index 0000000..c429c44 --- /dev/null +++ b/tests/test_asgi.py @@ -0,0 +1,498 @@ +"""M3 ASGI acceptance tests: uvicorn + FastAPI (HTTP & WebSocket) on hvloop. + +Plan section 12.3 (the acceptance gate): a real uvicorn server serving a real +FastAPI app over real TCP, driven together with real clients (httpx for HTTP, +the ``websockets`` library for WebSocket) -- everything on ONE hvloop event +loop. + +Harness design +-------------- +Each test uses the synchronous ``loop`` fixture (a fresh ``hvloop`` loop) and +drives an ``async def main()`` via ``loop.run_until_complete``. Inside, we run +``uvicorn.Server(Config(...)).serve()`` as a task on that very loop and talk to +it from httpx/websockets clients on the same loop. Both the inbound +(create_server) and outbound (create_connection) TCP paths are thus exercised +at once. In this serve()-as-task mode uvicorn never creates a loop itself +(``Config.get_loop_factory()`` is not consulted), so no policy juggling is +needed and the suite avoids ``asyncio.set_event_loop_policy`` -- deprecated on +Python 3.14. + +uvicorn's OWN loop construction (``Server.run()`` -> ``get_loop_factory()`` + +``asyncio_run``) is covered separately by the wiring regression tests at the +bottom of this file. NOTE: with uvicorn >= 0.36, ``loop="asyncio"`` maps +directly to ``asyncio.SelectorEventLoop`` and ignores the event-loop policy; +the supported production wirings are ``loop="hvloop:new_event_loop"`` +(recommended, used by ``examples/fastapi_app.py``) and ``hvloop.install()`` + +``loop="none"`` -- both documented in the README. +""" + +from __future__ import annotations + +import asyncio +import contextlib +import importlib.util +import signal +import socket +import sys +import threading +import time + +import pytest + +# The ASGI stack is an optional test-only dependency (pyproject [test] extra). +# Skip the whole module cleanly rather than error if it is missing. +fastapi = pytest.importorskip("fastapi") +httpx = pytest.importorskip("httpx") +uvicorn = pytest.importorskip("uvicorn") +websockets = pytest.importorskip("websockets") + +from fastapi import FastAPI, WebSocket, WebSocketDisconnect # noqa: E402 +from fastapi.responses import StreamingResponse # noqa: E402 + + +# --------------------------------------------------------------------------- +# HTTP protocol matrix: h11 is always available; add httptools when installed +# so we cover both of uvicorn's HTTP implementations against our transport. +# --------------------------------------------------------------------------- +HTTP_PROTOCOLS = ["h11"] +if importlib.util.find_spec("httptools") is not None: + HTTP_PROTOCOLS.append("httptools") + + +# --------------------------------------------------------------------------- +# App under test +# --------------------------------------------------------------------------- +def make_app(lifespan_events=None): + """Build a FastAPI app. If ``lifespan_events`` (a list) is given, append + "startup"/"shutdown" markers to it around ``yield`` so lifespan ordering + can be asserted.""" + lifespan = None + if lifespan_events is not None: + @contextlib.asynccontextmanager + async def lifespan(_app): # noqa: F811 + lifespan_events.append("startup") + try: + yield + finally: + lifespan_events.append("shutdown") + + app = FastAPI(lifespan=lifespan) + + @app.get("/json") + async def json_endpoint(): + return {"framework": "fastapi", "value": 123} + + @app.get("/items/{item_id}") + async def read_item(item_id: int, q: str | None = None): + # Path param is coerced to int by FastAPI; query param is optional. + return {"item_id": item_id, "q": q, "doubled": item_id * 2} + + @app.get("/async") + async def async_endpoint(): + return {"mode": "async", "on_main_thread": _is_main_thread()} + + @app.get("/sync") + def sync_endpoint(): + # Starlette runs plain ``def`` endpoints in a worker thread; proving we + # are NOT on the loop/main thread shows the thread pool path works. + return {"mode": "sync", "on_main_thread": _is_main_thread()} + + @app.get("/stream") + async def stream_endpoint(): + async def gen(): + for i in range(5): + yield f"chunk{i}\n".encode() + await asyncio.sleep(0) + return StreamingResponse(gen(), media_type="text/plain") + + @app.websocket("/ws") + async def ws_echo(ws: WebSocket): + await ws.accept() + try: + while True: + msg = await ws.receive_text() + await ws.send_text("echo:" + msg) + except WebSocketDisconnect: + pass + + return app + + +def _is_main_thread(): + return threading.current_thread() is threading.main_thread() + + +# Shared app for the stateless tests (built once). +APP = make_app() + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- +def _free_port(): + with socket.socket() as s: + s.bind(("127.0.0.1", 0)) + return s.getsockname()[1] + + +@contextlib.asynccontextmanager +async def running_server(app, **config_kwargs): + """Start ``uvicorn`` serving ``app`` as a task on the current hvloop loop, + yield ``(server, port)`` once it is up, and shut it down gracefully via + ``should_exit`` on exit.""" + port = _free_port() + # No ``loop=`` setting: serve() runs on the caller's (hvloop) loop, so + # Config.get_loop_factory() is never consulted in this mode. + config = uvicorn.Config( + app, + host="127.0.0.1", + port=port, + log_level="warning", + **config_kwargs, + ) + server = uvicorn.Server(config) + task = asyncio.get_running_loop().create_task(server.serve()) + try: + deadline = time.monotonic() + 10.0 + while not server.started: + if task.done(): + task.result() # re-raise a startup failure, if any + raise RuntimeError("uvicorn task ended before startup") + if time.monotonic() > deadline: + raise TimeoutError("uvicorn did not start within 10s") + await asyncio.sleep(0.01) + yield server, port + finally: + server.should_exit = True + with contextlib.suppress(asyncio.TimeoutError): + await asyncio.wait_for(asyncio.shield(task), timeout=10.0) + if not task.done(): + task.cancel() + with contextlib.suppress(BaseException): + await task + + +# --------------------------------------------------------------------------- +# HTTP: JSON, path/query params, async vs sync (thread pool), streaming +# --------------------------------------------------------------------------- +@pytest.mark.parametrize("http_protocol", HTTP_PROTOCOLS) +def test_http_json_endpoint(loop, http_protocol): + async def main(): + async with running_server(APP, http=http_protocol) as (_server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + r = await client.get("/json") + assert r.status_code == 200 + assert r.json() == {"framework": "fastapi", "value": 123} + + loop.run_until_complete(main()) + + +@pytest.mark.parametrize("http_protocol", HTTP_PROTOCOLS) +def test_http_path_and_query_params(loop, http_protocol): + async def main(): + async with running_server(APP, http=http_protocol) as (_server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + r = await client.get("/items/42", params={"q": "hello"}) + assert r.status_code == 200 + assert r.json() == {"item_id": 42, "q": "hello", "doubled": 84} + + # Missing optional query param. + r = await client.get("/items/7") + assert r.json() == {"item_id": 7, "q": None, "doubled": 14} + + # Bad path param type -> FastAPI validation error (422). + r = await client.get("/items/not-an-int") + assert r.status_code == 422 + + loop.run_until_complete(main()) + + +def test_http_async_and_sync_endpoints(loop): + """async def endpoints run on the loop (main) thread; plain def endpoints + run in the thread pool (not the main thread).""" + async def main(): + async with running_server(APP) as (_server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + ra = await client.get("/async") + assert ra.status_code == 200 + assert ra.json() == {"mode": "async", "on_main_thread": True} + + rs = await client.get("/sync") + assert rs.status_code == 200 + body = rs.json() + assert body["mode"] == "sync" + assert body["on_main_thread"] is False + + loop.run_until_complete(main()) + + +def test_http_streaming_response(loop): + async def main(): + async with running_server(APP) as (_server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + expected = b"".join(f"chunk{i}\n".encode() for i in range(5)) + + # Buffered read. + r = await client.get("/stream") + assert r.status_code == 200 + assert r.content == expected + # No Content-Length -> chunked transfer encoding. + assert "content-length" not in r.headers + + # Incremental streaming read: collect chunks as they arrive. + collected = bytearray() + async with client.stream("GET", "/stream") as resp: + assert resp.status_code == 200 + async for chunk in resp.aiter_bytes(): + collected.extend(chunk) + assert bytes(collected) == expected + + loop.run_until_complete(main()) + + +def test_http_concurrent_requests(loop): + """Many concurrent in-flight requests on one loop stay correct.""" + async def main(): + async with running_server(APP) as (_server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + results = await asyncio.gather( + *(client.get(f"/items/{i}") for i in range(25)) + ) + for i, r in enumerate(results): + assert r.status_code == 200 + assert r.json()["item_id"] == i + + loop.run_until_complete(main()) + + +# --------------------------------------------------------------------------- +# Lifespan startup/shutdown ordering +# --------------------------------------------------------------------------- +def test_lifespan_startup_shutdown_order(loop): + events: list[str] = [] + app = make_app(lifespan_events=events) + + async def main(): + async with running_server(app, lifespan="on") as (_server, port): + # startup must have fired before we can serve a request. + assert events == ["startup"] + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + r = await client.get("/json") + assert r.status_code == 200 + # shutdown has not fired yet (server still running). + assert events == ["startup"] + # After graceful shutdown the shutdown event has fired, in order. + assert events == ["startup", "shutdown"] + + loop.run_until_complete(main()) + + +# --------------------------------------------------------------------------- +# WebSocket: echo, and two concurrent connections that don't cross-talk +# --------------------------------------------------------------------------- +def test_websocket_echo(loop): + async def main(): + async with running_server(APP) as (_server, port): + uri = f"ws://127.0.0.1:{port}/ws" + async with websockets.connect(uri) as ws: + await ws.send("hello") + assert await ws.recv() == "echo:hello" + await ws.send("world") + assert await ws.recv() == "echo:world" + + loop.run_until_complete(main()) + + +def test_websocket_two_connections_isolated(loop): + async def main(): + async with running_server(APP) as (_server, port): + uri = f"ws://127.0.0.1:{port}/ws" + async with websockets.connect(uri) as a, websockets.connect(uri) as b: + # Interleave sends; each connection must only see its own echoes. + await a.send("a1") + await b.send("b1") + assert await a.recv() == "echo:a1" + assert await b.recv() == "echo:b1" + + await b.send("b2") + await a.send("a2") + assert await b.recv() == "echo:b2" + assert await a.recv() == "echo:a2" + + loop.run_until_complete(main()) + + +# --------------------------------------------------------------------------- +# Graceful exit: should_exit returns serve() and frees the port +# --------------------------------------------------------------------------- +def test_graceful_should_exit_releases_port(loop): + async def main(): + async with running_server(APP) as (_server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + assert (await client.get("/json")).status_code == 200 + # Server has stopped; the listen port must be free to rebind. + s = socket.socket() + s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + try: + s.bind(("127.0.0.1", port)) + finally: + s.close() + return port + + loop.run_until_complete(main()) + + +# --------------------------------------------------------------------------- +# Graceful exit via SIGINT (uvicorn's default signal path) +# +# uvicorn 0.49's Server.capture_signals() installs signal.signal(SIGINT, +# handle_exit) directly (not loop.add_signal_handler) whenever serve() runs on +# the main thread, and RE-RAISES any captured signal after serve() returns. We +# install a no-op SIGINT handler first so (a) that no-op is what capture_signals +# saves/restores and (b) the trailing re-raise hits the no-op instead of +# KeyboardInterrupt, then restore the real handler in finally. +# --------------------------------------------------------------------------- +@pytest.mark.skipif( + sys.platform == "win32", reason="POSIX signal semantics (plan section 9)" +) +def test_sigint_graceful_return(loop): + async def main(): + async with running_server(APP) as (server, port): + async with httpx.AsyncClient( + base_url=f"http://127.0.0.1:{port}" + ) as client: + assert (await client.get("/json")).status_code == 200 + # Deliver SIGINT: uvicorn's handle_exit sets should_exit=True and + # main_loop() notices it on its next 0.1s tick, so serve() returns. + signal.raise_signal(signal.SIGINT) + deadline = time.monotonic() + 10.0 + while not server.should_exit: + if time.monotonic() > deadline: + raise TimeoutError("SIGINT did not set should_exit") + await asyncio.sleep(0.01) + # running_server's __aexit__ then awaits serve() to completion. + + prev = signal.getsignal(signal.SIGINT) + signal.signal(signal.SIGINT, lambda *_a: None) + try: + loop.run_until_complete(main()) + finally: + signal.signal(signal.SIGINT, prev) + + +# --------------------------------------------------------------------------- +# Outbound: httpx.AsyncClient against the local uvicorn server exercises the +# create_connection() client path (this is what M3's "出站请求" gate calls for; +# every HTTP test above also goes through it, this one asserts it explicitly). +# --------------------------------------------------------------------------- +def test_outbound_httpx_create_connection(loop): + async def main(): + async with running_server(APP) as (_server, port): + async with httpx.AsyncClient() as client: + # Full absolute URL, default (create_connection-backed) transport. + r = await client.get(f"http://127.0.0.1:{port}/json") + assert r.status_code == 200 + assert r.json()["framework"] == "fastapi" + # Keep-alive reuse: a second request on the same connection. + r2 = await client.get(f"http://127.0.0.1:{port}/async") + assert r2.status_code == 200 + + loop.run_until_complete(main()) + + +# --------------------------------------------------------------------------- +# Loop-factory wiring regression tests +# +# All tests above run serve() as a task on an already-running hvloop loop, so +# they never exercise uvicorn's own loop construction. uvicorn >= 0.36 replaced +# the policy mechanism with Config.get_loop_factory(): ``loop="asyncio"`` maps +# DIRECTLY to asyncio.SelectorEventLoop, so the old ``hvloop.install()`` + +# ``loop="asyncio"`` recipe silently falls back to stock asyncio. These tests +# drive uvicorn's real entry point -- Server.run(), i.e. get_loop_factory() + +# asyncio_run() -- in a subthread and assert, over real HTTP, that the loop +# serving the request is an hvloop Loop for both supported wirings: +# 1. loop="hvloop:new_event_loop" (custom "module:callable" factory string) +# 2. loop="none" + hvloop.install() (no factory -> asyncio.new_event_loop() +# -> event-loop policy) +# --------------------------------------------------------------------------- +async def _loopclass_app(scope, receive, send): + """Tiny ASGI app: responds with the running loop's qualified class name.""" + assert scope["type"] == "http" + cls = type(asyncio.get_running_loop()) + body = f"{cls.__module__}.{cls.__qualname__}".encode() + await send({ + "type": "http.response.start", + "status": 200, + "headers": [(b"content-type", b"text/plain")], + }) + await send({"type": "http.response.body", "body": body}) + + +def _run_uvicorn_in_thread_and_probe(loop_setting): + """Start uvicorn via Server.run() (the real get_loop_factory/asyncio_run + path) in a subthread, GET the loop-class probe over real TCP, shut down + via should_exit, and return the reported loop class name.""" + port = _free_port() + config = uvicorn.Config( + _loopclass_app, + host="127.0.0.1", + port=port, + loop=loop_setting, + lifespan="off", + log_level="warning", + ) + server = uvicorn.Server(config) + # Not the main thread -> capture_signals() is a no-op (no signal handlers + # are touched from the subthread). + thread = threading.Thread(target=server.run, daemon=True) + thread.start() + try: + deadline = time.monotonic() + 10.0 + while not server.started: + if not thread.is_alive(): + raise RuntimeError("uvicorn thread died during startup") + if time.monotonic() > deadline: + raise TimeoutError("uvicorn did not start within 10s") + time.sleep(0.01) + resp = httpx.get(f"http://127.0.0.1:{port}/", timeout=10.0) + assert resp.status_code == 200 + return resp.text + finally: + server.should_exit = True + thread.join(timeout=10.0) + assert not thread.is_alive(), "uvicorn thread did not exit" + + +def test_uvicorn_run_with_hvloop_factory_string(): + """loop="hvloop:new_event_loop" makes uvicorn itself build an hvloop loop + (the recommended wiring; zero glue, no policy involved).""" + loop_class = _run_uvicorn_in_thread_and_probe("hvloop:new_event_loop") + assert loop_class == "hvloop.Loop", loop_class + + +def test_uvicorn_run_with_policy_and_loop_none(): + """loop="none" + hvloop.install(): uvicorn uses no explicit factory, so + its runner falls back to asyncio.new_event_loop(), which consults the + policy hvloop.install() set.""" + import hvloop + + hvloop.install() + try: + loop_class = _run_uvicorn_in_thread_and_probe("none") + finally: + hvloop.uninstall() # restore the default policy for other tests + assert loop_class == "hvloop.Loop", loop_class diff --git a/tests/test_create_connection.py b/tests/test_create_connection.py deleted file mode 100644 index 909f890..0000000 --- a/tests/test_create_connection.py +++ /dev/null @@ -1,93 +0,0 @@ -# coding:utf-8 -import time -import unittest -import threading -import select -import socket -import asyncio -from hvloop import new_event_loop -# from asyncio import new_event_loop - - -class EchoProtocol(asyncio.Protocol): - - def connection_made(self, transport) -> None: - super().connection_made(transport) - assert transport.get_extra_info('sockname') is not None - assert transport.get_extra_info('peername') is not None - self.transport = transport - self.future = None - - def data_received(self, data: bytes) -> None: - super().data_received(data) - if self.future: - self.future.set_result(data) - - def eof_received(self): - return super().eof_received() - - async def echo(self, data, waiter): - self.future = waiter - self.transport.write(data) - return await waiter - - -class OnceEchoServer(threading.Thread): - def __init__(self, addr, *args, **kwargs): - super().__init__(*args, **kwargs) - self.addr = addr - self.s = socket.create_server(self.addr, family=socket.AF_INET, backlog=1) - - def run(self): - client, _ = self.s.accept() - data = client.recv(4096) - client.sendall(data) - client.close() - self.s.close() - - -class TestCreateConnection(unittest.TestCase): - - def setUp(self): - self.addr = ('127.0.0.1', 50001) - self.server = OnceEchoServer(self.addr) - self.server.start() - - def test_connection(self): - loop = new_event_loop() - - msg = b"hello world" - - async def send_to_echo(data): - transport, protocol = await loop.create_connection( - EchoProtocol, host=self.addr[0], port=self.addr[1] - ) - waiter = loop.create_future() - return await protocol.echo(data, waiter) - - resp = loop.run_until_complete(send_to_echo(msg)) - assert resp == msg - - def test_connection_with_sock(self): - sock = socket.socket(family=socket.AF_INET, type=socket.SOCK_STREAM) - sock.setblocking(False) - try: - sock.connect(self.addr) - except BlockingIOError: - _, wlist, _ = select.select([], [sock.fileno()], []) - err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR) - if err != 0: - raise OSError(err, f"Connect call failed {self.addr}") - loop = new_event_loop() - - msg = b"hello world" - - async def send_to_echo(data): - transport, protocol = await loop.create_connection( - EchoProtocol, sock=sock - ) - waiter = loop.create_future() - return await protocol.echo(data, waiter) - - resp = loop.run_until_complete(send_to_echo(msg)) - assert resp == msg diff --git a/tests/test_create_datagram_endpoint.py b/tests/test_create_datagram_endpoint.py deleted file mode 100644 index 769c274..0000000 --- a/tests/test_create_datagram_endpoint.py +++ /dev/null @@ -1,62 +0,0 @@ -import asyncio -import time -from asyncio import transports -from typing import Optional -import unittest -import threading -import socket -from hvloop import new_event_loop -# from asyncio import new_event_loop - - -class EchoServerProtocol(asyncio.DatagramProtocol): - def connection_made(self, transport: transports.BaseTransport) -> None: - self.transport = transport - - def datagram_received(self, data: bytes, addr) -> None: - print("server received: %s, from: %s" % (data, addr)) - self.transport.sendto(data, addr) - self.transport.close() - - -class EchoClientProtocol(asyncio.DatagramProtocol): - def connection_made(self, transport: transports.BaseTransport) -> None: - self.transport = transport - self.waiter = None - - def datagram_received(self, data: bytes, addr) -> None: - print("recv: %s from <%s>" % (data, addr)) - if self.waiter: - self.waiter.set_result(data) - - def send(self, data): - self.transport.sendto(data) - self.transport.close() - - async def echo(self, data, waiter): - self.waiter = waiter - self.transport.sendto(data) - msg = await self.waiter - self.transport.close() - return msg - - -class TestCreateDatagramEndpoint(unittest.TestCase): - - def test_create_datagram_endpoint(self): - loop = new_event_loop() - self.address = ('127.0.0.1', 52002) - - async def _test_echo(): - await loop.create_datagram_endpoint( - EchoServerProtocol, local_addr=self.address) - - _, proto = await loop.create_datagram_endpoint( - EchoClientProtocol, remote_addr=self.address - ) - msg = b'hello world' - waiter = loop.create_future() - recv_msg = await proto.echo(msg, waiter) - assert msg == recv_msg - - loop.run_until_complete(_test_echo()) diff --git a/tests/test_create_server.py b/tests/test_create_server.py deleted file mode 100644 index bf8209f..0000000 --- a/tests/test_create_server.py +++ /dev/null @@ -1,71 +0,0 @@ -import asyncio -import time -from asyncio import transports -from typing import Optional -import unittest -import threading -import socket -from hvloop import new_event_loop -# from asyncio import new_event_loop - - -class EchoServerProtocol(asyncio.Protocol): - def connection_made(self, transport: transports.BaseTransport) -> None: - peername = transport.get_extra_info('peername') - print("connection from {}".format(peername)) - self.transport = transport - - def data_received(self, data: bytes) -> None: - print("server received: %s", data) - self.transport.write(data) - self.transport.close() - - def eof_received(self) -> Optional[bool]: - pass - - def connection_lost(self, exc: Optional[Exception]) -> None: - pass - - -class TestCreateServer(unittest.TestCase): - - def test_create_server(self): - loop = new_event_loop() - self.address = ('127.0.0.1', 50002) - lock = threading.Lock() - - server = None - - async def _server(): - nonlocal server - server = await loop.create_server(EchoServerProtocol, self.address[0], self.address[1], start_serving=False) - await server.start_serving() - lock.release() - await server.serve_forever() - - def _run(): - try: - loop.run_until_complete(_server()) - except asyncio.exceptions.CancelledError: - pass - # loop.run_until_complete(_server()) - - lock.acquire() - threading.Thread(target=_run, daemon=True).start() - - lock.acquire() - s = socket.socket(family=socket.AF_INET) - s.settimeout(3) - s.connect(self.address) - msg = b"hello world" - s.sendall(msg) - # - received = s.recv(4096) - s.close() - assert msg == received - def _close_server(): - nonlocal server - server.close() - - # loop.call_soon_threadsafe(_close_server) - diff --git a/tests/test_fd_signal.py b/tests/test_fd_signal.py new file mode 100644 index 0000000..5193bc0 --- /dev/null +++ b/tests/test_fd_signal.py @@ -0,0 +1,547 @@ +"""M2b tests: add_reader/add_writer/remove_reader/remove_writer and Unix +signal handling (tech design plan sections 5 and 9). + +Synchronous tests that construct and drive an hvloop Loop directly (same +style as test_loop.py / test_tcp.py). The watched fds are always caller-owned +socketpairs: hvloop must never close them, neither on remove_* nor on +loop.close(). +""" + +import asyncio +import importlib.util +import os +import signal +import socket +import sys +import threading +import time + +import pytest + +import hvloop + + +# --------------------------------------------------------------------------- +# helpers +# --------------------------------------------------------------------------- +def _nonblocking_socketpair(): + a, b = socket.socketpair() + a.setblocking(False) + b.setblocking(False) + return a, b + + +def _run_with_deadline(loop, seconds=5.0): + """run_forever with a safety-net stop so a broken test cannot hang.""" + guard = loop.call_later(seconds, loop.stop) + try: + loop.run_forever() + finally: + guard.cancel() + + +# --------------------------------------------------------------------------- +# add_reader / add_writer: echo round trip +# --------------------------------------------------------------------------- +def test_reader_writer_echo_roundtrip(loop): + # a --payload--> b (b's reader recvs) --echo--> a (a's reader collects). + # Exercises add_writer for the initial send, add_reader on both ends, a + # flow-controlled echo writer (add_writer/remove_writer on demand) and a + # reader+writer registered on the same fd (a). + a, b = _nonblocking_socketpair() + try: + payload = os.urandom(256 * 1024) + chunk = 16 * 1024 + sent = 0 + echo_buf = bytearray() + echo_writer_on = False + back = bytearray() + + def a_writable(): + nonlocal sent + if sent >= len(payload): + assert loop.remove_writer(a) is True + return + try: + n = a.send(payload[sent:sent + chunk]) + except BlockingIOError: + return + sent += n + if sent >= len(payload): + assert loop.remove_writer(a) is True + + def b_flush(): + nonlocal echo_writer_on + while echo_buf: + try: + n = b.send(bytes(echo_buf[:chunk])) + except BlockingIOError: + break + del echo_buf[:n] + if echo_buf and not echo_writer_on: + loop.add_writer(b, b_flush) + echo_writer_on = True + elif not echo_buf and echo_writer_on: + assert loop.remove_writer(b) is True + echo_writer_on = False + + def b_readable(): + try: + data = b.recv(64 * 1024) + except BlockingIOError: + return + echo_buf.extend(data) + b_flush() + + def a_readable(): + try: + data = a.recv(64 * 1024) + except BlockingIOError: + return + back.extend(data) + if len(back) >= len(payload): + loop.stop() + + loop.add_writer(a, a_writable) + loop.add_reader(b, b_readable) + loop.add_reader(a, a_readable) + _run_with_deadline(loop, 10.0) + + assert bytes(back) == payload + assert loop.remove_reader(a) is True + assert loop.remove_reader(b) is True + finally: + a.close() + b.close() + + +def test_add_reader_replaces_previous_callback(loop): + a, b = _nonblocking_socketpair() + try: + calls = [] + + def old_reader(): + calls.append('old') + b.recv(100) + loop.stop() + + def new_reader(): + calls.append('new') + b.recv(100) + loop.stop() + + loop.add_reader(b, old_reader) + loop.add_reader(b, new_reader) # replaces old_reader + a.send(b'x') + _run_with_deadline(loop) + assert calls == ['new'] + finally: + a.close() + b.close() + + +def test_add_writer_replaces_previous_callback(loop): + a, b = _nonblocking_socketpair() + try: + calls = [] + + def old_writer(): + calls.append('old') + loop.stop() + + def new_writer(): + calls.append('new') + loop.remove_writer(a) + loop.stop() + + loop.add_writer(a, old_writer) + loop.add_writer(a, new_writer) # replaces old_writer + _run_with_deadline(loop) + assert calls == ['new'] + finally: + a.close() + b.close() + + +def test_reader_callback_gets_args_and_repeats(loop): + # The same registration must keep firing (level-triggered) for every + # arriving chunk, with its *args intact each time. + a, b = _nonblocking_socketpair() + try: + seen = [] + + def reader(tag): + seen.append((tag, b.recv(100))) + if len(seen) == 2: + loop.stop() + else: + a.send(b'second') + + loop.add_reader(b, reader, 'tag') + a.send(b'first') + _run_with_deadline(loop) + assert seen == [('tag', b'first'), ('tag', b'second')] + finally: + a.close() + b.close() + + +# --------------------------------------------------------------------------- +# remove_reader / remove_writer semantics +# --------------------------------------------------------------------------- +def test_remove_reader_writer_return_values(loop): + a, b = _nonblocking_socketpair() + try: + # Nothing registered yet. + assert loop.remove_reader(b) is False + assert loop.remove_writer(b) is False + + loop.add_reader(b, lambda: None) + assert loop.remove_reader(b) is True + assert loop.remove_reader(b) is False # already removed + + loop.add_writer(b, lambda: None) + assert loop.remove_writer(b) is True + assert loop.remove_writer(b) is False + finally: + a.close() + b.close() + + +def test_fd_accepts_fileobj_and_int(loop): + a, b = _nonblocking_socketpair() + try: + loop.add_reader(b, lambda: None) # socket object + assert loop.remove_reader(b.fileno()) is True # int fd + loop.add_writer(b.fileno(), lambda: None) # int fd + assert loop.remove_writer(b) is True # socket object + with pytest.raises(ValueError): + loop.add_reader(object(), lambda: None) + with pytest.raises(ValueError): + loop.add_reader(-1, lambda: None) + finally: + a.close() + b.close() + + +def test_same_fd_reader_and_writer_independent_remove(loop): + a, b = _nonblocking_socketpair() + try: + reads = [] + + def reader(): + reads.append(b.recv(100)) + loop.stop() + + loop.add_reader(b, reader) + loop.add_writer(b, lambda: None) + + # Removing the writer must not disturb the reader. + assert loop.remove_writer(b) is True + a.send(b'ping') + _run_with_deadline(loop) + assert reads == [b'ping'] + + # And the reader can then be removed on its own. + assert loop.remove_reader(b) is True + assert loop.remove_reader(b) is False + assert loop.remove_writer(b) is False + finally: + a.close() + b.close() + + +def test_fd_still_usable_after_remove(loop): + a, b = _nonblocking_socketpair() + try: + loop.add_reader(b, lambda: None) + loop.add_writer(b, lambda: None) + assert loop.remove_reader(b) is True + assert loop.remove_writer(b) is True + + # The fd is caller-owned: it must still be open and fully usable. + b.getsockname() # portable "still open" check (os.fstat fails on Windows sockets) + a.send(b'alive') + time.sleep(0.05) + assert b.recv(100) == b'alive' + b.send(b'back') + time.sleep(0.05) + assert a.recv(100) == b'back' + finally: + a.close() + b.close() + + +def test_fd_still_usable_after_loop_close(): + # A watcher left registered at loop.close() must be torn down without + # closing the caller's fd (plan/M2b: fd ownership stays with the caller). + loop = hvloop.new_event_loop() + a, b = _nonblocking_socketpair() + try: + loop.add_reader(b, lambda: None) + loop.add_writer(a, lambda: None) + loop.close() + + a.getsockname() # portable "still open" check (os.fstat fails on Windows sockets) + b.getsockname() + a.send(b'post-close') + time.sleep(0.05) + assert b.recv(100) == b'post-close' + + # remove_* after close: False, not an error (asyncio semantics). + assert loop.remove_reader(b) is False + assert loop.remove_writer(a) is False + # add_* after close: RuntimeError. + with pytest.raises(RuntimeError): + loop.add_reader(b, lambda: None) + finally: + a.close() + b.close() + if not loop.is_closed(): + loop.close() + + +def test_reader_exception_goes_to_exception_handler(loop): + a, b = _nonblocking_socketpair() + try: + contexts = [] + loop.set_exception_handler( + lambda lp, ctx: (contexts.append(ctx), lp.stop())) + + def bad_reader(): + b.recv(100) + raise ValueError('boom in reader') + + loop.add_reader(b, bad_reader) + a.send(b'x') + _run_with_deadline(loop) + assert len(contexts) == 1 + assert isinstance(contexts[0]['exception'], ValueError) + + # The registration survives the exception (level-triggered, repeat + # handle): another chunk fires the callback again. + contexts.clear() + a.send(b'y') + _run_with_deadline(loop) + assert len(contexts) == 1 + finally: + a.close() + b.close() + + +# --------------------------------------------------------------------------- +# no busy-polling regression +# --------------------------------------------------------------------------- +@pytest.mark.skipif( + importlib.util.find_spec("resource") is None, + reason="resource.getrusage not available on this platform (e.g. Windows)", +) +def test_add_reader_idle_does_not_burn_cpu(loop): + # Level-triggered backend: with a reader registered and NO data pending, + # an idle second must not spin the poll (revents must be cleared after + # each dispatch, and an armed-but-quiet fd must not wake the loop). + import resource + + a, b = _nonblocking_socketpair() + try: + loop.add_reader(b, lambda: None) + + u0 = resource.getrusage(resource.RUSAGE_SELF) + cpu0 = u0.ru_utime + u0.ru_stime + + loop.run_until_complete(asyncio.sleep(1.0)) + + u1 = resource.getrusage(resource.RUSAGE_SELF) + cpu1 = u1.ru_utime + u1.ru_stime + + cpu_used = cpu1 - cpu0 + assert cpu_used < 0.3, ( + "idle loop with add_reader burned {:.3f}s CPU".format(cpu_used)) + assert loop.remove_reader(b) is True + finally: + a.close() + b.close() + + +# --------------------------------------------------------------------------- +# Unix signals (plan section 9) +# --------------------------------------------------------------------------- +requires_unix_signals = pytest.mark.skipif( + sys.platform == 'win32', + reason='add_signal_handler is Unix-only (NotImplementedError on Windows)') + + +@requires_unix_signals +def test_signal_handler_runs_as_loop_callback(loop): + seen = [] + + def handler(tag, value): + seen.append((tag, value, threading.get_ident())) + loop.stop() + + loop.add_signal_handler(signal.SIGUSR1, handler, 'usr1', 42) + + fired = [] + + def fire(): + signal.raise_signal(signal.SIGUSR1) + # The Python-level handler must NOT have run synchronously here; it + # is dispatched through the wakeup fd as a loop callback. + fired.append(list(seen)) + + loop.call_soon(fire) + _run_with_deadline(loop) + + assert fired == [[]] # nothing ran inside raise_signal itself + assert seen == [('usr1', 42, threading.get_ident())] # loop (main) thread + assert loop.remove_signal_handler(signal.SIGUSR1) is True + + +@requires_unix_signals +def test_signal_handler_fires_repeatedly(loop): + hits = [] + + def handler(): + hits.append(1) + if len(hits) >= 3: + loop.stop() + else: + loop.call_soon(signal.raise_signal, signal.SIGUSR1) + + loop.add_signal_handler(signal.SIGUSR1, handler) + loop.call_soon(signal.raise_signal, signal.SIGUSR1) + _run_with_deadline(loop) + assert len(hits) == 3 + assert loop.remove_signal_handler(signal.SIGUSR1) is True + + +@requires_unix_signals +def test_remove_signal_handler_stops_dispatch(loop): + hits = [] + loop.add_signal_handler(signal.SIGUSR1, hits.append, 'never') + assert loop.remove_signal_handler(signal.SIGUSR1) is True + assert loop.remove_signal_handler(signal.SIGUSR1) is False + + # remove restored SIG_DFL (default for SIGUSR1 would kill the process on + # a real delivery), so install a plain recording handler before raising. + assert signal.getsignal(signal.SIGUSR1) is signal.SIG_DFL + plain = [] + signal.signal(signal.SIGUSR1, lambda s, f: plain.append(s)) + try: + loop.call_soon(signal.raise_signal, signal.SIGUSR1) + loop.call_later(0.2, loop.stop) + _run_with_deadline(loop) + assert hits == [] # loop handler no longer registered + assert plain == [signal.SIGUSR1] # the plain handler got it instead + finally: + signal.signal(signal.SIGUSR1, signal.SIG_DFL) + + +@requires_unix_signals +def test_sigint_handler_stops_run_forever(loop): + loop.add_signal_handler(signal.SIGINT, loop.stop) + loop.call_soon(signal.raise_signal, signal.SIGINT) + guard = loop.call_later(5.0, loop.stop) + loop.run_forever() # must return normally, no KeyboardInterrupt + guard.cancel() + + # asyncio semantics: removing the SIGINT handler restores + # default_int_handler (not SIG_DFL). + assert loop.remove_signal_handler(signal.SIGINT) is True + assert signal.getsignal(signal.SIGINT) is signal.default_int_handler + + +@requires_unix_signals +def test_add_signal_handler_rejects_coroutines(loop): + async def coro_func(): + pass + + with pytest.raises(TypeError): + loop.add_signal_handler(signal.SIGUSR1, coro_func) + + coro = coro_func() + try: + with pytest.raises(TypeError): + loop.add_signal_handler(signal.SIGUSR1, coro) + finally: + coro.close() + + # Neither attempt may have touched the signal disposition. + assert signal.getsignal(signal.SIGUSR1) is signal.SIG_DFL + + +@requires_unix_signals +def test_signal_argument_validation(loop): + with pytest.raises(TypeError): + loop.add_signal_handler('SIGUSR1', lambda: None) + with pytest.raises(ValueError): + loop.add_signal_handler(0, lambda: None) + with pytest.raises(ValueError): + loop.add_signal_handler(max(signal.valid_signals()) + 1000, + lambda: None) + with pytest.raises(TypeError): + loop.remove_signal_handler('SIGUSR1') + with pytest.raises(ValueError): + loop.remove_signal_handler(0) + + +@requires_unix_signals +def test_add_signal_handler_from_non_main_thread_raises(loop): + result = {} + + def worker(): + try: + loop.add_signal_handler(signal.SIGUSR1, lambda: None) + except BaseException as exc: # noqa: BLE001 + result['exc'] = exc + + t = threading.Thread(target=worker) + t.start() + t.join() + # set_wakeup_fd is main-thread-only; surfaced as RuntimeError (asyncio + # semantics). + assert isinstance(result.get('exc'), RuntimeError) + assert signal.getsignal(signal.SIGUSR1) is signal.SIG_DFL + + +@requires_unix_signals +def test_add_signal_handler_after_close_raises(loop): + loop.close() + with pytest.raises(RuntimeError): + loop.add_signal_handler(signal.SIGUSR1, lambda: None) + + +@requires_unix_signals +def test_close_restores_signal_state(): + loop = hvloop.new_event_loop() + try: + loop.add_signal_handler(signal.SIGUSR1, lambda: None) + loop.add_signal_handler(signal.SIGINT, lambda: None) + loop.close() + + # Dispositions restored per asyncio semantics. + assert signal.getsignal(signal.SIGUSR1) is signal.SIG_DFL + assert signal.getsignal(signal.SIGINT) is signal.default_int_handler + # The wakeup fd was restored: installing "none" returns the previous + # value, which must be -1 (i.e. not our — now closed — socketpair). + assert signal.set_wakeup_fd(-1) == -1 + finally: + if not loop.is_closed(): + loop.close() + + +@requires_unix_signals +def test_signal_handler_survives_across_runs(loop): + # The registration persists over run_forever() invocations. + hits = [] + + def handler(): + hits.append(1) + loop.stop() + + loop.add_signal_handler(signal.SIGUSR1, handler) + for _ in range(2): + loop.call_soon(signal.raise_signal, signal.SIGUSR1) + _run_with_deadline(loop) + assert len(hits) == 2 + assert loop.remove_signal_handler(signal.SIGUSR1) is True diff --git a/tests/test_loop.py b/tests/test_loop.py new file mode 100644 index 0000000..40a8772 --- /dev/null +++ b/tests/test_loop.py @@ -0,0 +1,868 @@ +"""M1 unit tests for the hvloop Loop core (plan section 12.1). + +Covers: call_soon FIFO ordering, call_later/call_at precision and +cancellation, call_soon_threadsafe cross-thread wakeup latency, stop/close +semantics, exception handler, run_until_complete exception propagation, +shutdown_asyncgens, and loop.time() monotonicity. + +These are synchronous tests that construct and drive an hvloop Loop directly. +""" + +import asyncio +import importlib.util +import sys +import threading +import time + +import pytest + +import hvloop + + +# --------------------------------------------------------------------------- +# Construction / lifecycle +# --------------------------------------------------------------------------- +def test_new_event_loop_type(): + loop = hvloop.new_event_loop() + try: + assert isinstance(loop, hvloop.Loop) + assert isinstance(loop, asyncio.AbstractEventLoop) + assert not loop.is_running() + assert not loop.is_closed() + assert "running=False" in repr(loop) + finally: + loop.close() + + +def test_close_is_idempotent(loop): + assert not loop.is_closed() + loop.close() + assert loop.is_closed() + loop.close() # second close is a no-op + assert loop.is_closed() + + +def test_close_while_running_raises(loop): + def try_close(): + with pytest.raises(RuntimeError): + loop.close() + loop.stop() + + loop.call_soon(try_close) + loop.run_forever() + + +def test_call_after_close_raises(loop): + loop.close() + with pytest.raises(RuntimeError): + loop.call_soon(lambda: None) + with pytest.raises(RuntimeError): + loop.call_later(0, lambda: None) + + +def test_context_manager_closes(): + with hvloop.new_event_loop() as loop: + assert not loop.is_closed() + assert loop.is_closed() + + +# --------------------------------------------------------------------------- +# call_soon ordering +# --------------------------------------------------------------------------- +def test_call_soon_fifo_order(loop): + order = [] + for i in range(20): + loop.call_soon(order.append, i) + loop.call_soon(loop.stop) + loop.run_forever() + assert order == list(range(20)) + + +def test_call_soon_scheduled_during_turn_runs_next_turn(loop): + # A callback scheduled while running the current ready snapshot must not + # starve the loop; it runs on a later turn (plan section 4). + seen = [] + + def first(): + seen.append("first") + loop.call_soon(second) + + def second(): + seen.append("second") + loop.stop() + + loop.call_soon(first) + loop.run_forever() + assert seen == ["first", "second"] + + +def test_call_soon_returns_cancellable_handle(loop): + calls = [] + h = loop.call_soon(calls.append, "x") + assert not h.cancelled() + h.cancel() + assert h.cancelled() + loop.call_soon(loop.stop) + loop.run_forever() + assert calls == [] + + +# --------------------------------------------------------------------------- +# Timers: call_later / call_at precision and cancellation +# --------------------------------------------------------------------------- +def test_call_later_precision(loop): + results = [] + start = loop.time() + + def cb(): + results.append(loop.time() - start) + loop.stop() + + loop.call_later(0.1, cb) + loop.run_forever() + assert len(results) == 1 + # Allow generous upper bound for CI jitter, but ensure it actually waited. + assert 0.08 <= results[0] <= 0.4, results[0] + + +def test_call_later_ordering(loop): + order = [] + loop.call_later(0.06, lambda: order.append("c")) + loop.call_later(0.02, lambda: order.append("a")) + loop.call_later(0.04, lambda: order.append("b")) + loop.call_later(0.08, loop.stop) + loop.run_forever() + assert order == ["a", "b", "c"] + + +def test_call_later_negative_runs_soon(loop): + order = [] + loop.call_later(-1, lambda: order.append("late")) + loop.call_soon(lambda: order.append("soon")) + loop.call_later(0.02, loop.stop) + loop.run_forever() + # Both should run; negative delay must still fire. + assert "late" in order and "soon" in order + + +def test_call_at_uses_loop_clock(loop): + results = [] + when = loop.time() + 0.05 + + def cb(): + results.append(loop.time()) + loop.stop() + + handle = loop.call_at(when, cb) + assert abs(handle.when() - when) < 1e-6 + loop.run_forever() + assert results[0] >= when - 0.01 + + +def test_timer_cancel_prevents_callback(loop): + fired = [] + h = loop.call_later(0.02, lambda: fired.append(1)) + h.cancel() + assert h.cancelled() + loop.call_later(0.06, loop.stop) + loop.run_forever() + assert fired == [] + + +def test_timer_cancel_is_idempotent(loop): + h = loop.call_later(10, lambda: None) + h.cancel() + h.cancel() + assert h.cancelled() + loop.call_soon(loop.stop) + loop.run_forever() + + +def test_many_timers(loop): + fired = [] + n = 50 + for i in range(n): + loop.call_later(0.001 * (i % 5), lambda i=i: fired.append(i)) + loop.call_later(0.1, loop.stop) + loop.run_forever() + assert len(fired) == n + + +# --------------------------------------------------------------------------- +# loop.time() monotonicity +# --------------------------------------------------------------------------- +def test_time_is_monotonic(loop): + samples = [loop.time() for _ in range(1000)] + for a, b in zip(samples, samples[1:]): + assert b >= a + + +def test_time_advances(loop): + t0 = loop.time() + time.sleep(0.02) + t1 = loop.time() + assert t1 > t0 + + +# --------------------------------------------------------------------------- +# call_soon_threadsafe cross-thread wakeup +# --------------------------------------------------------------------------- +def test_call_soon_threadsafe_wakeup_latency(loop): + # The loop is blocked in an (effectively infinite) poll with no timers. + # A threadsafe schedule must wake it well under libhv's 100ms block cap; + # we assert < 50ms to prove the wakeup eventfd path works. + latency = {} + + def worker(): + time.sleep(0.05) # ensure the loop is parked in poll + posted = time.monotonic() + + def cb(): + latency["value"] = time.monotonic() - posted + loop.stop() + + loop.call_soon_threadsafe(cb) + + t = threading.Thread(target=worker) + t.start() + loop.run_forever() + t.join() + + assert "value" in latency + assert latency["value"] < 0.05, latency["value"] + + +def test_call_soon_threadsafe_multiple(loop): + received = [] + + def worker(): + time.sleep(0.02) + for i in range(10): + loop.call_soon_threadsafe(received.append, i) + loop.call_soon_threadsafe(loop.stop) + + t = threading.Thread(target=worker) + t.start() + loop.run_forever() + t.join() + assert received == list(range(10)) + + +def test_stop_from_another_thread(loop): + started = threading.Event() + + def keepalive(): + # A repeating-ish chain so the loop stays busy until stopped. + if loop.is_running(): + loop.call_later(0.01, keepalive) + + def worker(): + started.wait(1.0) + time.sleep(0.05) + loop.call_soon_threadsafe(loop.stop) + + loop.call_soon(started.set) + loop.call_soon(keepalive) + t = threading.Thread(target=worker) + t.start() + loop.run_forever() + t.join() + assert not loop.is_running() + + +# --------------------------------------------------------------------------- +# stop semantics +# --------------------------------------------------------------------------- +def test_stop_before_run_runs_one_batch(loop): + # asyncio semantics: stop() before/at start lets the current ready batch + # run, then exits. We schedule stop first, then a callback; both queued + # callbacks in the first snapshot run. + ran = [] + loop.call_soon(loop.stop) + loop.call_soon(lambda: ran.append(1)) + loop.run_forever() + assert ran == [1] + assert not loop.is_running() + + +def test_run_forever_can_restart(loop): + counter = [] + loop.call_soon(lambda: (counter.append(1), loop.stop())) + loop.run_forever() + loop.call_soon(lambda: (counter.append(2), loop.stop())) + loop.run_forever() + assert counter == [1, 2] + + +def test_run_forever_while_running_raises(loop): + def reenter(): + with pytest.raises(RuntimeError): + loop.run_forever() + loop.stop() + + loop.call_soon(reenter) + loop.run_forever() + + +# --------------------------------------------------------------------------- +# Exception handler +# --------------------------------------------------------------------------- +def test_default_exception_handler_get_set(loop): + assert loop.get_exception_handler() is None + + def handler(lp, ctx): + pass + + loop.set_exception_handler(handler) + assert loop.get_exception_handler() is handler + loop.set_exception_handler(None) + assert loop.get_exception_handler() is None + + +def test_set_exception_handler_validates(loop): + with pytest.raises(TypeError): + loop.set_exception_handler(123) + + +def test_callback_exception_goes_to_handler(loop): + caught = [] + loop.set_exception_handler(lambda lp, ctx: caught.append(ctx)) + + def boom(): + raise ValueError("boom") + + loop.call_soon(boom) + loop.call_soon(loop.stop) + loop.run_forever() + assert len(caught) == 1 + assert isinstance(caught[0]["exception"], ValueError) + assert "message" in caught[0] + + +def test_timer_callback_exception_goes_to_handler(loop): + caught = [] + loop.set_exception_handler(lambda lp, ctx: caught.append(ctx)) + + def boom(): + raise RuntimeError("timer-boom") + + loop.call_later(0.01, boom) + loop.call_later(0.05, loop.stop) + loop.run_forever() + assert len(caught) == 1 + assert isinstance(caught[0]["exception"], RuntimeError) + + +def test_call_exception_handler_direct(loop): + caught = [] + loop.set_exception_handler(lambda lp, ctx: caught.append(ctx)) + loop.call_exception_handler({"message": "manual"}) + assert caught == [{"message": "manual"}] + + +# --------------------------------------------------------------------------- +# run_until_complete + exception propagation +# --------------------------------------------------------------------------- +def test_run_until_complete_returns_result(loop): + async def coro(): + await asyncio.sleep(0) + return 42 + + assert loop.run_until_complete(coro()) == 42 + + +def test_run_until_complete_propagates_exception(loop): + async def coro(): + await asyncio.sleep(0) + raise ValueError("propagated") + + with pytest.raises(ValueError, match="propagated"): + loop.run_until_complete(coro()) + + +def test_run_until_complete_with_future(loop): + fut = loop.create_future() + loop.call_later(0.01, fut.set_result, "done") + assert loop.run_until_complete(fut) == "done" + + +def test_run_until_complete_nested_error(loop): + async def inner(): + raise KeyError("inner") + + async def outer(): + return await inner() + + with pytest.raises(KeyError, match="inner"): + loop.run_until_complete(outer()) + + +# --------------------------------------------------------------------------- +# Futures / tasks +# --------------------------------------------------------------------------- +def test_create_future(loop): + fut = loop.create_future() + assert isinstance(fut, asyncio.Future) + assert fut.get_loop() is loop + + +def test_create_task_and_name(loop): + async def coro(): + return "ok" + + async def driver(): + task = loop.create_task(coro(), name="my-task") + assert task.get_name() == "my-task" + return await task + + assert loop.run_until_complete(driver()) == "ok" + + +@pytest.mark.skipif( + sys.version_info < (3, 11), + reason="loop.create_task(context=...) was added to asyncio in 3.11", +) +def test_create_task_with_context(loop): + import contextvars + + var = contextvars.ContextVar("var", default="default") + + async def coro(): + return var.get() + + async def driver(): + ctx = contextvars.copy_context() + ctx.run(var.set, "ctxval") + task = loop.create_task(coro(), context=ctx) + return await task + + assert loop.run_until_complete(driver()) == "ctxval" + + +def test_task_factory_get_set(loop): + assert loop.get_task_factory() is None + + def factory(lp, coro, **kw): + return asyncio.Task(coro, loop=lp, **kw) + + loop.set_task_factory(factory) + assert loop.get_task_factory() is factory + + async def coro(): + return "factory-ok" + + async def driver(): + return await loop.create_task(coro()) + + assert loop.run_until_complete(driver()) == "factory-ok" + loop.set_task_factory(None) + + +def test_set_task_factory_validates(loop): + with pytest.raises(TypeError): + loop.set_task_factory(123) + + +# --------------------------------------------------------------------------- +# Debug flag +# --------------------------------------------------------------------------- +def test_debug_flag(loop): + loop.set_debug(True) + assert loop.get_debug() is True + loop.set_debug(False) + assert loop.get_debug() is False + + +def test_debug_mode_rejects_coroutine_in_call_soon(loop): + loop.set_debug(True) + + async def coro(): + pass + + c = coro() + try: + with pytest.raises(TypeError): + loop.call_soon(c) + finally: + c.close() + + +# --------------------------------------------------------------------------- +# Executor / DNS +# --------------------------------------------------------------------------- +def test_run_in_executor(loop): + async def driver(): + return await loop.run_in_executor(None, lambda: 1 + 1) + + assert loop.run_until_complete(driver()) == 2 + + +def test_set_default_executor_validates(loop): + with pytest.raises(TypeError): + loop.set_default_executor(object()) + + +def test_getaddrinfo_localhost(loop): + async def driver(): + import socket + + return await loop.getaddrinfo( + "127.0.0.1", 80, family=socket.AF_INET, type=socket.SOCK_STREAM + ) + + infos = loop.run_until_complete(driver()) + assert any(info[4][0] == "127.0.0.1" for info in infos) + + +def test_getnameinfo(loop): + import socket + + async def driver(): + # NI_NUMERICHOST keeps the result stable regardless of /etc/hosts. + return await loop.getnameinfo(("127.0.0.1", 80), socket.NI_NUMERICHOST) + + host, service = loop.run_until_complete(driver()) + assert host == "127.0.0.1" + + +# --------------------------------------------------------------------------- +# shutdown_asyncgens +# --------------------------------------------------------------------------- +def test_shutdown_asyncgens(loop): + finalized = [] + + async def gen(): + try: + while True: + yield 1 + finally: + finalized.append(True) + + async def driver(): + g = gen() + assert await g.__anext__() == 1 + # Drop the only reference *and* explicitly shut down async gens. + await loop.shutdown_asyncgens() + + # Keep a live reference so finalization happens via shutdown, not GC. + holder = {} + + async def driver2(): + holder["g"] = gen() + assert await holder["g"].__anext__() == 1 + await loop.shutdown_asyncgens() + + loop.run_until_complete(driver2()) + assert finalized == [True] + + +def test_shutdown_asyncgens_empty(loop): + async def driver(): + await loop.shutdown_asyncgens() + + loop.run_until_complete(driver()) # should not raise + + +# --------------------------------------------------------------------------- +# asyncio infra hooks +# --------------------------------------------------------------------------- +def test_timer_handle_cancelled_hook(loop): + # Used by asyncio internals; must be callable and a no-op. + h = loop.call_later(10, lambda: None) + loop._timer_handle_cancelled(h) + h.cancel() + loop.call_soon(loop.stop) + loop.run_forever() + + +def test_shutdown_default_executor(loop): + async def driver(): + await loop.run_in_executor(None, lambda: 1) + await loop.shutdown_default_executor() + + loop.run_until_complete(driver()) + + +# --------------------------------------------------------------------------- +# Regression: close() teardown of un-fired htimers (M1 acceptance fix #1) +# --------------------------------------------------------------------------- +def test_cancel_after_close_does_not_crash(): + # Before the fix, close() freed the htimer_t via hloop_free without clearing + # our TimerHandle; a subsequent handle.cancel() then called htimer_del on + # freed memory (use-after-free). Now close() nulls the handle's timer first. + lp = hvloop.new_event_loop() + h = lp.call_later(100, lambda: None) + lp.close() + # These must be safe no-ops, not a crash. + h.cancel() + h.cancel() + assert h.cancelled() + + +def test_unfired_timers_collected_after_close(): + # Each registered htimer Py_INCREF'd its TimerHandle. Without close() + # teardown those references (and the callbacks/args they pin) leaked. Verify + # the handles are reclaimable once the loop is closed. + import gc + import weakref + + lp = hvloop.new_event_loop() + refs = [weakref.ref(lp.call_later(100, lambda: None)) for _ in range(200)] + # We intentionally keep no strong refs to the handles themselves. + assert sum(1 for r in refs if r() is not None) == 200 + lp.close() + gc.collect() + assert sum(1 for r in refs if r() is not None) == 0 + + +def test_close_does_not_leak_callback_objects(): + # The callback (and its closed-over args) must not be kept alive by a + # leaked registration reference after close(). + import gc + import weakref + + class Sentinel: + pass + + lp = hvloop.new_event_loop() + sentinel = Sentinel() + ref = weakref.ref(sentinel) + lp.call_later(100, lambda s=sentinel: None) + del sentinel + lp.close() + gc.collect() + assert ref() is None + + +# --------------------------------------------------------------------------- +# Regression: KeyboardInterrupt / SystemExit from a timer callback must +# propagate out of run_forever()/run_until_complete() (M1 acceptance fix #2) +# --------------------------------------------------------------------------- +def test_timer_callback_keyboardinterrupt_propagates(loop, capfd): + def boom(): + raise KeyboardInterrupt + + loop.call_later(0.01, boom) + # A long sleep so the loop would otherwise stay parked in poll. + fut = loop.create_future() + loop.call_later(5.0, fut.cancel) + + with pytest.raises(KeyboardInterrupt): + loop.run_forever() + + # No "Exception ignored in: ... _on_timer" stderr noise. + err = capfd.readouterr().err + assert "Exception ignored" not in err, err + + +def test_timer_callback_systemexit_propagates(loop, capfd): + def boom(): + raise SystemExit(7) + + loop.call_later(0.01, boom) + loop.call_later(5.0, loop.stop) + + with pytest.raises(SystemExit) as ei: + loop.run_forever() + assert ei.value.code == 7 + + err = capfd.readouterr().err + assert "Exception ignored" not in err, err + + +def test_timer_callback_ki_propagates_via_run_until_complete(loop, capfd): + async def main(): + loop.call_later(0.01, _raise_ki) + await asyncio.sleep(10) + + def _raise_ki(): + raise KeyboardInterrupt + + with pytest.raises(KeyboardInterrupt): + loop.run_until_complete(main()) + + err = capfd.readouterr().err + assert "Exception ignored" not in err, err + + +def test_timer_callback_plain_exception_still_goes_to_handler(loop): + # Fix #2 must not change behavior for ordinary exceptions: they keep going + # to call_exception_handler and the loop keeps running. + caught = [] + loop.set_exception_handler(lambda lp, ctx: caught.append(ctx)) + loop.call_later(0.01, lambda: (_ for _ in ()).throw(ValueError("x"))) + loop.call_later(0.05, loop.stop) + loop.run_forever() # must NOT raise + assert len(caught) == 1 + assert isinstance(caught[0]["exception"], ValueError) + + +# --------------------------------------------------------------------------- +# Regression: timer precision rounds UP, never fires before `when` +# (M1 acceptance fix #3) +# --------------------------------------------------------------------------- +def test_timer_never_fires_before_when(loop): + # 10.4ms with nearest-rounding used to truncate to 10ms and could fire + # ~0.4ms early. ceil() must guarantee the callback runs at or after `when`. + results = [] + when = loop.time() + 0.0104 + + def cb(): + results.append(loop.time()) + loop.stop() + + loop.call_at(when, cb) + loop.run_forever() + assert len(results) == 1 + assert results[0] >= when, (results[0], when, results[0] - when) + + +def test_timer_precision_repeated_no_early_fire(): + # Run several fresh loops to shake out rounding-direction regressions. + for _ in range(30): + lp = hvloop.new_event_loop() + try: + when = lp.time() + 0.0107 + got = {} + + def cb(): + got["t"] = lp.time() + lp.stop() + + lp.call_at(when, cb) + lp.run_forever() + assert got["t"] >= when, (got["t"], when) + finally: + lp.close() + + +# --------------------------------------------------------------------------- +# Regression: time() after close() does not jump back to 0.0 (fix #4) +# --------------------------------------------------------------------------- +def test_time_after_close_does_not_regress(): + lp = hvloop.new_event_loop() + before = lp.time() + assert before > 0.0 + lp.close() + after = lp.time() + # Must not collapse to 0.0; stays at the value snapshotted at close(). + assert after >= before + assert after > 0.0 + + +# --------------------------------------------------------------------------- +# Regression: idle loop must not busy-spin at 100% CPU. +# +# hvloop self-drives via hloop_process_events. libhv leaves a freshly created +# loop at HLOOP_STATUS_STOP (only hloop_run sets RUNNING), and in that state +# hloop_process_events bails out right after the poll and never runs +# hloop_process_pendings -- so the internal wakeup-fd reader never drains the +# eventfd, the fd stays readable, poll returns immediately every time, and the +# loop spins. run_forever() now flips the status to RUNNING (and back to STOP on +# exit) so the wakeup fd is drained and the loop actually blocks when idle. +# --------------------------------------------------------------------------- +@pytest.mark.skipif( + importlib.util.find_spec("resource") is None, + reason="resource.getrusage not available on this platform (e.g. Windows)", +) +def test_idle_loop_does_not_burn_cpu(loop): + import resource + + def worker(): + # Make sure the wakeup eventfd is created and written at least once, + # so a regression that only manifests after the first wakeup is caught. + time.sleep(0.1) + loop.call_soon_threadsafe(lambda: None) + + t = threading.Thread(target=worker) + t.start() + + u0 = resource.getrusage(resource.RUSAGE_SELF) + cpu0 = u0.ru_utime + u0.ru_stime + + loop.run_until_complete(asyncio.sleep(1.0)) + + u1 = resource.getrusage(resource.RUSAGE_SELF) + cpu1 = u1.ru_utime + u1.ru_stime + t.join() + + cpu_used = cpu1 - cpu0 + # Before the fix this was ~1.0s (100% of one core). A correctly-blocking + # idle loop uses almost nothing; allow generous headroom for CI jitter. + assert cpu_used < 0.3, "idle loop burned {:.3f}s CPU".format(cpu_used) + + +def test_threadsafe_wakeup_stays_effective_across_idle_periods(loop): + # Regression guard for "wakeup fd is read empty, then never wakes again": + # several call_soon_threadsafe calls separated by idle periods must each + # wake the parked poll promptly. If the wakeup-fd reader stopped draining + # (or the fd were left permanently readable), latency would blow up or the + # callback would never run. + latencies = [] + done = threading.Event() + rounds = 4 + + def worker(): + for _ in range(rounds): + time.sleep(0.1) # let the loop fully park in poll between wakeups + posted = time.monotonic() + + def cb(posted=posted): + latencies.append(time.monotonic() - posted) + + loop.call_soon_threadsafe(cb) + # Give the last callback a moment to run, then stop. + time.sleep(0.05) + loop.call_soon_threadsafe(loop.stop) + done.set() + + t = threading.Thread(target=worker) + t.start() + loop.run_forever() + t.join() + + assert done.is_set() + assert len(latencies) == rounds, latencies + for lat in latencies: + assert lat < 0.05, "wakeup latency regressed: {!r}".format(latencies) + + +def test_run_after_keyboardinterrupt_rearms_running_status(loop, capfd): + # A KeyboardInterrupt from a callback flips libhv's status back to STOP + # (via hloop_stop) to break out of the poll. Re-entering the loop must + # re-arm RUNNING so the loop blocks correctly again and timers still fire + # -- otherwise the second run would busy-spin / drop IO callbacks. + def boom(): + raise KeyboardInterrupt + + loop.call_soon(boom) + with pytest.raises(KeyboardInterrupt): + loop.run_until_complete(asyncio.sleep(10)) + + # No "Exception ignored in: ... _on_timer" stderr noise from the C frame. + capfd.readouterr() + + # Same loop must run cleanly again: a timer-driven sleep should complete, + # proving the status was re-armed to RUNNING (timers + IO callbacks work). + ran = [] + + async def again(): + await asyncio.sleep(0.05) + ran.append(True) + + loop.run_until_complete(again()) + assert ran == [True] + assert not loop.is_running() + + +# --------------------------------------------------------------------------- +# Regression: a very large call_later delay must not overflow the uint32 ms +# cast (undefined behaviour). It should clamp and still be cancellable. +# --------------------------------------------------------------------------- +def test_call_later_huge_delay_clamps_and_cancels(loop): + h = loop.call_later(1e9, lambda: None) # ~31 years; far past libhv's cap + assert not h.cancelled() + h.cancel() + assert h.cancelled() + # Cancel must be idempotent and not crash. + h.cancel() diff --git a/tests/test_smoke.py b/tests/test_smoke.py new file mode 100644 index 0000000..35de27d --- /dev/null +++ b/tests/test_smoke.py @@ -0,0 +1,127 @@ +"""Minimal smoke tests: stdlib asyncio primitives on top of hvloop. + +asyncio.sleep / gather / wait_for rely only on call_soon / call_at / Future, +which M1 provides, so they must work end-to-end on an hvloop loop. +""" + +import asyncio + +import pytest + +import hvloop + + +def test_asyncio_sleep(loop): + async def main(): + t0 = loop.time() + await asyncio.sleep(0.05) + return loop.time() - t0 + + elapsed = loop.run_until_complete(main()) + assert elapsed >= 0.04 + + +def test_asyncio_gather(loop): + async def work(n): + await asyncio.sleep(0.01 * n) + return n * n + + async def main(): + return await asyncio.gather(work(1), work(2), work(3)) + + assert loop.run_until_complete(main()) == [1, 4, 9] + + +def test_asyncio_gather_with_exception(loop): + async def good(): + await asyncio.sleep(0.01) + return "ok" + + async def bad(): + await asyncio.sleep(0.01) + raise ValueError("nope") + + async def main(): + return await asyncio.gather(good(), bad(), return_exceptions=True) + + results = loop.run_until_complete(main()) + assert results[0] == "ok" + assert isinstance(results[1], ValueError) + + +def test_asyncio_wait_for_timeout(loop): + async def main(): + with pytest.raises(asyncio.TimeoutError): + await asyncio.wait_for(asyncio.sleep(10), timeout=0.05) + return "timed-out" + + assert loop.run_until_complete(main()) == "timed-out" + + +def test_asyncio_wait_for_completes(loop): + async def quick(): + await asyncio.sleep(0.01) + return "value" + + async def main(): + return await asyncio.wait_for(quick(), timeout=1.0) + + assert loop.run_until_complete(main()) == "value" + + +def test_nested_tasks(loop): + async def child(n): + await asyncio.sleep(0.005) + return n + + async def parent(): + tasks = [asyncio.ensure_future(child(i)) for i in range(5)] + results = await asyncio.gather(*tasks) + return sum(results) + + assert loop.run_until_complete(parent()) == 10 + + +def test_event_synchronization(loop): + async def main(): + ev = asyncio.Event() + + async def setter(): + await asyncio.sleep(0.02) + ev.set() + + # Keep a strong reference: the loop only weakly tracks tasks, so an + # unreferenced task could in principle be GC'd before it fires (RUF006). + setter_task = asyncio.ensure_future(setter()) + await ev.wait() + await setter_task + return "set" + + assert loop.run_until_complete(main()) == "set" + + +def test_hvloop_run_helper(): + async def main(): + await asyncio.sleep(0.01) + return "hvloop.run works" + + assert hvloop.run(main()) == "hvloop.run works" + + +def test_hvloop_run_rejects_non_coroutine(): + with pytest.raises(ValueError): + hvloop.run(123) + + +def test_install_uninstall(): + hvloop.install() + try: + policy = asyncio.get_event_loop_policy() + assert isinstance(policy, hvloop.EventLoopPolicy) + new_loop = policy.new_event_loop() + try: + assert isinstance(new_loop, hvloop.Loop) + finally: + new_loop.close() + finally: + hvloop.uninstall() diff --git a/tests/test_sock.py b/tests/test_sock.py new file mode 100644 index 0000000..81bfaff --- /dev/null +++ b/tests/test_sock.py @@ -0,0 +1,276 @@ +"""M4 sock_* tests (tech design section 5, Phase 2). + +sock_recv / sock_recv_into / sock_sendall / sock_connect / sock_accept are +built on the M2b add_reader/add_writer machinery with asyncio *selector* +event loop semantics: non-blocking sockets (validated in debug mode), fds +stay caller-owned, one temporary reader/writer per pending operation. + +Constraint (documented in the implementation, same as asyncio): a socket +used with sock_* must not simultaneously be owned by a transport of the +same loop or carry a user add_reader/add_writer registration in the same +direction. +""" + +import asyncio +import socket +import ssl + +import pytest + + +def _nonblocking_socketpair(): + a, b = socket.socketpair() + a.setblocking(False) + b.setblocking(False) + return a, b + + +# --------------------------------------------------------------------------- +# sock_recv / sock_sendall round trip on a socketpair +# --------------------------------------------------------------------------- +def test_sock_recv_sendall_roundtrip(loop): + a, b = _nonblocking_socketpair() + + async def main(): + # Data already pending: sock_recv completes on the fast path. + await loop.sock_sendall(a, b"ping") + assert await asyncio.wait_for(loop.sock_recv(b, 100), 10) == b"ping" + + # No data pending: sock_recv must wait for readiness. + recv_task = loop.create_task(loop.sock_recv(a, 100)) + await asyncio.sleep(0.05) + assert not recv_task.done() + await loop.sock_sendall(b, b"pong") + assert await asyncio.wait_for(recv_task, 10) == b"pong" + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + a.close() + b.close() + + +def test_sock_sendall_large_payload(loop): + # Big enough to overflow the kernel socket buffer -> forces the + # add_writer retry path inside sock_sendall. + payload = b"\xcd" * (4 * 1024 * 1024) + a, b = _nonblocking_socketpair() + + async def main(): + async def drain(): + got = bytearray() + while len(got) < len(payload): + chunk = await loop.sock_recv(b, 256 * 1024) + assert chunk, "peer closed early" + got.extend(chunk) + return bytes(got) + + send_task = loop.create_task(loop.sock_sendall(a, payload)) + got = await asyncio.wait_for(drain(), 60) + await asyncio.wait_for(send_task, 10) + assert got == payload + + try: + loop.run_until_complete(asyncio.wait_for(main(), 90)) + finally: + a.close() + b.close() + + +def test_sock_recv_into(loop): + a, b = _nonblocking_socketpair() + + async def main(): + await loop.sock_sendall(a, b"buffer-me") + buf = bytearray(64) + n = await asyncio.wait_for(loop.sock_recv_into(b, buf), 10) + assert n == 9 + assert bytes(buf[:n]) == b"buffer-me" + + # Blocking path: no data yet. + buf2 = bytearray(16) + task = loop.create_task(loop.sock_recv_into(a, buf2)) + await asyncio.sleep(0.05) + assert not task.done() + await loop.sock_sendall(b, b"later") + n2 = await asyncio.wait_for(task, 10) + assert bytes(buf2[:n2]) == b"later" + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + a.close() + b.close() + + +def test_sock_recv_eof_returns_empty(loop): + a, b = _nonblocking_socketpair() + + async def main(): + task = loop.create_task(loop.sock_recv(b, 100)) + await asyncio.sleep(0.02) + a.close() + assert await asyncio.wait_for(task, 10) == b"" + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + b.close() + + +# --------------------------------------------------------------------------- +# sock_connect + sock_accept build a connection +# --------------------------------------------------------------------------- +def test_sock_connect_accept(loop): + lsock = socket.socket() + lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + lsock.bind(("127.0.0.1", 0)) + lsock.listen(8) + lsock.setblocking(False) + port = lsock.getsockname()[1] + + csock = socket.socket() + csock.setblocking(False) + + conn_holder = [] + + async def main(): + accept_task = loop.create_task(loop.sock_accept(lsock)) + await loop.sock_connect(csock, ("127.0.0.1", port)) + conn, addr = await asyncio.wait_for(accept_task, 10) + conn_holder.append(conn) + assert conn.gettimeout() == 0 # accepted socket is non-blocking + assert addr[0] == "127.0.0.1" + + # And the pair actually works with sock_sendall/sock_recv. + await loop.sock_sendall(csock, b"over-accept") + assert await asyncio.wait_for( + loop.sock_recv(conn, 100), 10) == b"over-accept" + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + for s in (lsock, csock, *conn_holder): + s.close() + + +def test_sock_connect_refused(loop): + # Grab a port that is certainly closed. + probe = socket.socket() + probe.bind(("127.0.0.1", 0)) + port = probe.getsockname()[1] + probe.close() + + csock = socket.socket() + csock.setblocking(False) + + async def main(): + with pytest.raises(ConnectionRefusedError): + await asyncio.wait_for( + loop.sock_connect(csock, ("127.0.0.1", port)), 10) + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + csock.close() + + +def test_sock_connect_resolves_hostname(loop): + lsock = socket.socket() + lsock.bind(("127.0.0.1", 0)) + lsock.listen(1) + lsock.setblocking(False) + port = lsock.getsockname()[1] + + csock = socket.socket() + csock.setblocking(False) + + async def main(): + accept_task = loop.create_task(loop.sock_accept(lsock)) + # Hostname (not numeric) exercises the getaddrinfo path. + await loop.sock_connect(csock, ("localhost", port)) + conn, _ = await asyncio.wait_for(accept_task, 10) + conn.close() + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + lsock.close() + csock.close() + + +# --------------------------------------------------------------------------- +# validation, asyncio-conformant +# --------------------------------------------------------------------------- +def test_sock_blocking_socket_rejected_in_debug(loop): + a, b = socket.socketpair() # blocking + + async def main(): + with pytest.raises(ValueError): + await loop.sock_recv(a, 10) + with pytest.raises(ValueError): + await loop.sock_recv_into(a, bytearray(4)) + with pytest.raises(ValueError): + await loop.sock_sendall(a, b"x") + with pytest.raises(ValueError): + await loop.sock_connect(a, ("127.0.0.1", 1)) + with pytest.raises(ValueError): + await loop.sock_accept(a) + + loop.set_debug(True) + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + loop.set_debug(False) + a.close() + b.close() + + +def test_sock_sslsocket_rejected(loop): + ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) + ctx.check_hostname = False + ctx.verify_mode = ssl.CERT_NONE + raw = socket.socket() + wrapped = ctx.wrap_socket(raw, do_handshake_on_connect=False) + + async def main(): + with pytest.raises(TypeError): + await loop.sock_recv(wrapped, 10) + with pytest.raises(TypeError): + await loop.sock_sendall(wrapped, b"x") + with pytest.raises(TypeError): + await loop.sock_connect(wrapped, ("127.0.0.1", 1)) + with pytest.raises(TypeError): + await loop.sock_accept(wrapped) + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + wrapped.close() + + +def test_sock_recv_cancellation_releases_reader(loop): + # Cancelling a pending sock_recv must remove the temporary reader so the + # fd is immediately reusable with add_reader (M2b machinery underneath). + a, b = _nonblocking_socketpair() + + async def main(): + task = loop.create_task(loop.sock_recv(b, 100)) + await asyncio.sleep(0.02) + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + + # The reader slot is free again: a plain add_reader works and fires. + fired = loop.create_future() + loop.add_reader(b, lambda: not fired.done() and + fired.set_result(None)) + a.send(b"x") + await asyncio.wait_for(fired, 10) + assert loop.remove_reader(b) is True + + try: + loop.run_until_complete(asyncio.wait_for(main(), 30)) + finally: + a.close() + b.close() diff --git a/tests/test_tcp.py b/tests/test_tcp.py new file mode 100644 index 0000000..4a93104 --- /dev/null +++ b/tests/test_tcp.py @@ -0,0 +1,878 @@ +"""M2a tests: TCPTransport, create_connection, create_server, Server. + +Plan section 12.2: echo client/server, large payloads, read pause/resume, +write watermarks (pause_writing/resume_writing), peer close -> connection_lost, +abort, the create_server(sock=...) fd-ownership path, asyncio streams smoke +(the real path DB drivers use), idle-CPU regression guard, and loop.close() +with still-open transports/servers. + +Same style as the M1 suite: synchronous tests that construct their own loop +(``loop`` fixture) and drive coroutines via run_until_complete. +""" + +import asyncio +import importlib.util +import os +import socket +import sys +import time + +import pytest + +import hvloop + + +# --------------------------------------------------------------------------- +# Helper protocols +# --------------------------------------------------------------------------- +class Recorder(asyncio.Protocol): + """Records everything; exposes futures for connect/close.""" + + def __init__(self, loop): + self.loop = loop + self.transport = None + self.data = bytearray() + self.eof = False + self.pauses = 0 + self.resumes = 0 + self.connected = loop.create_future() + self.closed = loop.create_future() + + def connection_made(self, transport): + self.transport = transport + if not self.connected.done(): + self.connected.set_result(None) + + def data_received(self, data): + self.data.extend(data) + + def eof_received(self): + self.eof = True + return False + + def pause_writing(self): + self.pauses += 1 + + def resume_writing(self): + self.resumes += 1 + + def connection_lost(self, exc): + if not self.closed.done(): + self.closed.set_result(exc) + + +class EchoRecorder(Recorder): + def data_received(self, data): + super().data_received(data) + self.transport.write(data) + + +async def _poll_until(cond, timeout=10.0, interval=0.005): + deadline = time.monotonic() + timeout + while not cond(): + if time.monotonic() > deadline: + raise TimeoutError("condition not met within {}s".format(timeout)) + await asyncio.sleep(interval) + + +async def _make_echo_server(loop, protos, **kwargs): + def factory(): + p = EchoRecorder(loop) + protos.append(p) + return p + + server = await loop.create_server(factory, "127.0.0.1", 0, **kwargs) + port = server.sockets[0].getsockname()[1] + return server, port + + +# --------------------------------------------------------------------------- +# Echo roundtrip & basic transport API +# --------------------------------------------------------------------------- +def test_echo_roundtrip(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + assert server.is_serving() + + cp = Recorder(loop) + tr, proto = await loop.create_connection(lambda: cp, "127.0.0.1", port) + assert proto is cp + await asyncio.wait_for(cp.connected, 5) + + payload = b"hello hvloop " * 64 + tr.write(payload) + await _poll_until(lambda: len(cp.data) >= len(payload)) + assert bytes(cp.data) == payload + + # extra_info: sockname/peername are required (uvicorn depends on them) + assert tr.get_extra_info("peername") == ("127.0.0.1", port) + sockname = tr.get_extra_info("sockname") + assert sockname[0] == "127.0.0.1" + # 'socket' is a dup()-based real socket object + sob = tr.get_extra_info("socket") + assert sob is not None + assert sob.getsockname() == sockname + assert tr.get_extra_info("nonexistent", "fallback") == "fallback" + + assert tr.can_write_eof() is True + assert tr.is_reading() is True + assert not tr.is_closing() + assert tr.get_protocol() is cp + + tr.close() + assert tr.is_closing() + assert (await asyncio.wait_for(cp.closed, 5)) is None + # server side observes the disconnect as well + assert (await asyncio.wait_for(server_protos[0].closed, 5)) is None + + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + assert not server.is_serving() + assert server.sockets == () + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_large_payload_roundtrip(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + payload = os.urandom(1024) * 1500 # ~1.5 MiB, non-trivial content + tr.write(payload) + await _poll_until(lambda: len(cp.data) >= len(payload), timeout=20) + assert bytes(cp.data) == payload + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +def test_writelines_and_write_validation(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + with pytest.raises(TypeError): + tr.write("not bytes") + tr.write(b"") # no-op + tr.writelines([b"a", bytearray(b"b"), memoryview(b"c")]) + await _poll_until(lambda: len(cp.data) >= 3) + assert bytes(cp.data) == b"abc" + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# pause_reading / resume_reading +# --------------------------------------------------------------------------- +def test_pause_resume_reading(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + # Wait for the server-side transport, then pause its reading. + await _poll_until(lambda: len(server_protos) == 1) + sp = server_protos[0] + await asyncio.wait_for(sp.connected, 5) + sp.transport.pause_reading() + assert not sp.transport.is_reading() + sp.transport.pause_reading() # idempotent, no error + + tr.write(b"x" * 1024) + # While paused the server protocol must receive nothing. + await asyncio.sleep(0.2) + assert len(sp.data) == 0 + + sp.transport.resume_reading() + assert sp.transport.is_reading() + sp.transport.resume_reading() # idempotent, no error + await _poll_until(lambda: len(sp.data) == 1024) + # echo comes back to the client + await _poll_until(lambda: len(cp.data) == 1024) + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# Write flow control: pause_writing / resume_writing +# --------------------------------------------------------------------------- +@pytest.mark.xfail( + sys.platform == "win32", + reason="Windows write-buffer backpressure differs: an 8 MiB write to a " + "paused peer is absorbed by the larger default loopback socket buffers " + "(and/or libhv's Windows write-queue accounting), so hio_write_bufsize " + "stays 0 and pause_writing never fires. Unverified on real hardware; " + "tracked as a known Windows limitation (see CLAUDE.md).", + strict=False, +) +def test_write_flow_control(loop): + class PausingServer(Recorder): + def connection_made(self, transport): + transport.pause_reading() # build backpressure + super().connection_made(transport) + + async def main(): + server_protos = [] + + def factory(): + p = PausingServer(loop) + server_protos.append(p) + return p + + server = await loop.create_server(factory, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + tr.set_write_buffer_limits(high=16 * 1024, low=4 * 1024) + assert tr.get_write_buffer_limits() == (4 * 1024, 16 * 1024) + + payload = b"x" * (8 * 1024 * 1024) # far beyond kernel buffers + tr.write(payload) + # The unsent remainder sits in libhv's write queue: over high water, + # pause_writing must have been delivered synchronously. + assert cp.pauses == 1 + assert tr.get_write_buffer_size() > 0 + + # Un-pause the peer; everything drains and resume_writing fires. + await _poll_until(lambda: len(server_protos) == 1) + await asyncio.wait_for(server_protos[0].connected, 5) + server_protos[0].transport.resume_reading() + await _poll_until(lambda: cp.resumes >= 1, timeout=30) + assert cp.pauses == 1 + await _poll_until( + lambda: len(server_protos[0].data) == len(payload), timeout=30 + ) + assert tr.get_write_buffer_size() == 0 + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +def test_set_write_buffer_limits_validation(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + with pytest.raises(ValueError): + tr.set_write_buffer_limits(high=10, low=20) + tr.set_write_buffer_limits(low=256) + assert tr.get_write_buffer_limits() == (256, 1024) + tr.set_write_buffer_limits() + assert tr.get_write_buffer_limits() == (16 * 1024, 64 * 1024) + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# Peer close -> eof_received + connection_lost +# --------------------------------------------------------------------------- +def test_peer_close_triggers_eof_and_connection_lost(loop): + class CloseOnConnect(Recorder): + def connection_made(self, transport): + super().connection_made(transport) + transport.close() + + async def main(): + server_protos = [] + + def factory(): + p = CloseOnConnect(loop) + server_protos.append(p) + return p + + server = await loop.create_server(factory, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + # Client sees the peer's clean shutdown: best-effort eof_received, + # then connection_lost(None). (libhv closes on EOF, so eof_received + # returning True can't keep the connection open -- documented + # deviation, plan section 6.) + exc = await asyncio.wait_for(cp.closed, 5) + assert exc is None + assert cp.eof is True + assert tr.is_closing() + + # server side got its own connection_lost(None) via close() + assert (await asyncio.wait_for(server_protos[0].closed, 5)) is None + + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +@pytest.mark.xfail( + sys.platform == "win32", + reason="Depends on a large write staying queued (get_write_buffer_size() > " + "0) right after write(); on Windows the payload is absorbed by loopback " + "socket buffers so the buffer reads 0. The flush-on-close behaviour itself " + "is fine; only the synchronous buffered-size assertion doesn't hold. " + "Unverified on real hardware; known Windows limitation (see CLAUDE.md).", + strict=False, +) +def test_close_flushes_pending_writes(loop): + # libhv's hio_close defers the actual close until the write queue is + # flushed; close() immediately after a large write must not truncate. + async def main(): + server_protos = [] + + def factory(): + p = Recorder(loop) + server_protos.append(p) + return p + + server = await loop.create_server(factory, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + payload = b"y" * (4 * 1024 * 1024) + tr.write(payload) + # close() while a good chunk of payload is still in libhv's queue + assert tr.get_write_buffer_size() > 0 + tr.close() + + await _poll_until(lambda: len(server_protos) == 1) + sp = server_protos[0] + await _poll_until(lambda: len(sp.data) == len(payload), timeout=30) + assert bytes(sp.data) == payload + + assert (await asyncio.wait_for(cp.closed, 10)) is None + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +# --------------------------------------------------------------------------- +# abort +# --------------------------------------------------------------------------- +def test_abort(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + + tr.write(b"z" * (4 * 1024 * 1024)) + tr.abort() # immediate close, pending buffer discarded + assert tr.is_closing() + # asyncio semantics: abort() reports connection_lost(None) + assert (await asyncio.wait_for(cp.closed, 5)) is None + + # the server side observes the connection going away (clean EOF or + # ECONNRESET depending on timing) + await _poll_until(lambda: len(server_protos) == 0 or + server_protos[0].closed.done(), timeout=10) + + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# write_eof +# --------------------------------------------------------------------------- +def test_write_eof(loop): + async def main(): + server_protos = [] + + def factory(): + p = Recorder(loop) + server_protos.append(p) + return p + + server = await loop.create_server(factory, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + assert tr.can_write_eof() is True + + payload = b"w" * (2 * 1024 * 1024) + tr.write(payload) + tr.write_eof() # SHUT_WR once the libhv write buffer drains + with pytest.raises(RuntimeError): + tr.write(b"after eof") + + sp = None + await _poll_until(lambda: len(server_protos) == 1) + sp = server_protos[0] + # The server receives the complete payload and then the EOF. + await _poll_until(lambda: len(sp.data) == len(payload), timeout=30) + assert bytes(sp.data) == payload + assert (await asyncio.wait_for(sp.closed, 10)) is None + assert sp.eof is True + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +# --------------------------------------------------------------------------- +# create_connection error paths +# --------------------------------------------------------------------------- +def test_create_connection_refused(loop): + async def main(): + # Grab a port that is definitely not listening. + probe = socket.socket() + probe.bind(("127.0.0.1", 0)) + port = probe.getsockname()[1] + probe.close() + + with pytest.raises(ConnectionRefusedError): + await asyncio.wait_for( + loop.create_connection(lambda: Recorder(loop), + "127.0.0.1", port), + 10, + ) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_create_connection_arg_validation(loop): + async def main(): + # TLS-related validation (asyncio semantics; M4 -- TLS is supported, + # the ssl-vs-server_hostname/timeout combinations must be checked). + with pytest.raises(ValueError): + await loop.create_connection(lambda: Recorder(loop), + "127.0.0.1", 80, + server_hostname="x") # no ssl + with pytest.raises(ValueError): + await loop.create_connection(lambda: Recorder(loop), + "127.0.0.1", 80, + ssl_handshake_timeout=1.0) # no ssl + with pytest.raises(ValueError): + # ssl with sock= (no host) requires an explicit server_hostname. + sock = socket.socket() + try: + await loop.create_connection( + lambda: Recorder(loop), sock=sock, ssl=True) + finally: + sock.close() + with pytest.raises(ValueError): + await loop.create_connection(lambda: Recorder(loop)) + with pytest.raises(ValueError): + sock = socket.socket() + try: + await loop.create_connection( + lambda: Recorder(loop), "127.0.0.1", 80, sock=sock) + finally: + sock.close() + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_create_connection_with_sock(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + + # Pre-connected socket handed to create_connection: the transport + # takes ownership (asyncio semantics). + raw = socket.create_connection(("127.0.0.1", port)) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, sock=raw) + assert raw.fileno() == -1 # detached: libhv owns the fd now + + tr.write(b"via sock=") + await _poll_until(lambda: len(cp.data) == 9) + assert bytes(cp.data) == b"via sock=" + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# create_server variations +# --------------------------------------------------------------------------- +def test_create_server_external_sock_fd_ownership(loop): + # plan section 7: an externally provided socket's fd belongs to the + # caller; server.close() must not close it. + async def main(): + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + sock.bind(("127.0.0.1", 0)) + port = sock.getsockname()[1] + + server_protos = [] + + def factory(): + p = EchoRecorder(loop) + server_protos.append(p) + return p + + server = await loop.create_server(factory, sock=sock) + assert server.sockets[0] is sock + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + tr.write(b"ext") + await _poll_until(lambda: len(cp.data) == 3) + tr.close() + await asyncio.wait_for(cp.closed, 5) + + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + # The caller's fd is still alive and well after server.close(). + assert sock.fileno() != -1 + sock.getsockname() # raises if the fd were closed (portable; os.fstat fails on Windows sockets) + sock.close() # and the caller can close it normally + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_create_server_start_serving_false(loop): + async def main(): + protos = [] + + def factory(): + p = EchoRecorder(loop) + protos.append(p) + return p + + server = await loop.create_server( + factory, "127.0.0.1", 0, start_serving=False) + assert not server.is_serving() + port = server.sockets[0].getsockname()[1] + + # No accept processing before start_serving: the connection sits in + # the backlog and no protocol is created. + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + await asyncio.sleep(0.2) + assert protos == [] + + await server.start_serving() + assert server.is_serving() + await _poll_until(lambda: len(protos) == 1) + + tr.write(b"go") + await _poll_until(lambda: len(cp.data) == 2) + + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_create_server_validation(loop): + async def main(): + with pytest.raises(TypeError): + # asyncio semantics: create_server(ssl=...) takes an SSLContext + # or None, never a bool. + await loop.create_server(lambda: None, "127.0.0.1", 0, ssl=True) + with pytest.raises(ValueError): + await loop.create_server(lambda: None, "127.0.0.1", 0, + ssl_handshake_timeout=1.0) # no ssl + with pytest.raises(ValueError): + await loop.create_server(lambda: None) + with pytest.raises(ValueError): + sock = socket.socket() + try: + await loop.create_server( + lambda: None, "127.0.0.1", 0, sock=sock) + finally: + sock.close() + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_server_async_context_manager_and_serve_forever(loop): + async def main(): + protos = [] + + def factory(): + p = EchoRecorder(loop) + protos.append(p) + return p + + async with await loop.create_server( + factory, "127.0.0.1", 0, start_serving=False) as server: + task = loop.create_task(server.serve_forever()) + await asyncio.sleep(0.05) + assert server.is_serving() + port = server.sockets[0].getsockname()[1] + + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + tr.write(b"sf") + await _poll_until(lambda: len(cp.data) == 2) + tr.close() + await asyncio.wait_for(cp.closed, 5) + + task.cancel() + with pytest.raises(asyncio.CancelledError): + await task + assert not server.is_serving() + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_wait_closed_waits_for_connections(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + await _poll_until(lambda: len(server_protos) == 1) + await asyncio.wait_for(server_protos[0].connected, 5) + + server.close() + waiter = loop.create_task(server.wait_closed()) + await asyncio.sleep(0.1) + # the accepted connection is still open -> wait_closed still pending + assert not waiter.done() + + tr.close() + await asyncio.wait_for(waiter, 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# asyncio streams smoke test (the real path DB drivers / clients use) +# --------------------------------------------------------------------------- +def test_asyncio_streams_echo(loop): + async def handler(reader, writer): + while True: + data = await reader.read(65536) + if not data: + break + writer.write(data) + await writer.drain() + writer.close() + + async def main(): + server = await asyncio.start_server(handler, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + + reader, writer = await asyncio.open_connection("127.0.0.1", port) + payload = os.urandom(256 * 1024) + writer.write(payload) + await writer.drain() + echoed = await asyncio.wait_for(reader.readexactly(len(payload)), 20) + assert echoed == payload + + peer = writer.get_extra_info("peername") + assert peer == ("127.0.0.1", port) + + writer.close() + await asyncio.wait_for(writer.wait_closed(), 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +# --------------------------------------------------------------------------- +# Idle CPU guard: a listening server must not busy-poll +# --------------------------------------------------------------------------- +@pytest.mark.skipif( + importlib.util.find_spec("resource") is None, + reason="resource.getrusage not available on this platform (e.g. Windows)", +) +def test_idle_server_does_not_burn_cpu(loop): + import resource + + async def main(): + server = await loop.create_server( + lambda: EchoRecorder(loop), "127.0.0.1", 0) + + u0 = resource.getrusage(resource.RUSAGE_SELF) + cpu0 = u0.ru_utime + u0.ru_stime + await asyncio.sleep(1.0) + u1 = resource.getrusage(resource.RUSAGE_SELF) + cpu1 = u1.ru_utime + u1.ru_stime + + server.close() + await server.wait_closed() + return cpu1 - cpu0 + + cpu_used = loop.run_until_complete(asyncio.wait_for(main(), 30)) + assert cpu_used < 0.3, "idle server burned {:.3f}s CPU".format(cpu_used) + + +# --------------------------------------------------------------------------- +# loop.close() with still-open transports / servers +# --------------------------------------------------------------------------- +def test_loop_close_with_open_transport_and_server(): + lp = hvloop.new_event_loop() + state = {} + + async def main(): + server_protos = [] + + def factory(): + p = EchoRecorder(lp) + server_protos.append(p) + return p + + server = await lp.create_server(factory, "127.0.0.1", 0) + port = server.sockets[0].getsockname()[1] + cp = Recorder(lp) + tr, _ = await lp.create_connection(lambda: cp, "127.0.0.1", port) + tr.write(b"live") + await _poll_until(lambda: len(cp.data) == 4) + state["server"] = server + state["tr"] = tr + state["server_tr"] = server_protos[0].transport + + lp.run_until_complete(asyncio.wait_for(main(), 30)) + + # Deliberately leave the server, the client transport and the accepted + # server-side transport open across loop.close(). + lp.close() + assert lp.is_closed() + + tr = state["tr"] + server = state["server"] + server_tr = state["server_tr"] + + # Post-close: every method must be a safe no-op / sane value, and must + # not touch freed libhv structures. + assert tr.is_closing() + assert not tr.is_reading() + tr.write(b"after close") # swallowed (conn_lost accounting) + tr.pause_reading() + tr.resume_reading() + tr.write_eof() + tr.close() + tr.abort() + assert tr.get_write_buffer_size() == 0 + assert tr.get_extra_info("socket") is None + # cached before close, still available + assert tr.get_extra_info("peername") is not None + + server_tr.close() + server_tr.abort() + + server.close() # listener already torn down by loop.close(); safe + assert server.sockets == () + + # And a fresh loop still works afterwards. + lp2 = hvloop.new_event_loop() + try: + assert lp2.run_until_complete(asyncio.sleep(0, result=42)) == 42 + finally: + lp2.close() + + +def test_external_sock_survives_loop_close(): + # Variant of fd ownership: loop.close() (not server.close()) must also + # leave a caller-owned listen socket open. + lp = hvloop.new_event_loop() + sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) + sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) + sock.bind(("127.0.0.1", 0)) + + async def main(): + return await lp.create_server(lambda: EchoRecorder(lp), sock=sock) + + server = lp.run_until_complete(main()) + assert server.is_serving() + lp.close() + + assert sock.fileno() != -1 + sock.getsockname() # portable "still open" check (os.fstat fails on Windows sockets) + sock.close() + + +# --------------------------------------------------------------------------- +# Misc transport behaviour +# --------------------------------------------------------------------------- +def test_set_get_protocol(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + cp = Recorder(loop) + tr, _ = await loop.create_connection(lambda: cp, "127.0.0.1", port) + assert tr.get_protocol() is cp + cp2 = Recorder(loop) + tr.set_protocol(cp2) + assert tr.get_protocol() is cp2 + tr.set_protocol(cp) + tr.close() + await asyncio.wait_for(cp.closed, 5) + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +def test_multiple_concurrent_connections(loop): + async def main(): + server_protos = [] + server, port = await _make_echo_server(loop, server_protos) + + clients = [] + for i in range(10): + cp = Recorder(loop) + tr, _ = await loop.create_connection( + lambda cp=cp: cp, "127.0.0.1", port) + clients.append((tr, cp, b"client-%d" % i)) + + for tr, cp, payload in clients: + tr.write(payload) + for tr, cp, payload in clients: + await _poll_until( + lambda cp=cp, payload=payload: len(cp.data) == len(payload)) + assert bytes(cp.data) == payload + + for tr, cp, _ in clients: + tr.close() + for tr, cp, _ in clients: + await asyncio.wait_for(cp.closed, 5) + + server.close() + await asyncio.wait_for(server.wait_closed(), 5) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) diff --git a/tests/test_tls.py b/tests/test_tls.py new file mode 100644 index 0000000..19637f8 --- /dev/null +++ b/tests/test_tls.py @@ -0,0 +1,391 @@ +"""M4 TLS tests (tech design section 8). + +hvloop reuses the stdlib asyncio.sslproto.SSLProtocol on top of its own +TCPTransport; these tests drive server and client both on ONE hvloop loop: + + * TLS echo (create_server(ssl=...) + create_connection(ssl=...)) + * 1MB+ payload round trip + * handshake failure (untrusted server certificate) surfaces sensible + exceptions on both sides + * get_extra_info('ssl_object' / 'peercert' / 'sslcontext') + * write flow control under TLS does not deadlock (streams drain()) + * uvicorn --ssl integration smoke (see test_asgi.py for the harness) + +Certificates: tests/certs/server.{crt,key} -- a committed self-signed pair +with SAN localhost/127.0.0.1/::1 (see tests/certs/README.md for why the +vendor/libhv cert is unusable: it has no SAN, so Python hostname +verification can never pass). +""" + +from __future__ import annotations + +import asyncio +import pathlib +import socket +import ssl +import sys + +import pytest + +CERT_DIR = pathlib.Path(__file__).parent / "certs" +SERVER_CERT = str(CERT_DIR / "server.crt") +SERVER_KEY = str(CERT_DIR / "server.key") + + +def _server_ctx() -> ssl.SSLContext: + ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) + ctx.load_cert_chain(SERVER_CERT, SERVER_KEY) + return ctx + + +def _client_ctx() -> ssl.SSLContext: + # Default (verifying) client context that trusts our self-signed cert. + ctx = ssl.create_default_context(cafile=SERVER_CERT) + return ctx + + +class _Echo(asyncio.Protocol): + """Server-side echo protocol (runs above the SSL app-transport).""" + + def __init__(self): + self.transport = None + + def connection_made(self, transport): + self.transport = transport + + def data_received(self, data): + self.transport.write(data) + + def connection_lost(self, exc): + pass + + +class _Collector(asyncio.Protocol): + """Client-side protocol collecting bytes until connection loss.""" + + def __init__(self, loop): + self.transport = None + self.data = bytearray() + self.connected = loop.create_future() + self.closed = loop.create_future() + + def connection_made(self, transport): + self.transport = transport + self.connected.set_result(None) + + def data_received(self, data): + self.data.extend(data) + + def connection_lost(self, exc): + if not self.closed.done(): + if exc is None: + self.closed.set_result(None) + else: + self.closed.set_exception(exc) + # Avoid "exception never retrieved" if a test doesn't await. + self.closed.exception() + + +# --------------------------------------------------------------------------- +# echo + payload sizes +# --------------------------------------------------------------------------- +@pytest.mark.parametrize("payload", [b"hello-tls", b"x" * (1024 * 1024 + 17)], + ids=["small", "1MB+"]) +def test_tls_echo_roundtrip(loop, payload): + async def main(): + server = await loop.create_server( + _Echo, "127.0.0.1", 0, ssl=_server_ctx()) + port = server.sockets[0].getsockname()[1] + + cp = _Collector(loop) + tr, proto = await loop.create_connection( + lambda: cp, "127.0.0.1", port, + ssl=_client_ctx(), server_hostname="localhost") + assert proto is cp + # The caller gets the SSL app-transport, not the raw TCP transport. + assert tr.get_extra_info("ssl_object") is not None + + tr.write(payload) + await asyncio.wait_for( + _wait_for_len(cp, len(payload)), 30) + assert bytes(cp.data) == payload + + tr.close() + await asyncio.wait_for(cp.closed, 10) + server.close() + await asyncio.wait_for(server.wait_closed(), 10) + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +async def _wait_for_len(cp, n): + while len(cp.data) < n: + await asyncio.sleep(0.005) + + +# --------------------------------------------------------------------------- +# extra_info surface +# --------------------------------------------------------------------------- +def test_tls_get_extra_info(loop): + async def main(): + client_ctx = _client_ctx() + server = await loop.create_server( + _Echo, "127.0.0.1", 0, ssl=_server_ctx()) + port = server.sockets[0].getsockname()[1] + + cp = _Collector(loop) + tr, _ = await loop.create_connection( + lambda: cp, "127.0.0.1", port, + ssl=client_ctx, server_hostname="localhost") + + ssl_obj = tr.get_extra_info("ssl_object") + assert isinstance(ssl_obj, ssl.SSLObject) + peercert = tr.get_extra_info("peercert") + assert peercert, "client must see the server certificate" + sans = dict.fromkeys( + v for _k, v in peercert.get("subjectAltName", ())) + assert "localhost" in sans + assert tr.get_extra_info("sslcontext") is client_ctx + # Raw-transport info is forwarded through the SSL app-transport. + assert tr.get_extra_info("peername")[1] == port + + tr.close() + await asyncio.wait_for(cp.closed, 10) + server.close() + await asyncio.wait_for(server.wait_closed(), 10) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# handshake failure: untrusted server certificate +# --------------------------------------------------------------------------- +def test_tls_handshake_failure_untrusted_cert(loop): + server_errors = [] + + def exc_handler(_loop, context): + server_errors.append(context.get("exception")) + + async def main(): + app_protos = [] + + def factory(): + p = _Echo() + app_protos.append(p) + return p + + server = await loop.create_server( + factory, "127.0.0.1", 0, ssl=_server_ctx()) + port = server.sockets[0].getsockname()[1] + + # Default client context WITHOUT our CA: verification must fail. + with pytest.raises(ssl.SSLCertVerificationError): + await asyncio.wait_for( + loop.create_connection( + lambda: _Collector(loop), "127.0.0.1", port, + ssl=ssl.create_default_context(), + server_hostname="localhost"), + 15) + + # Server side: the handshake failed before the app protocol was + # connected, so the app protocol never sees the connection and the + # server keeps serving. (asyncio semantics: SSLProtocol._fatal_error + # only *debug-logs* OSError-family errors -- ssl.SSLError included -- + # so nothing reaches the loop exception handler; anything that DOES + # reach it must still be an SSL/OS error, not e.g. an AttributeError + # from a broken transport/protocol wiring.) + await asyncio.sleep(0.1) + for p in app_protos: + assert p.transport is None, \ + "app protocol must not see a failed-handshake connection" + for e in server_errors: + assert e is None or isinstance(e, OSError), server_errors + + # ... and a well-configured client still connects fine afterwards. + cp = _Collector(loop) + tr, _ = await loop.create_connection( + lambda: cp, "127.0.0.1", port, + ssl=_client_ctx(), server_hostname="localhost") + tr.write(b"still alive") + await asyncio.wait_for(_wait_for_len(cp, 11), 10) + tr.close() + await asyncio.wait_for(cp.closed, 10) + + server.close() + await asyncio.wait_for(server.wait_closed(), 10) + + loop.set_exception_handler(exc_handler) + try: + loop.run_until_complete(asyncio.wait_for(main(), 60)) + finally: + loop.set_exception_handler(None) + + +def test_tls_ssl_true_uses_default_context(loop): + """ssl=True builds a default (verifying) client context: against our + self-signed server the handshake must fail verification -- proving the + default-context path is wired, without needing a public CA.""" + async def main(): + server = await loop.create_server( + _Echo, "127.0.0.1", 0, ssl=_server_ctx()) + port = server.sockets[0].getsockname()[1] + with pytest.raises(ssl.SSLCertVerificationError): + await asyncio.wait_for( + loop.create_connection( + lambda: _Collector(loop), "127.0.0.1", port, + ssl=True, server_hostname="localhost"), + 15) + server.close() + await asyncio.wait_for(server.wait_closed(), 10) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) + + +# --------------------------------------------------------------------------- +# flow control under TLS: bulk transfer with drain() must not deadlock +# --------------------------------------------------------------------------- +def test_tls_flow_control_bulk_no_deadlock(loop): + total = 8 * 1024 * 1024 # 8 MiB each direction + chunk = 64 * 1024 + + async def main(): + async def handle(reader, writer): + # Echo server: read chunks, write them back, honoring drain(). + try: + while True: + data = await reader.read(chunk) + if not data: + break + writer.write(data) + await writer.drain() + finally: + writer.close() + + server = await asyncio.start_server( + handle, "127.0.0.1", 0, ssl=_server_ctx()) + port = server.sockets[0].getsockname()[1] + + reader, writer = await asyncio.open_connection( + "127.0.0.1", port, ssl=_client_ctx(), + server_hostname="localhost") + + async def pump_out(): + sent = 0 + payload = b"\xab" * chunk + while sent < total: + writer.write(payload) + await writer.drain() # exercises pause/resume_writing + sent += len(payload) + + async def pump_in(): + got = 0 + while got < total: + data = await reader.read(chunk) + assert data, "connection closed early" + got += len(data) + return got + + _, got = await asyncio.gather(pump_out(), pump_in()) + assert got == total + + writer.close() + try: + await asyncio.wait_for(writer.wait_closed(), 10) + except (ConnectionError, ssl.SSLError): + pass + server.close() + await asyncio.wait_for(server.wait_closed(), 10) + + loop.run_until_complete(asyncio.wait_for(main(), 120)) + + +# --------------------------------------------------------------------------- +# uvicorn --ssl integration smoke +# --------------------------------------------------------------------------- +def test_uvicorn_tls_smoke(loop): + uvicorn = pytest.importorskip("uvicorn") + httpx = pytest.importorskip("httpx") + + async def app(scope, receive, send): + assert scope["type"] == "http" + assert scope["scheme"] == "https" + await send({ + "type": "http.response.start", + "status": 200, + "headers": [(b"content-type", b"text/plain")], + }) + await send({"type": "http.response.body", "body": b"hello-tls"}) + + async def main(): + port = _free_port() + config = uvicorn.Config( + app, + host="127.0.0.1", + port=port, + lifespan="off", + log_level="warning", + ssl_certfile=SERVER_CERT, + ssl_keyfile=SERVER_KEY, + ) + server = uvicorn.Server(config) + task = asyncio.get_running_loop().create_task(server.serve()) + try: + deadline = loop.time() + 15.0 + while not server.started: + if task.done(): + task.result() + raise RuntimeError("uvicorn ended before startup") + if loop.time() > deadline: + raise TimeoutError("uvicorn did not start within 15s") + await asyncio.sleep(0.01) + + client_ctx = _client_ctx() + async with httpx.AsyncClient(verify=client_ctx) as client: + r = await client.get(f"https://localhost:{port}/") + assert r.status_code == 200 + assert r.text == "hello-tls" + finally: + server.should_exit = True + try: + await asyncio.wait_for(asyncio.shield(task), 15) + except asyncio.TimeoutError: + task.cancel() + + loop.run_until_complete(asyncio.wait_for(main(), 60)) + + +def _free_port(): + with socket.socket() as s: + s.bind(("127.0.0.1", 0)) + return s.getsockname()[1] + + +# --------------------------------------------------------------------------- +# version-gated parameter surface +# --------------------------------------------------------------------------- +def test_ssl_shutdown_timeout_gate(loop): + async def main(): + if sys.version_info >= (3, 11): + # Accepted (passed through to sslproto) -- pair it with a real + # handshake so the parameter reaches SSLProtocol. + server = await loop.create_server( + _Echo, "127.0.0.1", 0, ssl=_server_ctx(), + ssl_shutdown_timeout=5.0) + port = server.sockets[0].getsockname()[1] + cp = _Collector(loop) + tr, _ = await loop.create_connection( + lambda: cp, "127.0.0.1", port, + ssl=_client_ctx(), server_hostname="localhost", + ssl_shutdown_timeout=5.0) + tr.close() + await asyncio.wait_for(cp.closed, 10) + server.close() + await asyncio.wait_for(server.wait_closed(), 10) + else: + # 3.10: pre-3.11 sslproto has no ssl_shutdown_timeout. + with pytest.raises(TypeError): + await loop.create_server( + _Echo, "127.0.0.1", 0, ssl=_server_ctx(), + ssl_shutdown_timeout=5.0) + + loop.run_until_complete(asyncio.wait_for(main(), 30)) diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..a928421 --- /dev/null +++ b/uv.lock @@ -0,0 +1,869 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.15'", + "python_full_version < '3.15'", +] + +[[package]] +name = "ast-serialize" +version = "0.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/81/9d/09e27731bd5864a9ce04e3244074e674bb8936bf62b45e0357248717adac/ast_serialize-0.5.0.tar.gz", hash = "sha256:5880091bfe6f4f986f22866375c2e884843e7a0b6343ae41aeea659613d879b6", size = 61157, upload-time = "2026-05-17T17:48:29.429Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/9a/13dde51ba9e15f8b97957ab7cb0120d0e381524d651c6bd630b9c359227f/ast_serialize-0.5.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:8f5c14f169eb0972c0c21bada5358b23d6047c76583b005234f865b11f1fa00a", size = 1183520, upload-time = "2026-05-17T17:47:30.831Z" }, + { url = "https://files.pythonhosted.org/packages/37/de/5a7f0a9fe68944f536632a5af84676739c7d2582be42deb082634bf3a754/ast_serialize-0.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7d1a2de9de5be04652f0ed60738356ef94f66db37924a9499fffe98dc491aa0b", size = 1175779, upload-time = "2026-05-17T17:47:32.551Z" }, + { url = "https://files.pythonhosted.org/packages/9c/81/0bb853e76e4f6e9a1855d569003c59e19ffac45f7079d91505d1bb212f92/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:be5173fb66f9b49026d9d5a2ff0fc7c7009077107c0eb285b2d60fdf1fe10bd1", size = 1233750, upload-time = "2026-05-17T17:47:34.731Z" }, + { url = "https://files.pythonhosted.org/packages/e5/d3/4cf705beeccc08754d0bbda99aefff26110e209b9a07ac8a6b60eec48531/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f8015cd071ac1339924ee2b8098c93e00e155f30a16f40ec9816fcf84f4753f6", size = 1235942, upload-time = "2026-05-17T17:47:36.287Z" }, + { url = "https://files.pythonhosted.org/packages/26/c8/ee097e437ea27dd2b8b227865c875492b585650a5802a22d82b304c8201b/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5499e8797edff2a9186aa313ed382c6b422e798e9332d9953badcee6e69a88f2", size = 1442517, upload-time = "2026-05-17T17:47:38.17Z" }, + { url = "https://files.pythonhosted.org/packages/ff/bd/68063442838f1ba68ec72b5436430bc75b3bb17a1a3c3063f09b0c05ae2b/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6848f2a093fb5548751a9a09bff8fcd229e2bbeb0e3331f391b6ae6d26cd9903", size = 1254081, upload-time = "2026-05-17T17:47:39.826Z" }, + { url = "https://files.pythonhosted.org/packages/50/e2/1e520793bc6a4e4524a6ab022391e827825eaa0c3811828bfdc6852eca26/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:832d4c998e0b091fd60a6d6bceee535483c4d490de9ba85003af835225719261", size = 1259910, upload-time = "2026-05-17T17:47:41.369Z" }, + { url = "https://files.pythonhosted.org/packages/4e/e1/49b60f467979979cfe6913b43948ff25bca971ad0591d181812f163a988e/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:16db7c62ec0b8efe1d7afd283a388d8f74f2605d56032e5a37747d2de8dba027", size = 1250678, upload-time = "2026-05-17T17:47:43.702Z" }, + { url = "https://files.pythonhosted.org/packages/74/ba/66ab9555de6275677566f6574e5ef6c29cb185ea866f643bc06f8280a8ee/ast_serialize-0.5.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:baf5eb061eb5bccade4128ad42da33787d72f6013809cd1b590376ece8b3c937", size = 1301603, upload-time = "2026-05-17T17:47:46.256Z" }, + { url = "https://files.pythonhosted.org/packages/66/42/6aca9b9abc710014b2be9059689e5dd1679339e78f567ffb4d255a9e2050/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:104e4a35bd7c124173c41760ef9aaea17ddb3f86c65cb643671d59afbe3ee94c", size = 1410332, upload-time = "2026-05-17T17:47:47.899Z" }, + { url = "https://files.pythonhosted.org/packages/47/68/2f76594432a22581ecf878b5e75a9b8601c24b2241cf0bbeb1e21fcf370c/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:36be371028fc1675acb38a331bde160dbab7ff907fdf00b67eb6911aa106951b", size = 1509979, upload-time = "2026-05-17T17:47:50.942Z" }, + { url = "https://files.pythonhosted.org/packages/40/ac/a93c9b58292653f6c595752f677a08e608f903b710594909e9231a389b3b/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:061ee58bdb52341c8201a6df41182a977736bae3b7ded87ca7176ca25a8a47ab", size = 1505002, upload-time = "2026-05-17T17:47:54.093Z" }, + { url = "https://files.pythonhosted.org/packages/14/2e/b278f68c497ee2f1d1576cbbef8db5281cd4a5f2db040537592ac9c8862e/ast_serialize-0.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b15219e9cdc9f53f6f4cb51c009203507228226148c05c5e8fe451c28b435eb3", size = 1456231, upload-time = "2026-05-17T17:47:56.311Z" }, + { url = "https://files.pythonhosted.org/packages/0b/43/419be1c566a4c504cd8fd60ce2f84e790f295495c0f327cfaeadf3d51012/ast_serialize-0.5.0-cp314-cp314t-win32.whl", hash = "sha256:842d1c004bb466c7df036f95fabef789570541922b10976b12f5592a69cf0b38", size = 1058668, upload-time = "2026-05-17T17:47:58.305Z" }, + { url = "https://files.pythonhosted.org/packages/03/6f/c9d4d549295ed05111aeb8853232d1afd9d0a179fddb01eeffbb3a4a6842/ast_serialize-0.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b0c06d760909b095cc466356dfccd05a1c7233a6ca191c020dca2c6a6f16c24c", size = 1101075, upload-time = "2026-05-17T17:48:00.35Z" }, + { url = "https://files.pythonhosted.org/packages/d0/8e/d00c5ab30c58222e07d62956fca86c59d91b9ad32997e633c38b526623a3/ast_serialize-0.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:787baedb0262cc49e8ce37cc15c00ae818e46a165a3b36f5e21ed174998104cb", size = 1075347, upload-time = "2026-05-17T17:48:01.753Z" }, + { url = "https://files.pythonhosted.org/packages/e0/9e/dc2530acb3a60dc6e46d65abf27d1d9f86721694757906a148d90a6860de/ast_serialize-0.5.0-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0668aa9459cfa8c9c49ddd2163ebcf43088ba045ef7492af6fe22e0098303101", size = 1191380, upload-time = "2026-05-17T17:48:03.738Z" }, + { url = "https://files.pythonhosted.org/packages/26/0a/bd3d18a582f273d6c843d16bb9e22e9e16365ff7991e92f18f798e9f1224/ast_serialize-0.5.0-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:bf683d6363edf2b39eed6b6d4fe22d34b6203867a67e27134d9e2a2680c4bc4a", size = 1183879, upload-time = "2026-05-17T17:48:05.463Z" }, + { url = "https://files.pythonhosted.org/packages/40/ae/1f919100f8620887af58fcc381c61a1f218cdf89c6e155f87b213e61010a/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc22cf0c9be65e71cf88fda130af60d61eb4a79370ad4cfe7900d48a4aa2211", size = 1244529, upload-time = "2026-05-17T17:48:07.008Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ca/6376559dcce707cdbc1d0d9a13c8d3baaaa501e949ce0ebdc4230cd881aa/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f66173891548c9f2726bf27957b41cabce12fa679dc6da505ddbde4d4b3b31cf", size = 1240560, upload-time = "2026-05-17T17:48:08.46Z" }, + { url = "https://files.pythonhosted.org/packages/35/b2/a620e206b5aeb7efbf2710336df57d457cffbb3991076bbcc1147ef9abd4/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e42d729ef2be96a14efbad355093284739e3670ece3e534f82cc8832790911d9", size = 1451172, upload-time = "2026-05-17T17:48:09.922Z" }, + { url = "https://files.pythonhosted.org/packages/fa/e0/4ad5c04c24a40481b2935ce9a0ccdb6023dc8b667167d06ae530cc3512f2/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b725026bafa801dbd7310eb13a75f0a2e370e7e51b2cb225f9d21fcfadf919ee", size = 1265072, upload-time = "2026-05-17T17:48:11.469Z" }, + { url = "https://files.pythonhosted.org/packages/b2/71/4d1d479aa56d0101c40e17720c3d6ac2af7269ea0487a80b18e7bfd1a5b7/ast_serialize-0.5.0-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b54f60c1d78767a53b67eaa663f0dfac3afe606aa07f1301572f588b73d64809", size = 1270488, upload-time = "2026-05-17T17:48:13.575Z" }, + { url = "https://files.pythonhosted.org/packages/6d/4f/0de1bbe06f6edef9fde4ed12ca8e7b3ec7e6e2bd4e672c5af487f7957665/ast_serialize-0.5.0-cp39-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:27d51654fc240a1e87e742d353d98eb45b75f62f129086b3596ab53df2ac2a43", size = 1260702, upload-time = "2026-05-17T17:48:15.141Z" }, + { url = "https://files.pythonhosted.org/packages/75/61/e00872439cfdddcc3c1b6cdaa6e5d904ba8e26a18807c67c4e14409d0ca8/ast_serialize-0.5.0-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2782c36237c46dd1674542f2109740ea5ea485a169bf1431939ada0434e17934", size = 1311182, upload-time = "2026-05-17T17:48:16.779Z" }, + { url = "https://files.pythonhosted.org/packages/76/8e/699a5b955f7926956c95e9e1d74132acad73c2fe7a426f94da89123c20aa/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1943db345233cc7194a470f13afa9c59772c0b123dea0c9414c4d4ca54369759", size = 1421410, upload-time = "2026-05-17T17:48:18.527Z" }, + { url = "https://files.pythonhosted.org/packages/a9/ae/d5b7626874478997adc7a29ab28accf21e596fb590c944290401dfd0b29e/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:df1c00022cbbcb064bfaa505aa9c9295362443ce5dacb459d1331d3da353f887", size = 1516587, upload-time = "2026-05-17T17:48:20.133Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ce/b59e02a82d9c4244d64cde502e0b00e83e38816abe19155ceb5437402c7f/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:cae65289fc456fde04af979a2be09302ef5d8ab92ef23e596d6746dc267ada27", size = 1515171, upload-time = "2026-05-17T17:48:21.921Z" }, + { url = "https://files.pythonhosted.org/packages/8b/38/d8d90042747d05aa08d4efcf1c99035a5f670a6bf4c214d31644392afbca/ast_serialize-0.5.0-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:239a4c354e8d676e9d94631d1d4a64edc6b266f86ff3a5a80aedd344f342c01d", size = 1464668, upload-time = "2026-05-17T17:48:23.544Z" }, + { url = "https://files.pythonhosted.org/packages/dd/51/5b840c4df7334104cecffa28f23904fe81ca89ca223d2450e288de39fd3c/ast_serialize-0.5.0-cp39-abi3-win32.whl", hash = "sha256:143a4ef63285a075871908fda3672dc21864b83a8ec3ee12304aa3e4c5387b9a", size = 1068311, upload-time = "2026-05-17T17:48:25.027Z" }, + { url = "https://files.pythonhosted.org/packages/41/11/ca5672c7d491825bc4cd6702dea106a6b60d928707712ec257c7833ae476/ast_serialize-0.5.0-cp39-abi3-win_amd64.whl", hash = "sha256:cf25572c526add400f26a4750dc6ce0c3bb93fc1f75e7ae0cad4ce4f2cd5c590", size = 1108931, upload-time = "2026-05-17T17:48:26.591Z" }, + { url = "https://files.pythonhosted.org/packages/45/19/cc8bd127d28a43da249aa955cfd164cf8fd534e79e42cea96c4854d72fd0/ast_serialize-0.5.0-cp39-abi3-win_arm64.whl", hash = "sha256:92a31c9c20d25a076edaeec76b128a3535d74a24f340b9a8a7e96c9b86dc9642", size = 1081181, upload-time = "2026-05-17T17:48:28.122Z" }, +] + +[[package]] +name = "backports-asyncio-runner" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8e/ff/70dca7d7cb1cbc0edb2c6cc0c38b65cba36cccc491eca64cabd5fe7f8670/backports_asyncio_runner-1.2.0.tar.gz", hash = "sha256:a5aa7b2b7d8f8bfcaa2b57313f70792df84e32a2a746f585213373f900b42162", size = 69893, upload-time = "2025-07-02T02:27:15.685Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/59/76ab57e3fe74484f48a53f8e337171b4a2349e506eabe136d7e01d059086/backports_asyncio_runner-1.2.0-py3-none-any.whl", hash = "sha256:0da0a936a8aeb554eccb426dc55af3ba63bcdc69fa1a600b5bb305413a4477b5", size = 12313, upload-time = "2025-07-02T02:27:14.263Z" }, +] + +[[package]] +name = "black" +version = "26.5.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "click" }, + { name = "mypy-extensions" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "platformdirs" }, + { name = "pytokens" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c0/37/5628dd55bf2b34257fc7603f0fe97c40e3aaf24265f416a9c85c95ca1436/black-26.5.1.tar.gz", hash = "sha256:dd321f668053961824bcc1be1cc1df748b2d7e4fa28086b08331e577b0100a73", size = 679439, upload-time = "2026-05-18T16:53:36.107Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/be/84/b3f55026206a9e8820a91503308075ca48eadc515e436731ca01dbe043b3/black-26.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9942db8888e06943c5dde66ca0037dcff82a2a4ec1ad0ada9e0d2ee9d9823893", size = 1987719, upload-time = "2026-05-18T17:05:02.757Z" }, + { url = "https://files.pythonhosted.org/packages/c6/34/7db312c5e5783d6e76cffd9d5ac8972a32badae4c6e3288dac0eed8d3bed/black-26.5.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:89c93167a74d3a75dfaa38a5c7cca015537d5820dd7f17d63267d674a61cae90", size = 1810083, upload-time = "2026-05-18T17:05:04.302Z" }, + { url = "https://files.pythonhosted.org/packages/33/e2/e0101e73c2c8727634e2efcb35e2b34bd23ad70dfa673789f5773a591b21/black-26.5.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:22f2cd76d069cc54c71f10360744ba8983fbb616903b4304a85b734915c8e1b4", size = 1860633, upload-time = "2026-05-18T17:05:06.391Z" }, + { url = "https://files.pythonhosted.org/packages/b0/4c/e15c0c5b23cf3651035fe5addcce90e283af3548a3f91bb03d81b83106ab/black-26.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:87ed5c6f450580a2f6790bc7cbfb016dfc73bc750249762268a3695361315eef", size = 1477886, upload-time = "2026-05-18T17:05:07.96Z" }, + { url = "https://files.pythonhosted.org/packages/9f/3f/59d43ade98d2ce5c8dc34a4e46cbecd177e6d55d7d4092969c6003ccc655/black-26.5.1-cp310-cp310-win_arm64.whl", hash = "sha256:58b4bd92cf88aacf83d88479c8f9caee044b1ec55f2451a337354a7ea2590a22", size = 1277111, upload-time = "2026-05-18T17:05:09.473Z" }, + { url = "https://files.pythonhosted.org/packages/4b/96/3c3e09f09f44a37aac36b178a279cd19aa7001bd796187a7b162a294c81f/black-26.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:96ae2c733b2aabdd9986e2c5df628ff3473676cd1c5faded1ff496cf6d74083c", size = 1970639, upload-time = "2026-05-18T17:05:11.461Z" }, + { url = "https://files.pythonhosted.org/packages/83/ea/5ad117b9ee3ecd933c712bcbae610006e5b7cc9f41c526cd7ed3b6c4124c/black-26.5.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0e48b87e03bf109288e55cfceadcfa15ff5470aca2851a851950ed2926f450d7", size = 1792130, upload-time = "2026-05-18T17:05:12.983Z" }, + { url = "https://files.pythonhosted.org/packages/06/3a/7c448bc623fcdfa96672531beb5a616ea5e64f6975955254d7731ffb0ad9/black-26.5.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5119fa92ae61f786e8c3662fd60aece1d0a2dd5cca5d0c79417a95e7a4272a59", size = 1846134, upload-time = "2026-05-18T17:05:14.506Z" }, + { url = "https://files.pythonhosted.org/packages/a1/5b/0b39b3a5917f0657ac014ad2edb58c139553a478adfe7f817abf1622ff6e/black-26.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:30d3c14661f2792e9142cce3eeeb1cbc175b3eb5f733be0c8eeb99651e52b0c3", size = 1478883, upload-time = "2026-05-18T17:05:16.542Z" }, + { url = "https://files.pythonhosted.org/packages/4c/48/dc222692e0f95030db1bbfb6c857e76858bad09058221ea7aae815255327/black-26.5.1-cp311-cp311-win_arm64.whl", hash = "sha256:1ef92b76f7733f282fd096ea406200b5a286c42947412b0eaff3a74e3616cefe", size = 1277776, upload-time = "2026-05-18T17:05:18.029Z" }, + { url = "https://files.pythonhosted.org/packages/24/99/7744b906703228264ef73bdd534df88ec1ef3de45c4e78f6d31b9e32d0c9/black-26.5.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4ad6fa01f941920f54f2bbb35f3df7673428a0ef98a0b0840c2eaef3b110efa8", size = 2012518, upload-time = "2026-05-18T17:05:20.108Z" }, + { url = "https://files.pythonhosted.org/packages/b7/c0/c5a3b1636dfd09c42534f2b3cf33506814f6d3e066fb0879ffa16c1ae860/black-26.5.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3915f256e75a2d7cf88d8953d37f780455dc586cc72dee059c528fe77f581217", size = 1816016, upload-time = "2026-05-18T17:05:21.84Z" }, + { url = "https://files.pythonhosted.org/packages/1f/0e/36044316b65ca471d3bb6d3703fd06fb50c6b727c3562f6a5a3153634f88/black-26.5.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d98d4137277c75dfb898ec8d846c4fd68ba1e9cf77f95e2865c203dc18f4c3d", size = 1884150, upload-time = "2026-05-18T17:05:23.546Z" }, + { url = "https://files.pythonhosted.org/packages/b3/33/dafc5808c2af43672912111d7c3354af1615f7e2be3bed7a878461abbe4d/black-26.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:a1dca32d9f1784af512a13410ec204c6f7f0aa9797a111c42e1c03449821c264", size = 1486825, upload-time = "2026-05-18T17:05:25.004Z" }, + { url = "https://files.pythonhosted.org/packages/82/14/b965ee6ad2a311f28bdbf692def3ee9848d2ae289dab28b27657fcee3e78/black-26.5.1-cp312-cp312-win_arm64.whl", hash = "sha256:1037d5ac7b7b310b2632ad867ec8d0e4c4819dcdb0b820f63135da746a24e418", size = 1288646, upload-time = "2026-05-18T17:05:26.477Z" }, + { url = "https://files.pythonhosted.org/packages/3f/5c/c384363980e11e25ca6b93205949bb331fbf35f4e0dbec376dfa6326cec8/black-26.5.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2b36cf2ddf5566e205f6535f782a62194a184d33e175b64ae8c40b1737522be3", size = 2009020, upload-time = "2026-05-18T17:05:28.132Z" }, + { url = "https://files.pythonhosted.org/packages/0b/df/9f31c5e0babbfed77d505fc5d120beb98b21b33feaeded3924ea941fe360/black-26.5.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1f7ea64ebfa01b50f693508fc39f875e264446d3b097088f84f203b9d09618a0", size = 1813335, upload-time = "2026-05-18T17:05:31.266Z" }, + { url = "https://files.pythonhosted.org/packages/fb/24/8e7b9a2fa61b0afd82209efe937557d180a1fa055bd7f6161eb9defc3719/black-26.5.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecb3e624844c798144e9bd986954e0adc81d8911a1f30f375e1252fe26e8c294", size = 1881614, upload-time = "2026-05-18T17:05:32.718Z" }, + { url = "https://files.pythonhosted.org/packages/49/ad/b4e0d9365ba8ac34f6bbab62a4b1b2dd5d618fac3fa1b8db968c844201b5/black-26.5.1-cp313-cp313-win_amd64.whl", hash = "sha256:e1a26503279b6b310669fb0b219c39e4820b77e8189fe80f522bb511f247db0a", size = 1488925, upload-time = "2026-05-18T17:05:34.259Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4b/652b859bf5df88a751c30451b09338f7fd26a77d1271c666992f836b7711/black-26.5.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c34b25da232ead53a6f335b76dbea124f4d152ad568b9080d6f944bc2b34b52", size = 1289883, upload-time = "2026-05-18T17:05:36.019Z" }, + { url = "https://files.pythonhosted.org/packages/a6/16/a8da8eb208c51c7f4ce74609a45d0dcc6d8a2141e45e81ee5289d1bb0d59/black-26.5.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:e88976690a64b0af98312ca958415849cb42423423c5f2ee74af4b49a97a2168", size = 2004800, upload-time = "2026-05-18T17:05:38.182Z" }, + { url = "https://files.pythonhosted.org/packages/11/8a/a479296a19e383b70a725882a6cf3d786540601ff03cabbaaf1cce864c5a/black-26.5.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32d5ea7f6c8bdfa6e648326ebca1f02b0764e2a029edc6f8dce2627e19d468c3", size = 1815576, upload-time = "2026-05-18T17:05:40.309Z" }, + { url = "https://files.pythonhosted.org/packages/81/6b/cfaf3d39f25132c156a068f6b805576c9103a84086019507c70e1911ee7d/black-26.5.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ea8d16dc41655aa113cd64665e7219446cd7e4ff2248d7178eaa905190c86b18", size = 1877927, upload-time = "2026-05-18T17:05:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/66/76/302e313964bcff7e28df329d39f84f5270095730d85ff0acc260610a0d82/black-26.5.1-cp314-cp314-win_amd64.whl", hash = "sha256:577f21094ea469ef92ec1adaf2c9441a226d2144d01a5be2fa823cecf6543e50", size = 1511860, upload-time = "2026-05-18T17:05:43.943Z" }, + { url = "https://files.pythonhosted.org/packages/27/4e/a3827e35e0e567f9f9ee59e2a0ab979267dca98718f25547ca8c6733afd4/black-26.5.1-cp314-cp314-win_arm64.whl", hash = "sha256:ed1a20af114c301a0269bf01163d51dbef72737fd65f850001e7cbe7f3c7abae", size = 1316632, upload-time = "2026-05-18T17:05:45.521Z" }, + { url = "https://files.pythonhosted.org/packages/94/51/f975cae76d44274cc2868dc9040ac5d58d464784610234455b4e7b19c6ef/black-26.5.1-py3-none-any.whl", hash = "sha256:4ed7f7da04046d2e488437170797d3b4a4ad83906683bcb7dfc68b673bbce5e2", size = 213693, upload-time = "2026-05-18T16:53:33.964Z" }, +] + +[[package]] +name = "build" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "os_name == 'nt'" }, + { name = "importlib-metadata", marker = "python_full_version < '3.10.2'" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/78/e0/df5e171f685f82f37b12e1f208064e24244911079d7b767447d1af7e0d70/build-1.5.0.tar.gz", hash = "sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647", size = 89796, upload-time = "2026-04-30T03:18:25.17Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0d/fe/6bea5c9162869c5beba5d9c8abbed835ec85bf1ec1fba05a3822325c45f3/build-1.5.0-py3-none-any.whl", hash = "sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f", size = 26018, upload-time = "2026-04-30T03:18:23.644Z" }, +] + +[[package]] +name = "cfgv" +version = "3.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/b5/721b8799b04bf9afe054a3899c6cf4e880fcf8563cc71c15610242490a0c/cfgv-3.5.0.tar.gz", hash = "sha256:d5b1034354820651caa73ede66a6294d6e95c1b00acc5e9b098e917404669132", size = 7334, upload-time = "2025-11-19T20:55:51.612Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/db/3c/33bac158f8ab7f89b2e59426d5fe2e4f63f7ed25df84c036890172b412b5/cfgv-3.5.0-py2.py3-none-any.whl", hash = "sha256:a8dc6b26ad22ff227d2634a65cb388215ce6cc96bbcc5cfde7641ae87e8dacc0", size = 7445, upload-time = "2025-11-19T20:55:50.744Z" }, +] + +[[package]] +name = "click" +version = "8.4.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/9b/98/518d8e5081007684232226f475082b30087d0f585e8457db087298259f49/click-8.4.1.tar.gz", hash = "sha256:918b5633eddf6b41c32d4f454bf0de810065c74e3f7dbf8ee5452f8be88d3e96", size = 353007, upload-time = "2026-05-22T04:08:37.769Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c7/0d/67e5b4109ea4a837e80daa87c2c696711955e40449a97e8926672534def2/click-8.4.1-py3-none-any.whl", hash = "sha256:482be17c6991b8c19c5429a1e995d9b0efdbb63172824c41f99965dc0ade8ec2", size = 116639, upload-time = "2026-05-22T04:08:35.26Z" }, +] + +[[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.14.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/54/fd/0ab2772530e946e1be1abd0bc09e647ec9b02e88f0867857601fefca8953/coverage-7.14.1.tar.gz", hash = "sha256:30c08f7d90415aa98b3c990385dea2939b0da55f38515e5b369b83655f8523be", size = 920132, upload-time = "2026-05-26T20:41:36.783Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/69/0d2ef01ff4b8fcecd4cba920d11e92fa4f96ae412441d3b56a90a258e69b/coverage-7.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:3e3680291c4a1d0dadfa84a2c459576a4af5133abb617905714339a0c73138cf", size = 219722, upload-time = "2026-05-26T20:38:14.002Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ae/9afdeaa31b9d9ce98124b6abf8bb49119bf71aecae04f8567c189d91299f/coverage-7.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a5274669f37f2343635a347b91a60777621341ab3378e9c6ac9335eee704bddf", size = 220240, upload-time = "2026-05-26T20:38:17.424Z" }, + { url = "https://files.pythonhosted.org/packages/51/69/c998589871df7ea7dba865cc5ee32b5a3e1d47ba6c68ef91104c7c46fa5e/coverage-7.14.1-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cfe5a5fec635799ef33428f1e5e61bafa45a92a96190ba731561ba558ccc214d", size = 246981, upload-time = "2026-05-26T20:38:19.266Z" }, + { url = "https://files.pythonhosted.org/packages/fc/10/1c7d04c13040dac531d21b712bbe08f902e6dd9b58f5d77875c4d030f8f2/coverage-7.14.1-cp310-cp310-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:62a9f70b52e0b5a95cfef4a5c5641b06983cadc5e538a3feeb5c00211f523ac2", size = 248812, upload-time = "2026-05-26T20:38:20.75Z" }, + { url = "https://files.pythonhosted.org/packages/c1/65/2a38a4607ef27cadcfbcee034dba5830ae2569f90144a0f4c7dbf47d30b0/coverage-7.14.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3c18ebc343e15be53049b3a2dce38fe82d58f37e20ab9094b3a39c0aa4f6bb47", size = 250675, upload-time = "2026-05-26T20:38:22.159Z" }, + { url = "https://files.pythonhosted.org/packages/c9/a2/a446ed9752a4a59b79e0fb6cbb319f6facb2183045c0725462625e66f87e/coverage-7.14.1-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b84ffdf877644e7096aa936991efeed873f7f3df57b9cd001312b7668ab08550", size = 252590, upload-time = "2026-05-26T20:38:23.63Z" }, + { url = "https://files.pythonhosted.org/packages/9e/fd/e81fbd7ba752365546e9842b1cbdaad3d6919d2a522c590aef16a281ec5e/coverage-7.14.1-cp310-cp310-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e854312c4103f2ad4c0dc023b69b77ebfd2c89db5f86c4c94dc2353f9a92167e", size = 247691, upload-time = "2026-05-26T20:38:25.057Z" }, + { url = "https://files.pythonhosted.org/packages/53/35/f3c26fdaae9ea937d154ca4d372e5ea0a4167ff70d36c6074ac2eacb2f83/coverage-7.14.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:c643734307300234fafa36bf2a040a7235f8f177ea1fd6ec1423aea6fb7b929f", size = 248716, upload-time = "2026-05-26T20:38:26.406Z" }, + { url = "https://files.pythonhosted.org/packages/2e/14/940b6c49551fd343e8507ee2b0ba7af5d0aa04ed5bf768285cb7c72a9884/coverage-7.14.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:84ac9499e48700399a5dd0ea7085b5091961fec52c68d66b4ec0d3cf7f4441b1", size = 246721, upload-time = "2026-05-26T20:38:28.282Z" }, + { url = "https://files.pythonhosted.org/packages/aa/2c/40fc0634186c28292a662dff578866b3913983d6c375a3c2a74020938719/coverage-7.14.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:7f02d09f70776579b926d889a4c9c235070a1f47c40458aeaca563fae5acfdb5", size = 250533, upload-time = "2026-05-26T20:38:29.753Z" }, + { url = "https://files.pythonhosted.org/packages/de/e3/2c26bf1e811f9df991ff2a9bdddebdd13ee0665d564df7d05979f9146297/coverage-7.14.1-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:ce66d8e46da2bb5ee313a745cbd2e391d319176c1f7a9451bfcd3a2fb920859b", size = 246990, upload-time = "2026-05-26T20:38:31.516Z" }, + { url = "https://files.pythonhosted.org/packages/a8/b0/060260ef56bd92363ebdce0c7095ce422b06e69aae71828efeca473ab1ca/coverage-7.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:c912c259304cfb5ee584481cfb7ce1ff932b4d61e6c9140b8f19cb7b5ed82332", size = 247593, upload-time = "2026-05-26T20:38:33.065Z" }, + { url = "https://files.pythonhosted.org/packages/63/f3/501502046efeb0d6d94b5ca54941d95f1184183dd6bdb7f283985783bb4a/coverage-7.14.1-cp310-cp310-win32.whl", hash = "sha256:1238cb94638e610e972c60dac68e813f868dc7d6e982535270558443058d9d59", size = 222330, upload-time = "2026-05-26T20:38:35.36Z" }, + { url = "https://files.pythonhosted.org/packages/a0/5d/1bf99f2c558f128faf7906817ccbdb576ba815d3b41ce2ac1719b70a3663/coverage-7.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:fc459e5d73be2d6332fcfe8dbf3d8994671fe33c700f4565988ecfa511547253", size = 223261, upload-time = "2026-05-26T20:38:37.196Z" }, + { url = "https://files.pythonhosted.org/packages/7d/d7/477ad149490e6cb849f28abea1dabb9c823cea72e7500c81b4240ce619c0/coverage-7.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:478b5bcd63c2e1357c5c7e16c070690df7b07f676b1c114d7b93e533c664309f", size = 219848, upload-time = "2026-05-26T20:38:38.715Z" }, + { url = "https://files.pythonhosted.org/packages/91/82/a5eb47257c50601bb7b9a9d2857c67b7a3a85ad74180eb2c98bb1fbe0ce5/coverage-7.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a24a81f9715ee42ef59a316cc11611c98fe23920f7c81861315c9f3ff4a230f4", size = 220354, upload-time = "2026-05-26T20:38:40.232Z" }, + { url = "https://files.pythonhosted.org/packages/43/8b/78419b5391a5cb706b6544390507e469d83ffc9a8248b02c4011aceb9365/coverage-7.14.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:196a13319ad88d6d8ef5ab489ec4f44ddde2143c0c7d5b27786f6c3ffd56a7e1", size = 250771, upload-time = "2026-05-26T20:38:41.782Z" }, + { url = "https://files.pythonhosted.org/packages/77/63/e77aaacd491182210d639636b7a8bba23ffffa9b82aa3762da9431855fa9/coverage-7.14.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:3d452fd08b5c72c5167c93e6867b5c08500bd40f2a21e1e854a500550b6cc36f", size = 252683, upload-time = "2026-05-26T20:38:43.305Z" }, + { url = "https://files.pythonhosted.org/packages/65/1c/a022e3cfbec2ac241640003cb3a817e161d9c7f5aa9b49173756cdc03204/coverage-7.14.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:23bf7fa51ac02e07fc7c96849b82946da47ae862dc8f86d183b2a4864fc38129", size = 254791, upload-time = "2026-05-26T20:38:45.361Z" }, + { url = "https://files.pythonhosted.org/packages/61/d6/967e408aca4c1ceb88cb0cc677169110ae7f5995fb5eaf5fb1f5a1bb8f5d/coverage-7.14.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bcaa50684dcaadfa599ac48f81103c756d791cfd85c97203d2217c593d48b860", size = 256748, upload-time = "2026-05-26T20:38:46.91Z" }, + { url = "https://files.pythonhosted.org/packages/b8/be/869188f7fe28638078ec479331ace6dc5f7b40b7153eb616f47ab79404d8/coverage-7.14.1-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:4ea1c034f95c9b056e856b794630b17f9fa3d57e4800ff1e503d3be0f9c9078c", size = 250907, upload-time = "2026-05-26T20:38:48.493Z" }, + { url = "https://files.pythonhosted.org/packages/07/aa/adb7d3b4278d690e68703abcd76ab1b948242e3668d921711551b78f9ddb/coverage-7.14.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c7e057326434e441306226fbeb5d1aaf14a2637efe97ba668306635835f32ad7", size = 252483, upload-time = "2026-05-26T20:38:50.074Z" }, + { url = "https://files.pythonhosted.org/packages/43/61/331c74103c62dcb0c4b9b3a0de9a61aca016208b0a90f109592a9f9ecc28/coverage-7.14.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:59baf88468dbc8d63b1887afd92bda52e40bb1561696e5819670601403810cec", size = 250545, upload-time = "2026-05-26T20:38:51.613Z" }, + { url = "https://files.pythonhosted.org/packages/f6/b6/c5dae3c104d89be04828f61810e6b3473825482e4c288cc4ed04553e08ae/coverage-7.14.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d34d75f892b3ab73ba11cab5442cce7b3e168fd64162b16f0e1e0d09c508edef", size = 254310, upload-time = "2026-05-26T20:38:53.503Z" }, + { url = "https://files.pythonhosted.org/packages/ad/a1/2b9d5863e3b83c01ad8199e3c597802fbb3a9dc90b058885804c20296d31/coverage-7.14.1-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:3a56abc20a472baf0304c455721bc601477440d28ecfde8a03dde79ede07e0df", size = 250266, upload-time = "2026-05-26T20:38:55.414Z" }, + { url = "https://files.pythonhosted.org/packages/7f/5e/0e511fbdb269359be26fe678a1c3fa1f2aa2a01573cc3f54268c8d6d4797/coverage-7.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6a3cb83d1552c0cd1b4906655b6a33fd4a8473229633a901c6b73bf86914dee9", size = 251174, upload-time = "2026-05-26T20:38:57.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/10/e55307b622b3dd9671cb321824502dc10f93e72f2802b9946159a8edadeb/coverage-7.14.1-cp311-cp311-win32.whl", hash = "sha256:10274a1fbeb8ec5d72966e17bb198a3104257aca4ac09d98667c5f8aca8c8548", size = 222354, upload-time = "2026-05-26T20:38:58.727Z" }, + { url = "https://files.pythonhosted.org/packages/71/cf/107421693cfb71e4f1ca5bf70443f64d4161878068d07a3e51c7ad21d17b/coverage-7.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:87ebdf787d4888e3f3f2d523eadc6e18c6d18c6d0eb173801a189641627fb37e", size = 223290, upload-time = "2026-05-26T20:39:00.413Z" }, + { url = "https://files.pythonhosted.org/packages/b8/1d/3e3644585eb29e9dafefb19555078529a4d7cce12bd21929664eea989277/coverage-7.14.1-cp311-cp311-win_arm64.whl", hash = "sha256:dd34767fa19848d35659ffc0a75314f58c7af3f1cd87ec521e8292a1238398a3", size = 221953, upload-time = "2026-05-26T20:39:02.159Z" }, + { url = "https://files.pythonhosted.org/packages/3d/b7/bdbb725ba02c5b42825b200c940f38b7a54fcad24627b7192f78f8110d76/coverage-7.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a06c76364a9360e33d6d23769aefdf7f66f38e2ffb60ceb1baaa4989d83b695c", size = 220022, upload-time = "2026-05-26T20:39:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/72/81/fdc0898a55c6219223291ec1a1fe89966ef212ce82276aa0899df84b5de0/coverage-7.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fad54e871165f6ec2f536063ac74c3104508a12963e64072ba44bd822de52b0c", size = 220379, upload-time = "2026-05-26T20:39:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/de/72/de048c4a25e13bce59ac6a339351c10bdf2515e07459afcdaf04dc3143a2/coverage-7.14.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:84b535f00655ecafe1d929d1fb00ed5d6fa3051ea643ab2c161a3887b86f294b", size = 251888, upload-time = "2026-05-26T20:39:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/28/30/300c343f68beb9d4cbb64ec81e58c5b6b80b56927f72d2b38654ac26e013/coverage-7.14.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:6b6b0853b895fe0e98cbfc580d1ec3393d9302b4b1e96a77b3f5c91fdab899e6", size = 254624, upload-time = "2026-05-26T20:39:09.037Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ed/7b25642496e8170b6bac14adce00537c6e5fa2d586159401a4de3e8b49e6/coverage-7.14.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:442cc9c952b2df400cda54bb04ab87330cf2cd08a8692cbbea36773531eb6f37", size = 255739, upload-time = "2026-05-26T20:39:10.889Z" }, + { url = "https://files.pythonhosted.org/packages/7f/a2/abd210b8c4e29c24e4624916db97bb519097a91034aaeb767f937e7da794/coverage-7.14.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8270544c361ed405a27a060dbc9ed2c124b084d96dfdc2d9a2510482aef981ad", size = 257998, upload-time = "2026-05-26T20:39:12.722Z" }, + { url = "https://files.pythonhosted.org/packages/7f/24/7c50beed3792fe62f6ce0545c6686ce83379719e2c0276179333d97eae92/coverage-7.14.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:48b283b1dd6372e8de2a7a9a4c4d5dc06f4d4fd209b876f3c88a7a205a0c8f84", size = 252296, upload-time = "2026-05-26T20:39:14.259Z" }, + { url = "https://files.pythonhosted.org/packages/15/05/0f874628ebcbfc77ead559ff210281ef06a97db08481832e7dd39274a135/coverage-7.14.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5b0c99ba93a07d56f6df340bb79be53202a082b2fdb81bfe6190b741a3470d54", size = 253658, upload-time = "2026-05-26T20:39:15.923Z" }, + { url = "https://files.pythonhosted.org/packages/99/6f/ca6ad067364b337ef997802115e7ecad2abd2248b05471464b0dea02b4d4/coverage-7.14.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e471bc5769ff073b058cfadb0d736b56ce067c8560eabeb0da88462df98c23e7", size = 251803, upload-time = "2026-05-26T20:39:17.537Z" }, + { url = "https://files.pythonhosted.org/packages/c0/30/b9b4d377cd9f40baf228068f5a81faf8450c6228503011bd499708483a50/coverage-7.14.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:f497a1ea81d4cd7c10ddcaa685135b9aabd291af3d55775a9ddf3cb7a364cdd9", size = 255873, upload-time = "2026-05-26T20:39:19.414Z" }, + { url = "https://files.pythonhosted.org/packages/3c/21/7c721a9e5e6bb88547d30a787aefb97512d3f54c1324c7488d9b3743f7f9/coverage-7.14.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:2222be86d0b54f5dd5a38f45f17f315f737245e857bf0bdedc70734f84a13c02", size = 251372, upload-time = "2026-05-26T20:39:21.169Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f8ae5a2200130e1503cd7661a6cd3b2b7bacef98277fbf3571fb13f8b766/coverage-7.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:85e85586565842f6932abebd4c18bcb1074223dc0b3576e7d173ca710622813a", size = 253245, upload-time = "2026-05-26T20:39:23.097Z" }, + { url = "https://files.pythonhosted.org/packages/34/62/70a9024672a5f6910517d9628c52c9afbdd3cf8f46426af52bb148a56fff/coverage-7.14.1-cp312-cp312-win32.whl", hash = "sha256:4a28fd227808366b196a75476dced2eb35b351d6766ba9c858dc93319e87f4f1", size = 222567, upload-time = "2026-05-26T20:39:24.868Z" }, + { url = "https://files.pythonhosted.org/packages/f6/81/8b7cd386839b039ebe1855733b9f9449a8dec5d79564018234f185a7fa70/coverage-7.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:54acdb6674a4661768d7bf7db32dfb9f46ab1d764f8aba6df75ce1a6a088724e", size = 223372, upload-time = "2026-05-26T20:39:26.603Z" }, + { url = "https://files.pythonhosted.org/packages/ae/ba/b44d472022f620d289d95fa830143235c0c36461c6f2437ea8d51e5481ed/coverage-7.14.1-cp312-cp312-win_arm64.whl", hash = "sha256:99cd41ff91afd94896fea3bc002706b6ae4ce95727d06e4a0f39c0a8d8bd8b1a", size = 221989, upload-time = "2026-05-26T20:39:28.242Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9e/5f6d56327c62b185225d145191c607e07515294a0aa6338e58805cd4a5ac/coverage-7.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:be9f2c802dcfce3f71298303aa5dad0dce440a76c52f2f60dacd8656dab78793", size = 220044, upload-time = "2026-05-26T20:39:29.902Z" }, + { url = "https://files.pythonhosted.org/packages/75/92/e82aca356744cbbc0f77a0b623e38918c1872361963413a3bab5d0340393/coverage-7.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6223a72fd0e4c7156353ec0f08a5f93623e1d3034d0e2683b9bb8ea674131b1d", size = 220412, upload-time = "2026-05-26T20:39:31.561Z" }, + { url = "https://files.pythonhosted.org/packages/27/c9/385bde0bf7ed0f4bf3a7ee5367060a86b5d218718cfd6fb943c0f836b34f/coverage-7.14.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7279d2110a28cebc738b6459ecda2771735a4c18465fbbd36b3288fe5ed92247", size = 251412, upload-time = "2026-05-26T20:39:33.337Z" }, + { url = "https://files.pythonhosted.org/packages/51/8c/23faf6a2343a0d17f960a4bd56c43bc7eb4cf312f774dd6ceebd82c7d8fc/coverage-7.14.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:9eeb3fcbc13ba40dfbdb22d01d196a28e9cef9ed4c29b60061a1e0e823a9929d", size = 254008, upload-time = "2026-05-26T20:39:35.009Z" }, + { url = "https://files.pythonhosted.org/packages/42/06/36f4aa9ca8a815e6036156e80706a67828bb97bd826948244f6996dda957/coverage-7.14.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f0cfc27c539f07cf5c0a4cfe211d0b6cae039f8f40526dbaa71944e64b50a7b", size = 255241, upload-time = "2026-05-26T20:39:36.71Z" }, + { url = "https://files.pythonhosted.org/packages/ca/79/95266316352f90f6b1c6736bb413302edfde2453fb32422d3911642691b3/coverage-7.14.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:221c70f316241a78e77e607c227cefc8808d4e08f28d99c04f35694690e940be", size = 257373, upload-time = "2026-05-26T20:39:38.412Z" }, + { url = "https://files.pythonhosted.org/packages/e3/9c/58316d1f66c488b5fca8a0eb3e98348807813efa8a0d0833b9021be27488/coverage-7.14.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:da028256b04ec30e5e0114b6f76172938c313991f0a2d3d894271315cf5d5e43", size = 251635, upload-time = "2026-05-26T20:39:40.268Z" }, + { url = "https://files.pythonhosted.org/packages/ef/5a/ca2398a568e16fed7bb713e84ba3603a7164fb65779abe645c565ec890d5/coverage-7.14.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:76a085d7005236a767e3426148b2c407e53ad61695c562f8a81da2d373324901", size = 253373, upload-time = "2026-05-26T20:39:42.145Z" }, + { url = "https://files.pythonhosted.org/packages/6e/2c/0396562c32deaebe7be51d865b3a41e9a87d7561acafe1a28f53b07e019a/coverage-7.14.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b553d04b5e778a8e56d57eb134aff42a92718ecba45e79c4764ecfa40efd92ff", size = 251341, upload-time = "2026-05-26T20:39:43.907Z" }, + { url = "https://files.pythonhosted.org/packages/fd/8f/a94f9221184c9cae1ee115820e3798e48b6b17777a9f19e46fb9a0c8dc74/coverage-7.14.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:46f714d2fb8ae2f4f29f23ada7f1e79b759fff5a70f94a1dac23af204c3ec9e4", size = 255497, upload-time = "2026-05-26T20:39:46.166Z" }, + { url = "https://files.pythonhosted.org/packages/71/69/505d70e47db1eaebcd002c39759707621ef184cd6b1ae084d9f41293f323/coverage-7.14.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:1896f5e19ff3f0431c7ce2172adc54890fd97f86b59ced8ca1649145d9ffe35d", size = 251159, upload-time = "2026-05-26T20:39:48.03Z" }, + { url = "https://files.pythonhosted.org/packages/e0/aa/58681c383aa33a9d2ed40a02d7a22fbf780d1fa4d575396365777828198c/coverage-7.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:62fd185ef9df3c33d1c8178c5af105f762afbad96038de9a4ae100aa6297ca33", size = 252934, upload-time = "2026-05-26T20:39:49.872Z" }, + { url = "https://files.pythonhosted.org/packages/eb/fd/11c928cd6bdffc7074bb5965c173d9ebf517fb00205e1da524b98d29ef92/coverage-7.14.1-cp313-cp313-win32.whl", hash = "sha256:ab4af6352741a604c431c6072fce5bee33bf0f20dc7a56618d6bf6bb89e9810c", size = 222584, upload-time = "2026-05-26T20:39:51.68Z" }, + { url = "https://files.pythonhosted.org/packages/6f/92/fb416fc26d340dcba19518c418d6048e913186e17243982c5e435e41fa7a/coverage-7.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:7af486dabe8954d03b087f0021540897afe084f04e16ff5579e08cc46f871416", size = 223394, upload-time = "2026-05-26T20:39:53.472Z" }, + { url = "https://files.pythonhosted.org/packages/73/c6/02d56e3867972f77d5036de924643f26c056e848f00452cafb4dbc3c29b4/coverage-7.14.1-cp313-cp313-win_arm64.whl", hash = "sha256:2224f89ffd0c5605ccce1ed7a584da162bc7c55f601ab1c946bc9de31a486b42", size = 222015, upload-time = "2026-05-26T20:39:55.374Z" }, + { url = "https://files.pythonhosted.org/packages/4d/9e/fcc77914050df73f7662fa1f00902774c79c075a8388ab334074574bf77e/coverage-7.14.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:de286598cc65d2b489411174b1faec2f5a7775fb3201fd925db2a76b4030f37d", size = 220733, upload-time = "2026-05-26T20:39:57.189Z" }, + { url = "https://files.pythonhosted.org/packages/f7/67/2963cbdaf5cbadec44efa3a1e39eaa1f02df4079585f05387607a221e126/coverage-7.14.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:042c46ded7c288aeb07cf14a28b6c1e10b78fcba40171c3fa1e939377eeef0b5", size = 221086, upload-time = "2026-05-26T20:39:59.019Z" }, + { url = "https://files.pythonhosted.org/packages/c8/c5/8701645574e11881f2f47d8930f98bc48b5d43b25eb5b4430dfc4a2f9f48/coverage-7.14.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:f4ddbe407477f04c45115d1a4e5bc480f753553b534d338d4c3358b1cdd0ea52", size = 262381, upload-time = "2026-05-26T20:40:00.822Z" }, + { url = "https://files.pythonhosted.org/packages/7c/28/7a64d73598263e0c5abd5084211a8474488d31b3c552ff531c719dfcff62/coverage-7.14.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:d13e6725992e2d2fd7d81d4f5241952d13740121dfd501da09201be39b2c003a", size = 264458, upload-time = "2026-05-26T20:40:02.506Z" }, + { url = "https://files.pythonhosted.org/packages/fa/d8/4969179db9f7eb4df218e69540adf829d1c835f59452513d065d15446802/coverage-7.14.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f747dc8edcfe740130f28f32f3995e955494285717e86ee25af51db2219df08a", size = 266884, upload-time = "2026-05-26T20:40:04.421Z" }, + { url = "https://files.pythonhosted.org/packages/a6/78/a45d5794dbc9bafd97afc96a4377c86c7820d78b6cf51b89bc1d4e919275/coverage-7.14.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ced2f09ef276fd58611a1ef502164ad266d2b75174e5a40cabbdb4033f9f6cf2", size = 268022, upload-time = "2026-05-26T20:40:06.298Z" }, + { url = "https://files.pythonhosted.org/packages/21/cb/4f5e354e9e3e67af96bd4e57113e6db6b22298c7168b13eec408a549903d/coverage-7.14.1-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b84800013769a78ccb9ef4659402e26d06867e337b61ec365f77ad008adea80e", size = 261631, upload-time = "2026-05-26T20:40:08.226Z" }, + { url = "https://files.pythonhosted.org/packages/ec/49/eced49af4cb996d5d8b7e94e736175c513e4facd3398507b89892b4326d8/coverage-7.14.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ea8cd6ca0ee9f616aaef3afc6882e32c2cbf18b00d96313ffd76af650574034d", size = 264443, upload-time = "2026-05-26T20:40:10.137Z" }, + { url = "https://files.pythonhosted.org/packages/f1/d8/5603a88a7c5913a6b54f6cb1a8c46f7b39cbb30f27cd3f492908da09b2d7/coverage-7.14.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:aa5e304a873fabddc11e484e9b6b738bd38bd7bed17b09aa84eecf5332e8b8bb", size = 262069, upload-time = "2026-05-26T20:40:11.999Z" }, + { url = "https://files.pythonhosted.org/packages/f0/59/2ae3cb79da554a06c8619d6c88ea19dd1e4aed4b834b6a83bb1fa243bdc5/coverage-7.14.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5a1c5215be81035e629d5bc756650634d0bf31991038db7a0eccb90f025ce16d", size = 265780, upload-time = "2026-05-26T20:40:13.858Z" }, + { url = "https://files.pythonhosted.org/packages/af/5f/b130c1dc999031f2648bd25317fbce505ad8d5562079b4ed81e736a84967/coverage-7.14.1-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:79058c47dae6788504b5effb319961bcd72d7240551464b91d474bc0ed186d69", size = 260970, upload-time = "2026-05-26T20:40:16.142Z" }, + { url = "https://files.pythonhosted.org/packages/87/d1/ec13ccddeb48ec963bdfa72a11224bac2584bd045ba13beca82f8113e9c7/coverage-7.14.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:370c5afae3fa0658e11694a32b24c2778f6bc2d17718121f94ee185e69f26b54", size = 263157, upload-time = "2026-05-26T20:40:18.382Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c2/cd91ead503045161092d3845f7bb95ea2f25131ce96d3e314dd835d91b9c/coverage-7.14.1-cp313-cp313t-win32.whl", hash = "sha256:3758dd0a7f1fa57365ef2e781df0f0731d38b6e3772259d13dae4bd8a958d4b1", size = 223259, upload-time = "2026-05-26T20:40:20.381Z" }, + { url = "https://files.pythonhosted.org/packages/71/9f/1e28d97e6bd2c76b07f38b7c02870f1371255ff6717f54eca578fcbbdd0e/coverage-7.14.1-cp313-cp313t-win_amd64.whl", hash = "sha256:6ff665fb023a77386fe11685190cee1f60a7d635994a30d9b0a061533d470fce", size = 224320, upload-time = "2026-05-26T20:40:22.316Z" }, + { url = "https://files.pythonhosted.org/packages/a9/e0/d936e908f0e1efa55e52b91e01b52f1055cef5e1ab2718493390ed8e2fb8/coverage-7.14.1-cp313-cp313t-win_arm64.whl", hash = "sha256:17a5a241e5997621a956a7f402a7433ef4221e5152809b785bec79e2323799f1", size = 222577, upload-time = "2026-05-26T20:40:24.894Z" }, + { url = "https://files.pythonhosted.org/packages/d6/34/fc2f101b151af3799a101f0550b0454aa008afdc0add677394ec4aa8ea10/coverage-7.14.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d5ed429d0b8edaac649e889b4ffcedb6c80b06629a3f93050e3dddfb99235bee", size = 220091, upload-time = "2026-05-26T20:40:27.249Z" }, + { url = "https://files.pythonhosted.org/packages/3d/a7/1ebae2ab5b961b5c79bb09fe7b3ac99edb190d8be4a8c510b2cf66f46468/coverage-7.14.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:8011224a62280e50dab346960c03cf47aca1a1e09e608c0fb33fd6e0cc8e9500", size = 220421, upload-time = "2026-05-26T20:40:30.084Z" }, + { url = "https://files.pythonhosted.org/packages/5e/90/92aca9cf0acc95123c96cd1eb1f08917897a7f5dee01e15738922971ec31/coverage-7.14.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:12c42ec1e14f553c4f817e989365982e646e27211f10a0f717855b94a79c8906", size = 251466, upload-time = "2026-05-26T20:40:32.542Z" }, + { url = "https://files.pythonhosted.org/packages/26/2b/78048cbe3b999f6cbf9cc0d90abba6a88a3e0863a8c1c6cbc762f3f8802f/coverage-7.14.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:06144cd511cf2624873a035c5069cf297144f6e77a73ee3d7a55b605ec5efb42", size = 253973, upload-time = "2026-05-26T20:40:34.473Z" }, + { url = "https://files.pythonhosted.org/packages/8e/21/c2e33b29d1cfde484a19d437afc343c6cd30b08d78cbbf9f5aff14e57b2b/coverage-7.14.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a311d8e1da24be5c1ccf85cbfb06315dbaa1703d5a1eab3f6432c72b837917c8", size = 255318, upload-time = "2026-05-26T20:40:38.154Z" }, + { url = "https://files.pythonhosted.org/packages/8e/ee/aad2f108d63b769121005302f16bf66db8625c88ceaba466942e09a2607e/coverage-7.14.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c79cead5b5bc584d9c71451cb984d0e3a84e0c0937379c8efcbf27c8d661b851", size = 257633, upload-time = "2026-05-26T20:40:40.164Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f8/11a2c29b4fd76d9849f81d0bb812ec0017a9396df3217214e38934a8c837/coverage-7.14.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:dcbf65f1f66a26cdd88c35cf68fb4729c5d1cd2e88added72420541dfb212034", size = 251488, upload-time = "2026-05-26T20:40:42.631Z" }, + { url = "https://files.pythonhosted.org/packages/c9/b8/9a5820de4b8ac2b71d85e3b5fb49108d7469c665f0e2ad0dd7569023e305/coverage-7.14.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fd86572566fb40189a8260446158235159bc7a82dfbc87a3b39cf4fb57fcec1c", size = 253329, upload-time = "2026-05-26T20:40:45.208Z" }, + { url = "https://files.pythonhosted.org/packages/6b/ff/f33e4823667e27548e8fd8df44217515303f9808d0ff29817db56f87d990/coverage-7.14.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:7771b601718fdde84832c3a434ca9bbf4ae9adbc49d84198b4110700c3c77c36", size = 251291, upload-time = "2026-05-26T20:40:47.502Z" }, + { url = "https://files.pythonhosted.org/packages/68/9b/489db0ebb209054766b90a9014a45f6d26eb724c02ec21311c3733b5a644/coverage-7.14.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:39b21e212c55af06fa375e3dbf90a8a8e38792f3a910c580066d23563830ddd5", size = 255564, upload-time = "2026-05-26T20:40:49.372Z" }, + { url = "https://files.pythonhosted.org/packages/27/b5/16bc2d4c2409b23c7737edb68c83bc89e345f378050549fe1d75ac7d34d5/coverage-7.14.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:f2302660e32562a532b442480121aef8aa61a5bdb20b30bf0adab29f10a5a4b4", size = 251107, upload-time = "2026-05-26T20:40:51.677Z" }, + { url = "https://files.pythonhosted.org/packages/7d/0c/2629997469a00cd069d588a41c9dc887610f2775ae89d250c4791e65272a/coverage-7.14.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:03a6f93c1ec3b7f2e77b5dbcc5573a2c21f12529a5c6bbe0f16f72303cc2fa4d", size = 252764, upload-time = "2026-05-26T20:40:54.267Z" }, + { url = "https://files.pythonhosted.org/packages/d2/ee/f78d63c8f079e0d7211c7e2401fa17e311514534ba61bae03e4b287ce4ab/coverage-7.14.1-cp314-cp314-win32.whl", hash = "sha256:8a3ce026d73290f42f08dafecbd82c193a74df280461fbf97300fec51fd133ee", size = 222837, upload-time = "2026-05-26T20:40:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b9/be539854f93a70dfbeec69117f33ec70dc42ff0b65b5b07ab8d40d04228e/coverage-7.14.1-cp314-cp314-win_amd64.whl", hash = "sha256:114c95ef29302423b87d159075805f4ab973254a2638a5d7d046c94887cc87d7", size = 223650, upload-time = "2026-05-26T20:40:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/fe/9e/24e2842fef40f35ac82ba3a7719c8023d011bf3bf652d0675316a9d088a1/coverage-7.14.1-cp314-cp314-win_arm64.whl", hash = "sha256:a07891c3f4805442b31b71e84ba3cf29ed1aa9a428284e06deeb4b23e5b46343", size = 222218, upload-time = "2026-05-26T20:41:00.321Z" }, + { url = "https://files.pythonhosted.org/packages/0a/1d/ac0a9df5fe31c1e8bdd658074905fc12844a05c1a7e3fdb8417e97c31e23/coverage-7.14.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1101a5ebb083aecb625ebb6209d4105b58f647b093cb2dc8122d7b33f743cfe1", size = 220822, upload-time = "2026-05-26T20:41:02.281Z" }, + { url = "https://files.pythonhosted.org/packages/32/cf/f964fd9aff20323f9f1a726c97135f8a76bcd87b92dad141a456a43f3c64/coverage-7.14.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:851b9e1e4e8a4608e77c79714b2e77c0970d2ed7202a05e92ae407817481887b", size = 221084, upload-time = "2026-05-26T20:41:04.593Z" }, + { url = "https://files.pythonhosted.org/packages/d8/5e/7e5ef2aba844de2b80d678619fcf0841b42e3f37f16411226f3fe4c1016f/coverage-7.14.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d5b89cdfb2ee051b71e8c3c70bd81a9eff81100f736a269136fe1a68efe00474", size = 262454, upload-time = "2026-05-26T20:41:06.641Z" }, + { url = "https://files.pythonhosted.org/packages/64/62/75809bded87015cc4935524218a2a8ed8dd1a8498bfed30a2f4f7a4b4d34/coverage-7.14.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0177614a0370f227888b4e436a7c55686d6a9f90eb1ade2b624ba685a1686e86", size = 264578, upload-time = "2026-05-26T20:41:08.556Z" }, + { url = "https://files.pythonhosted.org/packages/f3/42/d33392dc14633525012d2d504fa1a33b05538bf535f5c1d64675e5754b78/coverage-7.14.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2d69af5dea2de76fc485a83032a630523f985198b7e25be901ec60181587b01e", size = 266981, upload-time = "2026-05-26T20:41:10.824Z" }, + { url = "https://files.pythonhosted.org/packages/2a/49/0157c4428c2aca7f1e09d5565930586fd5ae36f1655f08b0daa7cf1fcae1/coverage-7.14.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:35ab22d91de736e8966b980dc355cbcdd2c6dbbcfe275f9a2991bc8a91b3df65", size = 268112, upload-time = "2026-05-26T20:41:12.966Z" }, + { url = "https://files.pythonhosted.org/packages/96/26/86b9ce71f4092b1ed325ce1421698081df1286b833400b6836912834d6e0/coverage-7.14.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:357d4e32935c36588aaba057d734fa32428c360c9fc2e4442afbf1b646beee6e", size = 261558, upload-time = "2026-05-26T20:41:15Z" }, + { url = "https://files.pythonhosted.org/packages/20/4c/c311210c5472cf5401d8422b0d7812cdd520f24417673afabda6c323faca/coverage-7.14.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:51bd64741cc6fa065abd300ede1afe5a5291ece9c31da8b24884deda48bcc3f8", size = 264447, upload-time = "2026-05-26T20:41:17.369Z" }, + { url = "https://files.pythonhosted.org/packages/fb/71/59513f8710ed3e6b0ac0a050a5b7e977bb9c9e880354863b5d00d8809256/coverage-7.14.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:9132cd363a68a4c3daa7c8704a654b1e39d3360f6f5b8ddd470608a945236c07", size = 262048, upload-time = "2026-05-26T20:41:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/84/8d/bceed32dc494f5bbf50f775cd2e78ca814953942b5ea28d3c1c3ac316f14/coverage-7.14.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:07c6290b1697b862c0478eab545eec949a0d0e4d6d03497f446d706da3b4f2de", size = 265781, upload-time = "2026-05-26T20:41:21.559Z" }, + { url = "https://files.pythonhosted.org/packages/e7/c5/9348fe40dbfd4991aaf78df2c6c3098bfb2cc834d1fd362a64b4efef855a/coverage-7.14.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:5ea0c297e27133853b4d8a3eb799bff5a2dbd9f2f41537a240d337ac9b4df890", size = 260896, upload-time = "2026-05-26T20:41:23.428Z" }, + { url = "https://files.pythonhosted.org/packages/ca/92/1ea0f03929da7cf87206b1fa24f4c8e9c158be0455481af29ec0a1f3503f/coverage-7.14.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:01b7733daad0237daa01ef80fe2dfceffc911e6a17fa7b55d14aa8214eaaaecd", size = 263214, upload-time = "2026-05-26T20:41:25.419Z" }, + { url = "https://files.pythonhosted.org/packages/f6/a9/b2493c054c0e01a643266742ab45e15744e60743f9260cd930c7142b1124/coverage-7.14.1-cp314-cp314t-win32.whl", hash = "sha256:6adc5a36984624a70bf11d7184e20fa0a49aa7c47ffab43804106a1a695ea22e", size = 223624, upload-time = "2026-05-26T20:41:27.795Z" }, + { url = "https://files.pythonhosted.org/packages/fc/bd/3e1e6a57fccd2d7c83fcdf338e93ba98eb85c6e877dd34731ac585375490/coverage-7.14.1-cp314-cp314t-win_amd64.whl", hash = "sha256:ddf799247318f34dbcd2efa8c95a8d0642674e926bb1774cf9b63dfd2a389d1c", size = 224728, upload-time = "2026-05-26T20:41:30.098Z" }, + { url = "https://files.pythonhosted.org/packages/bb/d7/31066cf1d2f0c6c797fce911bcfa01dd35642dc6da992a950256097c5860/coverage-7.14.1-cp314-cp314t-win_arm64.whl", hash = "sha256:145986fe66647eb489f18d9a997567a3fd358584c4b5a808769113abc07466af", size = 222752, upload-time = "2026-05-26T20:41:32.123Z" }, + { url = "https://files.pythonhosted.org/packages/8a/3c/1a983b9a745d7f83d53f057bcc5bf79ba6a2bbc08266b3f0c7d6fe630c9b/coverage-7.14.1-py3-none-any.whl", hash = "sha256:a252f21c27e38347e60111a3266b03827422a7d5525951aceee313aa68bab1d2", size = 211815, upload-time = "2026-05-26T20:41:34.078Z" }, +] + +[package.optional-dependencies] +toml = [ + { name = "tomli", marker = "python_full_version <= '3.11'" }, +] + +[[package]] +name = "distlib" +version = "0.4.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/96/8e/709914eb2b5749865801041647dc7f4e6d00b549cfe88b65ca192995f07c/distlib-0.4.0.tar.gz", hash = "sha256:feec40075be03a04501a973d81f633735b4b69f98b05450592310c0f401a4e0d", size = 614605, upload-time = "2025-07-17T16:52:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/33/6b/e0547afaf41bf2c42e52430072fa5658766e3d65bd4b03a563d1b6336f57/distlib-0.4.0-py2.py3-none-any.whl", hash = "sha256:9659f7d87e46584a30b5780e43ac7a2143098441670ff0a49d5f9034c54a6c16", size = 469047, upload-time = "2025-07-17T16:51:58.613Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "filelock" +version = "3.29.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b5/fe/997687a931ab51049acce6fa1f23e8f01216374ea81374ddee763c493db5/filelock-3.29.0.tar.gz", hash = "sha256:69974355e960702e789734cb4871f884ea6fe50bd8404051a3530bc07809cf90", size = 57571, upload-time = "2026-04-19T15:39:10.068Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/47/dd9a212ef6e343a6857485ffe25bba537304f1913bdbed446a23f7f592e1/filelock-3.29.0-py3-none-any.whl", hash = "sha256:96f5f6344709aa1572bbf631c640e4ebeeb519e08da902c39a001882f30ac258", size = 39812, upload-time = "2026-04-19T15:39:08.752Z" }, +] + +[[package]] +name = "hvloop" +version = "0.2.0" +source = { editable = "." } + +[package.optional-dependencies] +dev = [ + { name = "black" }, + { name = "build" }, + { name = "mypy" }, + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "pytest-cov" }, + { name = "ruff" }, +] +test = [ + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "pytest-cov" }, +] + +[package.metadata] +requires-dist = [ + { name = "black", marker = "extra == 'dev'" }, + { name = "build", marker = "extra == 'dev'" }, + { name = "mypy", marker = "extra == 'dev'" }, + { name = "pre-commit", marker = "extra == 'dev'" }, + { name = "pytest", marker = "extra == 'dev'", specifier = ">=8.0" }, + { name = "pytest", marker = "extra == 'test'", specifier = ">=8.0" }, + { name = "pytest-asyncio", marker = "extra == 'dev'", specifier = ">=0.23" }, + { name = "pytest-asyncio", marker = "extra == 'test'", specifier = ">=0.23" }, + { name = "pytest-cov", marker = "extra == 'dev'" }, + { name = "pytest-cov", marker = "extra == 'test'" }, + { name = "ruff", marker = "extra == 'dev'" }, +] +provides-extras = ["dev", "test"] + +[[package]] +name = "identify" +version = "2.6.19" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/52/63/51723b5f116cc04b061cb6f5a561790abf249d25931d515cd375e063e0f4/identify-2.6.19.tar.gz", hash = "sha256:6be5020c38fcb07da56c53733538a3081ea5aa70d36a156f83044bfbf9173842", size = 99567, upload-time = "2026-04-17T18:39:50.265Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/94/84/d9273cd09688070a6523c4aee4663a8538721b2b755c4962aafae0011e72/identify-2.6.19-py2.py3-none-any.whl", hash = "sha256:20e6a87f786f768c092a721ad107fc9df0eb89347be9396cadf3f4abbd1fb78a", size = 99397, upload-time = "2026-04-17T18:39:49.221Z" }, +] + +[[package]] +name = "importlib-metadata" +version = "9.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a9/01/15bb152d77b21318514a96f43af312635eb2500c96b55398d020c93d86ea/importlib_metadata-9.0.0.tar.gz", hash = "sha256:a4f57ab599e6a2e3016d7595cfd72eb4661a5106e787a95bcc90c7105b831efc", size = 56405, upload-time = "2026-03-20T06:42:56.999Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/38/3d/2d244233ac4f76e38533cfcb2991c9eb4c7bf688ae0a036d30725b8faafe/importlib_metadata-9.0.0-py3-none-any.whl", hash = "sha256:2d21d1cc5a017bd0559e36150c21c830ab1dc304dedd1b7ea85d20f45ef3edd7", size = 27789, upload-time = "2026-03-20T06:42:55.665Z" }, +] + +[[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 = "librt" +version = "0.11.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/40/08/9e7f6b5d2b5bed6ad055cdd5925f192bb403a51280f86b56554d9d0699a2/librt-0.11.0.tar.gz", hash = "sha256:075dc3ef4458a278e0195cbf6ac9d38808d9b906c5a6c7f7f79c3888276a3fb1", size = 200139, upload-time = "2026-05-10T18:17:25.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/83/10/37fd9e9ba96cb0bd742dfb20fc3d082e54bdbec759d7300df927f360ef07/librt-0.11.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6e94ebfcfa2d5e9926d6c3b9aa4617ffc42a845b4321fb84021b872358c82a0f", size = 141706, upload-time = "2026-05-10T18:15:16.129Z" }, + { url = "https://files.pythonhosted.org/packages/cf/72/1b1466f358e4a0b728051f69bc27e67b432c6eaa2e05b88db49d3785ae0d/librt-0.11.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:ae627397a2f351560440d872d6f7c8dbb4072e57868e7b2fc5b8b430fe489d45", size = 142605, upload-time = "2026-05-10T18:15:18.148Z" }, + { url = "https://files.pythonhosted.org/packages/ca/85/ed26dd2f6bc9a0baf48306433e579e8d354d70b2bcb78134ed950a5d0e1e/librt-0.11.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:dc329359321b67d24efdf4bc69012b0597001649544db662c001db5a0184794c", size = 476555, upload-time = "2026-05-10T18:15:19.569Z" }, + { url = "https://files.pythonhosted.org/packages/66/fe/11891191c0e0a3fd617724e891f6e67a71a7658974a892b9a9a97fdb2977/librt-0.11.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:7e82e642ab0f7608ce2fe53d76ca2280a9ee33a1b06556142c7c6fe80a86fc33", size = 468434, upload-time = "2026-05-10T18:15:20.87Z" }, + { url = "https://files.pythonhosted.org/packages/6f/50/5ec949d7f9ce1a07af903aa3e13abb98b717923bdead6e719b2f824ccc07/librt-0.11.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88145c15c67731d54283d135b03244028c750cc9edc334a96a4f5950ebdb2884", size = 496918, upload-time = "2026-05-10T18:15:22.616Z" }, + { url = "https://files.pythonhosted.org/packages/ea/c4/177336c7524e34875a38bf668e88b193a6723a4eb4045d07f74df6e1506c/librt-0.11.0-cp310-cp310-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9d36a51b3d93320b686588e27123f4995804dbf1bce81df78c02fc3c6eea9280", size = 490334, upload-time = "2026-05-10T18:15:24.2Z" }, + { url = "https://files.pythonhosted.org/packages/13/1f/da3112f7569eda3b49f9a2629bae1fe059812b6085df16c885f6454dff49/librt-0.11.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d00f3ac06a2a8b246327f11e186a53a100a4d5c7ed52346367e5ec751d51586c", size = 511287, upload-time = "2026-05-10T18:15:26.226Z" }, + { url = "https://files.pythonhosted.org/packages/fa/94/03fec301522e172d105581431223be56b27594ff46440ebfbb658a3735d5/librt-0.11.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:461bbceede621f1ffb8839755f8663e886087ee7af16294cab7fb4d782c62eeb", size = 517202, upload-time = "2026-05-10T18:15:27.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/6e/339f6e5a7b413ce014f1917a756dae630fe59cc99f34153205b1cb540901/librt-0.11.0-cp310-cp310-musllinux_1_2_riscv64.whl", hash = "sha256:0cad8a4d6a8ff03c9b76f9414caccd78e7cfbc8a2e12fa334d8e1d9932753783", size = 497517, upload-time = "2026-05-10T18:15:29.614Z" }, + { url = "https://files.pythonhosted.org/packages/cd/43/acdd5ce317cb46e8253ca9bfbdb8b12e68a24d745949336a7f3d5fb79ba0/librt-0.11.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f37aa505b3cf60701562eddb32df74b12a9e380c207fd8b06dd157a943ac7ea0", size = 538878, upload-time = "2026-05-10T18:15:30.928Z" }, + { url = "https://files.pythonhosted.org/packages/29/b5/7a25bb12e3172839f647f196b3e988318b7bb1ca7501732a225c4dce2ec0/librt-0.11.0-cp310-cp310-win32.whl", hash = "sha256:94663a21534637f0e787ec2a2a756022df6e5b7b2335a5cdd7d8e33d68a2af89", size = 100070, upload-time = "2026-05-10T18:15:32.551Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0d/ebbcf4d77999c02c937b05d2b90ff4cd4dcc7e9a365ba132329ac1fe7a0f/librt-0.11.0-cp310-cp310-win_amd64.whl", hash = "sha256:dec7db73758c2b54953fd8b7fe348c45188fe26b39ee18446196edd08453a5d4", size = 117918, upload-time = "2026-05-10T18:15:33.678Z" }, + { url = "https://files.pythonhosted.org/packages/fe/87/2bf31fe17587b29e3f93ec31421e2b1e1c3e349b8bf6c7c313dbad1d5340/librt-0.11.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:93d95bd45b7d58343d8b90d904450a545144eec19a002511163426f8ab1fae29", size = 141092, upload-time = "2026-05-10T18:15:34.795Z" }, + { url = "https://files.pythonhosted.org/packages/cf/08/5c5bf772920b7ebac6e32bc91a643e0ab3870199c0b542356d3baa83970a/librt-0.11.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ee278c769a713638cdacd4c0436d72156e75df3ebc0166ab2b9dc43acc386c9", size = 142035, upload-time = "2026-05-10T18:15:36.242Z" }, + { url = "https://files.pythonhosted.org/packages/06/20/662a03d254e5b000d838e8b345d83303ddb768c080fd488e40634c0fa66b/librt-0.11.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f230cb1cbc9faaa616f9a678f530ebcf186e414b6bcbd88b960e4ba1b92428d5", size = 475022, upload-time = "2026-05-10T18:15:37.56Z" }, + { url = "https://files.pythonhosted.org/packages/de/f3/aa81523e45184c6ec23dc7f63263362ec55f80a09d424c012359ecbe7e35/librt-0.11.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:5d63c855d86938d9de93e265c9bd8c705b51ec494de5738340ee93767a686e4b", size = 467273, upload-time = "2026-05-10T18:15:39.182Z" }, + { url = "https://files.pythonhosted.org/packages/6b/6f/59c74b560ca8853834d5501d589c8a2519f4184f273a085ffd0f37a1cc47/librt-0.11.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:993f028be9e96a08d31df3479ac80d99be374d17f3b78e4796b3fd3c913d4e89", size = 497083, upload-time = "2026-05-10T18:15:40.634Z" }, + { url = "https://files.pythonhosted.org/packages/fe/7b/5aa4d2c9600a719401160bf7055417df0b2a47439b9d88286ce45e56b65f/librt-0.11.0-cp311-cp311-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:258d73a0aa66a055e65b2e4d1b8cdb23b9d132c5bb915d9547d804fcaed116cc", size = 489139, upload-time = "2026-05-10T18:15:41.934Z" }, + { url = "https://files.pythonhosted.org/packages/d6/31/9143803d7da6856a69153785768c4936864430eec0fd9461c3ea527d9922/librt-0.11.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0827efe7854718f04aaddf6496e96960a956e676fe1d0f04eb41511fd8ad06d5", size = 508442, upload-time = "2026-05-10T18:15:43.206Z" }, + { url = "https://files.pythonhosted.org/packages/2f/5a/bce08184488426bda4ccc2c4964ac048c8f68ae89bd7120082eef4233cfd/librt-0.11.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7753e57d6e12d019c0d8786f1c09c709f4c3fcc57c3887b24e36e6c06ec938b7", size = 514230, upload-time = "2026-05-10T18:15:44.761Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/bb5e213d254b7505a0e658da199d8ab719086632ce09eef311ab27976523/librt-0.11.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:11bd19822431cc21af9f27374e7ae2e58103c7d98bda823536a6c47f6bb2bb3d", size = 494231, upload-time = "2026-05-10T18:15:46.308Z" }, + { url = "https://files.pythonhosted.org/packages/9d/fb/541cdad5b1ab1300398c74c4c9a497b88e5074c21b1244c8f49731d3a284/librt-0.11.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:22bdf239b219d3993761a148ffa134b19e52e9989c84f845d5d7b71d70a17412", size = 537585, upload-time = "2026-05-10T18:15:47.629Z" }, + { url = "https://files.pythonhosted.org/packages/8f/f2/464bb69295c320cb06bddb4f14a4ec67934ee14b2bffb12b19fb7ab287ba/librt-0.11.0-cp311-cp311-win32.whl", hash = "sha256:46c60b61e308eb535fbd6fa622b1ee1bb2815691c1ad9c98bf7b84952ec3bc8d", size = 100509, upload-time = "2026-05-10T18:15:49.157Z" }, + { url = "https://files.pythonhosted.org/packages/6d/e7/a17ee1788f9e4fbf548c19f4afa07c92089b9e24fef6cb2410863781ef4c/librt-0.11.0-cp311-cp311-win_amd64.whl", hash = "sha256:902e546ff044f579ff1c953ff5fce97b636fe9e3943996b2177710c6ef076f73", size = 118628, upload-time = "2026-05-10T18:15:50.345Z" }, + { url = "https://files.pythonhosted.org/packages/cc/c7/6c766214f9f9903bcfcfbef97d807af8d8f5aa3502d247858ab17582d212/librt-0.11.0-cp311-cp311-win_arm64.whl", hash = "sha256:65ac3bc20f78aa0ee5ae84baa68917f89fef4af63e941084dd019a0d0e749f0c", size = 103122, upload-time = "2026-05-10T18:15:52.068Z" }, + { url = "https://files.pythonhosted.org/packages/8b/d0/07c77e067f0838949b43bd89232c29d72efebb9d2801a9750184eb706b71/librt-0.11.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b87504f1690a23b9a2cca841191a04f83895d4fc2dd04df91d82b1a04ca2ad46", size = 144147, upload-time = "2026-05-10T18:15:53.227Z" }, + { url = "https://files.pythonhosted.org/packages/7a/24/8493538fa4f62f982686398a5b8f68008138a75086abdea19ade64bf4255/librt-0.11.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40071fc5fe0ce8daa6de616702314a01e1250711682b0523d6ab8d4525910cb3", size = 143614, upload-time = "2026-05-10T18:15:54.657Z" }, + { url = "https://files.pythonhosted.org/packages/ff/1e/f8bad050810d9171f34a1648ed910e56814c2ba61639f2bd53c6377ae24b/librt-0.11.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:137e79445c896a0ea7b265f52d23954e05b64222ee1af69e2cb34219067cbb67", size = 485538, upload-time = "2026-05-10T18:15:56.117Z" }, + { url = "https://files.pythonhosted.org/packages/c0/fe/3594ebfbaf03084ba4b120c9ba5c3183fd938a48725e9bbe6ff0a5159ad8/librt-0.11.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:cca6644054e78746d8d4ef238681f9c34ff8b584fe6b988ecebb8db3b15e622a", size = 479623, upload-time = "2026-05-10T18:15:57.544Z" }, + { url = "https://files.pythonhosted.org/packages/b0/da/5d1876984b3746c85dbd219dbfcb73c85f54ee263fd32e5b2a632ec14571/librt-0.11.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d5b0eea49f5562861ee8d757a32ef7d559c1d35be2aaaa1ec28941d74c9ffc8a", size = 513082, upload-time = "2026-05-10T18:15:58.805Z" }, + { url = "https://files.pythonhosted.org/packages/19/6e/55bdf5d5ca00c3e18430690bf2c953d8d3ffd3c337418173d33dec985dc9/librt-0.11.0-cp312-cp312-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0d1029d7e1ae1a7e647ed6fb5df8c4ce2dffefb7a9f5fd1376a4554d96dac09f", size = 508105, upload-time = "2026-05-10T18:16:00.2Z" }, + { url = "https://files.pythonhosted.org/packages/07/10/f1f23a7c595ee90ece4d35c851e5d104b1311a887ed1b4ac4c35bbd13da8/librt-0.11.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bc3ce6b33c5828d9e80592011a5c584cb2ce86edbc4088405f70da47dc1d1b3b", size = 522268, upload-time = "2026-05-10T18:16:01.708Z" }, + { url = "https://files.pythonhosted.org/packages/b6/02/5720f5697a7f54b78b3aefbe20df3a48cedcff1276618c4aa481177942ed/librt-0.11.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:936c5995f3514a42111f20099397d8177c79b4d7e70961e396c6f5a0a3566766", size = 527348, upload-time = "2026-05-10T18:16:03.496Z" }, + { url = "https://files.pythonhosted.org/packages/50/db/b4a47c6f91db4ff76348a0b3dd0cc65e090a078b765a810a62ff9434c3d3/librt-0.11.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:9bc0ca6ad9381cbe8e4aa6e5726e4c80c78115a6e9723c599ed1d73e092bc49d", size = 516294, upload-time = "2026-05-10T18:16:05.173Z" }, + { url = "https://files.pythonhosted.org/packages/9e/58/9384b2f4eb1ed1d273d40948a7c5c4b2360213b402ef3be4641c06299f9c/librt-0.11.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:070aa8c26c0a74774317a72df8851facc7f0f012a5b406557ac56992d92e1ec8", size = 553608, upload-time = "2026-05-10T18:16:06.839Z" }, + { url = "https://files.pythonhosted.org/packages/21/7b/5aa8848a7c6a9278c79375146da1812e695754ceec5f005e6043461a7315/librt-0.11.0-cp312-cp312-win32.whl", hash = "sha256:6bf14feb84b05ae945277395451998c89c54d0def4070eb5c08de544930b245a", size = 101879, upload-time = "2026-05-10T18:16:08.103Z" }, + { url = "https://files.pythonhosted.org/packages/37/33/8a745436944947575b584231750a41417de1a38cf6a2e9251d1065651c09/librt-0.11.0-cp312-cp312-win_amd64.whl", hash = "sha256:75672f0bc524ede266287d532d7923dbce94c7514ad07627bac3d0c6d92cc4d9", size = 119831, upload-time = "2026-05-10T18:16:09.174Z" }, + { url = "https://files.pythonhosted.org/packages/59/67/a6739ac96e28b7855808bdb0370e250606104a859750d209e5a0716fe7ab/librt-0.11.0-cp312-cp312-win_arm64.whl", hash = "sha256:2f10cf143e4a9bb0f4f5af568a00df94a2d69ef41c2579584454bb0fe5cc642c", size = 103470, upload-time = "2026-05-10T18:16:10.369Z" }, + { url = "https://files.pythonhosted.org/packages/82/61/e59168d4d0bf2bf90f4f0caf7a001bfc60254c3af4586013b04dc3ef517b/librt-0.11.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:78dc31f7fdfe9c9d0eb0e8f42d139db230e826415bbcabd9f0e9faaaee909894", size = 144119, upload-time = "2026-05-10T18:16:11.771Z" }, + { url = "https://files.pythonhosted.org/packages/61/fd/caa1d60b12f7dd79ccea23054e06eeaebe266a5f52c40a6b651069200ce5/librt-0.11.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fa475675db22290c3158e1d42326d0f5a65f04f44a0e68c3630a25b53560fb9c", size = 143565, upload-time = "2026-05-10T18:16:13.334Z" }, + { url = "https://files.pythonhosted.org/packages/b8/a9/dc744f5c2b4978d48db970be29f22716d3413d28b14ad99740817315cf2c/librt-0.11.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:621db29691044bdeda22e789e482e1b0f3a985d90e3426c9c6d17606416205ea", size = 485395, upload-time = "2026-05-10T18:16:14.729Z" }, + { url = "https://files.pythonhosted.org/packages/8f/21/7f8e97a1e4dae952a5a95948f6f8507a173bc1e669f54340bba6ca1ca31b/librt-0.11.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:a9010e2ed5b3a9e158c5fd966b3ab7e834bb3d3aacc8f66c91dd4b57a3799230", size = 479383, upload-time = "2026-05-10T18:16:16.321Z" }, + { url = "https://files.pythonhosted.org/packages/a6/6d/d8ee9c114bebf2c50e29ec2aa940826fccb62a645c3e4c18760987d0e16d/librt-0.11.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7c39513d8b7477a2e1ed8c43fc21c524e8d5a0f8d4e8b7b074dbdbe7820a08e2", size = 513010, upload-time = "2026-05-10T18:16:17.647Z" }, + { url = "https://files.pythonhosted.org/packages/f0/43/0b5708af2bd30a46400e72ba6bdaa8f066f15fb9a688527e34220e8d6c06/librt-0.11.0-cp313-cp313-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7aef3cf1d5af86e770ab04bfd993dfc4ae8b8c17f66fb77dd4a7d50de7bbb1a3", size = 508433, upload-time = "2026-05-10T18:16:19.309Z" }, + { url = "https://files.pythonhosted.org/packages/4a/50/356187247d09013490481033183b3532b58acf8028bcb34b2b56a375c9b2/librt-0.11.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:557183ddc36babe46b27dd60facbd5adb4492181a5be887587d57cda6e092f21", size = 522595, upload-time = "2026-05-10T18:16:20.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/e7/c6ac4240899c7f3248079d5a9900debe0dadb3fdeaf856684c987105ba47/librt-0.11.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:83d3e1f72bd42f6c5c0b7daec530c3f829bd02db42c70b8ddf0c2d90a2459930", size = 527255, upload-time = "2026-05-10T18:16:22.352Z" }, + { url = "https://files.pythonhosted.org/packages/eb/b5/a81322dbeedeeaf9c1ee6f001734d28a09d8383ac9e6779bc24bbd0743c6/librt-0.11.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:4ce1f21fbe589bc1afd7872dece84fb0e1144f794a288e58a10d2c54a55c43be", size = 516847, upload-time = "2026-05-10T18:16:23.627Z" }, + { url = "https://files.pythonhosted.org/packages/ae/66/6e6323787d592b55204a42595ff1102da5115601b53a7e9ddebc889a6da5/librt-0.11.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b09f7044ea2b64c9da42fd3d335666518cfd1c6e8a182c95da73d0214b41e", size = 553920, upload-time = "2026-05-10T18:16:25.025Z" }, + { url = "https://files.pythonhosted.org/packages/9c/21/623f8ca230857102066d9ca8c6c1734995908c4d0d1bee7bb2ef0021cb33/librt-0.11.0-cp313-cp313-win32.whl", hash = "sha256:78fddc31cd4d3caa897ad5d31f856b1faadc9474021ad6cb182b9018793e254e", size = 101898, upload-time = "2026-05-10T18:16:26.649Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1d/b4ebd44dd723f768469007515cb92251e0ae286c94c140f374801140fa74/librt-0.11.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ca8aa88751a775870b764e93bad5135385f563cb8dcee399abf034ea4d3cb47", size = 119812, upload-time = "2026-05-10T18:16:27.859Z" }, + { url = "https://files.pythonhosted.org/packages/3b/e4/b2f4ca7965ca373b491cdb4bc25cdb30c1649ca81a8782056a83850292a9/librt-0.11.0-cp313-cp313-win_arm64.whl", hash = "sha256:96f044bb325fd9cf1a723015638c219e9143f0dfbc0ca54c565df2b7fc748b44", size = 103448, upload-time = "2026-05-10T18:16:29.066Z" }, + { url = "https://files.pythonhosted.org/packages/29/eb/dbce197da4e227779e56b5735f2decc3eb36e55a1cdbf1bd65d6639d76c1/librt-0.11.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4a017a95e5837dc15a8c5661d60e05daa96b90908b1aa6b7acdf443cd25c8ebd", size = 143345, upload-time = "2026-05-10T18:16:30.674Z" }, + { url = "https://files.pythonhosted.org/packages/76/a3/254bebd0c11c8ba684018efb8006ff22e466abce445215cca6c778e7d9de/librt-0.11.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:b1ecbd9819deccc39b7542bf4d2a740d8a620694d39989e58661d3763458f8d4", size = 143131, upload-time = "2026-05-10T18:16:32.037Z" }, + { url = "https://files.pythonhosted.org/packages/f1/3f/f77d6122d21ac7bf6ae8a7dfced1bd2a7ac545d3273ebdcaf8042f6d619f/librt-0.11.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7da327dacd7be8f8ec36547373550744a3cc0e536d54665cd83f8bcd961200e8", size = 477024, upload-time = "2026-05-10T18:16:33.493Z" }, + { url = "https://files.pythonhosted.org/packages/ac/0a/2c996dadebaa7d9bbbd43ef2d4f3e66b6da545f838a41694ef6172cebec8/librt-0.11.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:0dc56b1f8d06e60db362cc3fdae206681817f86ce4725d34511473487f12a34b", size = 474221, upload-time = "2026-05-10T18:16:34.864Z" }, + { url = "https://files.pythonhosted.org/packages/0a/7e/f5d92af8486b8272c23b3e686b46ff72d89c8169585eb61eef01a2ac7147/librt-0.11.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:05fb8fb2ab90e21c8d12ea240d744ad514da9baf381ebfa70d91d20d21713175", size = 505174, upload-time = "2026-05-10T18:16:36.705Z" }, + { url = "https://files.pythonhosted.org/packages/af/1a/cb0734fe86398eb33193ab753b7326255c74cac5eb09e76b9b16536e7adb/librt-0.11.0-cp314-cp314-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cae74872be221df4374d10fec61f93ed1513b9546ea84f2c0bf73ab3e9bd0b03", size = 497216, upload-time = "2026-05-10T18:16:38.418Z" }, + { url = "https://files.pythonhosted.org/packages/18/06/094820f91558b66e29943c0ec41c9914f460f48dd51fc503c3101e10842d/librt-0.11.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:32bcc918c0148eb7e3d57385125bac7e5f9e4359d05f07448b09f6f778c2f31c", size = 513921, upload-time = "2026-05-10T18:16:39.848Z" }, + { url = "https://files.pythonhosted.org/packages/0b/c2/00de9018871a282f530cacb457d5ec0428f6ac7e6fedde9aff7468d9fb04/librt-0.11.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:f9743fc99135d5f78d2454435615f6dec0473ca507c26ce9d92b10b562a280d3", size = 520850, upload-time = "2026-05-10T18:16:41.471Z" }, + { url = "https://files.pythonhosted.org/packages/51/9d/64631832348fd1834fb3a61b996434edddaaf25a31d03b0a76273159d2cf/librt-0.11.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:5ba067f4aadae8fda802d91d2124c90c42195ff32d9161d3549e6d05cfe26f96", size = 504237, upload-time = "2026-05-10T18:16:43.15Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ec/ae5525eb16edc827a044e7bb8777a455ff95d4bca9379e7e6bddd7383647/librt-0.11.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:de3bf945454d032f9e390b85c4072e0a0570bf825421c8be0e71209fa65e1abe", size = 546261, upload-time = "2026-05-10T18:16:44.408Z" }, + { url = "https://files.pythonhosted.org/packages/5a/09/adce371f27ca039411da9659f7430fcc2ba6cd0c7b3e4467a0f091be7fa9/librt-0.11.0-cp314-cp314-win32.whl", hash = "sha256:d2277a05f6dcb9fd13db9566aac4fabd68c3ea1ea46ee5567d4eef8efa495a2f", size = 96965, upload-time = "2026-05-10T18:16:46.039Z" }, + { url = "https://files.pythonhosted.org/packages/d6/ee/8ac720d98548f173c7ce2e632a7ca94673f74cacd5c8162a84af5b35958a/librt-0.11.0-cp314-cp314-win_amd64.whl", hash = "sha256:ab73e8db5e3f564d812c1f5c3a175930a5f9bc96ccb5e3b22a34d7858b401cf7", size = 115151, upload-time = "2026-05-10T18:16:47.133Z" }, + { url = "https://files.pythonhosted.org/packages/94/20/c900cf14efeb09b6bef2b2dff20779f73464b97fd58d1c6bccc379588ae3/librt-0.11.0-cp314-cp314-win_arm64.whl", hash = "sha256:aea3caa317752e3a466fa8af45d91ee0ea8c7fdd96e42b0a8dd9b76a7931eba1", size = 98850, upload-time = "2026-05-10T18:16:48.597Z" }, + { url = "https://files.pythonhosted.org/packages/0c/71/944bfe4b64e12abffcd3c15e1cce07f72f3d55655083786285f4dedeb532/librt-0.11.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d1b36540d7aaf9b9101b3a6f376c8d8e9f7a9aec93ed05918f2c69d493ffef72", size = 151138, upload-time = "2026-05-10T18:16:49.839Z" }, + { url = "https://files.pythonhosted.org/packages/b6/10/99e64a5c86989357fda078c8143c533389585f6473b7439172dd8f3b3b2d/librt-0.11.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:efbb343ab2ce3540f4ecbe6315d677ed70f37cd9a72b1e58066c918ca83acbaa", size = 151976, upload-time = "2026-05-10T18:16:51.062Z" }, + { url = "https://files.pythonhosted.org/packages/21/31/5072ad880946d83e5ea4147d6d018c78eefce85b77819b19bdd0ee229435/librt-0.11.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aa0dd688aab3f7914d3e6e5e3554978e0383312fb8e771d84be008a35b9ee548", size = 557927, upload-time = "2026-05-10T18:16:52.632Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8d/70b5fb7cfbab60edbe7381614ab985da58e144fbf465c86d44c95f43cdca/librt-0.11.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.manylinux_2_28_i686.whl", hash = "sha256:f5fb36b8c6c63fdcbb1d526d94c0d1331610d43f4118cc1beb4efef4f3faacb2", size = 539698, upload-time = "2026-05-10T18:16:53.934Z" }, + { url = "https://files.pythonhosted.org/packages/fa/a3/ba3495a0b3edbd24a4cae0d1d3c64f39a9fc45d06e812101289b50c1a619/librt-0.11.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4a9a237d13addb93715b6fee74023d5ee3469b53fce527626c0e088aa585805f", size = 577162, upload-time = "2026-05-10T18:16:55.589Z" }, + { url = "https://files.pythonhosted.org/packages/f7/db/36e25fb81f99937ff1b96612a1dc9fd66f039cb9cc3aee12c01fac31aab9/librt-0.11.0-cp314-cp314t-manylinux_2_34_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5ddd17bd87b2c56ddd60e546a7984a2e64c4e8eab92fb4cf3830a48ad5469d51", size = 566494, upload-time = "2026-05-10T18:16:56.975Z" }, + { url = "https://files.pythonhosted.org/packages/33/0d/3f622b47f0b013eeb9cf4cc07ae9bfe378d832a4eec998b2b209fe84244d/librt-0.11.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bd43992b4473d42f12ff9e68326079f0696d9d4e6000e8f39a0238d482ba6ee2", size = 596858, upload-time = "2026-05-10T18:16:58.374Z" }, + { url = "https://files.pythonhosted.org/packages/a9/02/71b90bc93039c46a2000651f6ad60122b114c8f54c4ad306e0e96f5b75ad/librt-0.11.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:f8e3e8056dd674e279741485e2e512d6e9a751c7455809d0114e6ebf8d781085", size = 590318, upload-time = "2026-05-10T18:16:59.676Z" }, + { url = "https://files.pythonhosted.org/packages/04/04/418cb3f75621e2b761fb1ab0f017f4d70a1a72a6e7c74ee4f7e8d198c2f3/librt-0.11.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:c1f708d8ae9c56cf38a903c44297243d2ec83fd82b396b977e0144a3e76217e3", size = 575115, upload-time = "2026-05-10T18:17:01.007Z" }, + { url = "https://files.pythonhosted.org/packages/cc/2c/5a2183ac58dd911f26b5d7e7d7d8f1d87fcecdddd99d6c12169a258ff62c/librt-0.11.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0add982e0e7b9fc14cf4b33789d5f13f66581889b88c2f58099f6ce8f92617bd", size = 617918, upload-time = "2026-05-10T18:17:02.682Z" }, + { url = "https://files.pythonhosted.org/packages/15/1f/dc6771a52592a4451be6effa200cbfc9cec61e4393d3033d81a9d307961d/librt-0.11.0-cp314-cp314t-win32.whl", hash = "sha256:2b481d846ac894c4e8403c5fd0e87c5d11d6499e404b474602508a224ff531c8", size = 103562, upload-time = "2026-05-10T18:17:03.99Z" }, + { url = "https://files.pythonhosted.org/packages/62/4a/7d1415567027286a75ba1093ec4aca11f073e0f559c530cf3e0a757ad55c/librt-0.11.0-cp314-cp314t-win_amd64.whl", hash = "sha256:28edb433edde181112a908c78907af28f964eabc15f4dd16c9d66c834302677c", size = 124327, upload-time = "2026-05-10T18:17:05.465Z" }, + { url = "https://files.pythonhosted.org/packages/ce/62/b40b382fa0c66fee1478073eb8db352a4a6beda4a1adccf1df911d8c289c/librt-0.11.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dee008f20b542e3cd162ba338a7f9ec0f6d23d395f66fe8aeeec3c9d067ea253", size = 102572, upload-time = "2026-05-10T18:17:06.809Z" }, +] + +[[package]] +name = "mypy" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ast-serialize" }, + { name = "librt", marker = "platform_python_implementation != 'PyPy'" }, + { name = "mypy-extensions" }, + { name = "pathspec" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/82/15/cca9d88503549ed6fedeaa1d448cdddd542ee8a490232d732e278036fbf2/mypy-2.1.0.tar.gz", hash = "sha256:81e76ad12c2d804512e9b13240d1588316531bfba07558286078bfbce9613633", size = 3898359, upload-time = "2026-05-11T18:37:36.237Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a4/71/d351dca3e9b30da2328ee9d445c88b8388072808ebfbc49eb69d30b67749/mypy-2.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:11a6beb180257a805961aea9ec591bbd0bd17f1e18d35b8456d57aee5bedfedc", size = 14778792, upload-time = "2026-05-11T18:36:23.605Z" }, + { url = "https://files.pythonhosted.org/packages/2f/45/7d51594b644c17c0bcf74ed8cd5fc33b324276d708e8506f220b70dab9d9/mypy-2.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8ef78c1d306bbf9a8a12f526c44902c9c28dffd6c52c52bf6a72641ce18d3849", size = 13645739, upload-time = "2026-05-11T18:37:22.752Z" }, + { url = "https://files.pythonhosted.org/packages/65/01/455c31b170e9468265074840bf18863a8482a24103fdaabe4e199392aa5f/mypy-2.1.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c209a90853081ff01d01ee895cafe10f7db1474e0d95beaeef0f6c1db9119bbd", size = 14074199, upload-time = "2026-05-11T18:35:09.292Z" }, + { url = "https://files.pythonhosted.org/packages/41/5a/93093f0b29a9e982deafde698f740a2eb2e05886e79ccf0594c7fd5413a3/mypy-2.1.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47cebf61abde7c088a4e27718a8b13a81655686b2e9c251f5c0915a802248166", size = 14953128, upload-time = "2026-05-11T18:31:57.678Z" }, + { url = "https://files.pythonhosted.org/packages/7f/2f/a196f5331d96170ad3d28f144d2aba690d4b2911381f68d51e489c7ab82a/mypy-2.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d57a90ae5e872138a425ec328edbc9b235d1934c4377881a33ec05b341acc9a8", size = 15249378, upload-time = "2026-05-11T18:33:00.101Z" }, + { url = "https://files.pythonhosted.org/packages/54/de/94d321cc12da9f71341ac0c270efbed5c725750c7b4c334d957de9a087d9/mypy-2.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:aea7f7a8a55b459c34275fc468ada6ca7c173a5e43a68f5dbe588a563d8a06b8", size = 11060994, upload-time = "2026-05-11T18:33:18.848Z" }, + { url = "https://files.pythonhosted.org/packages/e1/62/0c27ca55219a7c764a7fb88c7bb2b7b2f9780ade8bbf16bc8ed8400eef6b/mypy-2.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:c989640253f0d76843e9c6c1bbf4bd48c5e85ada61bde4beb37cb3eca035685e", size = 9976743, upload-time = "2026-05-11T18:31:25.554Z" }, + { url = "https://files.pythonhosted.org/packages/0a/a1/639f3024794a2a15899cb90707fe02e044c4412794c39c5769fd3df2e2ef/mypy-2.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a683016b16fe2f572dc04c72be7ee0504ac1605a265d0200f5cea695fb788f41", size = 14691685, upload-time = "2026-05-11T18:33:27.973Z" }, + { url = "https://files.pythonhosted.org/packages/3b/08/9a585dea4325f20d8b80dc78623fa50d1fd2173b710f6237afd6ba6ab39b/mypy-2.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1a293c534adb55271fef24a26da04b855540a8c13cc07bc5917b9fd2c394f2ca", size = 13555165, upload-time = "2026-05-11T18:32:16.107Z" }, + { url = "https://files.pythonhosted.org/packages/81/dc/7c42cc9c6cb01e8eb09961f1f738741d3e9c7e9d5c5b30ec69222625cd5f/mypy-2.1.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7406f4d048e71e576f5356d317e5b0a9e666dfd966bd99f9d14ca06e1a341538", size = 13994376, upload-time = "2026-05-11T18:32:39.256Z" }, + { url = "https://files.pythonhosted.org/packages/d4/fa/285946c33bce716e082c11dfeee9ee196eaf1f5042efb3581a31f9f205e4/mypy-2.1.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e0210d626fc8b31ccc90233754c7bc90e1f43205e85d96387f7db1285b55c398", size = 14864618, upload-time = "2026-05-11T18:34:49.765Z" }, + { url = "https://files.pythonhosted.org/packages/2b/83/82397f48af6c27e295d57979ded8490c9829040152cf7571b2f026aeb9a0/mypy-2.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3712c20deed54e814eaaa825603bada8ea1c390670a397c95b98405347acc563", size = 15102063, upload-time = "2026-05-11T18:34:05.855Z" }, + { url = "https://files.pythonhosted.org/packages/40/68/b02dec39057b88eb03dc0aa854732e26e8361f34f9d0e20c7614967d1eba/mypy-2.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:fcaa0e479066e31f7cceb6a3bea39cb22b2ff51a6b2f24f193d19179ba17c389", size = 11060564, upload-time = "2026-05-11T18:35:36.494Z" }, + { url = "https://files.pythonhosted.org/packages/cf/a8/ea3dcbef31f99b634f2ee23bb0321cbc8c1b388b76a861eb849f13c347dc/mypy-2.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:0b1a5260c95aa443083f9ed3592662941951bca3d4ca224a5dc517c38b7cf666", size = 9966983, upload-time = "2026-05-11T18:37:14.139Z" }, + { url = "https://files.pythonhosted.org/packages/95/b1/55861beb5c339b44f9a2ba92df9e2cb1eeb4ae1eee674cdf7772c797778b/mypy-2.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:244358bf1c0da7722230bce60683d52e8e9fd030554926f15b747a84efb5b3af", size = 14874381, upload-time = "2026-05-11T18:37:31.784Z" }, + { url = "https://files.pythonhosted.org/packages/0b/b3/b7f770114b7d0ac92d0f76e8d93c2780844a70488a90e91821927850da86/mypy-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4ec7c57657493c7a75534df2751c8ae2cda383c16ecc55d2106c54476b1b16f6", size = 13665501, upload-time = "2026-05-11T18:34:23.063Z" }, + { url = "https://files.pythonhosted.org/packages/b6/f3/8ae2037967e2126689a0c11d99e2b707134a565191e92c60ca2572aec60a/mypy-2.1.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8161b6ff4392410023224f0969d17db93e1e154bc3e4ba62598e720723ae211", size = 14045750, upload-time = "2026-05-11T18:31:48.151Z" }, + { url = "https://files.pythonhosted.org/packages/a0/32/615eb5911859e43d054941b0d0a7d06cfa2870eba86529cf385b052b111c/mypy-2.1.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bf03e12003084a67395184d3eb8cbd6a489dc3655b5664b28c210a9e2403ab0b", size = 15061630, upload-time = "2026-05-11T18:37:06.898Z" }, + { url = "https://files.pythonhosted.org/packages/d4/03/4eafbfff8bfab1b87082741eae6e6a624028c984e6708b73bce2a8570c9d/mypy-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:20509760fd791c51579d573153407d226385ec1f8bcce55d730b354f3336bc22", size = 15288831, upload-time = "2026-05-11T18:31:18.07Z" }, + { url = "https://files.pythonhosted.org/packages/99/ee/919661478e5891a3c96e549c036e467e64563ab85995b10c53c8358e16a3/mypy-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:6753d0c1fdd6b1a23b9e4f283ce80b2153b724adcb2653b20b85a8a28ac6436b", size = 11135228, upload-time = "2026-05-11T18:34:31.23Z" }, + { url = "https://files.pythonhosted.org/packages/24/0a/6a12b9782ca0831a553192f351679f4548abc9d19a7cc93bb7feb02084c7/mypy-2.1.0-cp312-cp312-win_arm64.whl", hash = "sha256:98ebb6589bb3b6d0c6f0c459d53ca55b8091fbc13d277c4041c885392e8195e8", size = 10040684, upload-time = "2026-05-11T18:36:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/6e/dd/c7191469c777f07689c032a8f7326e393ea34c92d6d76eb7ce5ba57ea66d/mypy-2.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:35aac3bb114e03888f535d5eb51b8bafbb3266586b599da1940f9b1be3ec5bd5", size = 14852174, upload-time = "2026-05-11T18:31:38.929Z" }, + { url = "https://files.pythonhosted.org/packages/55/8c/aed55408879043d72bb9135f4d0d19a02b886dd569631e113e3d2706cb8d/mypy-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8de55a8c861f2a49331f807be98d90caeceeef520bde13d43a160207f8af613e", size = 13651542, upload-time = "2026-05-11T18:36:04.636Z" }, + { url = "https://files.pythonhosted.org/packages/3a/8e/f371a824b1f1fa8ea6e3dbb8703d232977d572be2329554a3bc4d960302f/mypy-2.1.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fdf2941a07434af755837d9880f7d7d25f1dacb1af9dcd4b9b66f2220a3024e", size = 14033929, upload-time = "2026-05-11T18:35:55.742Z" }, + { url = "https://files.pythonhosted.org/packages/94/21/f54be870d6dd53a82c674407e0f8eed7174b05ec78d42e5abd7b42e84fd5/mypy-2.1.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e195b817c13f02352a9c124301f9f30f078405444679b6753c1b96b6eed37285", size = 15039200, upload-time = "2026-05-11T18:33:10.281Z" }, + { url = "https://files.pythonhosted.org/packages/17/99/bf21748626a40ce59fd29a39386ab46afec88b7bd2f0fa6c3a97c995523f/mypy-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5431d42af987ebd92ba2f71d45c85ed41d8e6ca9f5fd209a69f68f707d2469e5", size = 15272690, upload-time = "2026-05-11T18:32:07.205Z" }, + { url = "https://files.pythonhosted.org/packages/d6/d7/9e90d2cf47100bea550ed2bc7b0d4de3a62181d84d5e37da0003e8462637/mypy-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:767fe8c66dc3e01e19e1737d4c38ebefead16125e1b8e58ad421903b376f5c65", size = 11147435, upload-time = "2026-05-11T18:33:56.477Z" }, + { url = "https://files.pythonhosted.org/packages/ec/46/e5c449e858798e35ffc90946282a27c62a77be743fe17480e4977374eb91/mypy-2.1.0-cp313-cp313-win_arm64.whl", hash = "sha256:ecfe70d43775ab99562ab128ce49854a362044c9f894961f68f898c23cb7429d", size = 10035052, upload-time = "2026-05-11T18:32:30.049Z" }, + { url = "https://files.pythonhosted.org/packages/b0/ca/b279a672e874aedd5498ae25f722dacc8aa86bbffb939b3f97cbb1cf6686/mypy-2.1.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:7354c5a7f69d9345c3d6e69921d57088eea3ddeeb6b20d34c1b3855b02c36ec2", size = 14848422, upload-time = "2026-05-11T18:35:45.984Z" }, + { url = "https://files.pythonhosted.org/packages/27/e6/3efe56c631d959b9b4454e208b0ac4b7f4f58b404c89f8bec7b49efdfc21/mypy-2.1.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:49890d4f76ac9e06ec117f9e09f3174da70a620a0c300953d8595c926e80947f", size = 13677374, upload-time = "2026-05-11T18:36:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/84/7f/8107ea87a44fd1f1b59882442f033c9c3488c127201b1d1d15f1cbd6022e/mypy-2.1.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:761be68e023ef5d94678772396a8af1220030f80837a3afd8d0aef3b419666f4", size = 14055743, upload-time = "2026-05-11T18:35:18.361Z" }, + { url = "https://files.pythonhosted.org/packages/51/4d/b6d34db183133b83761b9199a82d31557cdbb70a380d8c3b3438e11882a3/mypy-2.1.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c90345fc182dc363b891350457ec69c35140858538f38b4540845afcc32b1aef", size = 15020937, upload-time = "2026-05-11T18:34:59.618Z" }, + { url = "https://files.pythonhosted.org/packages/ff/d7/f08360c691d758acb02f45022c34d98b92892f4ea756644e1000d4b9f3d8/mypy-2.1.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b84802e7b5a6daf1f5e15bc9fcd7ddae77be13981ffab037f1c67bb84d67d135", size = 15253371, upload-time = "2026-05-11T18:36:41.081Z" }, + { url = "https://files.pythonhosted.org/packages/67/1b/09460a13719530a19bce27bd3bc8449e83569dd2ba7faf51c9c3c30c0b61/mypy-2.1.0-cp314-cp314-win_amd64.whl", hash = "sha256:022c771234936ceac541ebaf836fe9e2abeb3f5e09aff21588fe543ff006fe21", size = 11326429, upload-time = "2026-05-11T18:34:13.526Z" }, + { url = "https://files.pythonhosted.org/packages/40/62/75dbf0f82f7b6680340efc614af29dd0b3c17b8a4f1cd09b8bd2fd6bc814/mypy-2.1.0-cp314-cp314-win_arm64.whl", hash = "sha256:498207db725cec88829a6a5c2fc771205fd043719ef98bc49aba8fb9fc4e6d57", size = 10218799, upload-time = "2026-05-11T18:32:23.491Z" }, + { url = "https://files.pythonhosted.org/packages/b2/66/caca04ed7d972fb6eb6dd1ccd6df1de5c38fae8c5b3dc1c4e8e0d85ee6b9/mypy-2.1.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:7d5e5cad0efeba72b93cd17490cc0d69c5ac9ca132994fe3fb0314808aeeb83e", size = 15923458, upload-time = "2026-05-11T18:35:28.64Z" }, + { url = "https://files.pythonhosted.org/packages/ed/52/2d90cbe49d014b13ed7ff337930c30bad35893fe38a1e4641e756bb62191/mypy-2.1.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ff715050c127d724fd260a2e666e7747fdd83511c0c47d449d98238970aef780", size = 14757697, upload-time = "2026-05-11T18:36:14.208Z" }, + { url = "https://files.pythonhosted.org/packages/ac/37/d98f4a14e081b238992d0ed96b6d39c7cc0148c9699eb71eaa68629665ea/mypy-2.1.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:82208da9e09414d520e912d3e462d454854bed0810b71540bb016dcbca7308fd", size = 15405638, upload-time = "2026-05-11T18:33:48.249Z" }, + { url = "https://files.pythonhosted.org/packages/a3/c2/15c46613b24a84fad2aea1248bf9619b99c2767ae9071fe224c179a0b7d4/mypy-2.1.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e79ebc1b904b84f0310dff7469655a9c36c7a68bddb37bdd42b67a332df61d08", size = 16215852, upload-time = "2026-05-11T18:32:50.296Z" }, + { url = "https://files.pythonhosted.org/packages/5c/90/9c16a57f482c76d25f6379762b56bbf65c711d8158cf271fb2802cfb0640/mypy-2.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e583edc957cfb0deb142079162ae826f58449b116c1d442f2d91c69d9fced081", size = 16452695, upload-time = "2026-05-11T18:33:38.182Z" }, + { url = "https://files.pythonhosted.org/packages/0f/4c/215a4eeb63cacc5f17f516691ea7285d11e249802b942476bff15922a314/mypy-2.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b33b6cd332695bba180d55e717a79d3038e479a2c49cc5eb3d53603409b9a5d7", size = 12866622, upload-time = "2026-05-11T18:34:39.945Z" }, + { url = "https://files.pythonhosted.org/packages/4b/50/1043e1db5f455ffe4c9ab22747cd8ca2bc492b1e4f4e21b130a44ee2b217/mypy-2.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:4f910fe825376a7b66ef7ca8c98e5a149e8cd64c19ae71d84047a74ee060d4e6", size = 10610798, upload-time = "2026-05-11T18:36:31.444Z" }, + { url = "https://files.pythonhosted.org/packages/0d/2a/13ca1f292f6db1b98ff495ef3467736b331621c5917cad984b7043e7348d/mypy-2.1.0-py3-none-any.whl", hash = "sha256:a663814603a5c563fb87a4f96fb473eeb30d1f5a4885afcf44f9db000a366289", size = 2693302, upload-time = "2026-05-11T18:31:29.246Z" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" }, +] + +[[package]] +name = "nodeenv" +version = "1.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/24/bf/d1bda4f6168e0b2e9e5958945e01910052158313224ada5ce1fb2e1113b8/nodeenv-1.10.0.tar.gz", hash = "sha256:996c191ad80897d076bdfba80a41994c2b47c68e224c542b48feba42ba00f8bb", size = 55611, upload-time = "2025-12-20T14:08:54.006Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/b2/d0896bdcdc8d28a7fc5717c305f1a861c26e18c05047949fb371034d98bd/nodeenv-1.10.0-py2.py3-none-any.whl", hash = "sha256:5bb13e3eed2923615535339b3c620e76779af4cb4c6a90deccc9e36b274d3827", size = 23438, upload-time = "2025-12-20T14:08:52.782Z" }, +] + +[[package]] +name = "packaging" +version = "26.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/f1/e7a6dd94a8d4a5626c03e4e99c87f241ba9e350cd9e6d75123f992427270/packaging-26.2.tar.gz", hash = "sha256:ff452ff5a3e828ce110190feff1178bb1f2ea2281fa2075aadb987c2fb221661", size = 228134, upload-time = "2026-04-24T20:15:23.917Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/df/b2/87e62e8c3e2f4b32e5fe99e0b86d576da1312593b39f47d8ceef365e95ed/packaging-26.2-py3-none-any.whl", hash = "sha256:5fc45236b9446107ff2415ce77c807cee2862cb6fac22b8a73826d0693b0980e", size = 100195, upload-time = "2026-04-24T20:15:22.081Z" }, +] + +[[package]] +name = "pathspec" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/5a/82/42f767fc1c1143d6fd36efb827202a2d997a375e160a71eb2888a925aac1/pathspec-1.1.1.tar.gz", hash = "sha256:17db5ecd524104a120e173814c90367a96a98d07c45b2e10c2f3919fff91bf5a", size = 135180, upload-time = "2026-04-27T01:46:08.907Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/d9/7fb5aa316bc299258e68c73ba3bddbc499654a07f151cba08f6153988714/pathspec-1.1.1-py3-none-any.whl", hash = "sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189", size = 57328, upload-time = "2026-04-27T01:46:07.06Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.10.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d7/47/e4501f49c178ae1d9f4a75073fda4204f52647993f075a9db4d14930e0c5/platformdirs-4.10.0.tar.gz", hash = "sha256:31e761a6a0ca04faf7353ea759bdba55652be214725111e5aac52dfa29d4bef7", size = 31224, upload-time = "2026-05-28T03:32:53.587Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/e6/cd9575ac904136b3cbf7aa7ee819ef86eedb7274e46f230e94ea4342e729/platformdirs-4.10.0-py3-none-any.whl", hash = "sha256:fb516cdb12eb0d857d0cd85a7c57cea4d060bee4578d6cf5a14dfdf8cbf8784a", size = 22743, upload-time = "2026-05-28T03:32:52.175Z" }, +] + +[[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 = "pre-commit" +version = "4.6.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/8e/22/2de9408ac81acbb8a7d05d4cc064a152ccf33b3d480ebe0cd292153db239/pre_commit-4.6.0.tar.gz", hash = "sha256:718d2208cef53fdc38206e40524a6d4d9576d103eb16f0fec11c875e7716e9d9", size = 198525, upload-time = "2026-04-21T20:31:41.613Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/80/6e/4b28b62ecb6aae56769c34a8ff1d661473ec1e9519e2d5f8b2c150086b26/pre_commit-4.6.0-py2.py3-none-any.whl", hash = "sha256:e2cf246f7299edcabcf15f9b0571fdce06058527f0a06535068a86d38089f29b", size = 226472, upload-time = "2026-04-21T20:31:40.092Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pyproject-hooks" +version = "1.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/82/28175b2414effca1cdac8dc99f76d660e7a4fb0ceefa4b4ab8f5f6742925/pyproject_hooks-1.2.0.tar.gz", hash = "sha256:1e859bd5c40fae9448642dd871adf459e5e2084186e8d2c2a79a824c970da1f8", size = 19228, upload-time = "2024-09-29T09:24:13.293Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bd/24/12818598c362d7f300f18e74db45963dbcb85150324092410c8b49405e42/pyproject_hooks-1.2.0-py3-none-any.whl", hash = "sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913", size = 10216, upload-time = "2024-09-29T09:24:11.978Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" }, +] + +[[package]] +name = "pytest-asyncio" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "backports-asyncio-runner", marker = "python_full_version < '3.11'" }, + { name = "pytest" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/43/7c/d36d04db312ecf4298932ef77e6e4a9e8ad017906e24e34f0b0c361a2473/pytest_asyncio-1.4.0.tar.gz", hash = "sha256:c6c0d2259945122819f171a32ecea2c349ead889ee28176caaf492143424be42", size = 58514, upload-time = "2026-05-26T09:56:04.083Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/03/e2/08a497ef684b88559c9cc5f4ad53a37e7b99e727094a86d6ea32536d5d3c/pytest_asyncio-1.4.0-py3-none-any.whl", hash = "sha256:933ca923a23075a87fb7070c0ec272a6848489824d887c85c812670932835aa1", size = 16930, upload-time = "2026-05-26T09:56:02.576Z" }, +] + +[[package]] +name = "pytest-cov" +version = "7.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "coverage", extra = ["toml"] }, + { name = "pluggy" }, + { name = "pytest" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/51/a849f96e117386044471c8ec2bd6cfebacda285da9525c9106aeb28da671/pytest_cov-7.1.0.tar.gz", hash = "sha256:30674f2b5f6351aa09702a9c8c364f6a01c27aae0c1366ae8016160d1efc56b2", size = 55592, upload-time = "2026-03-21T20:11:16.284Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9d/7a/d968e294073affff457b041c2be9868a40c1c71f4a35fcc1e45e5493067b/pytest_cov-7.1.0-py3-none-any.whl", hash = "sha256:a0461110b7865f9a271aa1b51e516c9a95de9d696734a2f71e3e78f46e1d4678", size = 22876, upload-time = "2026-03-21T20:11:14.438Z" }, +] + +[[package]] +name = "python-discovery" +version = "1.4.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "filelock" }, + { name = "platformdirs" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a6/12/38c1a0b1e64806780c9563e3fc9f6e472251839662587cfbe9bfaf2ae10a/python_discovery-1.4.0.tar.gz", hash = "sha256:eb8bc7daad3c226c147e45bb4e970a1feb1bf4048ee178e6db59e197b8010ce3", size = 68455, upload-time = "2026-05-28T01:15:37.639Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c8/8d/3d316429f65029532bb1e28ff77b797d86b5ac3915bb44ca4e19aa283d43/python_discovery-1.4.0-py3-none-any.whl", hash = "sha256:26ed78d703e234879a66244c7d4114563fb13ec5cd30a2d1357e5fb4850782da", size = 33217, upload-time = "2026-05-28T01:15:36.573Z" }, +] + +[[package]] +name = "pytokens" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b6/34/b4e015b99031667a7b960f888889c5bd34ef585c85e1cb56a594b92836ac/pytokens-0.4.1.tar.gz", hash = "sha256:292052fe80923aae2260c073f822ceba21f3872ced9a68bb7953b348e561179a", size = 23015, upload-time = "2026-01-30T01:03:45.924Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/42/24/f206113e05cb8ef51b3850e7ef88f20da6f4bf932190ceb48bd3da103e10/pytokens-0.4.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2a44ed93ea23415c54f3face3b65ef2b844d96aeb3455b8a69b3df6beab6acc5", size = 161522, upload-time = "2026-01-30T01:02:50.393Z" }, + { url = "https://files.pythonhosted.org/packages/d4/e9/06a6bf1b90c2ed81a9c7d2544232fe5d2891d1cd480e8a1809ca354a8eb2/pytokens-0.4.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:add8bf86b71a5d9fb5b89f023a80b791e04fba57960aa790cc6125f7f1d39dfe", size = 246945, upload-time = "2026-01-30T01:02:52.399Z" }, + { url = "https://files.pythonhosted.org/packages/69/66/f6fb1007a4c3d8b682d5d65b7c1fb33257587a5f782647091e3408abe0b8/pytokens-0.4.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:670d286910b531c7b7e3c0b453fd8156f250adb140146d234a82219459b9640c", size = 259525, upload-time = "2026-01-30T01:02:53.737Z" }, + { url = "https://files.pythonhosted.org/packages/04/92/086f89b4d622a18418bac74ab5db7f68cf0c21cf7cc92de6c7b919d76c88/pytokens-0.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4e691d7f5186bd2842c14813f79f8884bb03f5995f0575272009982c5ac6c0f7", size = 262693, upload-time = "2026-01-30T01:02:54.871Z" }, + { url = "https://files.pythonhosted.org/packages/b4/7b/8b31c347cf94a3f900bdde750b2e9131575a61fdb620d3d3c75832262137/pytokens-0.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:27b83ad28825978742beef057bfe406ad6ed524b2d28c252c5de7b4a6dd48fa2", size = 103567, upload-time = "2026-01-30T01:02:56.414Z" }, + { url = "https://files.pythonhosted.org/packages/3d/92/790ebe03f07b57e53b10884c329b9a1a308648fc083a6d4a39a10a28c8fc/pytokens-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d70e77c55ae8380c91c0c18dea05951482e263982911fc7410b1ffd1dadd3440", size = 160864, upload-time = "2026-01-30T01:02:57.882Z" }, + { url = "https://files.pythonhosted.org/packages/13/25/a4f555281d975bfdd1eba731450e2fe3a95870274da73fb12c40aeae7625/pytokens-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a58d057208cb9075c144950d789511220b07636dd2e4708d5645d24de666bdc", size = 248565, upload-time = "2026-01-30T01:02:59.912Z" }, + { url = "https://files.pythonhosted.org/packages/17/50/bc0394b4ad5b1601be22fa43652173d47e4c9efbf0044c62e9a59b747c56/pytokens-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b49750419d300e2b5a3813cf229d4e5a4c728dae470bcc89867a9ad6f25a722d", size = 260824, upload-time = "2026-01-30T01:03:01.471Z" }, + { url = "https://files.pythonhosted.org/packages/4e/54/3e04f9d92a4be4fc6c80016bc396b923d2a6933ae94b5f557c939c460ee0/pytokens-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d9907d61f15bf7261d7e775bd5d7ee4d2930e04424bab1972591918497623a16", size = 264075, upload-time = "2026-01-30T01:03:04.143Z" }, + { url = "https://files.pythonhosted.org/packages/d1/1b/44b0326cb5470a4375f37988aea5d61b5cc52407143303015ebee94abfd6/pytokens-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:ee44d0f85b803321710f9239f335aafe16553b39106384cef8e6de40cb4ef2f6", size = 103323, upload-time = "2026-01-30T01:03:05.412Z" }, + { url = "https://files.pythonhosted.org/packages/41/5d/e44573011401fb82e9d51e97f1290ceb377800fb4eed650b96f4753b499c/pytokens-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:140709331e846b728475786df8aeb27d24f48cbcf7bcd449f8de75cae7a45083", size = 160663, upload-time = "2026-01-30T01:03:06.473Z" }, + { url = "https://files.pythonhosted.org/packages/f0/e6/5bbc3019f8e6f21d09c41f8b8654536117e5e211a85d89212d59cbdab381/pytokens-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6d6c4268598f762bc8e91f5dbf2ab2f61f7b95bdc07953b602db879b3c8c18e1", size = 255626, upload-time = "2026-01-30T01:03:08.177Z" }, + { url = "https://files.pythonhosted.org/packages/bf/3c/2d5297d82286f6f3d92770289fd439956b201c0a4fc7e72efb9b2293758e/pytokens-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:24afde1f53d95348b5a0eb19488661147285ca4dd7ed752bbc3e1c6242a304d1", size = 269779, upload-time = "2026-01-30T01:03:09.756Z" }, + { url = "https://files.pythonhosted.org/packages/20/01/7436e9ad693cebda0551203e0bf28f7669976c60ad07d6402098208476de/pytokens-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5ad948d085ed6c16413eb5fec6b3e02fa00dc29a2534f088d3302c47eb59adf9", size = 268076, upload-time = "2026-01-30T01:03:10.957Z" }, + { url = "https://files.pythonhosted.org/packages/2e/df/533c82a3c752ba13ae7ef238b7f8cdd272cf1475f03c63ac6cf3fcfb00b6/pytokens-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:3f901fe783e06e48e8cbdc82d631fca8f118333798193e026a50ce1b3757ea68", size = 103552, upload-time = "2026-01-30T01:03:12.066Z" }, + { url = "https://files.pythonhosted.org/packages/cb/dc/08b1a080372afda3cceb4f3c0a7ba2bde9d6a5241f1edb02a22a019ee147/pytokens-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8bdb9d0ce90cbf99c525e75a2fa415144fd570a1ba987380190e8b786bc6ef9b", size = 160720, upload-time = "2026-01-30T01:03:13.843Z" }, + { url = "https://files.pythonhosted.org/packages/64/0c/41ea22205da480837a700e395507e6a24425151dfb7ead73343d6e2d7ffe/pytokens-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5502408cab1cb18e128570f8d598981c68a50d0cbd7c61312a90507cd3a1276f", size = 254204, upload-time = "2026-01-30T01:03:14.886Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d2/afe5c7f8607018beb99971489dbb846508f1b8f351fcefc225fcf4b2adc0/pytokens-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29d1d8fb1030af4d231789959f21821ab6325e463f0503a61d204343c9b355d1", size = 268423, upload-time = "2026-01-30T01:03:15.936Z" }, + { url = "https://files.pythonhosted.org/packages/68/d4/00ffdbd370410c04e9591da9220a68dc1693ef7499173eb3e30d06e05ed1/pytokens-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:970b08dd6b86058b6dc07efe9e98414f5102974716232d10f32ff39701e841c4", size = 266859, upload-time = "2026-01-30T01:03:17.458Z" }, + { url = "https://files.pythonhosted.org/packages/a7/c9/c3161313b4ca0c601eeefabd3d3b576edaa9afdefd32da97210700e47652/pytokens-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:9bd7d7f544d362576be74f9d5901a22f317efc20046efe2034dced238cbbfe78", size = 103520, upload-time = "2026-01-30T01:03:18.652Z" }, + { url = "https://files.pythonhosted.org/packages/8f/a7/b470f672e6fc5fee0a01d9e75005a0e617e162381974213a945fcd274843/pytokens-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4a14d5f5fc78ce85e426aa159489e2d5961acf0e47575e08f35584009178e321", size = 160821, upload-time = "2026-01-30T01:03:19.684Z" }, + { url = "https://files.pythonhosted.org/packages/80/98/e83a36fe8d170c911f864bfded690d2542bfcfacb9c649d11a9e6eb9dc41/pytokens-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97f50fd18543be72da51dd505e2ed20d2228c74e0464e4262e4899797803d7fa", size = 254263, upload-time = "2026-01-30T01:03:20.834Z" }, + { url = "https://files.pythonhosted.org/packages/0f/95/70d7041273890f9f97a24234c00b746e8da86df462620194cef1d411ddeb/pytokens-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc74c035f9bfca0255c1af77ddd2d6ae8419012805453e4b0e7513e17904545d", size = 268071, upload-time = "2026-01-30T01:03:21.888Z" }, + { url = "https://files.pythonhosted.org/packages/da/79/76e6d09ae19c99404656d7db9c35dfd20f2086f3eb6ecb496b5b31163bad/pytokens-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f66a6bbe741bd431f6d741e617e0f39ec7257ca1f89089593479347cc4d13324", size = 271716, upload-time = "2026-01-30T01:03:23.633Z" }, + { url = "https://files.pythonhosted.org/packages/79/37/482e55fa1602e0a7ff012661d8c946bafdc05e480ea5a32f4f7e336d4aa9/pytokens-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:b35d7e5ad269804f6697727702da3c517bb8a5228afa450ab0fa787732055fc9", size = 104539, upload-time = "2026-01-30T01:03:24.788Z" }, + { url = "https://files.pythonhosted.org/packages/30/e8/20e7db907c23f3d63b0be3b8a4fd1927f6da2395f5bcc7f72242bb963dfe/pytokens-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:8fcb9ba3709ff77e77f1c7022ff11d13553f3c30299a9fe246a166903e9091eb", size = 168474, upload-time = "2026-01-30T01:03:26.428Z" }, + { url = "https://files.pythonhosted.org/packages/d6/81/88a95ee9fafdd8f5f3452107748fd04c24930d500b9aba9738f3ade642cc/pytokens-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79fc6b8699564e1f9b521582c35435f1bd32dd06822322ec44afdeba666d8cb3", size = 290473, upload-time = "2026-01-30T01:03:27.415Z" }, + { url = "https://files.pythonhosted.org/packages/cf/35/3aa899645e29b6375b4aed9f8d21df219e7c958c4c186b465e42ee0a06bf/pytokens-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d31b97b3de0f61571a124a00ffe9a81fb9939146c122c11060725bd5aea79975", size = 303485, upload-time = "2026-01-30T01:03:28.558Z" }, + { url = "https://files.pythonhosted.org/packages/52/a0/07907b6ff512674d9b201859f7d212298c44933633c946703a20c25e9d81/pytokens-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:967cf6e3fd4adf7de8fc73cd3043754ae79c36475c1c11d514fc72cf5490094a", size = 306698, upload-time = "2026-01-30T01:03:29.653Z" }, + { url = "https://files.pythonhosted.org/packages/39/2a/cbbf9250020a4a8dd53ba83a46c097b69e5eb49dd14e708f496f548c6612/pytokens-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:584c80c24b078eec1e227079d56dc22ff755e0ba8654d8383b2c549107528918", size = 116287, upload-time = "2026-01-30T01:03:30.912Z" }, + { url = "https://files.pythonhosted.org/packages/c6/78/397db326746f0a342855b81216ae1f0a32965deccfd7c830a2dbc66d2483/pytokens-0.4.1-py3-none-any.whl", hash = "sha256:26cef14744a8385f35d0e095dc8b3a7583f6c953c2e3d269c7f82484bf5ad2de", size = 13729, upload-time = "2026-01-30T01:03:45.029Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.15" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/84/6f/a76f7d96e5c962f5b69cee865e49c15c1116897c01990faa8a57edb62e7f/ruff-0.15.15.tar.gz", hash = "sha256:b8dff018130b46d8e5bf0f926ef6b60cf871d6d5ae45fc9334e09632daa741d6", size = 4706985, upload-time = "2026-05-28T14:16:57.784Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/fa/9d/3a45c05b8ab04b4705989de70a79008e27c8003296a0feaee9edc18dd7e9/ruff-0.15.15-py3-none-linux_armv6l.whl", hash = "sha256:cf93e5388f412e1b108b1f8b34a6e036b70fe8aff89393befad96fe48670311b", size = 10710652, upload-time = "2026-05-28T14:16:06.701Z" }, + { url = "https://files.pythonhosted.org/packages/05/66/da974431624bf3b49f6ee1f9543c02d929ff1cba78b0d5a79c38cf21f744/ruff-0.15.15-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ac5a646d1f6a7dadd5d50842dae2c1f9862ac887ef5d1b1375e02def791fde6e", size = 11096615, upload-time = "2026-05-28T14:16:23.313Z" }, + { url = "https://files.pythonhosted.org/packages/8c/09/7443452e5d290230a712103f2fdceeef7184f3ec99a2bd01c8be78aaceb5/ruff-0.15.15-py3-none-macosx_11_0_arm64.whl", hash = "sha256:77d955a431430c66f72dd94e379ad38a16daea3d25094872ac4edf9e797be530", size = 10436683, upload-time = "2026-05-28T14:16:40.974Z" }, + { url = "https://files.pythonhosted.org/packages/53/01/d330c26a57fa4f3943a14424904027428315b700fe4d14a84bb123a649e5/ruff-0.15.15-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7614ee79c69788cf6cedd568069ade9cecc22a1ad20494efe8d0c9ebb4b622d4", size = 10769064, upload-time = "2026-05-28T14:16:28.905Z" }, + { url = "https://files.pythonhosted.org/packages/1d/85/cc8770f8bdff541b1da8392d1634141fe4a0e3f4ee596605959b7906c27f/ruff-0.15.15-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3cdb1679e06a1f6b47bc384714ae96f6e2fb65ca441eb78c43d2ca554176ce1f", size = 10511987, upload-time = "2026-05-28T14:16:43.732Z" }, + { url = "https://files.pythonhosted.org/packages/7c/29/8c190c1472b63013583ba391f3342036e02010544c1270455ed8e519bdf3/ruff-0.15.15-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2728b93d7b23a603ea2c0ac6eb73d760bd38ec9de35f35fb41e18f7a3fee7622", size = 11275100, upload-time = "2026-05-28T14:16:55.244Z" }, + { url = "https://files.pythonhosted.org/packages/9f/6b/7e145ce2cc8e63d6834eca03d83a0e18d121def5c69f91b4cf4011ed4879/ruff-0.15.15-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:be582fcc0db438902c7792b08d6ddf6c9b9e21addaa10092c2c741cfb09e5a45", size = 12176903, upload-time = "2026-05-28T14:16:14.368Z" }, + { url = "https://files.pythonhosted.org/packages/80/a3/d5974637f68e451f7fadf015cf3101d1cd7d8ba5027cffe0b9e3826ebe6b/ruff-0.15.15-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7aa77465b8ecaf1a27bea098d696f7fed5e1eccbd10b321b682d6de586ae5627", size = 11404550, upload-time = "2026-05-28T14:16:20.138Z" }, + { url = "https://files.pythonhosted.org/packages/fe/1c/e6e5e568f22be4fb05d6244234aba384c06b451252453b821e1a529263cf/ruff-0.15.15-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:48decfa11d740de4889de623be1463308346312f2409a56e24aa280c86162dc4", size = 11382027, upload-time = "2026-05-28T14:16:46.615Z" }, + { url = "https://files.pythonhosted.org/packages/1d/01/170921b49fcd2e8858825593f91cf7146c3e40a5c3e6df763e4bb0484dde/ruff-0.15.15-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:a5015088452ca0081387063649ec67f06d3d1d6b8b936a1f836b5e9657ecd48c", size = 11366041, upload-time = "2026-05-28T14:16:26.247Z" }, + { url = "https://files.pythonhosted.org/packages/87/54/a7bad711d7de93254e15e06a4c375b89a03d18de45d3e5dcc86a4472fb1a/ruff-0.15.15-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f5294aab6356c81600fcdea3a62bb1b924dfd5e91767c12318d3f68f86af57cd", size = 10741795, upload-time = "2026-05-28T14:16:17.11Z" }, + { url = "https://files.pythonhosted.org/packages/c9/31/38c075963668f8b41c6914ee0f6f318727fbe30ab9145cb29e6df464c5fa/ruff-0.15.15-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:db5bd4d802415cca656dc1616070b725952d6ae95eb5d4831e49fbd94a38f75f", size = 10511117, upload-time = "2026-05-28T14:16:31.767Z" }, + { url = "https://files.pythonhosted.org/packages/9d/96/6ff689e1f7e375d1d97075eca022f74c2bab59554a432fe4d2e6f091986a/ruff-0.15.15-py3-none-musllinux_1_2_i686.whl", hash = "sha256:587a6278ed42059191c1a466e490bd7930fb50bd2e255398bc29616c895a61cb", size = 10994867, upload-time = "2026-05-28T14:16:35.149Z" }, + { url = "https://files.pythonhosted.org/packages/c3/c2/5dce0ab9f92a8d534fa62b9bf9caca3eddb8c1a81b616f5e195ada4f0d6e/ruff-0.15.15-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:df0c1c084f5f4be9812f61518a45c440d3c30d69ce4bf6c5270e66d38338f02a", size = 11482101, upload-time = "2026-05-28T14:16:49.598Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c0/1003b60edd697c649faf61f1a34094b1abb38fb3d1181e3f895781250a08/ruff-0.15.15-py3-none-win32.whl", hash = "sha256:29428ea79694afbe756d45fd59b36f22b6b020dc0443cf7de0173046236964b9", size = 10716774, upload-time = "2026-05-28T14:16:52.337Z" }, + { url = "https://files.pythonhosted.org/packages/02/a8/1269eddd6945a06c23f055ef7848886e37cf9d6a8bebb386a3115f01470c/ruff-0.15.15-py3-none-win_amd64.whl", hash = "sha256:8df0323902e15e24bc4bf246da830573d3cf3352bd0b9a164eab335d111ff4a4", size = 11868463, upload-time = "2026-05-28T14:16:11.333Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b2/920464c907b191e37469d477a1aa8bc048b8f36c4c1610dfa4ab87b39e18/ruff-0.15.15-py3-none-win_arm64.whl", hash = "sha256:3c8ceca6792f38196b8f589bc92eccd03eef286602da92e5dc05cc42ef6441b7", size = 11138498, upload-time = "2026-05-28T14:16:38.425Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "virtualenv" +version = "21.4.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, + { name = "python-discovery" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e1/0d/4e93c8e6d1001a75763f87d8f5ecda8ebc7f4aa2153dddfaf4ae8892821a/virtualenv-21.4.2.tar.gz", hash = "sha256:38e6ee0a555615c0ea9da2ac7e9998fe8dc3b911dd33ad8eaad2020957653b0c", size = 7613326, upload-time = "2026-05-31T17:01:22.827Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bf/c4/557dc082be035381b85fdb2b74e21d3d21b57750b74f2b47a32f3a639ff9/virtualenv-21.4.2-py3-none-any.whl", hash = "sha256:854210ca524a1a4d0d744734f4acbc721c3ffe163b85bbf5d56d14d5ae2f0fae", size = 7594079, upload-time = "2026-05-31T17:01:20.735Z" }, +] + +[[package]] +name = "zipp" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/b9/d8/eab98a517c14134c0b2eb4e2387bc5f457334293ec5d2dd3857ec2966802/zipp-4.1.0.tar.gz", hash = "sha256:4cb57381f544315db7688e976e922a2b18cdb513d21cc194eb42232ba2a3e602", size = 26214, upload-time = "2026-05-18T20:08:57.967Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/13/547360d81e6d88d58492968ffda9f9542854f11310ee556fef14260cc886/zipp-4.1.0-py3-none-any.whl", hash = "sha256:25ad4e16390cd314347dd8f1de67a2ac538ae658ed4ab9db16029c07c188e97f", size = 10238, upload-time = "2026-05-18T20:08:57.045Z" }, +] diff --git a/vendor/libhv b/vendor/libhv index 5d15aab..bb675b8 160000 --- a/vendor/libhv +++ b/vendor/libhv @@ -1 +1 @@ -Subproject commit 5d15aab81b2eba48e6f1660184be4234817a06ce +Subproject commit bb675b805df88da116f2521d8ae7350165f0d366