From f32c4f35f62feefa907cc19fe2f543018dca2d9f Mon Sep 17 00:00:00 2001 From: Piotr Roszatycki Date: Wed, 4 Nov 2026 13:59:24 +0100 Subject: [PATCH 1/2] Pyjo.Reactor.Winloop: the template of the distribution The repository of Pyjo-Reactor-Uvloop for Winloop, the fork of uvloop for Windows: the workflows, with the tests and the wheel on Windows, Trunk with Biome, Renovate, mise, the documentation, README.md, AGENTS.md and SECURITY.md, and a stub of the module, whose constructor raises NotImplementedError, with the tests and the examples of the reactor to be. Co-Authored-By: Claude Opus 5.5 --- .editorconfig | 12 + .github/release.yml | 11 + .github/workflows/biome-migrate.yaml | 138 +++++++ .github/workflows/build.yaml | 72 ++++ .github/workflows/cleanup-cache.yaml | 41 ++ .github/workflows/docs.yaml | 60 +++ .github/workflows/mise-lock-check.yaml | 78 ++++ .github/workflows/pypi.yaml | 58 +++ .github/workflows/release.yaml | 121 ++++++ .github/workflows/tag.yaml | 53 +++ .github/workflows/tests.yaml | 244 ++++++++++++ .github/workflows/trunk-check.yaml | 42 ++ .github/workflows/trunk-upgrade.yaml | 101 +++++ .github/workflows/version.yaml | 123 ++++++ .gitignore | 17 + .proverc | 2 + .readthedocs.yaml | 29 ++ .renovaterc.json | 56 +++ .trunk/.gitignore | 9 + .trunk/trunk.yaml | 147 +++++++ .yamllint.yaml | 7 + AGENTS.md | 180 +++++++++ CLAUDE.md | 1 + Pyjo/Reactor/Winloop.py | 97 +++++ README.md | 137 +++++++ SECURITY.md | 87 +++++ biome.jsonc | 49 +++ docs/conf.py | 116 ++++++ docs/index.rst | 40 ++ examples/hello_world_winloop.py | 13 + examples/loopback_winloop.py | 25 ++ mise.lock | 79 ++++ mise.toml | 6 + pyproject.toml | 97 +++++ t/Reactor_Winloop.py | 20 + t/docs/Reactor_Winloop.py | 73 ++++ t/examples.py | 78 ++++ uv.lock | 519 +++++++++++++++++++++++++ 38 files changed, 3038 insertions(+) create mode 100644 .editorconfig create mode 100644 .github/release.yml create mode 100644 .github/workflows/biome-migrate.yaml create mode 100644 .github/workflows/build.yaml create mode 100644 .github/workflows/cleanup-cache.yaml create mode 100644 .github/workflows/docs.yaml create mode 100644 .github/workflows/mise-lock-check.yaml create mode 100644 .github/workflows/pypi.yaml create mode 100644 .github/workflows/release.yaml create mode 100644 .github/workflows/tag.yaml create mode 100644 .github/workflows/tests.yaml create mode 100644 .github/workflows/trunk-check.yaml create mode 100644 .github/workflows/trunk-upgrade.yaml create mode 100644 .github/workflows/version.yaml create mode 100644 .gitignore create mode 100644 .proverc create mode 100644 .readthedocs.yaml create mode 100644 .renovaterc.json create mode 100644 .trunk/.gitignore create mode 100644 .trunk/trunk.yaml create mode 100644 .yamllint.yaml create mode 100644 AGENTS.md create mode 100644 CLAUDE.md create mode 100644 Pyjo/Reactor/Winloop.py create mode 100644 SECURITY.md create mode 100644 biome.jsonc create mode 100644 docs/conf.py create mode 100644 docs/index.rst create mode 100644 examples/hello_world_winloop.py create mode 100644 examples/loopback_winloop.py create mode 100644 mise.lock create mode 100644 mise.toml create mode 100644 pyproject.toml create mode 100644 t/Reactor_Winloop.py create mode 100644 t/docs/Reactor_Winloop.py create mode 100644 t/examples.py create mode 100644 uv.lock diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..83926e1 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,12 @@ +root = true + +[*] +charset = utf-8 +indent_style = space +indent_size = 4 +end_of_line = lf +insert_final_newline = true +trim_trailing_whitespace = true + +[*.{json,md,toml,yaml,yml}] +indent_size = 2 diff --git a/.github/release.yml b/.github/release.yml new file mode 100644 index 0000000..2c79b2a --- /dev/null +++ b/.github/release.yml @@ -0,0 +1,11 @@ +changelog: + categories: + - title: Changes + labels: + - "*" + exclude: + labels: + - renovate + - title: Dependencies + labels: + - renovate diff --git a/.github/workflows/biome-migrate.yaml b/.github/workflows/biome-migrate.yaml new file mode 100644 index 0000000..6c6a8b3 --- /dev/null +++ b/.github/workflows/biome-migrate.yaml @@ -0,0 +1,138 @@ +name: Biome Migrate + +# Renovate bumps the version of Biome in .trunk/trunk.yaml but cannot run +# `biome migrate`, so the $schema and the renamed options and rules of +# biome.jsonc stay behind. On its branches the update job below commits the +# migrated biome.jsonc; anywhere else, a biome.jsonc that the Biome of +# .trunk/trunk.yaml would migrate fails the check. +on: + pull_request: + branches: + - main + paths: + - .github/workflows/biome-migrate.yaml + - .trunk/trunk.yaml + - biome.jsonc + workflow_dispatch: {} + +permissions: + contents: read + +jobs: + check: + name: Check biome.jsonc + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + outputs: + stale: ${{ steps.up_to_date.outputs.stale }} + + env: + # Only branches of this repository qualify, never a fork's. + RENOVATE_PR: ${{ github.event_name == 'pull_request' && startsWith(github.head_ref, 'renovate/') + && github.event.pull_request.head.repo.full_name == github.repository }} + + steps: + # A Renovate branch is checked out at its head rather than merged with + # main, so that the migrated biome.jsonc matches the branch it is + # committed to. + - name: Checkout + uses: actions/checkout@v7 + with: + ref: ${{ env.RENOVATE_PR == 'true' && github.event.pull_request.head.sha || '' }} + + # The version is the one that Trunk runs, pinned with a trailing ! in + # .trunk/trunk.yaml. npx comes with the Node of the runner image. + - name: Migrate biome.jsonc + run: |- + BIOME_VERSION=$(perl -ne 'print $1 if /^\s*-\s*biome@([^!\s]+)/' .trunk/trunk.yaml) + if [[ -z $BIOME_VERSION ]]; then + echo "::error::No version of Biome in .trunk/trunk.yaml" >&2 + exit 1 + fi + echo "BIOME_VERSION=$BIOME_VERSION" >> "$GITHUB_ENV" + npx --yes "@biomejs/biome@${BIOME_VERSION}" migrate --write + + - name: Check biome.jsonc is up to date + id: up_to_date + run: |- + if git diff --exit-code --stat -- biome.jsonc; then + echo "biome.jsonc is up to date." + exit 0 + fi + + if [ "$RENOVATE_PR" = 'true' ]; then + git diff --binary -- biome.jsonc > biome.patch + echo "stale=true" | tee -a "$GITHUB_OUTPUT" + echo "::notice::biome.jsonc is not migrated on a Renovate branch; the update job commits it." + exit 0 + fi + + echo "::error::biome.jsonc is not migrated to the Biome of .trunk/trunk.yaml. Run \`npx --yes @biomejs/biome@$BIOME_VERSION migrate --write\` and commit the result." >&2 + exit 1 + + - name: Upload the patch + if: steps.up_to_date.outputs.stale == 'true' + uses: actions/upload-artifact@v7 + with: + name: biome-patch + path: biome.patch + retention-days: 1 + + # Commits the biome.jsonc that the check job migrated onto the Renovate + # branch, with the token of the workflow. A push with it starts no workflow, + # so the job starts the checks of the commit itself, as workflow_dispatch is + # the event that the token can start; this check among them, which fails if + # biome.jsonc still needs migrating, as it does not commit on such a run. The + # job runs no code of npm: it only applies the patch. + update: + name: Commit the migrated biome.jsonc + + needs: check + if: needs.check.outputs.stale == 'true' + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + permissions: + actions: write + contents: write + + steps: + - name: Checkout + uses: actions/checkout@v7 + with: + ref: ${{ github.event.pull_request.head.sha }} + + - name: Download the patch + uses: actions/download-artifact@v8 + with: + name: biome-patch + + # The author is in gitIgnoredAuthors of .renovaterc.json, so that + # Renovate keeps rebasing and updating the branch. The push goes to the + # commit that the check job migrated biome.jsonc for: if the branch moved + # meanwhile, the push is rejected, and the run of the newer commit takes + # over. + - name: Commit and push to the pull request branch + env: + BRANCH: ${{ github.head_ref }} + MESSAGE: Migrate biome.jsonc to the new version of Biome + run: |- + git apply --index biome.patch + rm biome.patch + git -c user.name='github-actions[bot]' \ + -c user.email='41898282+github-actions[bot]@users.noreply.github.com' \ + commit -m "$MESSAGE" + git push origin "HEAD:refs/heads/$BRANCH" + + - name: Run the checks of the commit + env: + BRANCH: ${{ github.head_ref }} + GH_TOKEN: ${{ github.token }} + run: |- + gh workflow run biome-migrate.yaml --ref "$BRANCH" + gh workflow run build.yaml --ref "$BRANCH" + gh workflow run tests.yaml --ref "$BRANCH" + gh workflow run trunk-check.yaml --ref "$BRANCH" diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml new file mode 100644 index 0000000..4109630 --- /dev/null +++ b/.github/workflows/build.yaml @@ -0,0 +1,72 @@ +name: Build + +# Checks that uv.lock matches pyproject.toml, builds the sdist and the wheel, +# checks that the wheel has the module of the reactor and nothing of the +# namespace of Pyjoyment, and installs it with Pyjoyment and imports it and +# runs examples/loopback_winloop.py, a request to a server of its own on the +# loop of Winloop, outside the checkout. +on: + push: + branches: + - main + pull_request: + branches: + - "*" + workflow_dispatch: {} + +permissions: + contents: read + +jobs: + build: + name: build + + # Windows, where the wheel installs Winloop, which the example runs on + runs-on: windows-2025 + defaults: + run: + shell: bash + timeout-minutes: 10 + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up mise + uses: jdx/mise-action@v5 + with: + version: 2026.10.25 # datasource=github-releases depName=jdx/mise + + # uv.lock has to match pyproject.toml. + - name: Check uv.lock + run: uv lock --check + + - name: Build sdist and wheel + run: uv build + + # The packages Pyjo and Pyjo.Reactor are those of Pyjoyment: a wheel + # with their __init__.py would overwrite the files of Pyjoyment. + - name: Check wheel contents + run: |- + python -m zipfile -l dist/*.whl | tee wheel.txt + grep -q 'Pyjo/Reactor/Winloop.py' wheel.txt + if grep -E 'Pyjo/(Reactor/)?__init__\.py' wheel.txt; then exit 1; fi + + # The wheel in an environment of its own, outside the checkout, so that + # nothing comes from it, with the Pyjoyment of PyPI that it depends on. + # The first line of the example is the class of the reactor and whether + # its loop is one of Winloop, so that Pyjo.Reactor.Asyncio or a loop of asyncio + # in their place fails the step. + - name: Install and run the wheel + shell: bash + run: |- + uv venv --python "$(command -v python)" "$RUNNER_TEMP/venv" + uv pip install --python "$RUNNER_TEMP/venv/Scripts/python" dist/*.whl + cp examples/loopback_winloop.py "$RUNNER_TEMP/" + cd "$RUNNER_TEMP" + venv/Scripts/python -c 'import Pyjo.Reactor.Winloop; print(Pyjo.Reactor.Winloop.__version__)' + venv/Scripts/python loopback_winloop.py | tee loopback.txt + diff - loopback.txt <<'EOF' + Pyjo_Reactor_Winloop winloop + 200 Your Pyjo is working! + EOF diff --git a/.github/workflows/cleanup-cache.yaml b/.github/workflows/cleanup-cache.yaml new file mode 100644 index 0000000..f60622e --- /dev/null +++ b/.github/workflows/cleanup-cache.yaml @@ -0,0 +1,41 @@ +name: Cleanup cache + +# Deletes the caches of a pull request once it is closed, which GitHub keeps +# until they expire and then evicts the ones of main first: the ones of its +# merge ref, and the ones of its branch, which the checks started with +# workflow_dispatch on the branches of the automated workflows leave. A pull +# request of a fork has a read-only token, which cannot delete them. +on: + pull_request: + types: + - closed + +permissions: + actions: write + +jobs: + cleanup-cache: + name: cleanup cache + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + env: + GH_REPO: ${{ github.repository }} + GH_TOKEN: ${{ github.token }} + + steps: + - name: Cleanup cache + run: |- + refs=("refs/pull/${NUMBER}/merge") + if [[ ${BRANCH} != "${DEFAULT_BRANCH}" ]]; then + refs+=("refs/heads/${BRANCH}") + fi + for ref in "${refs[@]}"; do + gh cache list --ref "${ref}" --limit 100 --json id --jq '.[].id' | xargs -n1 -r -t gh cache delete + done + continue-on-error: true + env: + BRANCH: ${{ github.event.pull_request.head.ref }} + DEFAULT_BRANCH: ${{ github.event.repository.default_branch }} + NUMBER: ${{ github.event.pull_request.number }} diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml new file mode 100644 index 0000000..bdf0cdf --- /dev/null +++ b/.github/workflows/docs.yaml @@ -0,0 +1,60 @@ +name: Docs + +# Builds the documentation with Sphinx of the group docs and the environment of +# uv.lock, as Read the Docs does, from the pages of docs, the docstrings of the +# module and the examples that the pages include: a warning of Sphinx, as a +# reference that is not found or a docstring that is not valid +# reStructuredText, fails the build. +on: + push: + branches: + - main + paths: + - .github/workflows/docs.yaml + - .readthedocs.yaml + - docs/** + - examples/** + - Pyjo/** + - mise.lock + - mise.toml + - pyproject.toml + - uv.lock + pull_request: + branches: + - "*" + paths: + - .github/workflows/docs.yaml + - .readthedocs.yaml + - docs/** + - examples/** + - Pyjo/** + - mise.lock + - mise.toml + - pyproject.toml + - uv.lock + workflow_dispatch: {} + +permissions: + contents: read + +jobs: + build: + name: build + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up mise + uses: jdx/mise-action@v5 + with: + version: 2026.10.25 # datasource=github-releases depName=jdx/mise + + # --keep-going reports all the warnings, which -W turns into errors. + - name: Build documentation + run: |- + uv run --locked --group docs \ + sphinx-build -W --keep-going -b html docs docs/_build/html diff --git a/.github/workflows/mise-lock-check.yaml b/.github/workflows/mise-lock-check.yaml new file mode 100644 index 0000000..e3765de --- /dev/null +++ b/.github/workflows/mise-lock-check.yaml @@ -0,0 +1,78 @@ +name: Mise Lock Check + +on: + pull_request: + branches: + - main + paths: + - mise.lock + - mise.toml + +permissions: + contents: read + +jobs: + check: + name: Check mise.lock + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + steps: + - name: Checkout + uses: actions/checkout@v7 + with: + fetch-depth: 0 + + # mise-action adds --locked on its own when a lockfile is present, so + # this downloads every tool and verifies it against the recorded + # checksums. It covers the runner platform only; the check below covers + # the rest. It also puts the pinned Python on PATH for that check. + - name: Install tools from mise.lock + uses: jdx/mise-action@v5 + with: + version: 2026.10.25 # datasource=github-releases depName=jdx/mise + + # Lock file maintenance PRs are automerged and nobody reads their diff, + # so the one thing a human could have spotted there is checked here: a + # checksum that changed while its URL did not, which means the artifact + # behind an already pinned URL was replaced. The comparison is keyed on + # tool + version + platform + URL, so adding a platform, relocking after a + # version bump, or a new build of the same version under a new URL, as + # python-build-standalone publishes, is not flagged. + - name: Check for replaced artifacts + env: + BASE_SHA: ${{ github.event.pull_request.base.sha }} + run: |- + set -eo pipefail + + if ! git show "$BASE_SHA:mise.lock" > base.lock 2> /dev/null; then + echo "No mise.lock on the base commit, nothing to compare." + exit 0 + fi + + python - base.lock mise.lock << 'EOF' + import sys, tomllib + + def flatten(path): + with open(path, "rb") as f: + lock = tomllib.load(f) + return { + (tool, entry["version"], key.removeprefix("platforms."), value.get("url")): value.get("checksum") + for tool, entries in lock.get("tools", {}).items() + for entry in entries + for key, value in entry.items() + if key.startswith("platforms.") + } + + base, head = flatten(sys.argv[1]), flatten(sys.argv[2]) + replaced = [(k, base[k], v) for k, v in head.items() if k in base and base[k] != v] + + for (tool, version, platform, url), was, now in replaced: + print(f" {tool} {version} ({platform})\n url: {url}\n was: {was}\n now: {now}") + + if replaced: + sys.exit("Checksum changed without a URL change - the artifact behind a pinned URL was replaced.") + + print("No checksum changed for an unchanged URL.") + EOF diff --git a/.github/workflows/pypi.yaml b/.github/workflows/pypi.yaml new file mode 100644 index 0000000..4ed8d78 --- /dev/null +++ b/.github/workflows/pypi.yaml @@ -0,0 +1,58 @@ +name: PyPI + +# Publishes on PyPI the sdist and the wheel of a published GitHub release, the +# latest one or the one of the tag of the input, once their attestations of +# Release verify, so that the files on PyPI are the ones of the release. The +# trusted publisher of PyPI names this file and the environment publishing. +on: + workflow_dispatch: + inputs: + tag: + description: The tag of the release, the latest release when empty + required: false + default: "" + +permissions: + contents: read + +jobs: + pypi: + name: pypi + + # The image of the action of PyPI has no build for ARM. + runs-on: ubuntu-26.04 + environment: publishing + timeout-minutes: 10 + + permissions: + attestations: read + contents: read + id-token: write + + env: + GH_REPO: ${{ github.repository }} + GH_TOKEN: ${{ github.token }} + TAG: ${{ inputs.tag }} + + steps: + # gh release view without a tag is the latest release, which is never a + # draft or a prerelease. + - name: Download release + run: | + read -r tag draft < <(gh release view ${TAG:+"${TAG}"} --json tagName,isDraft --jq '"\(.tagName) \(.isDraft)"') + test "${draft}" = false + echo "TAG=${tag}" >> "${GITHUB_ENV}" + gh release download "${tag}" --pattern '*.whl' --pattern '*.tar.gz' --dir dist + + - name: Verify attestations + run: | + for file in dist/*; do + gh attestation verify "${file}" \ + --repo "${GH_REPO}" \ + --signer-workflow "${GH_REPO}/.github/workflows/release.yaml" \ + --source-ref "refs/tags/${TAG}" + done + + # Trusted publishing, with the attestations of PEP 740 of each file. + - name: Publish on PyPI + uses: pypa/gh-action-pypi-publish@v1.14.3 diff --git a/.github/workflows/release.yaml b/.github/workflows/release.yaml new file mode 100644 index 0000000..83a25b8 --- /dev/null +++ b/.github/workflows/release.yaml @@ -0,0 +1,121 @@ +name: Release + +# Makes the draft of the GitHub release of a tag, pushed or created by +# Automated tag, which starts it with workflow_dispatch, as a tag of the token +# of a workflow starts no workflow. Its notes are written before it is +# published, and PyPI publishes its files after it. +on: + push: + tags: + - "[0-9]+.[0-9]+.[0-9]+*" + workflow_dispatch: {} + +permissions: + contents: read + +jobs: + build: + name: build + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + permissions: + attestations: write + contents: read + id-token: write + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up mise + uses: jdx/mise-action@v5 + with: + version: 2026.10.25 # datasource=github-releases depName=jdx/mise + + - name: Check the version + run: | + uv lock --check + test "${GITHUB_REF_TYPE}" = tag + test "${GITHUB_REF_NAME}" = "$(uv version --short)" + + - name: Build sdist and wheel + run: uv build + + - name: Set up Syft + id: syft + uses: anchore/sbom-action/download-syft@v0 + + # What an installation of the wheel gets: the distribution and its + # dependencies at the versions of uv.lock, without its dependency groups, + # which syft would take from uv.lock itself, installed in a virtual + # environment of their own. + - name: Create SBOM + run: | + uv export --frozen --no-default-groups --no-emit-project --no-hashes -o "${RUNNER_TEMP}/requirements.txt" + uv venv "${RUNNER_TEMP}/sbom" + uv pip install --python "${RUNNER_TEMP}/sbom/bin/python" -r "${RUNNER_TEMP}/requirements.txt" + uv pip install --python "${RUNNER_TEMP}/sbom/bin/python" --no-deps dist/*.whl + "${SYFT}" scan "dir:${RUNNER_TEMP}/sbom" \ + --override-default-catalogers python-installed-package-cataloger \ + --source-name pyjo-reactor-winloop \ + --source-version "${GITHUB_REF_NAME}" \ + --output "spdx-json=pyjo-reactor-winloop-${GITHUB_REF_NAME}.spdx.json" + env: + SYFT: ${{ steps.syft.outputs.cmd }} + + - name: Attest build provenance + uses: actions/attest@v4 + with: + subject-path: |- + dist/* + pyjo-reactor-winloop-*.spdx.json + + - name: Attest SBOM + uses: actions/attest@v4 + with: + subject-path: dist/* + sbom-path: pyjo-reactor-winloop-${{ github.ref_name }}.spdx.json + + - name: Upload artifacts + uses: actions/upload-artifact@v7 + with: + name: release + path: |- + dist/ + pyjo-reactor-winloop-*.spdx.json + if-no-files-found: error + + release: + name: release + + needs: build + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + permissions: + contents: write + + steps: + - name: Download artifacts + uses: actions/download-artifact@v8 + with: + name: release + + - name: Create draft release + run: | + prerelease=() + if [[ ${GITHUB_REF_NAME} =~ (a|b|rc)[0-9]+$ ]]; then + prerelease=(--prerelease) + fi + gh release create "${GITHUB_REF_NAME}" dist/* pyjo-reactor-winloop-*.spdx.json \ + --draft \ + --verify-tag \ + --generate-notes \ + --title "${GITHUB_REF_NAME}" \ + "${prerelease[@]}" + env: + GH_REPO: ${{ github.repository }} + GH_TOKEN: ${{ github.token }} diff --git a/.github/workflows/tag.yaml b/.github/workflows/tag.yaml new file mode 100644 index 0000000..a32c9dd --- /dev/null +++ b/.github/workflows/tag.yaml @@ -0,0 +1,53 @@ +name: Automated tag + +# Tags the merge commit of the pull request of Automated version with the +# version of its pyproject.toml, when it is merged or with a comment /tag of a +# maintainer on it, and starts Release on the tag with workflow_dispatch, as a +# tag of the token of the workflow starts no workflow. A development version is +# not tagged. +on: + issue_comment: + types: + - created + pull_request: + branches: + - main + types: + - closed + +permissions: + actions: write + contents: write + pull-requests: read + +jobs: + tag: + name: tag + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + if: (github.event.issue.pull_request && startsWith(github.event.issue.title, 'Automated version') + && github.event.comment.body == '/tag' && contains(fromJSON('["OWNER", "MEMBER", "COLLABORATOR"]'), + github.event.comment.author_association)) || (startsWith(github.event.pull_request.title, 'Automated + version') && github.event.pull_request.merged) + + env: + GH_REPO: ${{ github.repository }} + GH_TOKEN: ${{ github.token }} + + steps: + - name: Create tag + run: | + sha=$(gh pr view "${NUMBER}" --json mergeCommit --jq .mergeCommit.oid) + test -n "${sha}" + version=$(gh api "repos/${GH_REPO}/contents/pyproject.toml?ref=${sha}" --jq .content | base64 -d | + python3 -c 'import sys, tomllib; print(tomllib.load(sys.stdin.buffer)["project"]["version"])') + if ! [[ ${version} =~ ^[0-9]+\.[0-9]+\.[0-9]+((a|b|rc)[0-9]+)?(\.post[0-9]+)?$ ]]; then + echo "Version ${version} is not a release" + exit + fi + gh api "repos/${GH_REPO}/git/refs" -f ref="refs/tags/${version}" -f sha="${sha}" + gh workflow run release.yaml --ref "${version}" + env: + NUMBER: ${{ github.event.pull_request.number || github.event.issue.number }} diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml new file mode 100644 index 0000000..097424f --- /dev/null +++ b/.github/workflows/tests.yaml @@ -0,0 +1,244 @@ +name: Tests + +on: + push: + branches: + - main + pull_request: + branches: + - "*" + workflow_dispatch: + inputs: + pyjoyment-ref: + description: The branch, tag or commit of Pyjoyment to test against, or the release of uv.lock + required: false + +permissions: + contents: read + +jobs: + # The Pyjoyment to test against: the release of uv.lock, with which the + # reactor is installed, and its tag, whose suite the job prove runs on the + # reactor, or its commit when uv.lock has it from Git until a release; or + # the ref of a dispatch, whose checkout is laid over the release with + # `--with-editable`, so that the checkout is what is tested. + pyjoyment: + name: pyjoyment + + runs-on: ubuntu-26.04-arm + timeout-minutes: 5 + + outputs: + ref: ${{ steps.resolve.outputs.ref }} + editable: ${{ steps.resolve.outputs.editable }} + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Resolve the ref of Pyjoyment + id: resolve + shell: bash + env: + REF: ${{ inputs.pyjoyment-ref }} + run: |- + if [ -n "$REF" ]; then + echo "ref=$REF" >> "$GITHUB_OUTPUT" + echo "editable=../Pyjoyment" >> "$GITHUB_OUTPUT" + else + python3 -c 'import tomllib; p = next(p for p in tomllib.load(open("uv.lock", "rb"))["package"] if p["name"] == "pyjoyment"); print("ref=" + (p["source"]["git"].rpartition("#")[2] if "git" in p["source"] else p["version"]))' >> "$GITHUB_OUTPUT" + fi + + # The whole suite of Pyjoyment on this reactor, as a reactor has to pass all + # of it, and the test of the reactor itself, on Windows, + # the one system that Winloop has wheels for. + prove: + name: prove (python ${{ matrix.python }}) + needs: pyjoyment + + strategy: + fail-fast: false + matrix: + python: + - "3.12" + - "3.13" + - "3.14" + - "3.15" + - 3.15t + + runs-on: windows-2025 + timeout-minutes: 15 + + steps: + - name: Checkout + uses: actions/checkout@v7 + with: + path: Pyjo-Reactor-Winloop + + - name: Checkout Pyjoyment + uses: actions/checkout@v7 + with: + repository: pyjoyment/Pyjoyment + ref: ${{ needs.pyjoyment.outputs.ref }} + path: Pyjoyment + + - name: Set up Python + uses: actions/setup-python@v7 + with: + python-version: ${{ matrix.python }} + allow-prereleases: true + + - name: Set up uv + uses: astral-sh/setup-uv@v10.3.3 + with: + version: 0.13.6 # datasource=github-releases depName=astral-sh/uv + + - name: Install + working-directory: Pyjo-Reactor-Winloop + shell: bash + run: uv sync --python "$(command -v python)" + + # As in Pyjoyment: invalid escape sequences and deprecated APIs fail, and + # the ResourceWarning of the development mode of Python, which only goes + # to the standard error, is checked in the output. + - name: Run the tests of the reactor + working-directory: Pyjo-Reactor-Winloop + shell: bash + env: + PYTHONDEVMODE: "1" + PYTHONWARNINGS: error::SyntaxWarning,error::DeprecationWarning + PYJOYMENT: ${{ needs.pyjoyment.outputs.editable }} + run: | + mkdir -p "$GITHUB_WORKSPACE/junit" + uv run ${PYJOYMENT:+--with-editable "$PYJOYMENT"} python -m Pyjo.Prove -l --color --timeout 60 --capture-stderr --formatter "junit=$GITHUB_WORKSPACE/junit/pyjo-reactor-winloop.xml" --formatter "markdown=$GITHUB_STEP_SUMMARY" -r t 2>&1 | tee prove.log + if grep -n 'ResourceWarning:' prove.log; then exit 1; fi + + # As in Pyjoyment: the debug mode of asyncio of PYTHONDEVMODE logs a + # callback of more than 0.1 seconds, which TLS and the applications of the + # tests take on a busy runner, so the loops log only one of more than 5 + # seconds, with PYJO_ASYNCIO_SLOW_CALLBACK. + - name: Run the tests of Pyjoyment on the reactor + working-directory: Pyjoyment + shell: bash + env: + PYJO_REACTOR: Pyjo.Reactor.Winloop + PYTHONDEVMODE: "1" + PYJO_ASYNCIO_SLOW_CALLBACK: "5" + PYTHONWARNINGS: error::SyntaxWarning,error::DeprecationWarning + TEST_ONLINE: "1" + run: |- + uv run --project ../Pyjo-Reactor-Winloop --with-editable . python -m Pyjo.Prove -l --color -j 4 --timeout 120 --capture-stderr --stderr-lines 1000 --formatter "junit=$GITHUB_WORKSPACE/junit/pyjoyment.xml" --formatter "markdown=$GITHUB_STEP_SUMMARY" -r t 2>&1 | tee prove.log + if grep -n 'ResourceWarning:' prove.log; then exit 1; fi + + # As in Pyjoyment: the JUnit XML of the harness, of the tests of the + # reactor and of Pyjoyment, as the annotations of the failed tests, + # without a check of its own, and without the summary of the job, which + # the harness writes itself with its formatter markdown + - name: Publish the report of the tests + if: ${{ !cancelled() }} + uses: mikepenz/action-junit-report@v6 + with: + report_paths: junit/*.xml + annotate_only: true + job_summary: false + include_skipped: false + + # The JUnit XML for the summary of the summaries of all the jobs, which + # the job report makes, both files in one directory, as its script reads + # the files of the directory of each job only + - name: Upload the report of the tests + if: ${{ !cancelled() }} + uses: actions/upload-artifact@v7 + with: + name: junit-prove (python ${{ matrix.python }}) + path: junit/*.xml + if-no-files-found: ignore + retention-days: 7 + + # The summary of the summaries of the jobs of the tests, from the JUnit XML + # that they upload, as the summary of this job and as a comment of the pull + # request, which each run edits, as in Pyjoyment, with the script of its + # checkout of main, which needs Pyjo.DOM. A pull request of a fork has a + # token that cannot comment. + report: + name: report + needs: + - prove + if: ${{ !cancelled() }} + runs-on: ubuntu-26.04-arm + timeout-minutes: 5 + permissions: + actions: read + contents: read + pull-requests: write + + steps: + - name: Checkout Pyjoyment + uses: actions/checkout@v7 + with: + repository: pyjoyment/Pyjoyment + ref: main + path: Pyjoyment + + - name: Set up Python + uses: actions/setup-python@v7 + with: + python-version: 3.15.2 + allow-prereleases: true + + - name: Download the reports of the tests + uses: actions/download-artifact@v8 + with: + pattern: junit-* + path: reports + + # The names and the URLs of the jobs of the run, of its latest attempt, + # which link the jobs of the summary + - name: Summary of the reports + shell: bash + env: + GH_TOKEN: ${{ github.token }} + PYTHONPATH: Pyjoyment + run: |- + gh api --paginate "repos/$GITHUB_REPOSITORY/actions/runs/$GITHUB_RUN_ID/jobs" --jq '.jobs[] | [.name, .html_url] | @tsv' > jobs.tsv + python Pyjoyment/.github/scripts/test-report.py reports jobs.tsv > report.md + cat report.md >> "$GITHUB_STEP_SUMMARY" + + # The comment that starts with the marker of the report, edited, or a new one + - name: Comment on the pull request + if: ${{ github.event_name == 'pull_request' && github.event.pull_request.head.repo.full_name == + github.repository }} + shell: bash + env: + GH_TOKEN: ${{ github.token }} + PR: ${{ github.event.pull_request.number }} + run: |- + id="$(gh api --paginate "repos/$GITHUB_REPOSITORY/issues/$PR/comments" --jq '.[] | select(.body | startswith("")) | .id' | head -n 1)" + if [ -n "$id" ]; then + gh api --method PATCH "repos/$GITHUB_REPOSITORY/issues/comments/$id" -F body=@report.md > /dev/null + else + gh api --method POST "repos/$GITHUB_REPOSITORY/issues/$PR/comments" -F body=@report.md > /dev/null + fi + + # The one check that the ruleset of main requires, whatever the matrix has, + # as in Pyjoyment: it fails when a job failed or was cancelled, so a new + # version of Python needs no change of the ruleset. + tests: + name: Tests + needs: + - pyjoyment + - prove + if: always() + runs-on: ubuntu-26.04-arm + timeout-minutes: 5 + + steps: + - name: Check the results of the jobs + shell: bash + env: + RESULTS: ${{ join(needs.*.result, ' ') }} + run: |- + echo "$RESULTS" + for result in $RESULTS; do + test "$result" = success + done diff --git a/.github/workflows/trunk-check.yaml b/.github/workflows/trunk-check.yaml new file mode 100644 index 0000000..d9f5544 --- /dev/null +++ b/.github/workflows/trunk-check.yaml @@ -0,0 +1,42 @@ +name: Trunk Check + +on: + push: + branches: + - main + pull_request: + branches: + - "*" + workflow_dispatch: {} + +permissions: + contents: read + +jobs: + trunk: + name: Trunk Check + + runs-on: ubuntu-26.04-arm + timeout-minutes: 15 + + env: + DO_NOT_TRACK: "1" + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up mise + uses: jdx/mise-action@v5 + with: + version: 2026.10.25 # datasource=github-releases depName=jdx/mise + + # The environment of uv sync, with Pyjoyment and Winloop, for pyright, + # as tool.pyright of pyproject.toml says. + - name: Install + run: uv sync + + - name: Trunk Check + uses: trunk-io/trunk-action@v2.0.0 + with: + check-mode: all diff --git a/.github/workflows/trunk-upgrade.yaml b/.github/workflows/trunk-upgrade.yaml new file mode 100644 index 0000000..7887ab5 --- /dev/null +++ b/.github/workflows/trunk-upgrade.yaml @@ -0,0 +1,101 @@ +name: Automated trunk upgrade + +# Runs trunk upgrade every day and keeps the changes in the pull request of +# the branch automated/trunk-upgrade, which a comment /rerun on it runs again. +# It works with the token of the workflow: a push and a pull request of that +# token start no workflow, so the job starts Tests and Trunk Check on the +# branch with workflow_dispatch. +on: + issue_comment: + types: + - created + push: + branches: + - main + paths: + - .trunk/** + schedule: + - cron: 2 6 * * * + workflow_dispatch: {} + +permissions: + actions: write + contents: write + issues: write + pull-requests: write + +jobs: + trunk-upgrade: + name: trunk upgrade + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + if: github.event_name != 'issue_comment' || (startsWith(github.event.issue.title, 'Automated trunk + upgrade') && contains(github.event.comment.body, '/rerun')) + + env: + BRANCH: automated/trunk-upgrade + DO_NOT_TRACK: "1" + GH_TOKEN: ${{ github.token }} + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up Trunk + run: curl https://get.trunk.io -fsSL | bash -s -- -y + + - name: Trunk upgrade + run: | + set -o pipefail + trunk upgrade --yes-to-all --no-progress --ci --color | tee .github/update.log + sed -e '/Downloading Trunk/,/Unpacking Trunk... done/d' -e 's/\x1b\[[0-9;]*m//g' -e 's/^\( \)\{0,1\} /\1- /' .github/update.log > .github/pr_body.log + perl -0777 -ne 'print join ", ", map {s/://gr} map {s/^- //r} grep {/^(-|cli) /} split "\n"' .github/pr_body.log > .github/pr_title.log + + - name: Check for changes + run: | + if git diff --exit-code; then + echo "changes=false" >> "${GITHUB_ENV}" + else + echo "changes=true" >> "${GITHUB_ENV}" + fi + + - name: Commit and push to branch + if: env.changes == 'true' + run: | + git add --all -- . ':!.github/*.log' + git -c user.name='github-actions[bot]' \ + -c user.email='41898282+github-actions[bot]@users.noreply.github.com' \ + commit -m 'Automated trunk upgrade' + git push --force origin "HEAD:refs/heads/${BRANCH}" + + - name: Create pull request + if: env.changes == 'true' + run: | + gh label create automated --color ededed --force + gh label create trunk --color ededed --force + title="Automated trunk upgrade $(cat .github/pr_title.log)" + if [[ $(gh pr view "${BRANCH}" --json state --jq .state || true) != "OPEN" ]]; then + gh pr create \ + --base main \ + --head "${BRANCH}" \ + --title "${title}" \ + --body-file .github/pr_body.log \ + --label automated \ + --label trunk + else + gh pr edit "${BRANCH}" \ + --title "${title}" \ + --body-file .github/pr_body.log + fi + + - name: Run the checks of the commit + if: env.changes == 'true' + run: |- + gh workflow run tests.yaml --ref "${BRANCH}" + gh workflow run trunk-check.yaml --ref "${BRANCH}" + + - name: Close pull request + if: env.changes == 'false' + run: gh pr list --head "${BRANCH}" --json number --jq '.[].number' | xargs -rn1 gh pr close --delete-branch diff --git a/.github/workflows/version.yaml b/.github/workflows/version.yaml new file mode 100644 index 0000000..a10995c --- /dev/null +++ b/.github/workflows/version.yaml @@ -0,0 +1,123 @@ +name: Automated version + +# Sets the version of pyproject.toml and uv.lock with uv version and keeps it +# in the pull request of the branch automated/version, whose merge Automated +# tag tags. It works with the token of the workflow, so the job starts the +# checks on the branch with workflow_dispatch, as Automated trunk upgrade does. +on: + workflow_dispatch: + inputs: + bump: + description: The components of uv version --bump. After a release major, minor, patch, post, or the next + version with a pre-release, as "patch dev"; after a development version or a pre-release also stable, or + the same or a later pre-release alone, as rc after alpha; manual takes the version below + type: choice + options: + - patch + - minor + - major + - post + - stable + - dev + - alpha + - beta + - rc + - patch dev + - minor dev + - major dev + - patch alpha + - minor alpha + - major alpha + - patch beta + - minor beta + - major beta + - patch rc + - minor rc + - major rc + - manual + default: patch + version: + description: The version of the bump manual, as "1.0.0" + required: false + +permissions: + actions: write + contents: write + issues: write + pull-requests: write + +jobs: + version: + name: version + + runs-on: ubuntu-26.04-arm + timeout-minutes: 10 + + env: + BRANCH: automated/version + GH_TOKEN: ${{ github.token }} + + steps: + - name: Checkout + uses: actions/checkout@v7 + + - name: Set up mise + uses: jdx/mise-action@v5 + with: + version: 2026.10.25 # datasource=github-releases depName=jdx/mise + + - name: Set version + run: | + set -o pipefail + args=() + if [[ ${BUMP} == manual ]]; then + if [[ -z ${VERSION} ]]; then + echo "::error::The bump manual needs a version" >&2 + exit 1 + fi + args=("${VERSION}") + else + for bump in ${BUMP}; do + args+=(--bump "${bump}") + done + fi + uv version --no-sync "${args[@]}" | tee "${RUNNER_TEMP}/pr_body.log" + uv version --short > "${RUNNER_TEMP}/version.log" + env: + BUMP: ${{ inputs.bump }} + VERSION: ${{ inputs.version }} + + - name: Commit and push to branch + run: | + git diff --exit-code && exit + git add pyproject.toml uv.lock + git -c user.name='github-actions[bot]' \ + -c user.email='41898282+github-actions[bot]@users.noreply.github.com' \ + commit -m "Automated version $(cat "${RUNNER_TEMP}/version.log")" + git push --force origin "HEAD:refs/heads/${BRANCH}" + echo "changes=true" >> "${GITHUB_ENV}" + + - name: Create pull request + if: env.changes == 'true' + run: | + gh label create automated --color ededed --force + title="Automated version $(cat "${RUNNER_TEMP}/version.log")" + if [[ $(gh pr view "${BRANCH}" --json state --jq .state || true) != "OPEN" ]]; then + gh pr create \ + --base main \ + --head "${BRANCH}" \ + --title "${title}" \ + --body-file "${RUNNER_TEMP}/pr_body.log" \ + --label automated + else + gh pr edit "${BRANCH}" \ + --title "${title}" \ + --body-file "${RUNNER_TEMP}/pr_body.log" + fi + + - name: Run the checks of the commit + if: env.changes == 'true' + run: |- + gh workflow run build.yaml --ref "${BRANCH}" + gh workflow run tests.yaml --ref "${BRANCH}" + gh workflow run trunk-check.yaml --ref "${BRANCH}" diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8ca567c --- /dev/null +++ b/.gitignore @@ -0,0 +1,17 @@ +# Python +__pycache__/ +*.py[cod] +*.egg-info/ +/build/ +/dist/ +/docs/_build/ + +# Virtual environments of uv +.venv +.venv-* + +# Caches of the tools +.ruff_cache/ + +# macOS +.DS_Store diff --git a/.proverc b/.proverc new file mode 100644 index 0000000..3edad36 --- /dev/null +++ b/.proverc @@ -0,0 +1,2 @@ +--ext=py +--exec=python diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000..8e97826 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,29 @@ +# Read the Docs configuration: https://docs.readthedocs.com/platform/stable/config-file/v2.html +version: 2 + +build: + os: ubuntu-26.04 + tools: + python: "3.14" + jobs: + # A pull request of Renovate is cancelled, which Read the Docs reports to + # GitHub as passed, as the workflow Docs builds it already. Read the Docs + # knows the number of a pull request, not its branch, so the author of the + # last commit tells it. + post_checkout: + - | + if [ "$READTHEDOCS_VERSION_TYPE" = "external" ] && git log -1 --format=%ae | grep -q "renovate\\[bot\\]"; then + exit 183 + fi + +sphinx: + configuration: docs/conf.py + +# uv sync of uv.lock, with the Pyjoyment and the Winloop that autodoc imports and the Sphinx of the group docs, so that +# Read the Docs builds with the versions that the workflow Docs builds with +python: + install: + - method: uv + command: sync + groups: + - docs diff --git a/.renovaterc.json b/.renovaterc.json new file mode 100644 index 0000000..ca9fdb7 --- /dev/null +++ b/.renovaterc.json @@ -0,0 +1,56 @@ +{ + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "description": [ + "rangeStrategy: always bump dependencies, even when the new version is already in the range.", + "rebaseWhen: rebase only on conflicts, to save unnecessary workflow runs.", + "gitIgnoredAuthors: Biome Migrate commits the migrated biome.jsonc to Renovate branches as github-actions. Without this, Renovate would see the branch as modified by someone else and stop rebasing and updating it." + ], + "extends": ["config:recommended", ":semanticCommitsDisabled"], + "addLabels": ["renovate"], + "gitIgnoredAuthors": [ + "41898282+github-actions[bot]@users.noreply.github.com" + ], + "osvVulnerabilityAlerts": true, + "rangeStrategy": "bump", + "vulnerabilityAlerts": { + "description": "Security fixes must not be delayed by minimumReleaseAge.", + "labels": ["security"], + "minimumReleaseAge": "0 days" + }, + "rebaseWhen": "conflicted", + "minimumReleaseAge": "1 day", + "internalChecksFilter": "strict", + "lockFileMaintenance": { + "description": [ + "mise.lock pins a checksum and a URL per tool per platform, but a local `mise install` re-locks only the platform it runs on and silently leaves the others stale.", + "Lock file maintenance runs plain `mise lock`, which refreshes every tool on every platform already in the file, and `uv lock --upgrade`, which moves the dependencies of uv.lock, as Pyjoyment, to their latest releases.", + "Defaults are disabled and weekly, hence the explicit settings." + ], + "enabled": true, + "schedule": ["at any time"], + "automerge": true + }, + "packageRules": [ + { + "description": "requires-python of pyproject.toml is the lowest Python that the distribution supports, on purpose, not the Python of mise.toml, so rangeStrategy bump must not raise it.", + "matchManagers": ["pep621"], + "matchDepTypes": ["requires-python"], + "enabled": false + } + ], + "customManagers": [ + { + "description": "Renovate hints in a comment after the version.", + "customType": "regex", + "extractVersionTemplate": "^v?(?.*)$", + "managerFilePatterns": [ + "/^\\.github/workflows/.*\\.ya?ml$/", + "/^\\.trunk/trunk\\.yaml$/" + ], + "matchStrings": [ + "(\\s+|.*?@)(?\\S+?)!?\\s*#\\s*datasource=(?\\S+)\\s+depName=(?\\S+)(\\s+versioning=(?\\S+))?(\\s+registryUrl=(?\\S+))?\\s*\\n" + ], + "versioningTemplate": "{{#if versioning}}{{{versioning}}}{{else}}semver{{/if}}" + } + ] +} diff --git a/.trunk/.gitignore b/.trunk/.gitignore new file mode 100644 index 0000000..15966d0 --- /dev/null +++ b/.trunk/.gitignore @@ -0,0 +1,9 @@ +*out +*logs +*actions +*notifications +*tools +plugins +user_trunk.yaml +user.yaml +tmp diff --git a/.trunk/trunk.yaml b/.trunk/trunk.yaml new file mode 100644 index 0000000..195d1f1 --- /dev/null +++ b/.trunk/trunk.yaml @@ -0,0 +1,147 @@ +# This file controls the behavior of Trunk: https://docs.trunk.io/cli +# To learn more about the format of this file, see https://docs.trunk.io/reference/trunk-yaml +version: 0.1 +cli: + version: 1.29.0 +# Trunk provides extensibility via plugins. (https://docs.trunk.io/plugins) +plugins: + sources: + - id: trunk + ref: v1.11.0 + uri: https://github.com/trunk-io/plugins +# Many linters and tools depend on runtimes - configure them here. (https://docs.trunk.io/runtimes) +runtimes: + enabled: + - node@24.21.0 + - python@3.14.4 +# actionlint comes from the maintained fork of kjanat, which continues the +# releases of rhysd/actionlint after 1.7.12 with the same names of the files, +# where the plugin downloads them from rhysd/actionlint. +downloads: + - name: actionlint + downloads: + - os: + linux: linux + macos: darwin + cpu: + x86_64: amd64 + arm_64: arm64 + url: https://github.com/kjanat/actionlint/releases/download/v${version}/actionlint_${version}_${os}_${cpu}.tar.gz + - os: windows + cpu: + x86_64: amd64 + arm_64: arm64 + url: https://github.com/kjanat/actionlint/releases/download/v${version}/actionlint_${version}_windows_${cpu}.zip +# This is the section where you manage your linters. (https://docs.trunk.io/check/configuration) +lint: + definitions: + # Biome formats and lints CSS, HTML, JavaScript, JSON, Markdown and YAML, + # with biome.jsonc. parse_regex is matched against the whole output of a + # batch, so `^` needs `(?m)` to match at every line; without it Trunk + # reports only the first issue that Biome prints. Trunk runs Biome on a copy + # of the files in a sandbox outside the repository, with a copy of + # biome.jsonc of direct_configs, not --config-path of the one of the + # repository, as Biome takes the options of its parser, as the front matter + # of Markdown, only for the files under the directory of its + # configuration. The sandbox has no .gitignore, which vcs.useIgnoreFile + # reads, so the commands turn it off, as Trunk applies .gitignore itself, + # and --no-errors-on-unmatched passes a file that biome.jsonc leaves out. + - name: biome + direct_configs: + - biome.jsonc + files: + - css + - html + - javascript + - json + - markdown + - yaml + commands: + - output: regex + success_codes: + - 0 + - 1 + batch: true + cache_results: false + name: lint + parse_regex: (?m)^::(?P.*) title=(?P[^,]+),file=(?P[^,]+),line=(?P[^,]+),endLine=[^,]+,col=(?P[^,]+),endColumn=[^:]+::(?P.*) + read_output_from: stdout + run: biome check --vcs-use-ignore-file=false --reporter=github --no-errors-on-unmatched ${target} + run_from: ${root_or_parent_with(biome.jsonc)} + - output: regex + success_codes: + - 0 + batch: true + cache_results: false + formatter: true + name: fmt + parse_regex: (?m)^::(?P.*) title=(?P[^,]+),file=(?P[^,]+),line=(?P[^,]+),endLine=[^,]+,col=(?P[^,]+),endColumn=[^:]+::(?P.*) + read_output_from: stdout + run: biome format --vcs-use-ignore-file=false --reporter=github --write --no-errors-on-unmatched ${target} + run_from: ${root_or_parent_with(biome.jsonc)} + run_timeout: 1m + enabled: + - actionlint@1.17.0 + # Renovate bumps it, and Biome Migrate migrates biome.jsonc on its branch; + # the ! keeps it from trunk upgrade + - biome@2.6.4! # datasource=npm depName=@biomejs/biome + - git-diff-check + - pyright@1.1.414 + # The format command of ruff is disabled in the plugin by default + - ruff@0.17.3: + commands: + - lint + - format + - taplo@0.10.0 + # yamllint checks what Biome does not, as the duplicated keys and the + # values that YAML 1.1 reads otherwise + - yamllint@1.38.0 + disabled: + # bandit: security checks for Python code; not used here + - bandit + # black: Python formatter; ruff formats the code + - black + # checkov: scanner for infrastructure as code; there is none here + - checkov + # isort: sorts Python imports; ruff sorts them (rule I) + - isort + # markdownlint: lints Markdown; Biome formats it and has its rules that are + # not about formatting + - markdownlint + # pinact: pins GitHub Actions to commit hashes; the actions are pinned by + # their tags, as in Pyjoyment + - pinact + # prettier: formats CSS, HTML, JavaScript, JSON, Markdown and YAML; Biome + # formats them + - prettier + # renovate: validates the Renovate configuration; Renovate validates it + # itself on every run, and the linter is a heavy npm package + - renovate + # trivy: scanner for containers, infrastructure as code and dependencies; + # nothing to scan here + - trivy + # trufflehog: secret scanner; not needed here + - trufflehog + # yamlfmt: formats YAML; Biome formats it + - yamlfmt + ignore: + # Rewritten by trunk upgrade + - linters: + - biome + paths: + - .trunk/trunk.yaml + # Examples, tests and docs/conf.py, outside the package: pyright takes + # the regular package Pyjo of Pyjoyment for them, which hides + # Pyjo.Reactor.Winloop of the checkout; the module itself is checked, strictly + - linters: + - pyright + paths: + - docs/** + - examples/** + - t/** +actions: + enabled: + - trunk-announce + - trunk-check-pre-push + - trunk-fmt-pre-commit + - trunk-upgrade-available diff --git a/.yamllint.yaml b/.yamllint.yaml new file mode 100644 index 0000000..184e251 --- /dev/null +++ b/.yamllint.yaml @@ -0,0 +1,7 @@ +rules: + quoted-strings: + required: only-when-needed + extra-allowed: ["{|}"] + key-duplicates: {} + octal-values: + forbid-implicit-octal: true diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..7dc7478 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,180 @@ +# Agent Guide: Pyjo-Reactor-Winloop + +## Overview + +`Pyjo.Reactor.Winloop` is a reactor of Pyjoyment on the event loop of +Winloop, the fork of uvloop for Windows, in a distribution of its own, as +every reactor of Pyjoyment with a dependency is: Pyjoyment has no runtime +dependencies, and one reactor does not pull the dependencies of another. The +conventions are those of Pyjoyment: read its `AGENTS.md` in the checkout next +to this one, `../Pyjoyment/AGENTS.md`. The repository is made of the one of +Pyjo-Reactor-Uvloop, whose workflows and linters it shares, and whose +`AGENTS.md`, in `../Pyjo-Reactor-Uvloop`, says what the loop of uvloop needed. + +## How it works + +The reactor is not implemented yet: the module is the stub of the template, +whose constructor raises `NotImplementedError`, so that nothing falls back to +the loop of asyncio in the meantime. What it is to be: + +- `Pyjo.Reactor.Uvloop` for Winloop: a subclass of `Pyjo.Reactor.Asyncio` + that overrides `_own_loop` with a loop of Winloop, `winloop.Loop` or a + subclass of it, in the place of `asyncio.new_event_loop()`. +- `_Loop` of `Pyjo.Reactor.Uvloop` works around the libuv and the uvloop that + Winloop has too: the wakeup fd of the signals, the hook of the finalizer of + an async generator in the debug mode, the poll after `stop`, the blocking + mode of a handle and the error of a handle. Each of them is to be checked on + Winloop, which is libuv on Windows, with its IOCP, and taken, changed or + left out, as found, and written down here; the fork and `POLLERR` of Linux + do not apply. +- What the reactor is for is the servers of Pyjoyment, `daemon` and + `prethread`, as Windows has no fork for `prefork`, and its blocking user + agent, where no loop runs and the reactor makes one. +- Winloop has wheels for CPython on Windows only, with the free-threaded + build, not for PyPy, so the matrix of Tests is CPython 3.12 to 3.15 and + 3.15t on `windows-2025`. + +## Development + +The distribution depends on the release of Pyjoyment on PyPI, with the lowest +version that has what it uses, which `uv.lock` pins. A change of Pyjoyment that +is not released yet would be its Git repository in `[tool.uv.sources]` of +`pyproject.toml`, until its release, and not a path to the checkout next to +this one: uv applies the sources of a dependency of Git, so whoever installs +the reactor from Git would get a subdirectory of this repository that does not +exist. That is the Pyjoyment of `main` now, for its tests that recognize a +subclass of `Pyjo.Reactor.Asyncio`, pyjoyment/Pyjoyment#510: before a release +of the reactor, the source goes and the lowest version of `dependencies` +becomes the release of Pyjoyment that has it, as a wheel carries no sources of +uv and would install Pyjoyment 0.2.0. +The tests lay the checkout next to this one over it with `--with-editable`, +so that they test what is there: +Winloop is installed on Windows only, `sys_platform == 'win32'` of +`dependencies`, as it has wheels for Windows only, so the tests run on Windows, +and CI runs them on `windows-2025`; on Linux and macOS, where Trunk and Read +the Docs run, the environment has no Winloop. + + +```sh +mise exec -- uv sync +mise exec -- uv run --with-editable ../Pyjoyment python -m Pyjo.Prove -l -r t +``` + +Perl's `prove` runs them too, with `.proverc`, under `uv run`, whose `python` +is the one of the environment, where Pyjoyment and the reactor are installed, +so that it needs no `PYTHONPATH`, unlike in Pyjoyment: + +```sh +mise exec -- uv run --with-editable ../Pyjoyment prove -r t +``` + +The tests of Pyjoyment run on this reactor as well, with `PYJO_REACTOR`: + +```sh +cd ../Pyjoyment +PYJO_REACTOR=Pyjo.Reactor.Winloop mise exec -- uv run --project ../Pyjo-Reactor-Winloop --with-editable . \ + python -m Pyjo.Prove -l -j 4 -r t +``` + +The workflow Tests runs the tests of the reactor against the release of +`uv.lock`, without `--with-editable`, so that a pull request tests what an +installation gets, and the suite of Pyjoyment of the tag of that release on +the reactor, or of its commit when `uv.lock` has it from Git. A dispatch with +`pyjoyment-ref` lays a checkout of the ref over it, as in development, so +that what the next release of Pyjoyment breaks is known before the release. +It ends with the job `Tests`, the one check of it +that the ruleset of `main` requires, as in Pyjoyment: it fails when a job of +the matrix failed or was cancelled, so a new version of Python needs no change +of the ruleset. + +Trunk checks the files with the linters of Pyjoyment, from `.trunk/trunk.yaml`: + +```sh +trunk check --all +``` + +actionlint is the one of the maintained fork kjanat/actionlint, whose releases +continue those of rhysd/actionlint after 1.7.12, as in Pyjoyment: `downloads` +in `.trunk/trunk.yaml` replaces the URLs of the plugin with those of the fork, +whose files have the same names. + +Biome formats and lints JSON, Markdown and YAML, with `biome.jsonc`, in the +place of prettier, markdownlint and yamlfmt, as in Pyjoyment, and yamllint +checks what Biome does not, as the duplicated keys. The version of Biome is +the pinned one of `.trunk/trunk.yaml`, where `!` keeps it from +`trunk upgrade`, and which Renovate bumps: the repository has no +`package.json` of its own. Renovate cannot run `biome migrate`, so the +workflow Biome Migrate runs it with `npx --yes @biomejs/biome@` of +that version, migrates `biome.jsonc` on the branch of Renovate and commits it +with the token of the workflow, as the author that `gitIgnoredAuthors` of +`.renovaterc.json` names, so that Renovate keeps updating the branch, and +starts the checks of the commit with `workflow_dispatch`; anywhere else, a +`biome.jsonc` that this Biome would migrate fails the check. The definition of +Biome in `.trunk/trunk.yaml` is the one of Pyjoyment, which explains why it is +not the one of the plugin of Trunk. + +Its pyright needs the environment of `uv sync`, `.venv`, which `tool.pyright` of +`pyproject.toml` names, as the reactor imports Pyjoyment and Winloop, while +Pyjoyment has no dependencies to find; Trunk Check of CI runs `uv sync` first. +The examples and the tests, and `docs/conf.py`, are not checked by pyright: for them it takes the +regular package `Pyjo` of Pyjoyment, which hides `Pyjo.Reactor.Winloop` of the +checkout. + +The documentation is one page, `docs/index.rst`: the docstrings of the +module, which autodoc imports, and the examples from `examples/`, included, +never copied, as in Pyjoyment. Read the Docs installs it with `uv sync` of `uv.lock` and the +group `docs`, not with pip and a `docs/requirements.txt` as Pyjoyment does, +so that it builds with the versions of the lock, as the workflow Docs does. +The links to the modules of Pyjoyment come from intersphinx, to its stable +version from the stable one, and to latest from the others. The examples are +a rubric, not a section: they follow the docstring of the module, whose +sections are its own, so that a section would be a second title of the page. +The workflow Docs builds it with `-W`, as Read the Docs does, with the +Pyjoyment of `uv.lock`: + +```sh +mise exec -- uv run --group docs --with-editable ../Pyjoyment sphinx-build -W --keep-going -b html docs docs/_build/html +``` + +`t/Reactor_Winloop.py` is to be `t/Reactor_Uvloop.py` of Pyjo-Reactor-Uvloop, +`t/Pyjo/Reactor_Asyncio.py` of Pyjoyment with subtests of its own, for the +loop of Winloop; it is a stub of the template now. +`t/docs/Reactor_Winloop.py` runs the synopsis of the module, in both forms, as +`t/docs` of Pyjoyment does. + +## Releases + +The releases are those of Pyjoyment, with its workflows: a release is a tag of +the version of `pyproject.toml`, without a `v`, as `0.2.0`, which Automated +version sets with `uv version`, the components of its `--bump` from a list, as +`patch dev` or `minor rc`, or the version of `manual`, in the pull request of +the branch `automated/version`. After a release, a pre-release goes with the +release that it comes before, as PEP 440 orders `0.2.0.dev1` before `0.2.0`, +so `dev` alone after `0.2.0` fails. Automated tag tags the merge commit of +that pull request when it is merged, or with a comment `/tag` of a maintainer +on it, and starts Release on the tag. A development version, as `0.2.1.dev1`, +is not tagged. The version is static in `pyproject.toml`, as `uv version` +cannot set a dynamic one, and `__version__` of the module reads it from the +metadata of the distribution. + +Release builds the sdist and the wheel, attests their build provenance with +`actions/attest`, and makes a draft of the GitHub release with them, whose +notes are rewritten before it is published, and an SBOM in SPDX, attested +with them. The module bundles nothing, unlike the package of Pyjoyment, whose +SBOM lists the JavaScript libraries of its package, so the SBOM is what an +installation of the wheel gets: the distribution and its dependencies, as +Pyjoyment and Winloop, at the versions of `uv.lock`, installed in a virtual +environment of their own, which Syft scans. Syft on `uv.lock` itself would +take its dependency groups too, as Sphinx, which an installation does not get. +The sdist does not carry the SBOM, as the one of Pyjoyment does, as it is made +of the wheel, which is built after the sdist. + +The workflow PyPI, run manually, publishes the files of the latest published +release, or of the release of the tag of its input, on PyPI once their +attestations of Release verify, in the environment `publishing`, which waits +for an approval and takes `main` and tags only. The trusted publisher of PyPI +names `pypi.yaml` and that environment. + +```sh +gh attestation verify pyjo_reactor_winloop-0.2.0.tar.gz -R pyjoyment/Pyjo-Reactor-Winloop +``` diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..43c994c --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1 @@ +@AGENTS.md diff --git a/Pyjo/Reactor/Winloop.py b/Pyjo/Reactor/Winloop.py new file mode 100644 index 0000000..3595f6a --- /dev/null +++ b/Pyjo/Reactor/Winloop.py @@ -0,0 +1,97 @@ +""" +Pyjo.Reactor.Winloop - Low-level event reactor on Winloop +========================================================= +:: + + from Pyjo.Reactor.Winloop import Winloop + + # Watch if handle becomes readable or writable + reactor = Winloop() + reactor.io(first, lambda reactor, writable: print( + 'First handle is writable' if writable else 'First handle is readable' + )) + + # Or import the module, as in Google Python Style Guide + + import Pyjo.Reactor.Winloop + + # Watch if handle becomes readable or writable + reactor = Pyjo.Reactor.Winloop.new() + reactor.io(first, lambda reactor, writable: print( + 'First handle is writable' if writable else 'First handle is readable' + )) + + # Change to watching only if handle becomes writable + reactor.watch(first, False, True) + + # Watch a file descriptor if it becomes readable + reactor.io(fd, lambda reactor, writable: print( + 'Second handle is writable' if writable else 'Second handle is readable' + )).watch(fd, True, False) + + # Add a timer + def timeout(reactor): + reactor.remove(first) + reactor.remove(fd) + print('Timeout!') + + reactor.timer(15, timeout) + + # Start reactor if necessary + if not reactor.is_running: + reactor.start() + + +:mod:`Pyjo.Reactor.Winloop` is a low-level event reactor based on +`Winloop `_, the fork of uvloop for +Windows, the implementation of the event loop of :mod:`asyncio` on libuv. It +is :mod:`Pyjo.Reactor.Asyncio` with an event loop of its own of Winloop, in +the place of the one of :mod:`asyncio`, so that the servers of Pyjoyment, as +:mod:`Pyjo.Server.Daemon` and :mod:`Pyjo.Server.Prethread`, and the blocking +requests of its user agent run on Winloop on Windows. ``PYJO_REACTOR`` +selects it for :mod:`Pyjo.IOLoop`:: + + PYJO_REACTOR=Pyjo.Reactor.Winloop python myapp.py daemon + +The reactor is not implemented yet. + +Events +------ + +:mod:`Pyjo.Reactor.Winloop` inherits all events from :mod:`Pyjo.Reactor.Asyncio`. + +See also +-------- + +:mod:`Pyjo.Reactor.Asyncio`, :mod:`Pyjoyment`, https://github.com/pyjoyment/Pyjoyment. + +Classes +------- +""" + +import Pyjo.Reactor.Asyncio + +import importlib.metadata + +from typing import Any + + +__version__ = importlib.metadata.version('Pyjo-Reactor-Winloop') +"""The version of the distribution, of its metadata, which the workflow Automated version sets in pyproject.toml.""" + + +class Pyjo_Reactor_Winloop(Pyjo.Reactor.Asyncio.object): + """ + :mod:`Pyjo.Reactor.Winloop` inherits all methods from + :mod:`Pyjo.Reactor.Asyncio`. + """ + + # The template of the distribution: the reactor on Winloop is to be written, so that nothing falls back to the loop + # of asyncio in the meantime + def __init__(self, *args: Any, **kwargs: Any) -> None: + raise NotImplementedError('Pyjo.Reactor.Winloop is not implemented yet') + + +new = Pyjo_Reactor_Winloop.new +object = Pyjo_Reactor_Winloop +Winloop = Pyjo_Reactor_Winloop diff --git a/README.md b/README.md index 56d2109..7fd70a1 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,141 @@ +[![Home](https://img.shields.io/badge/%F0%9F%8F%A0-Pyjoyment-02a7a0)](https://github.com/pyjoyment/Pyjoyment) +[![GitHub](https://img.shields.io/github/stars/pyjoyment/Pyjo-Reactor-Winloop?style=flat&label=GitHub%20%E2%AD%90&logo=github)](https://github.com/pyjoyment/Pyjo-Reactor-Winloop) +[![Documentation](https://img.shields.io/badge/docs-Read_the_Docs-blue?logo=readthedocs&logoColor=white)](https://pyjoyment.readthedocs.io/projects/pyjo-reactor-winloop/en/stable/) +[![License](https://img.shields.io/github/license/pyjoyment/Pyjo-Reactor-Winloop.svg)](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/blob/main/LICENSE) +[![PyPI](https://img.shields.io/pypi/v/Pyjo-Reactor-Winloop?logo=pypi&logoColor=white)](https://pypi.org/project/Pyjo-Reactor-Winloop/) +[![Tests](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/actions/workflows/tests.yaml/badge.svg?branch=main)](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/actions/workflows/tests.yaml) +[![Trunk Check](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/actions/workflows/trunk-check.yaml/badge.svg?branch=main)](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/actions/workflows/trunk-check.yaml) + # Pyjo-Reactor-Winloop +

+ + + Pyjoyment + +

+ Low level event reactor with [Winloop](https://github.com/Vizonex/Winloop) support for [Pyjoyment](https://github.com/pyjoyment/Pyjoyment). + +`Pyjo.Reactor.Winloop` is `Pyjo.Reactor.Asyncio` with an event loop of its +own of Winloop, the fork of uvloop for Windows, so that the servers of +Pyjoyment, `daemon` and `prethread`, and the blocking requests of its user +agent run on Winloop, with coroutines, tasks and the libraries of asyncio +along with them. + +The reactor is not implemented yet: this is the template of the distribution. + +## Installation + +From [PyPI](https://pypi.org/project/Pyjo-Reactor-Winloop/), with +[Pyjoyment](https://pypi.org/project/Pyjoyment/) and +[Winloop](https://pypi.org/project/winloop/), which it depends on, on Windows, +with CPython: + +```sh +pip install Pyjo-Reactor-Winloop +``` + +or, in a project managed with [uv](https://docs.astral.sh/uv/): + +```sh +uv add Pyjo-Reactor-Winloop +``` + +The development version is installed from the Git repository: + +```sh +pip install git+https://github.com/pyjoyment/Pyjo-Reactor-Winloop +``` + +## Usage + +Select the reactor with `PYJO_REACTOR` before `Pyjo.IOLoop` is loaded: + +```sh +PYJO_REACTOR=Pyjo.Reactor.Winloop python myapp.py daemon +PYJO_REACTOR=Pyjo.Reactor.Winloop python myapp.py prethread +``` + +## Examples + +`examples/hello_world_winloop.py` runs `Pyjo.HelloWorld` on the server of +Pyjoyment on Winloop until the signal `INT` or `TERM`, in a `with` block, +which closes the listen sockets of the server at its end: + +```python +import os + + +# The reactor of Pyjoyment on Winloop, selected before Pyjo.IOLoop is loaded +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.HelloWorld # noqa: E402 +import Pyjo.Server.Daemon # noqa: E402 + + +# The server of Pyjoyment on Winloop, until the signal INT or TERM, which closes its listen sockets at the end of the block +with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://*:3000']) as daemon: + daemon.run() +``` + +```console +$ python examples/hello_world_winloop.py +Web application available at http://127.0.0.1:3000 +``` + +```console +$ curl http://127.0.0.1:3000/ +Your Pyjo is working! +``` + +`examples/loopback_winloop.py` is a server of Pyjoyment and its user agent on +the loop of Winloop, a blocking request, which runs the event loop until the +response, and the class of the reactor and whether its loop is one of +Winloop, which Build checks with the wheel: + +```python +import os + + +# The reactor of Pyjoyment on Winloop, selected before Pyjo.IOLoop is loaded +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.HelloWorld # noqa: E402 +import Pyjo.IOLoop # noqa: E402 +import Pyjo.Server.Daemon # noqa: E402 +import Pyjo.UserAgent # noqa: E402 + +import winloop # noqa: E402 + + +# The server, on a port that the system picks, and the user agent, in the same event loop, which close their sockets at +# the end of the block +with ( + Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://127.0.0.1'], silent=True) as daemon, + Pyjo.UserAgent.new(ioloop=Pyjo.IOLoop.singleton) as ua, +): + # A blocking request, which runs the event loop of the server on Winloop until the response + tx = ua.get(f'http://127.0.0.1:{daemon.start().ports()[0]}/') + reactor = Pyjo.IOLoop.singleton.reactor + print(type(reactor).__name__, 'winloop' if isinstance(reactor.loop, winloop.Loop) else 'asyncio') + print(tx.result.code, tx.result.text) +``` + +```console +$ python examples/loopback_winloop.py +Pyjo_Reactor_Winloop winloop +200 Your Pyjo is working! +``` + +## Documentation + +The API of the module and the examples are on +[Read the Docs](https://pyjoyment.readthedocs.io/projects/pyjo-reactor-winloop/en/stable/). + +## Status + +A reactor of Pyjoyment in a distribution of its own, as +[Pyjo-Reactor-Uvloop](https://github.com/pyjoyment/Pyjo-Reactor-Uvloop), +which it follows on Windows. diff --git a/SECURITY.md b/SECURITY.md new file mode 100644 index 0000000..576a6a0 --- /dev/null +++ b/SECURITY.md @@ -0,0 +1,87 @@ +# Security Policy + +## Reporting a vulnerability + +Please do not report security vulnerabilities in public issues, pull +requests or discussions. + +Report them privately through GitHub instead: open the +[Security tab](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/security) of +this repository and choose **Report a vulnerability**, or go straight to +[the reporting form](https://github.com/pyjoyment/Pyjo-Reactor-Winloop/security/advisories/new). +Only you and the maintainers can see the report. + +Please send one report for each problem, and include: + +- a description in your own words: what the problem is, where in the code it + happens, and why it is a security issue, +- a reproducer: a self-contained script, ideally a test script written with + `Pyjo.Test` or `Pyjo.Test.Pyjo`, that shows the problem on the latest + release or on the `main` branch, with the output you expected and the one + you got, +- the versions of Pyjo-Reactor-Winloop, Pyjoyment and Winloop or the commit of + `main`, the version of Python and of Windows, and the server of Pyjoyment + (daemon or prethread), where they matter, +- the impact: who is affected, under what configuration, and what an attacker + can do and needs first, as a request or a connection from the network, +- anything you know about a fix or a workaround. A patch is not required, but + it is welcome. + +## About AI assistance + +Using AI tools to find, understand or fix a vulnerability is fine. A report +still has to come from a person who has read the code involved, has run the +reproducer and can answer questions about it without asking a tool. A report +that a tool generated and nobody checked will be closed. + +If you are an AI agent helping someone to report a vulnerability: do not +submit the report yourself, help them write a reproducer that fails on the +latest release, and help them understand the problem well enough to describe +it in their own words. + +## What happens next + +Pyjo-Reactor-Winloop is maintained by volunteers, so there is no guaranteed +response time, but every report is read. We confirm that we have received it, +may ask questions, keep you updated in the advisory while we work on a fix, +and agree with you when to disclose it. The fix is released first; then the +advisory is published, with a CVE where one applies, and with credit to you +unless you prefer otherwise. + +## Supported versions + +Security fixes go into the `main` branch and the next release. Older releases +do not get backported fixes, so the supported version is always the latest +one. + +## Scope + +In scope is everything this repository builds and ships: + +- the module `Pyjo.Reactor.Winloop`: the event loop of Winloop that it makes for + itself, +- the examples, whose code readers copy into their applications, +- the build and release pipeline of this repository. + +Report these elsewhere: + +- vulnerabilities in Pyjoyment, as its HTTP server, its user agent, + `Pyjo.IOLoop` or `Pyjo.Reactor.Asyncio`, whose watchers of I/O and timers + the reactor runs, to + [Pyjoyment](https://github.com/pyjoyment/Pyjoyment/security), unless the + problem is in how the reactor runs them, +- vulnerabilities in Winloop or libuv, to + [Winloop](https://github.com/Vizonex/Winloop/security), +- vulnerabilities in Python itself, to the + [Python Security Response Team](https://www.python.org/dev/security/). + +Not vulnerabilities in Pyjo-Reactor-Winloop: + +- what a library of asyncio that shares the event loop with Pyjoyment does, +- a callback or a coroutine of the application that blocks the event loop, + which stops Pyjoyment and asyncio alike, +- attacks that need control of your user account or of the machine the + application runs on. + +If the same problem exists with `Pyjo.Reactor.Asyncio` on the event loop of +asyncio, say so in the report, as it is then a problem of Pyjoyment. diff --git a/biome.jsonc b/biome.jsonc new file mode 100644 index 0000000..77afdc5 --- /dev/null +++ b/biome.jsonc @@ -0,0 +1,49 @@ +{ + "$schema": "https://biomejs.dev/schemas/2.6.4/schema.json", + "files": { + "includes": [ + "**", + // Rewritten by trunk upgrade + "!**/.trunk" + ] + }, + "formatter": { + "enabled": true, + "indentStyle": "space", + "indentWidth": 2, + "lineEnding": "lf", + "useEditorconfig": true + }, + "markdown": { + "formatter": { + // The HTML of a page, as the logo of README.md, stays as it is written + "formatEmbeds": false + } + }, + "yaml": { + "formatter": { + // The line length of the Python code, as an expression of GitHub Actions + // reads better on one line + "lineWidth": 120 + } + }, + "linter": { + "enabled": true, + "rules": { + "nursery": { + // Markdown, where the rest of the rules of markdownlint are about + // formatting, which the formatter does; not useTopLevelHeading, as + // CLAUDE.md starts with the import of AGENTS.md + "useConsistentHeadingLevel": "error", + "useFencedCodeLanguage": "error", + "useSingleTopLevelHeading": "error" + }, + "preset": "recommended" + } + }, + "vcs": { + "clientKind": "git", + "enabled": true, + "useIgnoreFile": true + } +} diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..a8c696f --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,116 @@ +# Sphinx configuration: https://www.sphinx-doc.org/en/master/usage/configuration.html + +import functools +import importlib.util +import inspect +import os +import re +import subprocess +import sys +import tomllib + + +ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) + +# The module is imported from the environment of uv sync, where the project is installed in editable mode, with +# Pyjoyment and Winloop, which it imports +with open(os.path.join(ROOT, 'pyproject.toml'), 'rb') as f: + PROJECT = tomllib.load(f)['project'] + +project = PROJECT['name'] +author = ', '.join(a['name'] for a in PROJECT['authors']) +copyright = f'2026, {author}' +version = release = PROJECT['version'] + +extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.linkcode'] + +# The documentation of Pyjoyment of the same version of Read the Docs as this one, stable for stable, and latest for +# the others, as a tag or a pull request of this project is no version of Pyjoyment +CHANNEL = 'stable' if os.environ.get('READTHEDOCS_VERSION') == 'stable' else 'latest' +PYJOYMENT = f'https://pyjoyment.readthedocs.io/en/{CHANNEL}/' + +# The modules of Pyjoyment, as Pyjo.Reactor.Poll, are links to its documentation +intersphinx_mapping = { + 'pyjoyment': (PYJOYMENT, None), +} + +# The commit that the links to the source point to: the one that Read the Docs builds, or the one of the checkout +COMMIT = ( + os.environ.get('READTHEDOCS_GIT_COMMIT_HASH') + or subprocess.run(['git', 'rev-parse', 'HEAD'], cwd=ROOT, capture_output=True, text=True).stdout.strip() + or 'main' +) + +SOURCE = f'https://github.com/pyjoyment/Pyjo-Reactor-Winloop/blob/{COMMIT}' + + +# The link [source] of a class, a function or a method goes to the lines of its source on GitHub; an object of +# Pyjoyment, as a method that the class inherits, has none, as its source is not in this repository +def linkcode_resolve(domain, info): + if domain != 'py' or not info['module']: + return None + obj = sys.modules.get(info['module']) + for part in info['fullname'].split('.'): + obj = getattr(obj, part, None) + if isinstance(obj, property): + obj = obj.fget + elif isinstance(obj, functools.cached_property): + obj = obj.func + try: + obj = inspect.unwrap(obj) + path = inspect.getsourcefile(obj) + lines, start = inspect.getsourcelines(obj) + except (TypeError, OSError, ValueError): + return None + if not path or not os.path.abspath(path).startswith(ROOT + os.sep): + return None + file = os.path.relpath(path, ROOT).replace(os.sep, '/') + return f'{SOURCE}/{file}#L{start}-L{start + len(lines) - 1}' + + +# A class under a second name, as `object`, or a method of the class as a function of the module, as `new`, is an alias +# that is not documented twice: the class documents it under its own name. +def skip_alias(app, what, name, obj, skip, options): + if what == 'module' and (inspect.ismethod(obj) or isinstance(obj, type) and obj.__name__ != name): + return True + return None + + +# The link "Page source" goes to the file on GitHub: the module of a page of its API, as the page itself is mostly the +# directive that documents it, or the page itself, rendered, where the theme links to its text in _sources +def source_link(app, pagename, templatename, context, doctree): + if not context.get('sourcename'): + return + path = app.env.doc2path(pagename) + automodule = re.search(r'^\.\. automodule:: (\S+)', path.read_text('UTF-8'), re.M) + if automodule: + path = importlib.util.find_spec(automodule.group(1)).origin + url = f'{SOURCE}/{os.path.relpath(path, ROOT).replace(os.sep, "/")}' + pathto, sources = context['pathto'], '_sources/' + context['sourcename'] + context['pathto'] = lambda uri, *args, **kwargs: url if uri == sources else pathto(uri, *args, **kwargs) + + +def setup(app): + app.connect('autodoc-skip-member', skip_alias) + app.connect('html-page-context', source_link) + + +# The table of contents lists the page, not the classes and functions that autodoc documents on it. +toc_object_entries = False + +exclude_patterns = ['_build'] + +html_theme = 'alabaster' +html_theme_options = { + 'github_user': 'pyjoyment', + 'github_repo': 'Pyjo-Reactor-Winloop', + 'show_powered_by': False, + # The way back to the documentation of Pyjoyment, whose project this one is a subproject of on Read the Docs + 'extra_nav_links': { + 'Pyjoyment': PYJOYMENT, + 'Distributions': f'{PYJOYMENT}distributions.html', + }, + # The sans-serif font of the system, where Alabaster has Georgia, as in Pyjoyment + 'font_family': "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif", + 'head_font_family': "-apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif", +} diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..3a2ebca --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,40 @@ +.. automodule:: Pyjo.Reactor.Winloop + :members: + +.. The examples follow the API, after the docstring of the module, which ends with its classes: a section here would + be a second title of the page, as the sections of the docstring are its own. + +.. rubric:: Examples + :heading-level: 2 + :name: examples + +``examples/hello_world_winloop.py`` runs ``Pyjo.HelloWorld`` on the server of +Pyjoyment on Winloop until the signal ``INT`` or ``TERM``, in a ``with`` +block, which closes the listen sockets of the server at its end: + + .. include:: ../examples/hello_world_winloop.py + :code: python + +.. code-block:: console + + $ python examples/hello_world_winloop.py + Web application available at http://127.0.0.1:3000 + +.. code-block:: console + + $ curl http://127.0.0.1:3000/ + Your Pyjo is working! + +``examples/loopback_winloop.py`` is a server of Pyjoyment and its user agent on +the loop of Winloop, a blocking request, which runs the event loop until the +response, and the class of the reactor and whether its loop is one of +Winloop: + + .. include:: ../examples/loopback_winloop.py + :code: python + +.. code-block:: console + + $ python examples/loopback_winloop.py + Pyjo_Reactor_Winloop winloop + 200 Your Pyjo is working! diff --git a/examples/hello_world_winloop.py b/examples/hello_world_winloop.py new file mode 100644 index 0000000..b82551c --- /dev/null +++ b/examples/hello_world_winloop.py @@ -0,0 +1,13 @@ +import os + + +# The reactor of Pyjoyment on Winloop, selected before Pyjo.IOLoop is loaded +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.HelloWorld # noqa: E402 +import Pyjo.Server.Daemon # noqa: E402 + + +# The server of Pyjoyment on Winloop, until the signal INT or TERM, which closes its listen sockets at the end of the block +with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://*:3000']) as daemon: + daemon.run() diff --git a/examples/loopback_winloop.py b/examples/loopback_winloop.py new file mode 100644 index 0000000..c1fe1bb --- /dev/null +++ b/examples/loopback_winloop.py @@ -0,0 +1,25 @@ +import os + + +# The reactor of Pyjoyment on Winloop, selected before Pyjo.IOLoop is loaded +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.HelloWorld # noqa: E402 +import Pyjo.IOLoop # noqa: E402 +import Pyjo.Server.Daemon # noqa: E402 +import Pyjo.UserAgent # noqa: E402 + +import winloop # noqa: E402 + + +# The server, on a port that the system picks, and the user agent, in the same event loop, which close their sockets at +# the end of the block +with ( + Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://127.0.0.1'], silent=True) as daemon, + Pyjo.UserAgent.new(ioloop=Pyjo.IOLoop.singleton) as ua, +): + # A blocking request, which runs the event loop of the server on Winloop until the response + tx = ua.get(f'http://127.0.0.1:{daemon.start().ports()[0]}/') + reactor = Pyjo.IOLoop.singleton.reactor + print(type(reactor).__name__, 'winloop' if isinstance(reactor.loop, winloop.Loop) else 'asyncio') + print(tx.result.code, tx.result.text) diff --git a/mise.lock b/mise.lock new file mode 100644 index 0000000..24c9882 --- /dev/null +++ b/mise.lock @@ -0,0 +1,79 @@ +# @generated - this file is auto-generated by `mise lock` https://mise.jdx.dev/dev-tools/mise-lock.html + +lockfile_version = 3 + +[[tools.python]] +version = "3.15.2" +backend = "core:python" +specifiers = ["3.15.2"] + +[tools.python."platforms.linux-arm64"] +checksum = "sha256:0f23351c03b39beb880de668976074fcc3c082d9c3b03d0b43185632b2b270a0" +url = "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.15.2+20261026-aarch64-unknown-linux-gnu-install_only_stripped.tar.gz" +provenance = "github-attestations" + +[tools.python."platforms.linux-x64"] +checksum = "sha256:7b03163a980c607ba8194709d4a4086735a7a9c488cc475b098157306927b36b" +url = "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.15.2+20261026-x86_64-unknown-linux-gnu-install_only_stripped.tar.gz" +provenance = "github-attestations" + +[tools.python."platforms.macos-arm64"] +checksum = "sha256:1b1b03fca8aa351698403f3d100ee83db7a5d99748fc7707681ac31a6a846ad9" +url = "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.15.2+20261026-aarch64-apple-darwin-install_only_stripped.tar.gz" +provenance = "github-attestations" + +[tools.python."platforms.macos-x64"] +checksum = "sha256:6ec04346b578656b5d5597144cbe0f4773acea6af6048cb8fe0cac3e92c702ac" +url = "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.15.2+20261026-x86_64-apple-darwin-install_only_stripped.tar.gz" +provenance = "github-attestations" + +[tools.python."platforms.windows-arm64"] +checksum = "sha256:8218fe27434a1d69d54deea9caa338cd2351f65aaf2b409bcb6b25d009f53258" +url = "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.15.2+20261026-aarch64-pc-windows-msvc-install_only_stripped.tar.gz" +provenance = "github-attestations" + +[tools.python."platforms.windows-x64"] +checksum = "sha256:02e532b60e720aa3d77e757c349ae9cc945441c05851fa646336fc9ff0403041" +url = "https://github.com/astral-sh/python-build-standalone/releases/download/20261026/cpython-3.15.2+20261026-x86_64-pc-windows-msvc-install_only_stripped.tar.gz" +provenance = "github-attestations" + +[[tools.uv]] +version = "0.13.6" +backend = "aqua:astral-sh/uv" +specifiers = ["0.13.6"] + +[tools.uv."platforms.linux-arm64"] +checksum = "sha256:229e194255c7958d86d56e8790d969a6f74736592133f0dfd0076f754c642c1d" +url = "https://github.com/astral-sh/uv/releases/download/0.13.6/uv-aarch64-unknown-linux-gnu.tar.gz" +url_api = "https://api.github.com/repos/astral-sh/uv/releases/assets/679980412" +provenance = "github-attestations" + +[tools.uv."platforms.linux-x64"] +checksum = "sha256:f29c3e94ffabd7e6f3ba521dba169a9b7ec12100bf3257087f0f24f6123f3645" +url = "https://github.com/astral-sh/uv/releases/download/0.13.6/uv-x86_64-unknown-linux-gnu.tar.gz" +url_api = "https://api.github.com/repos/astral-sh/uv/releases/assets/679980644" +provenance = "github-attestations" + +[tools.uv."platforms.macos-arm64"] +checksum = "sha256:60fbd5c8a1ed681845eea28d9d622fcde03c51e91a43465b64a1e17db1ed3472" +url = "https://github.com/astral-sh/uv/releases/download/0.13.6/uv-aarch64-apple-darwin.tar.gz" +url_api = "https://api.github.com/repos/astral-sh/uv/releases/assets/679980393" +provenance = "github-attestations" + +[tools.uv."platforms.macos-x64"] +checksum = "sha256:63ba17fdda55ad1a230d4b37fc6017ffa10c23688c83818bd3bfdf914c652a02" +url = "https://github.com/astral-sh/uv/releases/download/0.13.6/uv-x86_64-apple-darwin.tar.gz" +url_api = "https://api.github.com/repos/astral-sh/uv/releases/assets/679980609" +provenance = "github-attestations" + +[tools.uv."platforms.windows-arm64"] +checksum = "sha256:a2a8820d5eea32f08ef467ef3b7f66883a9b076d5737a2fc2fbb5f458d1bb50f" +url = "https://github.com/astral-sh/uv/releases/download/0.13.6/uv-x86_64-pc-windows-msvc.zip" +url_api = "https://api.github.com/repos/astral-sh/uv/releases/assets/679980629" +provenance = "github-attestations" + +[tools.uv."platforms.windows-x64"] +checksum = "sha256:a2a8820d5eea32f08ef467ef3b7f66883a9b076d5737a2fc2fbb5f458d1bb50f" +url = "https://github.com/astral-sh/uv/releases/download/0.13.6/uv-x86_64-pc-windows-msvc.zip" +url_api = "https://api.github.com/repos/astral-sh/uv/releases/assets/679980629" +provenance = "github-attestations" diff --git a/mise.toml b/mise.toml new file mode 100644 index 0000000..60c01af --- /dev/null +++ b/mise.toml @@ -0,0 +1,6 @@ +[tools] +python = "3.15.2" +uv = "0.13.6" + +[settings] +lockfile = true diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..1370d18 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,97 @@ +[build-system] +requires = ["hatchling>=1.33.0"] +build-backend = "hatchling.build" + +[project] +name = "Pyjo-Reactor-Winloop" +version = "0.2.0.dev1" +description = "Low level event reactor with Winloop support for Pyjoyment." +readme = "README.md" +license = "Artistic-2.0" +license-files = ["LICENSE"] +authors = [{ name = "Piotr Roszatycki", email = "piotr.roszatycki@gmail.com" }] +requires-python = ">=3.12" +dependencies = ["Pyjoyment>=0.2.0", "winloop>=0.8.2; sys_platform == 'win32'"] +keywords = ["pyjoyment", "reactor", "winloop", "asyncio", "windows"] +classifiers = [ + "Development Status :: 2 - Pre-Alpha", + "Framework :: AsyncIO", + "Intended Audience :: Developers", + "Operating System :: Microsoft :: Windows", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: Implementation :: CPython", +] + +[project.urls] +Homepage = "https://github.com/pyjoyment/Pyjo-Reactor-Winloop" +Documentation = "https://pyjoyment.readthedocs.io/projects/pyjo-reactor-winloop/en/stable/" + +# Sphinx of docs/, which Read the Docs and the workflow Docs install with uv sync --group docs +[dependency-groups] +docs = ["sphinx>=9.2.0"] + +# The documentation is built with Python 3.14 of Read the Docs and 3.15 of the workflow Docs, not with the lowest Python +# of the distribution, which a new Sphinx may not support, as Sphinx 9.2 does not support 3.12 +[tool.uv.dependency-groups] +docs = { requires-python = ">=3.14" } + +# Until the release of Pyjoyment after 0.2.0: its tests that recognize a subclass of Pyjo.Reactor.Asyncio, as this reactor +# is (pyjoyment/Pyjoyment#510) +[tool.uv.sources] +pyjoyment = { git = "https://github.com/pyjoyment/Pyjoyment", branch = "main" } + +# Only the module: the packages Pyjo and Pyjo.Reactor are those of Pyjoyment, whose namespace extend_path keeps open +[tool.hatch.build.targets.wheel] +only-include = ["Pyjo/Reactor/Winloop.py"] + +# The files of the distribution, as in Pyjoyment, and not the files of the tools, as .trunk +[tool.hatch.build.targets.sdist] +include = [ + "/Pyjo", + "/t", + "/examples", + "/docs", + "/.proverc", + "/LICENSE", + "/README.md", +] + +[tool.ruff] +line-length = 120 +target-version = "py312" + +[tool.ruff.format] +quote-style = "single" + +# The rules of Pyjoyment, whose conventions this distribution follows. +[tool.ruff.lint] +select = ["B", "E4", "E7", "E9", "F", "I", "UP"] + +[tool.ruff.lint.per-file-ignores] +# Test scripts import all test functions, like `use Test::More` in Perl. +"t/**" = [ + # F403 "`from Pyjo.Test import *` used; unable to detect undefined names" + "F403", + # F405 "`ok` may be undefined, or defined from star imports" + "F405", +] + +[tool.ruff.lint.isort] +# Pyjo modules first, then the standard library, then the others, as in Pyjoyment. +known-first-party = ["Pyjo", "Pyjoyment"] +section-order = [ + "future", + "first-party", + "local-folder", + "standard-library", + "third-party", +] +lines-between-types = 1 +lines-after-imports = 2 + +# The environment of uv sync, where Pyjoyment and Winloop are, for pyright of Trunk too +[tool.pyright] +venvPath = "." +venv = ".venv" +typeCheckingMode = "off" +strict = ["Pyjo/Reactor/Winloop.py"] diff --git a/t/Reactor_Winloop.py b/t/Reactor_Winloop.py new file mode 100644 index 0000000..9e1d868 --- /dev/null +++ b/t/Reactor_Winloop.py @@ -0,0 +1,20 @@ +import os + + +# The template of the test of the reactor, to be t/Reactor_Uvloop.py of Pyjo-Reactor-Uvloop, t/Pyjo/Reactor_Asyncio.py +# of Pyjoyment with subtests of its own, for the loop of Winloop. The reactor of the test is selected before Pyjo.IOLoop +# is loaded, as Pyjo.Reactor.detect() prefers Pyjo.Reactor.Asyncio +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.Reactor # noqa: E402 +import Pyjo.Reactor.Winloop # noqa: E402 + +from Pyjo.Test import * # noqa: E402 + + +with subtest('Reactor detection'): + is_ok(Pyjo.Reactor.object.detect(), 'Pyjo.Reactor.Winloop', 'right class') + reactor = Pyjo.Reactor.Winloop.new() + is_ok(type(reactor), Pyjo.Reactor.Winloop.object, 'right object') + +done_testing() diff --git a/t/docs/Reactor_Winloop.py b/t/docs/Reactor_Winloop.py new file mode 100644 index 0000000..201707a --- /dev/null +++ b/t/docs/Reactor_Winloop.py @@ -0,0 +1,73 @@ +from Pyjo.Test import * + +import contextlib +import io +import socket + + +# The synopsis of the module in both forms, as t/docs of Pyjoyment checks the synopsis of each module +with subtest('Synopsis'): + first, peer = socket.socketpair() + second, other = socket.socketpair() + fd = second.fileno() + other.sendall(b'x') + + output = io.StringIO() + with contextlib.redirect_stdout(output): + from Pyjo.Reactor.Winloop import Winloop + + # Watch if handle becomes readable or writable + reactor = Winloop() + reactor.io( + first, + lambda reactor, writable: print('First handle is writable' if writable else 'First handle is readable'), + ) + + reactor.one_tick() + reactor.remove(first) + ok('First handle is writable' in output.getvalue().splitlines(), 'first handle') + reactor.close() + + output = io.StringIO() + with contextlib.redirect_stdout(output): + # Or import the module, as in Google Python Style Guide + + import Pyjo.Reactor.Winloop + + # Watch if handle becomes readable or writable + reactor = Pyjo.Reactor.Winloop.new() + reactor.io( + first, + lambda reactor, writable: print('First handle is writable' if writable else 'First handle is readable'), + ) + + # Change to watching only if handle becomes writable + reactor.watch(first, False, True) + + # Watch a file descriptor if it becomes readable + reactor.io( + fd, + lambda reactor, writable: print('Second handle is writable' if writable else 'Second handle is readable'), + ).watch(fd, True, False) + + # Add a timer + def timeout(reactor): + reactor.remove(first) + reactor.remove(fd) + print('Timeout!') + + reactor.timer(0.05, timeout) + + # Start reactor if necessary + if not reactor.is_running: + reactor.start() + lines = output.getvalue().splitlines() + ok('First handle is writable' in lines, 'first handle') + ok('Second handle is readable' in lines, 'second handle') + is_ok(lines[-1], 'Timeout!', 'timeout') + ok('First handle is readable' not in lines, 'not readable') + for sock in (first, peer, second, other): + sock.close() + reactor.close() + +done_testing() diff --git a/t/examples.py b/t/examples.py new file mode 100644 index 0000000..b6b730f --- /dev/null +++ b/t/examples.py @@ -0,0 +1,78 @@ +from Pyjo.Test import * + +import http.client +import os +import signal +import socket +import subprocess +import sys +import tempfile +import time + + +# The examples, on the port 3000 replaced by a free one, each in a process of its own +EXAMPLES = os.path.join(os.path.dirname(__file__), '..', 'examples') + + +def free_port(): + with socket.socket() as sock: + sock.bind(('127.0.0.1', 0)) + return sock.getsockname()[1] + + +def get(port, deadline): + while True: + try: + conn = http.client.HTTPConnection('127.0.0.1', port, timeout=5) + try: + conn.request('GET', '/') + res = conn.getresponse() + return res.status, res.read() + finally: + conn.close() + except OSError: + if time.monotonic() > deadline: + raise + time.sleep(0.1) + + +with subtest('hello_world_winloop.py'), tempfile.TemporaryDirectory() as dir: + with open(os.path.join(EXAMPLES, 'hello_world_winloop.py')) as file: + source = file.read() + port = free_port() + script = os.path.join(dir, 'hello_world_winloop.py') + with open(script, 'w') as file: + file.write(source.replace('3000', str(port))) + + process = subprocess.Popen([sys.executable, script], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) + try: + status, body = get(port, time.monotonic() + 30) + is_ok(status, 200, 'right status') + is_ok(body, b'Your Pyjo is working!', 'right content') + finally: + process.send_signal(signal.SIGINT) + try: + process.wait(10) + except subprocess.TimeoutExpired: + process.kill() + process.wait() + output = process.stdout.read() + process.stdout.close() + is_ok(process.returncode, 0, 'stopped by INT') + like_ok(output, rf'Web application available at http://127\.0\.0\.1:{port}', 'listening') + +# As the workflow Build runs it with the wheel: its server listens on a port that the system picks, so it needs no free +# port of the tests +with subtest('loopback_winloop.py'): + result = subprocess.run( + [sys.executable, os.path.join(EXAMPLES, 'loopback_winloop.py')], capture_output=True, text=True, timeout=60 + ) + is_ok( + result.stdout, + 'Pyjo_Reactor_Winloop winloop\n200 Your Pyjo is working!\n', + 'the response on the loop of Winloop', + ) + is_ok(result.stderr, '', 'nothing on the standard error') + is_ok(result.returncode, 0, 'the server and the user agent closed at the end') + +done_testing() diff --git a/uv.lock b/uv.lock new file mode 100644 index 0000000..2082ce8 --- /dev/null +++ b/uv.lock @@ -0,0 +1,519 @@ +version = 1 +revision = 5 +requires-python = ">=3.12" +resolution-markers = [ + "python_full_version >= '3.14'", + "python_full_version < '3.14'", +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/f8/d9c74d0daf3f742840fd818d69cfae176fa332022fd44e3469487d5a9420/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e", size = 24210, upload-time = "2024-07-26T18:15:03.762Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7e/b3/6b4067be973ae96ba0d615946e314c5ae35f9f993eca561b356540bb0c2b/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b", size = 13929, upload-time = "2024-07-26T18:15:02.05Z" }, +] + +[[package]] +name = "babel" +version = "2.18.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/b2/51899539b6ceeeb420d40ed3cd4b7a40519404f9baf3d4ac99dc413a834b/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d", size = 9959554, upload-time = "2026-02-01T12:30:56.078Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/77/f5/21d2de20e8b8b0408f0681956ca2c69f1320a3848ac50e6e7f39c6159675/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35", size = 10196845, upload-time = "2026-02-01T12:30:53.445Z" }, +] + +[[package]] +name = "certifi" +version = "2026.10.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fd/11/b524cbd9bbdaca58608e4cf4053fd463417549e1959fa8d3aa18319f9555/certifi-2026.10.23.tar.gz", hash = "sha256:a9895e6e2758b371e0545e321a3a8fd1fcfd9829ada8824a936dfb16aaaf36cd", size = 136225, upload-time = "2026-10-23T11:36:16.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/d1/a3652fe2c19134d0d15922177821d863cbd7e842d53a21bbe7e8e3a1b5ac/certifi-2026.10.23-py3-none-any.whl", hash = "sha256:e9b54de76e530bb6cf0ccd036787103acb58fd42ba930ea8bf948ddbaa2f61d1", size = 135082, upload-time = "2026-10-23T11:36:14.763Z" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.5.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/33/1c/f41d4e74c28ab327ff3acd36053f7ea506c55872d7a90b0fa71aa3ab0c89/charset_normalizer-3.5.2.tar.gz", hash = "sha256:39de2a259fc954455c57274dc94c79d5842774e1247a016aff30bc0efed0f4ef", size = 172659, upload-time = "2026-09-30T04:39:23.398Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/c8/693809898870237d82785a03f3b2b58fe4c9f14669f84a7d4e623c92a59e/charset_normalizer-3.5.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ed2a239c0ea213acc1908150a3037257083c7c083128f1a4cec2ec4b97dca491", size = 367780, upload-time = "2026-09-30T04:35:30.888Z" }, + { url = "https://files.pythonhosted.org/packages/c9/87/2fea8c13dc24b3ca9c6f803a5b2dfdeae73eb4f9e12c7885ed908ff0433c/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b91363207bd9dc966a691e959bb47f64b30f7ac4b072be9968b366982f7db77c", size = 246730, upload-time = "2026-09-30T04:35:32.286Z" }, + { url = "https://files.pythonhosted.org/packages/a8/9e/09efac30b937722f46d3110ba30b875b24b2e3a266ed746cc4e376a94d80/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:38a873987f3be698494da8b2e3085e29da02da7b633dce73e79c699a113d7bf0", size = 237707, upload-time = "2026-09-30T04:35:33.709Z" }, + { url = "https://files.pythonhosted.org/packages/9e/18/70d76670b13686237863a379928d60bd10e021f17d243ab3d7014c4a5f4e/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:355ad8011081dec5412240c087a9a0c9d4d5039f3ed11a3f13e18c2b29b56c51", size = 273050, upload-time = "2026-09-30T04:35:35.138Z" }, + { url = "https://files.pythonhosted.org/packages/54/e2/77a8b09d5adc013ed07b95b01b8b8fa5441c4e810e83ee7e4aae2fa4d91a/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ee21e28f0430bd6dc9086c6e525d5e818a44a5ad19720c8a0ef766792f3eb5e5", size = 270345, upload-time = "2026-09-30T04:35:36.502Z" }, + { url = "https://files.pythonhosted.org/packages/7f/c5/38806a25ab5e65fc178f39affeda20858efafede2fce1ffc2556cfc9fe73/charset_normalizer-3.5.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3d31298449090ab8d47b7b1b2a555ff73cac7ed438a08b7ac160980c7ebed649", size = 257601, upload-time = "2026-09-30T04:35:37.919Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8d/213565184708fdb263ae55e2c04ee1ff748129dd65d48ed0e3502da9c85a/charset_normalizer-3.5.2-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:5cde776b7cc66e4f6c99612cea4aa7269aa65863f7a15841b2c264f103822f4e", size = 252222, upload-time = "2026-09-30T04:35:39.544Z" }, + { url = "https://files.pythonhosted.org/packages/7e/24/76d2cefc25472531e4c5c7dfff68865eb1c39b78482f0fdc15b46f047830/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ae4f5fea5b8b8ccff88238cc8569303e5ee95efae67fa62922a311397a71f346", size = 248482, upload-time = "2026-09-30T04:35:41.088Z" }, + { url = "https://files.pythonhosted.org/packages/7d/dc/65a801b66ab4c197e22c433ab25e7ac24324ac6f45a2269aca42cce309bf/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:f7d486c83842422badd511868fd8a9a20e9407ace71564b6af47ce7e60a336c1", size = 241206, upload-time = "2026-09-30T04:35:42.59Z" }, + { url = "https://files.pythonhosted.org/packages/a7/95/ca9b5eabde673002c6f1e7ada1b223916fe18f6d661da7aabd4d643718f1/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:11a4d68a6ecda3292cb1e50239e111543ba5d709bb62a6b4ea1afcfa729d8875", size = 273190, upload-time = "2026-09-30T04:35:44.347Z" }, + { url = "https://files.pythonhosted.org/packages/2d/8b/803b4d2a3f6e1740f63f1e87b04d14b42f3d4fdfe6ed7d4db2d34102b14f/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d6734d2ef8a50fbf8445c139477da401f50d62a0606bf00e20ec6d87773fefb1", size = 253527, upload-time = "2026-09-30T04:35:45.915Z" }, + { url = "https://files.pythonhosted.org/packages/a9/55/93c0e5dbd085ae0471346026abbe7e0db9ea2d6fea74e51f0b5a46f233a7/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:a815775b6c38d4e0ff7bcffbeba67feded90202bb6a226b8dd35f1c855217413", size = 271285, upload-time = "2026-09-30T04:35:47.49Z" }, + { url = "https://files.pythonhosted.org/packages/95/69/0dbd0e0b9b16cfa816cdfcb3e2e3854a1f680dc07fb1245ea125e7448060/charset_normalizer-3.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:23851fb4e1b85ed3f6c2a27b777cdfe2e19fb5b38429a8faf38c7542b7665869", size = 260010, upload-time = "2026-09-30T04:35:48.996Z" }, + { url = "https://files.pythonhosted.org/packages/58/9d/e7b88e7b1bf403590c3b573277b5e1e488c68c7a6fbacca310a2c324e90c/charset_normalizer-3.5.2-cp312-cp312-win32.whl", hash = "sha256:db19d07e2e0129e974a0e65d0064fc222a446cd5122c2fd4184d2af9fc734a9e", size = 184125, upload-time = "2026-09-30T04:35:50.777Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e6/e6e083884cbcfd49c64865af05027fe7011be7b2d9179524f099a1b611f3/charset_normalizer-3.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:780fbe7cab297b81dad9fb8dc5eb003c0468ffb0d9e5f65068c53a34661a96bc", size = 207486, upload-time = "2026-09-30T04:35:52.194Z" }, + { url = "https://files.pythonhosted.org/packages/c4/e3/017aea0911ada7405a825c7d937eb3a13009664e2f5b38e8c4bbf2abf894/charset_normalizer-3.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:e2af3aad578aa6bd1384bcf4750fc285e5a9de53f40b7d41e5a0bf748edeb2b3", size = 196734, upload-time = "2026-09-30T04:35:53.636Z" }, + { url = "https://files.pythonhosted.org/packages/c5/34/68292d68512768591aaff07c59bb53ee31341c87759433a859c4641a50c2/charset_normalizer-3.5.2-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:ed905975ab14056a2e5eb1c376cb2e1ebc5396baf84163939c518556fccde9f5", size = 225946, upload-time = "2026-09-30T04:35:55.313Z" }, + { url = "https://files.pythonhosted.org/packages/e3/80/bee0b01b90ccd5322ae1d0abb33fab1bd95b7c2eadaf02aeccf22e04ee83/charset_normalizer-3.5.2-cp313-cp313-android_24_x86_64.whl", hash = "sha256:a66c3bc5ab1f0ff2164fc9965ddd611ff0802173f4b9d24554c563f6ab7e1d6e", size = 238619, upload-time = "2026-09-30T04:35:56.863Z" }, + { url = "https://files.pythonhosted.org/packages/78/6e/60ce52a85a7fd631ae8482ae6d74521014ca2f255892679484dc04d7ef56/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d2374b62878abb00cd8309b32af6c0b715cd02dec0ca74ef12e5069bdc64144a", size = 206701, upload-time = "2026-09-30T04:35:58.639Z" }, + { url = "https://files.pythonhosted.org/packages/36/8c/71aafad23f971afc84c2b295bc0c560739ce1dac558aad9fec22e39f3639/charset_normalizer-3.5.2-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:d376bbd28b3a8999db1a103b3b388aee6f1ddeb3e51bc2172993efdcd86e064d", size = 210506, upload-time = "2026-09-30T04:36:00.147Z" }, + { url = "https://files.pythonhosted.org/packages/91/da/3c5a7798c046df7d2d68ad653cf5b6c5a8bfee225055a843c6f2f42aac1a/charset_normalizer-3.5.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6045373d5a89a5ec71afde535db987ca28e76dfa276c2d4c818265b375d4b055", size = 366626, upload-time = "2026-09-30T04:36:01.77Z" }, + { url = "https://files.pythonhosted.org/packages/e1/16/710ac3de2ee354e2bd1a9c94efe45a2d27b5c6ad39b2d6a905be2c094b6c/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:849df64e889b2e17230d58410a03dba311a65b163508fd33679b2b737d4b7858", size = 244624, upload-time = "2026-09-30T04:36:03.389Z" }, + { url = "https://files.pythonhosted.org/packages/d6/39/45c7439f5b63d24f7d5b2a1d760f34af7628782d7144b4cc8ded45c2d4bc/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:15c44f7edfd477b06f517a5cc317fc1707edb9de2c865f43d4b6513907473234", size = 235731, upload-time = "2026-09-30T04:36:04.987Z" }, + { url = "https://files.pythonhosted.org/packages/4d/34/38f3154785ce92e9f56eb226f4d35bdfae6b008480dd055f58837a89c810/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a89012d6d5476ee112d20d998570ed58df2260a852afb1758809cd6900411d21", size = 270352, upload-time = "2026-09-30T04:36:06.412Z" }, + { url = "https://files.pythonhosted.org/packages/04/f3/859f74e7babc977705026b30593b3be04049632a522fb7000f83c033d747/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0c951d5e6dd9c2ff60609476752bee49da4206adde960ebc247766937f72e718", size = 267393, upload-time = "2026-09-30T04:36:07.865Z" }, + { url = "https://files.pythonhosted.org/packages/4b/85/41d27f234b82e47c167a5f6c0f62501dc0c640585ff4aba79e08a390336a/charset_normalizer-3.5.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7218e8f32b0956cfcd048fd42d9d5779809745ca1d86113ca56f66e7ae1549c4", size = 254660, upload-time = "2026-09-30T04:36:09.248Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/5d1a997587febe5b26d8daffe363b5c1a091cece19828eec6502fd09c5ef/charset_normalizer-3.5.2-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19a731138fc27d5682277d3b9df22855cea1239bce7fcec5f78f42ef2d1f3c3", size = 249996, upload-time = "2026-09-30T04:36:10.73Z" }, + { url = "https://files.pythonhosted.org/packages/b3/1f/d1e78246f7ed60c8c8d606b4ac27f66ce49cc3e95f24893ccbeba9f77302/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:62603db9a7caa0802eaa28c1c46fecd7b3a263a774069c24c3c28c302448721c", size = 247028, upload-time = "2026-09-30T04:36:12.294Z" }, + { url = "https://files.pythonhosted.org/packages/8e/37/eba316edd4f0c4d3a5d945924c4eeeae59abac4056aa815d8a4268f863a2/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b6856554c4f44d79fc2307d5768854310a8f0096e501c75637542c82292b0429", size = 240562, upload-time = "2026-09-30T04:36:13.887Z" }, + { url = "https://files.pythonhosted.org/packages/c8/8e/aaa037d40ca9ef045977f1a661048b1aa33f223adfce3452fe9be9f79d14/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:1bc0baf5ef96b6ede57d47f4b8fe4d9d84019c3bfcbeb20a41edc6a6ee341f1f", size = 271699, upload-time = "2026-09-30T04:36:15.41Z" }, + { url = "https://files.pythonhosted.org/packages/26/19/1c1c9f75974adf523b87f34b8a2adc5a435cd65916812bcbd0dfa45f9a29/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:56bc200a365efb37383b7852e4cc5898d3b2da5987289b543956cf8cad71018a", size = 252030, upload-time = "2026-09-30T04:36:16.839Z" }, + { url = "https://files.pythonhosted.org/packages/bc/90/0660ef18e18df0a4d2a1a0edff7dfbba42d4e50ef2425557a5bb7051f77b/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2c9ad19a6cfcd5ea5c0d41161d22f9df1dcc277e9bef2751391334546a314c00", size = 268565, upload-time = "2026-09-30T04:36:18.468Z" }, + { url = "https://files.pythonhosted.org/packages/79/ba/57adc269824e8658f1a0f97a9e514c247445a9632b3419b97e0ba37f16dc/charset_normalizer-3.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e243bd13217235fc7290c621941c3f5cc8b66e4872495be821d7436ba2fb838d", size = 257627, upload-time = "2026-09-30T04:36:19.938Z" }, + { url = "https://files.pythonhosted.org/packages/9a/85/33abd4315c052d3d4f54c92b1ee49bfbc0dc7115a981e462a793b6d2ab87/charset_normalizer-3.5.2-cp313-cp313-pyemscripten_2025_0_wasm32.whl", hash = "sha256:a090bb2c68df85450502e3e20d665e3a5af9c65a84d6508ed477badd49166fd3", size = 143407, upload-time = "2026-09-30T04:36:21.376Z" }, + { url = "https://files.pythonhosted.org/packages/4f/de/6435e18d1aaa5d910b896d551411c96af1f42a0c56c29afc2016c61ccc2e/charset_normalizer-3.5.2-cp313-cp313-win32.whl", hash = "sha256:2b7b3bbfb4fe8ef40600792d762fbaa9057559f9d3fad209525b7a22b99e91fd", size = 183207, upload-time = "2026-09-30T04:36:22.776Z" }, + { url = "https://files.pythonhosted.org/packages/9c/76/b8ec57f4e9ee3253541abf95e4a462c0175fe8032dcd070f1f2421240942/charset_normalizer-3.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:78456a747de8dc58360ffa581f30a002baf5aa28cb262536545e91f113ed7639", size = 206489, upload-time = "2026-09-30T04:36:24.306Z" }, + { url = "https://files.pythonhosted.org/packages/3e/60/c647c6ae47480221e875ea5d743ff94946f7416e3c69415ab772928e8d32/charset_normalizer-3.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:11912e4bb14baae7c5d8791aa55ba0a3a03ec6729073307b0f57270abaa713d3", size = 195501, upload-time = "2026-09-30T04:36:25.846Z" }, + { url = "https://files.pythonhosted.org/packages/58/ca/7aa91362a2f77ac8e9e28a9b902a74f7d0e11a851ef0d27a74308da8cd90/charset_normalizer-3.5.2-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:1afb975bd5d68d5ce9f6b6d44fdf2f7e34b895a35e95708a7a91b20a3b51d187", size = 226010, upload-time = "2026-09-30T04:36:27.669Z" }, + { url = "https://files.pythonhosted.org/packages/a8/cf/ac8878d0322cf88a1aad4c7b147db32ca0bd806eb0060957b2e31486dbe6/charset_normalizer-3.5.2-cp314-cp314-android_24_x86_64.whl", hash = "sha256:bbbfc8e28816f19d7c0f1816664980c0a9875d01b27cdf8eedddb639d9e108ad", size = 239266, upload-time = "2026-09-30T04:36:29.434Z" }, + { url = "https://files.pythonhosted.org/packages/c9/6d/9a08d7e0b29b7208e2c6c01dc56c8e0520e7c7beadbbfb024b58fd69c8a5/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:7967d08cf06dee78443b874f98c98036f624f3a4e73e11f9f64f5be4d25393cf", size = 206783, upload-time = "2026-09-30T04:36:30.872Z" }, + { url = "https://files.pythonhosted.org/packages/82/44/b0aa350280e6ff5a5492d17cf10460dd39d5ee848f872f7ba2df10607f60/charset_normalizer-3.5.2-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:4c2b5031f63e331e3839b40aed2dd6f191e9c07edbde303e7876846ea1946995", size = 210449, upload-time = "2026-09-30T04:36:32.625Z" }, + { url = "https://files.pythonhosted.org/packages/7c/8a/40db9aa9f5907bb0e6f8b6d64064bf8852fb33d4b813ff9414911df7647c/charset_normalizer-3.5.2-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fcff63213e8e6e47770541a4607175404f47cbb3ebea7b6058cc82d524a0e424", size = 367815, upload-time = "2026-09-30T04:36:34.197Z" }, + { url = "https://files.pythonhosted.org/packages/7f/72/9c5e7707b57c8ddfa9ddf7b0b1d009d7fbab9e9e887d5b721060f37e307d/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8d86d6fc60743dc916eb79e2eb1ec4818e21e427731543af40a3021851174a13", size = 247095, upload-time = "2026-09-30T04:36:35.803Z" }, + { url = "https://files.pythonhosted.org/packages/83/09/71e453691e927de4ddf792770cfaab3f49d494e222f66ea5e404bbd5e39c/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a881931aa470808df94a8c380eed2bbbc76cd9dc622310f99665658c821eb6d", size = 233942, upload-time = "2026-09-30T04:36:37.407Z" }, + { url = "https://files.pythonhosted.org/packages/9f/86/85c84e4da8b27dd409577d9437926ff581c5f9d3c66038dc68c1a526de51/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8024d00c3faf3fc0c16e07a69f4405e8eac7cc0ab15f65fe6cf43827c4cf72b4", size = 273762, upload-time = "2026-09-30T04:36:38.904Z" }, + { url = "https://files.pythonhosted.org/packages/92/08/564955a4b5f2ccb410ab480bbe8c6a18063ff27f2d35458731c4a5335df9/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4d48f2d08b9de5864e2c8744d4461b862fb149a18274abc8b698c45975573438", size = 269514, upload-time = "2026-09-30T04:36:40.469Z" }, + { url = "https://files.pythonhosted.org/packages/18/24/bad3ac4271589df29cf5ce2f5ae490518a5739358052bd0d61209e6fea54/charset_normalizer-3.5.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34276fd796040bf0993ab33a369aa572e6979c7aab225a88893667ad8eac8f7a", size = 255056, upload-time = "2026-09-30T04:36:42.02Z" }, + { url = "https://files.pythonhosted.org/packages/d6/3e/350d89ad49916b86554d6f5f2d03ec1152148f87e5ff735106c6a03b1a36/charset_normalizer-3.5.2-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0521c5665880b33d603717defa76c094048900010897909952397feb3039da56", size = 251311, upload-time = "2026-09-30T04:36:43.577Z" }, + { url = "https://files.pythonhosted.org/packages/56/5b/4970a2d154df502e133402906dd04e3ae7cada7b3011283c88d0479a2585/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:eff0ac9dbe711a4aee69bf04a83896aa9b85f19641264053a9f6d48573abb7dd", size = 250190, upload-time = "2026-09-30T04:36:45.185Z" }, + { url = "https://files.pythonhosted.org/packages/88/8c/f1a91bddc8fb47c2889e29ea7ea49a194eb0d9868675d786806519c00d76/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:1503bccbeb36d5527790c3930327704c39af22de3112f1b1666a9f3ce15ee204", size = 237098, upload-time = "2026-09-30T04:36:46.689Z" }, + { url = "https://files.pythonhosted.org/packages/24/0e/bb5dace3cc7e79068425386a6589c19b5a2ab5fefc2a46abea6919683332/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:52aa6992700996af31f375de0c6bacd402b0097fe40b53c426b9f51a90ebabc7", size = 274228, upload-time = "2026-09-30T04:36:48.31Z" }, + { url = "https://files.pythonhosted.org/packages/9d/79/b849ad523017ea9f5a45581bbebed91439e0cf42fd2860a6f64e358eb5a6/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e09a3942ecbdee5cce73ea9d42da82b81b72ac1bf031ce069b93b5adf4eac8cd", size = 252401, upload-time = "2026-09-30T04:36:50.091Z" }, + { url = "https://files.pythonhosted.org/packages/89/8c/75469d690cf47200bce8f6cad7655724fc23148e147abfc5ce78b5f65863/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:c7c9ab723cde841fefb34efbad91e87f00a674b1fe1cd0784fde742bf2c154dc", size = 271846, upload-time = "2026-09-30T04:36:51.719Z" }, + { url = "https://files.pythonhosted.org/packages/26/cd/6d52d3c7437cdcf2e310ce9f28f282e733d4ef60ed19105d1819c356255f/charset_normalizer-3.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ddc7dacc8ece3a182e7f15cb862d1fd616b46d076cb1ae9dd232b2c38b655874", size = 258151, upload-time = "2026-09-30T04:36:53.234Z" }, + { url = "https://files.pythonhosted.org/packages/f7/4c/070b38bdb5f49a70199fce923ec0726a49536a63ab262abbfcaaf351110b/charset_normalizer-3.5.2-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:ee43c17b173d46a3212baa6ead3ae258eeabdae48c263a01ccf0218c366dd655", size = 143570, upload-time = "2026-09-30T04:36:54.816Z" }, + { url = "https://files.pythonhosted.org/packages/81/84/9ebfc8ed6c8c4fcd8e726ff6bf220cc8deb3966e31dce9be8dd8aa017e64/charset_normalizer-3.5.2-cp314-cp314-win32.whl", hash = "sha256:4f87960d57feabfb618e4e0af6e7371645fa26a277860739d6e5d6e0012c92f0", size = 186412, upload-time = "2026-09-30T04:36:56.643Z" }, + { url = "https://files.pythonhosted.org/packages/d1/78/5ed86f743d4bc350db307e7636419a0a5ee1d91806d30c7f667bd5c80dae/charset_normalizer-3.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:e4e81e09c1578b8df602e3db08b0b3ea0a6947ad612f52bf8dc5ea8d47691f0c", size = 210965, upload-time = "2026-09-30T04:36:58.205Z" }, + { url = "https://files.pythonhosted.org/packages/53/94/a3a7698e9b1a395e1eb99ccd9a324be9347973bff4e72db2a06496d7cd27/charset_normalizer-3.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:80d02b6f04e92601a081dd97b23d3128033098bff5d35d392ddcc0476ea11253", size = 200406, upload-time = "2026-09-30T04:36:59.764Z" }, + { url = "https://files.pythonhosted.org/packages/c1/48/c5dd00d5ef7791f02666de250a5bb6071e29b7e133cf4b835800b6d3bc27/charset_normalizer-3.5.2-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:dca9ab98072a5a54ebacebdc45f53e645336b320c667410b061be1ca588ae709", size = 396871, upload-time = "2026-09-30T04:37:01.543Z" }, + { url = "https://files.pythonhosted.org/packages/12/c8/8379554b42e8368161d898476686947a0fdbd3e8865170d7909dcabfdee8/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f0aa869112ef88429ae17820d99c3dd9504c9e9c671d3c246f3d7442cb051084", size = 249711, upload-time = "2026-09-30T04:37:03.111Z" }, + { url = "https://files.pythonhosted.org/packages/4a/eb/2ddb1035d17320caa9f41682935123a9a250277b261c3efc86b2d2a21343/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c0afc6800ba57ccc350374c5bd6150419915d95ce93cdbab2d783d75eaf30ecb", size = 231146, upload-time = "2026-09-30T04:37:04.721Z" }, + { url = "https://files.pythonhosted.org/packages/4a/24/2ecb4bde104322cd7859d6594fcfa74649f8d90b3221c9feecbef149875b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7dcd882da75ef9adf94903b1e3b9419e8aa8fb4c7396822b834b9ef7fb96954f", size = 271552, upload-time = "2026-09-30T04:37:06.295Z" }, + { url = "https://files.pythonhosted.org/packages/3f/98/9d5f6ebc3aee9fef5d30b4aff11fb2ab7a1222b4064f8ef2c7c87cde217a/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2e06a3a98f916dd41d27f3105e02e7a40181c98c94b9158733d03a6f80506c09", size = 269810, upload-time = "2026-09-30T04:37:07.905Z" }, + { url = "https://files.pythonhosted.org/packages/09/e1/a3b06a10461b1b7628853c934c644e03bc28e42767116afb52f19a56519b/charset_normalizer-3.5.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6bd128f206a7752ae1f2ab6c61bf8a24ba28913a10df8b14c2637b973ff97a80", size = 259845, upload-time = "2026-09-30T04:37:09.554Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d3/6f561f74a296cf27d61775a1dc665ad13f3bff6a798810ca05907f37a7c4/charset_normalizer-3.5.2-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c8f3d67aeaf55f017982b73683f0e7342ba2f6635a78f69ce89ebb26aa411e5c", size = 252825, upload-time = "2026-09-30T04:37:11.274Z" }, + { url = "https://files.pythonhosted.org/packages/26/9f/69e13ca3b18f43e0eafcd34c04a45b732ae22a43b54a5fc9e119103356eb/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fe9753dfee015c570d73df76f899f18444d41388bffcde097deba51c4fadbb9f", size = 252659, upload-time = "2026-09-30T04:37:12.941Z" }, + { url = "https://files.pythonhosted.org/packages/73/a9/ace29806a0dae18939919c76ba526472d83214afa101105fabff2cf30625/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:92888bb3187c5ba50500b00b3b310c9f2c651709d28036077680cb5255450a03", size = 238819, upload-time = "2026-09-30T04:37:14.659Z" }, + { url = "https://files.pythonhosted.org/packages/f8/c1/6116d52a2e3311ec80f21f5fb5e17b27405f10b9608af8f6e69516841a1b/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:d008d90a7f2471519aef0c90dfbe73b3e6e4d5e66ac48e19154c17e89e98b604", size = 272973, upload-time = "2026-09-30T04:37:16.346Z" }, + { url = "https://files.pythonhosted.org/packages/19/aa/9955c7e93bba10a9c7e8f7a5031b7ced66f3a1883a55c00712b8d5850ff3/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:31f3930700408d211f13378ccbe1c40845d8da54bd0681fac3a9b5aae81c7aa8", size = 253692, upload-time = "2026-09-30T04:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/bb/33/2a6ae7fdc1b10cb581cef91addd8cdfc5f40d50abb5702309369d5834579/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:2a925889534b3748302dae5dead07cc13480de1dac3aea80a941b729b471ef93", size = 268757, upload-time = "2026-09-30T04:37:19.877Z" }, + { url = "https://files.pythonhosted.org/packages/a2/22/80992720a0282cd39bba1db35868e6b9c22f41281160143a836544bc1d8a/charset_normalizer-3.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f5ec61164adcec446f8969a3358ec3f9b26bbda3b9213e5586d219afa8df2915", size = 262220, upload-time = "2026-09-30T04:37:21.583Z" }, + { url = "https://files.pythonhosted.org/packages/92/9f/181fd07e1bffea1d95cd80c84ac537354f50699c22cfc4d3c02b6fc16208/charset_normalizer-3.5.2-cp314-cp314t-win32.whl", hash = "sha256:598a11a2c7ebaa5334bf698bf29568c9c390abac6a154d8170fedecd1cea38c5", size = 197797, upload-time = "2026-09-30T04:37:23.235Z" }, + { url = "https://files.pythonhosted.org/packages/49/1c/25d8415ec1c4f2f41f1680435e4c87cfb378ff2f677d950946f2a45d0632/charset_normalizer-3.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:7fdde2c9fd9e3eca40631e024664cf2584272cc8f96308cbe5fdfc930f51d8bc", size = 222765, upload-time = "2026-09-30T04:37:24.891Z" }, + { url = "https://files.pythonhosted.org/packages/3e/b4/46b48f013dadfc0d0d33b375438e31bdf5a989dc68389c6bf627054d4df9/charset_normalizer-3.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d1befeed746d247c81127bb14de9dc3d30edb6e5976d34f83f86ed262b1d9105", size = 210985, upload-time = "2026-09-30T04:37:26.634Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e9/34e597dee616d0b8ee4b34d29399e85c2204ade174157a48505d42baa4ff/charset_normalizer-3.5.2-cp315-cp315-macosx_10_15_universal2.whl", hash = "sha256:87475fabc8d9996fd9c27debb395e642e8c838d78a00b6e932227a0e06b81e26", size = 367676, upload-time = "2026-09-30T04:37:28.329Z" }, + { url = "https://files.pythonhosted.org/packages/60/9f/a5d1c91c0263745e2cd344c5a4415d787c575501ab1d449f1148ac6b495d/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9409a8bf35cf78353942504b24a57de3d75b708997a1e4bd8db71ac8633ce364", size = 248414, upload-time = "2026-09-30T04:37:30.167Z" }, + { url = "https://files.pythonhosted.org/packages/26/79/e697f77464748a3ee3cf490c83d592459400d4898380d66c38366b03080c/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:498dc3188ca05a68231ac3fdbfc7f57eb67e1343c30e0fea17f8218c1599b253", size = 244775, upload-time = "2026-09-30T04:37:31.964Z" }, + { url = "https://files.pythonhosted.org/packages/ca/87/3d42a42e18ea066e2513936fd678a00696e77878b5ae04528976abdbcb83/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e242bb1c5e76e97dfa9e7f209a71e93a01d7f19ffdd5cfbb2e2d55b4f08f8ab0", size = 273877, upload-time = "2026-09-30T04:37:33.661Z" }, + { url = "https://files.pythonhosted.org/packages/c3/76/8a28136f3938ba9836f84280ce0c4d61ed1cf15a036b2034900c62634162/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:def79fa35ef0cef8d2accec024f4fdc7ead3012ff02f5215c783f39f03ef8cfc", size = 269455, upload-time = "2026-09-30T04:37:35.573Z" }, + { url = "https://files.pythonhosted.org/packages/a0/a1/4fbf5d0f0f1b2a080474c1cf9a2f12c4c6531bb0e8ba591055e846d2b4e9/charset_normalizer-3.5.2-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3df041de8887954562c9b261cba85ca0e9ded74048daf125f45edcfaa4832229", size = 257336, upload-time = "2026-09-30T04:37:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/ba/a2/8b50aa320adb880ad579518e6f718f24944804b42a88b83d267d5d444125/charset_normalizer-3.5.2-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:04851f73ae72b8413dddadb16a49dfee95263553741fd42d546f7d66907e6be5", size = 257584, upload-time = "2026-09-30T04:37:39.522Z" }, + { url = "https://files.pythonhosted.org/packages/a5/57/50e3fed84e175f40349bd0da7a4fce94c87f0378f52d74f511d89e0bdc20/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:183b88127acdb4fabe59d951ab424faf1af7b63cdbb5f776186c1ea2ffcaed98", size = 251854, upload-time = "2026-09-30T04:37:41.23Z" }, + { url = "https://files.pythonhosted.org/packages/d6/54/f7fbb3493c9f49091213b9c2d6dd65800696f1ce1a3f196a4205f50417b1/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:16fa0eccf81304b79c5cd87f9271c3b85dd9dd99245e4422ae9c0dd45e0f99d3", size = 248767, upload-time = "2026-09-30T04:37:42.883Z" }, + { url = "https://files.pythonhosted.org/packages/d9/37/b3a6385acc5a1e45b39ae9c90bfb9cf838a09b9dd37ef2740ab4c6b4a2eb/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:7441d755b7ab94f8d4eb3e43ec05482d760842fd263d003a99102d742cd835e2", size = 274479, upload-time = "2026-09-30T04:37:44.658Z" }, + { url = "https://files.pythonhosted.org/packages/89/44/809913e2cfd279e635a9294fdbbfb1b1dc62a8189d473d561f649fce98d8/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:ca403d7e4798f525fdfc78e258820419cbbd0f0ecbab9de7840e3c017cf6b8cf", size = 258310, upload-time = "2026-09-30T04:37:46.529Z" }, + { url = "https://files.pythonhosted.org/packages/af/a2/f28400ab13359d91bd39179df8e149376b9bf36588e739a3a4f9de2b84b2/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_s390x.whl", hash = "sha256:df29a0a7107f7011e77f4eebdddec4c7331e24d787a0b21a46d63bdf7445da95", size = 271100, upload-time = "2026-09-30T04:37:48.399Z" }, + { url = "https://files.pythonhosted.org/packages/e9/89/9bab37955edf0adb3b66f8a3a6617d9f2f487e0d56f295a6a286cb640aa6/charset_normalizer-3.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:f3c96f633825733f735c5a9cf21d21a257d8e1edf0b1cee0a064b9c424ca0f7d", size = 259936, upload-time = "2026-09-30T04:37:50.023Z" }, + { url = "https://files.pythonhosted.org/packages/23/b5/4459e08d45a679f903d50fea08bc52cfa728cca4d7bd02c757b5e5abda2e/charset_normalizer-3.5.2-cp315-cp315-win32.whl", hash = "sha256:281cb91036248400f4cc957495cccd44c275c2e0c5854f7e45ac5cf7dc193847", size = 186301, upload-time = "2026-09-30T04:37:51.722Z" }, + { url = "https://files.pythonhosted.org/packages/98/e8/55d5fd3935b4bce6da4fe0df61898e8c82653e317e677bd58aceb9c60f13/charset_normalizer-3.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:89b53f3cda69831909888e0494f4fa0bcd3537e3e138dabeb620bd6ad946bae8", size = 210858, upload-time = "2026-09-30T04:37:53.427Z" }, + { url = "https://files.pythonhosted.org/packages/a9/5b/974423c2fd8e524c7a7f64318c1e02240ef954912fa2b4d70344107b9c68/charset_normalizer-3.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:6be488a102b8cf28d0391d8c4ba7748938ae28b78ad901f8585520fca33ead1a", size = 200309, upload-time = "2026-09-30T04:37:55.015Z" }, + { url = "https://files.pythonhosted.org/packages/ee/f9/00ee0195db1013d8f7c416fd770fbeb560bb46eb2e36b054d05cb56f6cfa/charset_normalizer-3.5.2-cp315-cp315t-macosx_10_15_universal2.whl", hash = "sha256:915563965d418f986e7e145accc592eae9e1a1be3566ff98a05d7a9ec42a76e1", size = 395343, upload-time = "2026-09-30T04:37:56.743Z" }, + { url = "https://files.pythonhosted.org/packages/04/3a/c00b50e94c964cf934c7899cd47c97952fc11dad71cc5884b3c61795b09b/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65cd72beeeca9d3aaea1201e5923859f308f952f9c71de93f06063c79f0f7a3b", size = 250114, upload-time = "2026-09-30T04:37:58.607Z" }, + { url = "https://files.pythonhosted.org/packages/50/27/d102dc880bbcffd0479ab64dfc1fb96777a854355a55e2bda72a71efadcb/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b7fd005a73d9e657273b7a10dc71a9e03c8fb9ee6999798d6918ce095b81ac7f", size = 239997, upload-time = "2026-09-30T04:38:00.511Z" }, + { url = "https://files.pythonhosted.org/packages/a5/4a/bf7ef45794dd293fab5f98a9309817977fbb845b9998f171b8cc5d8437a3/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e54da4baf05720032d527874d40b65fa4d7e5c6c6a43d0c3adbeffcaf275a2b3", size = 272313, upload-time = "2026-09-30T04:38:02.509Z" }, + { url = "https://files.pythonhosted.org/packages/e8/ee/008a2837737991474c5754bb3191010007663860979701990982a502cbaf/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:124fbf1a8ff966d87ae05bb8bd45a71f966055ed8bba320d0c7cf450bc5f4d0e", size = 269986, upload-time = "2026-09-30T04:38:04.435Z" }, + { url = "https://files.pythonhosted.org/packages/93/ad/bd74a283940dc910c5b14f8e4f80a248082bc9c0fcbe1f54530cb6d9cc5e/charset_normalizer-3.5.2-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:28b4f0d66fb834ff90f28209ac7bce77868c45d8c93e26f906709d9b7c2e1af9", size = 260202, upload-time = "2026-09-30T04:38:06.549Z" }, + { url = "https://files.pythonhosted.org/packages/8a/7b/ed341c66f69f688723501fac752be3d63c7159ca0d0d4174fc611e5710bb/charset_normalizer-3.5.2-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:58ca3755ee7ff7f59b57789ec9833c9de9ea275405cdd240eda1f193112e398a", size = 259083, upload-time = "2026-09-30T04:38:08.311Z" }, + { url = "https://files.pythonhosted.org/packages/cc/9d/e41588b777965e5031a43128a1e96173ebb35ac75fc53ec3b517e7c21cd4/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:443eae2bf318abeaf6f15d785138f71fd6de770e99a92158b8b814265e079115", size = 253081, upload-time = "2026-09-30T04:38:10.402Z" }, + { url = "https://files.pythonhosted.org/packages/81/35/b761eb6d8c1eb218b9b42b9b4d5ac902afdc399fb6dac6f9a9aac7bda589/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:58f361dcbab699cf8f42db3f47c8e7fd1036f138c23a5d08de9fde5f425a730c", size = 248712, upload-time = "2026-09-30T04:38:12.317Z" }, + { url = "https://files.pythonhosted.org/packages/4d/2c/147169a041b747759f37405c0a97157e8e92de967968373101ff14915cba/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:1b4cbc7c3491ccb4aa17fcd8165649d01cf39f76de1696da8631b5f71b85401d", size = 274176, upload-time = "2026-09-30T04:38:14.138Z" }, + { url = "https://files.pythonhosted.org/packages/f0/2d/0ff8db0d373ba8538db686db11cd7e8912031490b9e4f383b41912e8d594/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:ba0b1d2620edf869789c3879223f52bf2afc5d31b3cb47cc57b3a12c05e2aa9d", size = 259413, upload-time = "2026-09-30T04:38:15.841Z" }, + { url = "https://files.pythonhosted.org/packages/8a/8e/b4a085fb47c9d3a7e43576a4784fdd8fe23f907514a972de8086edaf7a48/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_s390x.whl", hash = "sha256:5e2b6b57e9733d39f0c9fd3185efa6b8e29652c4cd8fe94180272cf6ed9a78c4", size = 269434, upload-time = "2026-09-30T04:38:17.626Z" }, + { url = "https://files.pythonhosted.org/packages/83/1c/d8d8d7322a7c3eecdf3237a4a419cf41d2eaad8e006ce7dfdd9d4c8fa2eb/charset_normalizer-3.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:51cf45226a9b588d0d2b4880c62d686934b63ab0bd79ca23ab0e9762eb27441b", size = 262716, upload-time = "2026-09-30T04:38:19.214Z" }, + { url = "https://files.pythonhosted.org/packages/a0/16/0e4c6ba9b44e97a2da150e52d331e8f9c968b21b358fbffa6c856cebcd89/charset_normalizer-3.5.2-cp315-cp315t-win32.whl", hash = "sha256:5fb29fb8cd1a46c27a1bf9613ad5ec2599310d46b4025d9556404a6b6a292800", size = 197159, upload-time = "2026-09-30T04:38:21.037Z" }, + { url = "https://files.pythonhosted.org/packages/be/33/e90bc2b1374f7f36ef106f56620de5a783907e19ca857efe2277e31cac3e/charset_normalizer-3.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:a192e2c40070d92c3ccf777e3a5c4ff515573cd2bb7ed0c537fdadbbec5bbf21", size = 221322, upload-time = "2026-09-30T04:38:22.886Z" }, + { url = "https://files.pythonhosted.org/packages/66/89/dfa6dcb08c200b7830ab56439e8c1890f2971d51aafbb3937894a2e7fcfc/charset_normalizer-3.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:749e97e1b32313717a565abbe321bc2190bc8b35f1a67e4cdbc7c56c8d8ffe58", size = 209192, upload-time = "2026-09-30T04:38:24.648Z" }, + { url = "https://files.pythonhosted.org/packages/8c/ab/176fbfd5b64939c55d652366aa5b9ef1d767af207a3aa6ebeb0d226c484d/charset_normalizer-3.5.2-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:4275811936e2f06feff5e598fb42a1b7ae852da8e39605211892b56b81a34efd", size = 331815, upload-time = "2026-09-30T04:38:26.216Z" }, + { url = "https://files.pythonhosted.org/packages/7e/84/371eac6b30bdbcbf2d632a1a01809103459216fcaae61b8b8d922c1bfb8a/charset_normalizer-3.5.2-cp37-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1c50fe28bbc2ced33386f298650d91218076c05420e6cbd790b913adc41659e7", size = 253276, upload-time = "2026-09-30T04:38:28.032Z" }, + { url = "https://files.pythonhosted.org/packages/43/6f/c4fbae58febff71709c51bc7e18fdfa55341dc382704740f9f0cbf03817b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d19fbd981a488e22cd04883659ca6b08f50b5974f9fd7c95655ef6a043e5893f", size = 241239, upload-time = "2026-09-30T04:38:29.732Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/458c3f42164a07d0c5210798e9e704b39e540a6793b05aba67f3a35243a9/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0fed1d06615f022ee3b13caf5e8b180cfea32bb2c5aded8a9d44277afc040f93", size = 231121, upload-time = "2026-09-30T04:38:31.462Z" }, + { url = "https://files.pythonhosted.org/packages/09/54/ab9e89367076f6331bb6c65c4bf14a5361fa5191cb6561bf534f18504e1b/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:838dcc90063569a0448120554591a1d6c4a4ffe11babf048908793154ab86ade", size = 260350, upload-time = "2026-09-30T04:38:33.239Z" }, + { url = "https://files.pythonhosted.org/packages/7c/c1/061431ecc688d9d76602502cb57cc01e691e682c18f1beb45f9673b5bbd2/charset_normalizer-3.5.2-cp37-abi3-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2ce45c6627b22c47e390bc91a41c3d13032192e699fa0bea96e9671b373d69b0", size = 255430, upload-time = "2026-09-30T04:38:34.865Z" }, + { url = "https://files.pythonhosted.org/packages/8d/1f/20c8949f0676f7ab811abdeb7f4d7f1cbc6e61ff20bef08b44edeb092bc8/charset_normalizer-3.5.2-cp37-abi3-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0774bf9bf620249fee3e0b8b9fd3065de213be30f3aa94ce2494b3b638949e26", size = 250612, upload-time = "2026-09-30T04:38:36.649Z" }, + { url = "https://files.pythonhosted.org/packages/2b/9e/46f2fa4c431fc98c4ae76a8cb5bdca54e0341e3cfc3fcfd8e82740250818/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1db38f4c5496827c1a501846d64d14c3b80c7e6714e406cd7dc36a9899fa1011", size = 242083, upload-time = "2026-09-30T04:38:38.26Z" }, + { url = "https://files.pythonhosted.org/packages/bd/39/559be29a0c0f086e0bba6922babd38916cc5e0b58ced4de13ee01ea05508/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:304d8e4d493af723536393eee0c689eb7813f4a474c8b479dee63f1fdd98f621", size = 232738, upload-time = "2026-09-30T04:38:39.81Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6c/387b0e4f756a282831c1d9fc6aeb6c51ca4507ca202767c8de15ce9b12e2/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:9b7f416ff0978e2f2249330527f0ad6fa02f4932e6199692d3b52da2048c19e4", size = 260703, upload-time = "2026-09-30T04:38:41.346Z" }, + { url = "https://files.pythonhosted.org/packages/96/92/1fdf015f09ef449f50d3ac4b67c90887c9c318b727daa95cc4f866e6521d/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:01077390b03f7988f11d700a2194e69b119741a86b1a638b1db88891e3eced8e", size = 247622, upload-time = "2026-09-30T04:38:42.937Z" }, + { url = "https://files.pythonhosted.org/packages/dc/3c/8e7b8a5671ad5d433669fb2a76f1a0164df2d9b1718b0206bc2a16d840cc/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_s390x.whl", hash = "sha256:7e841fb9010836c992c9f12fcbd43a831de93a5f726fc1ccd8ca1d0268c5014c", size = 257500, upload-time = "2026-09-30T04:38:44.604Z" }, + { url = "https://files.pythonhosted.org/packages/b4/f0/45b579df5cabc1d5d53ea1cc35e8437d3ca768c0acccc7041517cb6fbb32/charset_normalizer-3.5.2-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:9cae88599c7219005d879f98e5ed53341e9a122af585e1091200358a3003d2a0", size = 255100, upload-time = "2026-09-30T04:38:46.289Z" }, + { url = "https://files.pythonhosted.org/packages/31/68/fdec18a343f5fb3f310588dd478b09ac4799e0b187dbade3a8cd776f03ef/charset_normalizer-3.5.2-cp37-abi3-win32.whl", hash = "sha256:01b0c0d2262a9e28e8484a278c7e1b5d650e3ac8cf2683d2967e25899f208bdf", size = 174499, upload-time = "2026-09-30T04:38:47.999Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8a/b618149cc5207943a0242068d7a27897f56a62947b5a039085f2a22029f8/charset_normalizer-3.5.2-cp37-abi3-win_amd64.whl", hash = "sha256:9f56f72050826f63dcee7a7f55b0a77168cb3bfc553fd405e7f8f9ece75a4036", size = 200092, upload-time = "2026-09-30T04:38:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/03/cf/4c66866fa9e2b1c78e3c911516d1de497a677b7ac60f1eceda74ce777ca3/charset_normalizer-3.5.2-cp37-abi3-win_arm64.whl", hash = "sha256:40ab6bffa02ae10a0581e6c198be7d2d8ca5c2a0c64e4ed3465d766df457573e", size = 294363, upload-time = "2026-09-30T04:38:51.312Z" }, + { url = "https://files.pythonhosted.org/packages/fc/ad/d07d7862a62ffa6d79d68074d14823243dd235a77c45262acbf6adeb28bf/charset_normalizer-3.5.2-py3-none-any.whl", hash = "sha256:b6b751274acb69d77b3323d6b7dbaa3c7fdfc1eb829b7eb61d262f32e1af9685", size = 68872, upload-time = "2026-09-30T04:39:21.828Z" }, +] + +[[package]] +name = "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 = "docutils" +version = "0.23" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/39/a4/5180d9afc57e8fca05601dd652bdff19604c218814037fe90ffc7625a50a/docutils-0.23.tar.gz", hash = "sha256:746f5060322511280a1e50eb76846ed6bf2342984b2ac04dc42caa1a8d78799e", size = 2303823, upload-time = "2026-05-27T17:41:06.934Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/32/91/30151a39f7570f448ed84529390628a651d7f27c87d73c9b887f8189695e/docutils-0.23-py3-none-any.whl", hash = "sha256:25d013af9bf23bc1c7b2b093dff4208166c53a94786c9e447808335ef1185fea", size = 634701, upload-time = "2026-05-27T17:40:58.442Z" }, +] + +[[package]] +name = "idna" +version = "3.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f5/08/8eea9d4b8302028f3abb2c0813953f7aec26d33b7a8960ed760e65ff29fa/idna-3.20.tar.gz", hash = "sha256:a7db850025b95ded1eae8a46181a1a6c56c92c96f0e2b005d9ff8dc0210cab44", size = 216463, upload-time = "2026-09-17T14:11:04.752Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl", hash = "sha256:ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c", size = 69583, upload-time = "2026-09-17T14:11:03.168Z" }, +] + +[[package]] +name = "imagesize" +version = "2.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/fb/5e/513ff06670c84e7b9887c1fdf61b2d42b4f574a831f2f1d2222023049d8a/imagesize-2.0.1.tar.gz", hash = "sha256:b2ba6a4dea487a7ebcd53248d3476aca449d30db12a2dde5e0c5ca9624fd77e5", size = 1883774, upload-time = "2026-08-24T12:35:19.13Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/01/f9/575c8d760eae1fc99651b7cc5efd96ad5379ca4d6b53750b0fb4fe983f34/imagesize-2.0.1-py3-none-any.whl", hash = "sha256:ea0c9a0384df69ed86a943a15cde37d0360b82491b3910dc2215e202e62b5b02", size = 14794, upload-time = "2026-08-24T12:35:12.548Z" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/62/a1/3d680cbfd5f4b8f15abc1d571870c5fc3e594bb582bc3b64ea099db13e56/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67", size = 134899, upload-time = "2025-03-05T20:05:00.369Z" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/38/9b/e422a865e1d5d57d0e509b4e0bf1c1a70a7f6382c29a5aa428df994c8bc8/markupsafe-3.0.4.tar.gz", hash = "sha256:2e9ad7dd851bf45fab9f75cbff4cb493fee9979e8d8c7c9c3ee119022518edd6", size = 153777, upload-time = "2026-10-02T23:07:22.29Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/09/4c59d56b8461ae8eb0d8ba34bb25b7e618547044679d58a82ef9b2479fc1/markupsafe-3.0.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:61631e08084be9e21a8967ec3139c7616ed7c5e9368e05c86d1b39562c8a57b6", size = 11658, upload-time = "2026-10-02T23:04:51.876Z" }, + { url = "https://files.pythonhosted.org/packages/a2/f0/d6613774d86fbf6d145751d43c59875e47a6f9f17daee0aef173bd36d90e/markupsafe-3.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0930db9bdc62d22944e10b066448bb65dc9abe9112880c7cab8da54db4284d5f", size = 12050, upload-time = "2026-10-02T23:04:52.931Z" }, + { url = "https://files.pythonhosted.org/packages/0d/f2/8f18e0b806eb13c1f8d07d917a720831ead54253a6dec011fbc78098a6f8/markupsafe-3.0.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a45c3d514f2436064db00d7fc8778d888f0236ebfed649b53d13a59e69ad51b", size = 24363, upload-time = "2026-10-02T23:04:53.895Z" }, + { url = "https://files.pythonhosted.org/packages/60/ce/fa07dbe8a5675558fa36dea033e19995bc783de2dec5f540ccb9030b06aa/markupsafe-3.0.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1e1451fab512d1bcc3dc26988ec1edb0b82c2db909132872cd9356070a6b63df", size = 28525, upload-time = "2026-10-02T23:04:54.905Z" }, + { url = "https://files.pythonhosted.org/packages/85/40/be87c01f3868ec217f8a2015089d71c22c8c5a75324822e5ed1cdd87210d/markupsafe-3.0.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bd3ce56ae2cbae3ba82b683bc425cd7e48d2ed8b10f3e818186b6f5646d9271c", size = 24733, upload-time = "2026-10-02T23:04:56.229Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a7/aeedb5140afa41fc74c225e9184ab96723a6e873b6ee1c9fede7283456d8/markupsafe-3.0.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e124f974786f831d6043728e38296969d3579db8896fe004682f5758e613581", size = 22985, upload-time = "2026-10-02T23:04:57.521Z" }, + { url = "https://files.pythonhosted.org/packages/c3/fc/e91352bb08c6a59da3ef0909d457bf95a5f5908fbf151b30a06d9dbcfbb4/markupsafe-3.0.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:c02e8f18bdedba082cef725942ac823b9b60656db07f7e265cb31618dfd00d77", size = 22001, upload-time = "2026-10-02T23:04:58.597Z" }, + { url = "https://files.pythonhosted.org/packages/5d/f8/bffee5e7d2a3deb59748a797650a48af7e672025cf641a79344a771ad106/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:9f098115c247e11d138ab83a28fa0323c77015007ea2df73ba5fd714dfefd67c", size = 23793, upload-time = "2026-10-02T23:04:59.686Z" }, + { url = "https://files.pythonhosted.org/packages/ed/59/b853d6628ecb4d658e1d637224846d5e9bb4adf4f8df97f3be9f29dce2ec/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d5f93ebbeb8032d47e349328ec8662d973d9b05a70b3c35df1f91fe419b84749", size = 22640, upload-time = "2026-10-02T23:05:00.768Z" }, + { url = "https://files.pythonhosted.org/packages/09/b2/1506df394f0f075797c418d0301498f49e43be194e3ffcb49e6fe6ccf022/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:64511c54db4e4987aef4c41923235927428729e8174c5dba488429be70a998ed", size = 24074, upload-time = "2026-10-02T23:05:01.813Z" }, + { url = "https://files.pythonhosted.org/packages/c7/81/5ed69cda630ac69ef60d06c09ba5a7f84ff66a2e28cf986fd5614ab3c6e6/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:e1a622f13970d81f95d0c72f9dc090dce9085fccfa4c9f2174377ee32bd15786", size = 21563, upload-time = "2026-10-02T23:05:03.239Z" }, + { url = "https://files.pythonhosted.org/packages/0c/fe/fb1e79be0fea60aa32602ebefc9c35a82bb42b4df157285ab7dfec12341a/markupsafe-3.0.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c9a7f43c0b202b334cc9184af09bb8f21d3a209e038efaf106936fb69e6b026e", size = 23048, upload-time = "2026-10-02T23:05:04.479Z" }, + { url = "https://files.pythonhosted.org/packages/c8/52/7632a53360671a9b750cdbabaf9cdd89f18b42248b8e4cb42c0b0296e459/markupsafe-3.0.4-cp312-cp312-win32.whl", hash = "sha256:f0ec3b750b59375eab5b0fb2b9254810c00a3375be6d789899f1055a1d556237", size = 14108, upload-time = "2026-10-02T23:05:05.513Z" }, + { url = "https://files.pythonhosted.org/packages/3f/bf/62495e180b7000aaf30000fff849e933f74264638057176cf46852500adc/markupsafe-3.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:11935df9bf455ed0c04eb87bcd720f02b1fe5e02128a9430f23aed6f93336fc7", size = 14303, upload-time = "2026-10-02T23:05:06.538Z" }, + { url = "https://files.pythonhosted.org/packages/c5/8e/4c24208776a65878d656996945aacfbfe010d3720d1a98fc0eb8491fc03b/markupsafe-3.0.4-cp312-cp312-win_arm64.whl", hash = "sha256:a4bbd2d87dd233b9fc5812160c3d0ffbe42edc22a26ce0469f58479ede633fe9", size = 14174, upload-time = "2026-10-02T23:05:07.617Z" }, + { url = "https://files.pythonhosted.org/packages/6d/18/4bc5ba32499e87bb2b0ef5b3a9bb9c00a131fa961ddf0be548cb550f548b/markupsafe-3.0.4-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:de8b364c423ef0a4bad9069657d617f9a5d2b2062457a89b1fa16ee199c399c1", size = 12786, upload-time = "2026-10-02T23:05:08.709Z" }, + { url = "https://files.pythonhosted.org/packages/4e/6f/17f0c099bf25f3e31e63cc19244d9f6af861a9a4ab778c203997903cfdd0/markupsafe-3.0.4-cp313-cp313-android_24_x86_64.whl", hash = "sha256:34bdde374c5932765d7dc685c4a1d191a3207852d67e8e0a9eb6ea85156181f1", size = 12510, upload-time = "2026-10-02T23:05:09.93Z" }, + { url = "https://files.pythonhosted.org/packages/11/af/1a141081b905036ee904ec4bd945e1f70b4e1b32d33c4e59e8cf1d58b247/markupsafe-3.0.4-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:6bd9e1788e15bfcf6a9082de42e30387e7b85d211ab21e57a939bb8cfaaf8d96", size = 11583, upload-time = "2026-10-02T23:05:10.884Z" }, + { url = "https://files.pythonhosted.org/packages/e7/0a/a89385ae590232622a03e091805cff12f24fabe6c11e0e8bae096cece81c/markupsafe-3.0.4-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:5066b244f576f91afc8ee3ba029a89f99d39c79b1853fe9d39bea9f0afbec148", size = 11801, upload-time = "2026-10-02T23:05:11.913Z" }, + { url = "https://files.pythonhosted.org/packages/ed/85/ea548dc013962eb73653124bc595635fbf9e0fa41d1f181a967ccb784dfb/markupsafe-3.0.4-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:7a83aa6e4805df46fed18e989d3d16f86ef60cb50bbc8d9ce3a6be89165fbf6e", size = 11443, upload-time = "2026-10-02T23:05:12.887Z" }, + { url = "https://files.pythonhosted.org/packages/cc/72/15f2e5ec9cf2eb00d5cdfe968d94e4156a7bd7303832c3f3b2c403a36839/markupsafe-3.0.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2d1b7d9308288661f56672b1b157d75fc536714d3638487bbea17b6318a78248", size = 11665, upload-time = "2026-10-02T23:05:13.829Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e0/4030bea613677e333c8a2c901fd405055f657f9d06acba5b7357984b6ef7/markupsafe-3.0.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:73e77980c7207854f00fc4e71fb1626868d5740ab4012623d55c7a99ad122a72", size = 12061, upload-time = "2026-10-02T23:05:14.807Z" }, + { url = "https://files.pythonhosted.org/packages/f3/a5/28b76a7449eb702966b88bef599e2360b411fbb3afeee8fe560939be06ec/markupsafe-3.0.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7018d4af1cd272e847aa5917983ab5e83e4f6579f9dbfecd4a79c0ca80b144c2", size = 24395, upload-time = "2026-10-02T23:05:15.909Z" }, + { url = "https://files.pythonhosted.org/packages/07/6c/21232811afc3a063b5e934b1ae2efda52f46154ec382f585149c020e61fe/markupsafe-3.0.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c90d5b3d4e944e065a301d741b3c1d784f6bd1f503aa68b4967e32b2ba313d85", size = 27183, upload-time = "2026-10-02T23:05:16.976Z" }, + { url = "https://files.pythonhosted.org/packages/14/38/6ccdfa5b59049cb36fb80cbc80aee9cf1fc9bb77d1335ad435f2070b08cf/markupsafe-3.0.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:18a801868a884f216e784d7d14db2a4077143ce7610440aee2ce8f734e7cfcde", size = 24772, upload-time = "2026-10-02T23:05:18.209Z" }, + { url = "https://files.pythonhosted.org/packages/63/e0/cec6865dfe88cb48fedd4b20aed6af5158e41092adcbf3e028bcc6ec2108/markupsafe-3.0.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:434139499bb20b502ed3baa1f169e618f924a97e7a777fea1a49446d80106cf6", size = 23017, upload-time = "2026-10-02T23:05:19.286Z" }, + { url = "https://files.pythonhosted.org/packages/ee/76/6ed4940bb7648a9aac457c14f870cfdd5105f139a0fb1f29cd61fafa47d1/markupsafe-3.0.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:9e227f3dbe6bde7491cf0a9965d00b88c6b1a4a95d11480ddf88bb96d397c19f", size = 22036, upload-time = "2026-10-02T23:05:20.352Z" }, + { url = "https://files.pythonhosted.org/packages/a1/4f/ed476226d4fe46a09090a36025bf319296810028df55eb12f1253b540f3a/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b8cd1f918b26fd7b1832ece557cc18f2d8747309ff8b3f0ef9d4250c5ad67a39", size = 23786, upload-time = "2026-10-02T23:05:21.576Z" }, + { url = "https://files.pythonhosted.org/packages/9a/35/66ff30450e35ef5fba9ebc930c9411747e537fd9447b65e44f5007e2b84d/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:a5fcffb37e602b0b3c1638a97746b9b96125caa9bcf6fa41d337a9261de231ee", size = 22672, upload-time = "2026-10-02T23:05:22.922Z" }, + { url = "https://files.pythonhosted.org/packages/32/0b/72f45ce4b4efcbca4b80cf1b06703eff0be8d37e82abb78f66c85a7ead1e/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5989cb26b2e1efc6a42216a9f6b5ee495ce5ace2e5b352a9af489976b32d1ee2", size = 24107, upload-time = "2026-10-02T23:05:24.175Z" }, + { url = "https://files.pythonhosted.org/packages/d2/03/71776e5fdcba04614b384cc102e8a4198208579d896fd1394cb7cb9aa900/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:add96447a86d205ab616665d53b2950ee81083757f56e6ea833c8b2917646b46", size = 21615, upload-time = "2026-10-02T23:05:25.215Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5f/801ce02a02e7aee0f784b1ec7843026178f6adeb9c93ac67eb1992a9a84d/markupsafe-3.0.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2628d3a8cb648ecebb3c5d6b0a1052d400e4d8b7ac0fb786be8d285b50040d17", size = 23076, upload-time = "2026-10-02T23:05:26.423Z" }, + { url = "https://files.pythonhosted.org/packages/4a/85/c43776625428f3bb4a61e8633940400e3efe6409e3c6f5bff26de5e45618/markupsafe-3.0.4-cp313-cp313-win32.whl", hash = "sha256:672d207103e6b16ca098611b0f9efad6bc00afd47c03d6ef62186495ca677dc0", size = 14118, upload-time = "2026-10-02T23:05:27.716Z" }, + { url = "https://files.pythonhosted.org/packages/6f/36/163da64de88a13db79214ef75fa041be7fa13bdb42261cf5b7484de14bfb/markupsafe-3.0.4-cp313-cp313-win_amd64.whl", hash = "sha256:1f1f9477e174582b0a1b583d60b66e1f2cf5d3fe12cee985e4aedf44766600e5", size = 14313, upload-time = "2026-10-02T23:05:28.749Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a8/9b662783ffaa1149221432a923cee562f78b9cbbb8baa3df9b3753e63e1e/markupsafe-3.0.4-cp313-cp313-win_arm64.whl", hash = "sha256:06de8ef6331f6e822c28d577dc8bf43fe398800477c49498f38fc38b67ff33fc", size = 14189, upload-time = "2026-10-02T23:05:29.917Z" }, + { url = "https://files.pythonhosted.org/packages/5c/c3/a944f3b0df22bd129e96915b9f4e98d2eeca6516687d7618304a966c3c74/markupsafe-3.0.4-cp314-cp314-android_24_arm64_v8a.whl", hash = "sha256:4ed644d75aa94a2baf7ec3a96eaa160ea58c742eb9d27c6506053c5c40fc84ed", size = 12787, upload-time = "2026-10-02T23:05:30.971Z" }, + { url = "https://files.pythonhosted.org/packages/d4/d6/a44863f69d88b6c7e27889108f70d47aed259edf89d5df3c5fca1eac87d6/markupsafe-3.0.4-cp314-cp314-android_24_x86_64.whl", hash = "sha256:6d2a9efe686f9de00d0d1ea32a4a5a86d558a2277501bd78d964214eab625e59", size = 12525, upload-time = "2026-10-02T23:05:32.263Z" }, + { url = "https://files.pythonhosted.org/packages/17/8f/168ba80e532dd6a93f96f8f706f1ad41d7990b6e1aeedc1cc0d211a33497/markupsafe-3.0.4-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8781a792a070cf2bd1b86d3aa943894115faaba6e88122a7bf32d62072742453", size = 11589, upload-time = "2026-10-02T23:05:33.251Z" }, + { url = "https://files.pythonhosted.org/packages/32/b3/aa2c95a574d3af39403a469b295886eb9b6d448da568cbebb5a2cbfdc2e5/markupsafe-3.0.4-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:971a3bbb75d97ae4e2e8f7d4834236f86f85f0c85e04ab2e191db1123b04f80b", size = 11801, upload-time = "2026-10-02T23:05:34.315Z" }, + { url = "https://files.pythonhosted.org/packages/60/d0/34b810107d83840e768bf485de795893ebbae35b26ab061b487adfa0a692/markupsafe-3.0.4-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:8909c2f1c6dd65e054ac4b573a91c8384d1492281e55d82d159d653f7a13adf6", size = 11447, upload-time = "2026-10-02T23:05:35.302Z" }, + { url = "https://files.pythonhosted.org/packages/6c/ab/2f8488f0f817a39fca068d2b17daf446bf5cdb3eae28c3720af534d873b4/markupsafe-3.0.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:4cf3468d5ec187ffffcaca8e61929a37448f215dafc1386a12c750a72fe53634", size = 11722, upload-time = "2026-10-02T23:05:36.363Z" }, + { url = "https://files.pythonhosted.org/packages/ad/40/e2d117b048d47282ade906fbfd92814cbee5647afc13fda88a3406039372/markupsafe-3.0.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:52704c5d36eb6dda8866493decd61111fff86244c9b1ad225ca01b9e91e5970f", size = 12061, upload-time = "2026-10-02T23:05:37.397Z" }, + { url = "https://files.pythonhosted.org/packages/9a/a8/73a81135e85ba66217f5af7facb03bbb386807e1a729ab64532e4c802652/markupsafe-3.0.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1caa2fa5a6184fb233153b35f654e6687bd555476f6170f29d8ee9be1a8b0af9", size = 24434, upload-time = "2026-10-02T23:05:38.407Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ca/fa9216dd01efee2dfdacafe7df32b4d0170fbac694b0c258a193d6e53999/markupsafe-3.0.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:387d8cd30e69b3f0a72877b9ae717033396404e19095b17fe89753a981fda44f", size = 27183, upload-time = "2026-10-02T23:05:39.581Z" }, + { url = "https://files.pythonhosted.org/packages/fa/4e/a469509e538d37af51103b17b073126973f2b1cbf197ff32c7ddf025cfe5/markupsafe-3.0.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:051417f74bcaaefa316276e0ff723f541616ca51043d070da00249d9bddd3e3c", size = 24813, upload-time = "2026-10-02T23:05:40.671Z" }, + { url = "https://files.pythonhosted.org/packages/8f/db/d7282caf7ab03af44d5d6fdbaa019b35c7d7f1c90588b839c07cba640d6a/markupsafe-3.0.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8e9f292fcda89b324f2f5c91d13f1424a153e40fc2756f38ee23b15835ff300", size = 23049, upload-time = "2026-10-02T23:05:41.864Z" }, + { url = "https://files.pythonhosted.org/packages/30/f3/b6a425206e6964efda6acee544d0eb01d1501784d0b8e2dcc74986f33b17/markupsafe-3.0.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:df1ae86ff54725a01fa1a0510b914ca53a161b7050be74f6204e24aded5971d0", size = 22088, upload-time = "2026-10-02T23:05:43.014Z" }, + { url = "https://files.pythonhosted.org/packages/ea/8a/84d3582fc1f0d5bd466cdf2eebf175e172158a6e70701aacec1de1b35430/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8965520ac587c94a4ac48b729be3d8b8de00af39699b17585dfb599babe77977", size = 23846, upload-time = "2026-10-02T23:05:44.098Z" }, + { url = "https://files.pythonhosted.org/packages/1c/65/db101cce51b7ba4864ac491a9859d297dd1adf0e55b103fee9db9c47c527/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:340cbb1957ba99929cbf19a75626d36ba1ae21d1730b287d1cf7f824a20c4fc7", size = 22674, upload-time = "2026-10-02T23:05:45.23Z" }, + { url = "https://files.pythonhosted.org/packages/e0/49/ddee9813d71db0c7a5c9d97c832125e6758a0c844777f1cf076569bb0e22/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:3a93d9616ddecfb393727a0041a562cf0b15a244e20f2bd25efc7949be4c4f17", size = 24104, upload-time = "2026-10-02T23:05:46.398Z" }, + { url = "https://files.pythonhosted.org/packages/aa/0e/7d8518d726726870a2399d69fd30d0fa36c5e57a2132c336b58d7c491073/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:d2e56fd3b00222722abfb3f5f0759ddbae4b90811b5ad4343c64030ad1bde70c", size = 21637, upload-time = "2026-10-02T23:05:47.48Z" }, + { url = "https://files.pythonhosted.org/packages/b4/b0/b505e8a361ba557dbf3b3aa7331ea39b00d2022a26e925ff8463b9714bb3/markupsafe-3.0.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:0d9c47709875fdb321452056622e930c52afbc07a7d780762fbb8b4d91ce6fa4", size = 23081, upload-time = "2026-10-02T23:05:48.611Z" }, + { url = "https://files.pythonhosted.org/packages/1c/ea/9cc3cea873f980c75cbdb6f4277ce30ee955de38be0b3d02f14c108e0698/markupsafe-3.0.4-cp314-cp314-win32.whl", hash = "sha256:38fc55594dab834470b6733dead2ee9e3f657fb0608c769dcafa0ba5ab52f45c", size = 14272, upload-time = "2026-10-02T23:05:49.707Z" }, + { url = "https://files.pythonhosted.org/packages/80/f0/5792ff768a410f93ee3f84fc19345295ffc352d2c936b424cb37e514714c/markupsafe-3.0.4-cp314-cp314-win_amd64.whl", hash = "sha256:c1bc67752d5f21013cfe430df4062441714eab79f65a6a05e01505957e9c35fe", size = 14501, upload-time = "2026-10-02T23:05:50.788Z" }, + { url = "https://files.pythonhosted.org/packages/5f/cf/3d074a8edffcc6899355232ff2543ae8d929733239596423b7db79698bc9/markupsafe-3.0.4-cp314-cp314-win_arm64.whl", hash = "sha256:7e1636da3d8dfc220b6dd10264db5f2b165e4888c4518594898fbe381049af8a", size = 14364, upload-time = "2026-10-02T23:05:51.857Z" }, + { url = "https://files.pythonhosted.org/packages/d9/31/87ce42159aae2163cf3bbbd0c44bc87780510eecab1ea3859099aed95dcb/markupsafe-3.0.4-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:805c8b84534fa10891890f0e4be39f3a99e94615d93e8836bf9fa1fdca2feeb2", size = 11759, upload-time = "2026-10-02T23:05:52.951Z" }, + { url = "https://files.pythonhosted.org/packages/5f/53/b047207eeb7752e960aca3eb1df5fb7eefa7dd4c62ac49bb156456c8a702/markupsafe-3.0.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:fa95848c929b6a75f6848d3c9793e59db365ee436776e57db835cdbfa79ba977", size = 12096, upload-time = "2026-10-02T23:05:54.066Z" }, + { url = "https://files.pythonhosted.org/packages/ee/51/4326c88a13c7b755657d44b4bb986f8c3d9843ecba7e22d98661d87f9a57/markupsafe-3.0.4-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e916035e3e9930cbdfdd10abf48861340221857f45509565898e012263f7b289", size = 25699, upload-time = "2026-10-02T23:05:55.15Z" }, + { url = "https://files.pythonhosted.org/packages/f2/bb/990581b7474bfcf2cf34bed6ba5ea23bd87adb9d671213d68e88620e7a6b/markupsafe-3.0.4-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b4d12837e0203bbace818ff4a7461afdcd78bcd782351cea148139180d7bcffe", size = 27804, upload-time = "2026-10-02T23:05:56.29Z" }, + { url = "https://files.pythonhosted.org/packages/6b/89/89491878c28e8291f5aa2fffe2c2d57230d10ae366d55dd810b840513d78/markupsafe-3.0.4-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5086f9975abb1ab531ee6afca1761e4b59a19b446f3f6522ed776963228cfe5a", size = 25912, upload-time = "2026-10-02T23:05:57.416Z" }, + { url = "https://files.pythonhosted.org/packages/30/77/680998b54efdea06fc114565cd739b6d059f826a0279219b218dfa750d29/markupsafe-3.0.4-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b4a635a0487774f841cb1fb62e907e7195cc95bc761e053184b8acc3ceb20733", size = 23623, upload-time = "2026-10-02T23:05:58.557Z" }, + { url = "https://files.pythonhosted.org/packages/ae/75/2709f5ac5de9467b40b10e2bb8f89cc63dfb74582e09aa734b1124a217de/markupsafe-3.0.4-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb96e6e088d6cf71c1ea977510948320234824cf226e32f6f6e044f7a9c82b34", size = 23301, upload-time = "2026-10-02T23:05:59.94Z" }, + { url = "https://files.pythonhosted.org/packages/a0/c8/39eadc6c5b14c9c7679bfb98f4d4c6a97863b5beb91839aca4d2d6e16e55/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8b5d563170ff8ba3181caa967c99a3c804d1dedb702c7cb93a6a7c32247da978", size = 24950, upload-time = "2026-10-02T23:06:01.289Z" }, + { url = "https://files.pythonhosted.org/packages/1a/5e/01037f8a43e8ccb0bffb4fbdc5212db05bf080fdd7286cd392332d58128a/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:396ec4e65cc889f69786b3b89478b471cee5a3bcf468b9d9bb03e1a30fb291fc", size = 23330, upload-time = "2026-10-02T23:06:02.441Z" }, + { url = "https://files.pythonhosted.org/packages/d4/f4/23e83ce0596bb0cbe670502d31df8f757bbd01a392aa486fa3b40d1ed399/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:15ba9e28640feef770374b116a6f019c21f52404aeabe516aa7f800587b98cfc", size = 25239, upload-time = "2026-10-02T23:06:03.579Z" }, + { url = "https://files.pythonhosted.org/packages/88/5b/3708897368073cc683d524750474f41a77d2986152c380dcc55b20fdf340/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d920abdfa61279ba1a2ef9484aab07bf03331f8c08a10120fa332353d06e6932", size = 22767, upload-time = "2026-10-02T23:06:04.699Z" }, + { url = "https://files.pythonhosted.org/packages/c6/61/ebda1307864b409e6b3115757a3d4a09cca46cfb6cc65191b5de226b424b/markupsafe-3.0.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a9f54054101545a9a9cccefddf54316aa6e4491611fcbef9e91b3b6bebec04f6", size = 23668, upload-time = "2026-10-02T23:06:05.9Z" }, + { url = "https://files.pythonhosted.org/packages/09/15/98075cceac3b5ba0dbb8e4762a847be967d2befc349a2cf2d0ac77f62c9d/markupsafe-3.0.4-cp314-cp314t-win32.whl", hash = "sha256:12a606a492de952afcb43b59a14aaaaad120e708d3663dd0fdf2d738d427a691", size = 14301, upload-time = "2026-10-02T23:06:07.109Z" }, + { url = "https://files.pythonhosted.org/packages/0b/a3/768b560fcc4156685cb563d922b217810cfa7bc135773367f62f1f9d2078/markupsafe-3.0.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a18f38cafc329bac5e3c2b96c765b4c96d3d103421ed22ab7988c1e3fce27464", size = 14526, upload-time = "2026-10-02T23:06:08.276Z" }, + { url = "https://files.pythonhosted.org/packages/93/63/da554b4c97a6b0ea3229ca7fe8cbfb620be81613d517f482e85958550537/markupsafe-3.0.4-cp314-cp314t-win_arm64.whl", hash = "sha256:eba154571c16e032112afac0dc2dfe9e63c2ceb7aedd07bb7eecf2ce26d4dd4c", size = 14421, upload-time = "2026-10-02T23:06:09.402Z" }, + { url = "https://files.pythonhosted.org/packages/a9/30/54d11c8ca027114898cab97421fb39e4ffd9ddf47cdbc44df2ec76722da9/markupsafe-3.0.4-cp315-cp315-android_24_arm64_v8a.whl", hash = "sha256:737c9c3981998eba27f11786f84fddcbabc74068b72a4a1f454ea02094b57b65", size = 12791, upload-time = "2026-10-02T23:06:10.485Z" }, + { url = "https://files.pythonhosted.org/packages/10/6d/97c913e253a14bd3cd0e15a5c56d13203b823fa7ee32498342896a072dc4/markupsafe-3.0.4-cp315-cp315-android_24_x86_64.whl", hash = "sha256:489505b03f692c3f376394e49194fa7a7f9e8558d6e293a7056a0032b0c38163", size = 12527, upload-time = "2026-10-02T23:06:11.834Z" }, + { url = "https://files.pythonhosted.org/packages/26/f9/b86d032042a4d597d9e1997f0e5f63a3eedaf11258e0a05760b0a0a826ea/markupsafe-3.0.4-cp315-cp315-ios_13_0_arm64_iphoneos.whl", hash = "sha256:077293e425f28ec737dbcad442a71752e28f8ae27cde3d68acd1fb212091cd92", size = 11602, upload-time = "2026-10-02T23:06:13.122Z" }, + { url = "https://files.pythonhosted.org/packages/f2/dc/73c14c1eedf0ac5fa3292ba43435e6c49d2c2050f33cebde541f8f4807f1/markupsafe-3.0.4-cp315-cp315-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:9348cbb300d224fe3b89793262cb093504d4ae927004468463f745188a193e4a", size = 11817, upload-time = "2026-10-02T23:06:14.227Z" }, + { url = "https://files.pythonhosted.org/packages/8f/69/2c2fcaa5fcee22d72c7819c0d536fd181c74a688e6143845419579cd2863/markupsafe-3.0.4-cp315-cp315-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:b807e598953730f82e4eae3bd30f6a122cf6b31c398c6b504c0e04c13c170429", size = 11446, upload-time = "2026-10-02T23:06:15.574Z" }, + { url = "https://files.pythonhosted.org/packages/88/54/9e5ec76c62e6e2834d5a93623018c943e8b3bb41d663e3fd4c03303b9b85/markupsafe-3.0.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:799c39bdf5e2f1292fedd3009f7b3c9e760f10b2420cb9638d56920840ff6db8", size = 11719, upload-time = "2026-10-02T23:06:16.701Z" }, + { url = "https://files.pythonhosted.org/packages/96/24/3ec292b44064c16229e064d770b2625bd8ea941aa61f44905a9fa44942c0/markupsafe-3.0.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:ae9dcb8fbe244cb82f8a6458b455b927a03685e383d9bacf1ea5ce180b96dc97", size = 12075, upload-time = "2026-10-02T23:06:17.855Z" }, + { url = "https://files.pythonhosted.org/packages/aa/85/b64fdb1f304848518742136983c24e96d967bfb59a0ea160e92736901ab0/markupsafe-3.0.4-cp315-cp315-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4bced6e2a6dba6a28f7dd3c6ce14df1b2dd495923f16ea484cad03decd463b2b", size = 24656, upload-time = "2026-10-02T23:06:18.963Z" }, + { url = "https://files.pythonhosted.org/packages/9c/18/23997d4c65b355da6390d61cd56e0ab3befd6ba8dda25cb40c602bd0fa6b/markupsafe-3.0.4-cp315-cp315-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3882fb412298575bae3b9c46868251f15cc69307359f87bb1b382e53d6e5a2c9", size = 27737, upload-time = "2026-10-02T23:06:20.117Z" }, + { url = "https://files.pythonhosted.org/packages/d4/36/35998dead3c6af88c38265a56e58100211f036234ab88eb2283fd4cbce44/markupsafe-3.0.4-cp315-cp315-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:04e7902ba80ee4bac1d50a549606527a1dcf0476cd81403db41099d3b60ec653", size = 25003, upload-time = "2026-10-02T23:06:21.284Z" }, + { url = "https://files.pythonhosted.org/packages/82/96/ef49135ce260db4ca4a12b119ed468449cd248db6b1468e2112b546d7a2e/markupsafe-3.0.4-cp315-cp315-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:925f929d6b59a8b3f8b8c6ac363cd0af7eecc81efb3071770b3c6717c450a369", size = 23111, upload-time = "2026-10-02T23:06:22.524Z" }, + { url = "https://files.pythonhosted.org/packages/50/7d/83126e338bd88c17a220668235368ad719fd4638e426739858cbb8508f77/markupsafe-3.0.4-cp315-cp315-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f68edfc67aabac33708941f26f22a7b8e9f81429bc0cf249fcf7d66b23af8d19", size = 22403, upload-time = "2026-10-02T23:06:23.785Z" }, + { url = "https://files.pythonhosted.org/packages/83/dd/daf7e420de23c8206c365204e7b85e1251d8e19d34196a56336f316e5ed2/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:e5c802729725bd07e2bc3ab7b76dc7e0bbfc53129d8f1eb1c002c24cf774717e", size = 24083, upload-time = "2026-10-02T23:06:25.037Z" }, + { url = "https://files.pythonhosted.org/packages/19/3c/11eecdc06bc44ad5570350085b572ebf049e8f9a38d1ece6d76640b739cd/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_armv7l.whl", hash = "sha256:55ffd6ce583d97dc71dc92e930324c8c0d25aea7e3ade6ae54ef77cedb096811", size = 22931, upload-time = "2026-10-02T23:06:26.328Z" }, + { url = "https://files.pythonhosted.org/packages/0d/9e/ac0fd77f2a726e56ecc3ca0235d095feace1358d1b822406c2a2ef26a4dc/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_ppc64le.whl", hash = "sha256:2cb3dd71fc6be918ad4264346a8ed69485f9b7ed7bf35495d8e22807cd6b8bea", size = 24299, upload-time = "2026-10-02T23:06:27.742Z" }, + { url = "https://files.pythonhosted.org/packages/d7/09/c6bd842ad58ff5b3bc76eeed7e9a42a6f11adc5d090ec697b72c9672731e/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_riscv64.whl", hash = "sha256:94f5407f7bc64fa6463906b896f9904beeeb7dd8dc116ee8e9056c8714ff9916", size = 21948, upload-time = "2026-10-02T23:06:29.274Z" }, + { url = "https://files.pythonhosted.org/packages/a3/46/82f586711fed61e86faa1ee1bc317d68cd45a10c8bdbe3f7d1fdf9026ad8/markupsafe-3.0.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2dad610540cb2e6272855c178f08ae9a1c7ac258a7fb71660553a5f104b42741", size = 23150, upload-time = "2026-10-02T23:06:30.583Z" }, + { url = "https://files.pythonhosted.org/packages/19/2d/2dfdce99318abbfa26925195fbc17db188c46a1ec6457be121b6f9cfeb42/markupsafe-3.0.4-cp315-cp315-win32.whl", hash = "sha256:03470d1a8268e692ecf79ecd565593e59d44219377a7ead61f1f1b94c1f7ff6b", size = 14269, upload-time = "2026-10-02T23:06:31.949Z" }, + { url = "https://files.pythonhosted.org/packages/5b/ec/6000fd82e8791e58fcd0456ec20f098957e2b03d5ed02eb73241a577c0ba/markupsafe-3.0.4-cp315-cp315-win_amd64.whl", hash = "sha256:d882a373d8093c2941e01291b7ced96e9cbe4781da9a7751ca7e6c70385e5214", size = 14496, upload-time = "2026-10-02T23:06:33.258Z" }, + { url = "https://files.pythonhosted.org/packages/bc/66/e73bd5016421d5d6e2fb6de7dd609f9de020942ac8c626526bd8c6eeaf82/markupsafe-3.0.4-cp315-cp315-win_arm64.whl", hash = "sha256:353bd63081912ab8cfa6a0c7d185934cdf8426f04c618bba6bc4b394f2069b67", size = 14361, upload-time = "2026-10-02T23:06:34.539Z" }, + { url = "https://files.pythonhosted.org/packages/90/df/cb8c3dc98d313a951df2f8968f44e4cb5643df6d3cab749a530ce2f7d972/markupsafe-3.0.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:c61750fadcd119d0825bcb7d7d675dd264dcc89cc05292aab5be68ebdbb374ad", size = 11760, upload-time = "2026-10-02T23:06:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/d6/bb/4af9b3ca0753d654ac75f9531d5bd741bb77ca6e696f36807c475ffc099a/markupsafe-3.0.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:1c0df495a977d10460a94941799c72d5b5ab03d3858d949b55b5a66c8f371c99", size = 12108, upload-time = "2026-10-02T23:06:37.089Z" }, + { url = "https://files.pythonhosted.org/packages/3f/d4/b56429313aee5fd59b079c3df5615299959e25e7113eb6d8caadbdd7d38a/markupsafe-3.0.4-cp315-cp315t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:02fa4acbc6a3fc5c693c34d4dd8c1130b7fe99cc915181b0ddd6f72aeb296002", size = 25762, upload-time = "2026-10-02T23:06:38.419Z" }, + { url = "https://files.pythonhosted.org/packages/65/f5/34c181e891aa4f7d59c918584672e0c5eb7fffe76c1387d1246008bf4081/markupsafe-3.0.4-cp315-cp315t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:05295589e619b9bed252a86b532b8e27350abc372d18ba89b59375325e91ec1e", size = 28400, upload-time = "2026-10-02T23:06:39.819Z" }, + { url = "https://files.pythonhosted.org/packages/ce/b5/ad14694fd0ac9a5ce30bc6498f2999378f418583dd1679cca5a1b512957e/markupsafe-3.0.4-cp315-cp315t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:be6cb0c799abb0e2ba3e618e6d28ddddf7e485f6c2ce938dfa237daf3905072c", size = 25946, upload-time = "2026-10-02T23:06:41.381Z" }, + { url = "https://files.pythonhosted.org/packages/d6/a8/26b606445387d0ceb1eb1f21840094b84e4e3c3c3983d80d10b89823b490/markupsafe-3.0.4-cp315-cp315t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:26e9867520db70d37f7fb421a7f0d8adb40171011fb84ce869afa1a83370dfa8", size = 23634, upload-time = "2026-10-02T23:06:42.748Z" }, + { url = "https://files.pythonhosted.org/packages/39/a2/b8814de672f1f0094d498bf646f2fec9d6356b503d28ef500b71c5095377/markupsafe-3.0.4-cp315-cp315t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f03460ff076f70ab595bb45a0205ccea1971443575b6920c52e755dec2b3fbfe", size = 23488, upload-time = "2026-10-02T23:06:44.176Z" }, + { url = "https://files.pythonhosted.org/packages/db/c7/287223376fb73335a3cc5d6eb22c6ab01358cf33945a9c39c06b9dac3f4b/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:436e3ffc6310d3c41878c601db29098102fe5d8a467c49da4a4125254e0980f2", size = 25037, upload-time = "2026-10-02T23:06:45.646Z" }, + { url = "https://files.pythonhosted.org/packages/f9/29/4df8355e313426d19e62ba33e0253c009ca12a0894ee77d67fa67255361c/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:4e2c4809c14559aa7ef426f27fb35afbb38104c349a903bf8f3600456764bb38", size = 23543, upload-time = "2026-10-02T23:06:47.264Z" }, + { url = "https://files.pythonhosted.org/packages/71/e5/8377731e8495668dcc768f645e717df18318c841edaf023a99395f6da9b4/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_ppc64le.whl", hash = "sha256:da2af0d7aebfc2074080d72efa6ab8317c62481ef1f896f65d9999c1c01f4494", size = 25282, upload-time = "2026-10-02T23:06:48.795Z" }, + { url = "https://files.pythonhosted.org/packages/ed/5f/373456e37ceb1478d657d6fe769cbe0a39f0a8dfc1548eeb19c471eefdd9/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_riscv64.whl", hash = "sha256:aa2c838cc024642cc04c6854232f32b43e5e22833dd11119c1766c7873b8370d", size = 22993, upload-time = "2026-10-02T23:06:50.31Z" }, + { url = "https://files.pythonhosted.org/packages/d7/93/2cbd5628435afb6f541bbaced4bce0c2edac4b09a142e6e928b8b0da9858/markupsafe-3.0.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:b91cc9d336957239ff200f30097e6fea2dc6d6fb3c81e853eaa09eac904fd894", size = 23712, upload-time = "2026-10-02T23:06:51.759Z" }, + { url = "https://files.pythonhosted.org/packages/81/99/157e10966b033b363aeda5263e82596ee232a0b1d082fdbf90aa417ff083/markupsafe-3.0.4-cp315-cp315t-win32.whl", hash = "sha256:e49fb0d1ce92cfa0cb198cc5b1b11cdf9d0638658e2a2db2687e39db7c87fc78", size = 14300, upload-time = "2026-10-02T23:06:53.241Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/55884815414c9706a23deca150b72c25a62109e65b0b6ce232077802c719/markupsafe-3.0.4-cp315-cp315t-win_amd64.whl", hash = "sha256:4f6e0852a0283b1b1fd776eeb7b766a5f440b3e2bd31ab51af3b400585f3965c", size = 14522, upload-time = "2026-10-02T23:06:54.729Z" }, + { url = "https://files.pythonhosted.org/packages/92/f9/ecbde7149e95b8a0f18e16d5d747f7dc06049d5da2e4f77f6f5e4a1f46a8/markupsafe-3.0.4-cp315-cp315t-win_arm64.whl", hash = "sha256:39dbacefc411633db5b4378b066a9aca70a3d7e2922c9e578d825f844026eeba", size = 14417, upload-time = "2026-10-02T23:06:56.246Z" }, +] + +[[package]] +name = "packaging" +version = "26.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/7d/fa/3944b40b07da9ce895c0e6303a5ab7d53da063554f534556b134a54d6093/packaging-26.3.tar.gz", hash = "sha256:94edc256424af38762eb31306eed28beb9f0efc50a8837492c9d6fd6004aed79", size = 313412, upload-time = "2026-08-04T18:15:28.737Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/63/34/ba1c580383c9eada3711951fef0795c80b829a078d72188184bcab9dd527/packaging-26.3-py3-none-any.whl", hash = "sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c", size = 129956, upload-time = "2026-08-04T18:15:27.159Z" }, +] + +[[package]] +name = "pygments" +version = "2.21.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/2e/ced460408999b33da6b31b0021b0f37d329e202d4169aeb164493778f25b/pygments-2.21.0.tar.gz", hash = "sha256:610ca751c9bc2492b38eb9a38a7fbc93edbbb2d7182edaf34e66ae493dee5c8c", size = 5005329, upload-time = "2026-08-17T08:02:48.824Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/46/17f022dd3e953bf20a04a028a21ec746d942f8d2af30fa0f124fa0e6a684/pygments-2.21.0-py3-none-any.whl", hash = "sha256:2363c69b61c4a97c838da3b130dcd6468f4848992b21a82f2a63ec34377137d9", size = 1250147, upload-time = "2026-08-17T08:02:44.912Z" }, +] + +[[package]] +name = "pyjo-reactor-winloop" +version = "0.2.0.dev1" +source = { editable = "." } +dependencies = [ + { name = "pyjoyment" }, + { name = "winloop", marker = "sys_platform == 'win32'" }, +] + +[package.dev-dependencies] +docs = [ + { name = "sphinx", marker = "python_full_version >= '3.14'" }, +] + +[package.group-requires-python] +docs = ">=3.14" + +[package.metadata] +requires-dist = [ + { name = "pyjoyment", git = "https://github.com/pyjoyment/Pyjoyment?branch=main" }, + { name = "winloop", marker = "sys_platform == 'win32'", specifier = ">=0.8.2" }, +] + +[package.metadata.requires-dev] +docs = [{ name = "sphinx", marker = "python_full_version >= '3.14'", specifier = ">=9.2.0" }] + +[[package]] +name = "pyjoyment" +version = "0.2.1.dev1" +source = { git = "https://github.com/pyjoyment/Pyjoyment?branch=main#25fbbfa112d5c9bea9a8e8c4cedef2dbd8977d77" } + +[[package]] +name = "requests" +version = "2.34.2" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/f4/c67b0b3f1b9245e8d266f0f112c500d50e5b4e83cb6f3b71b6528104182a/requests-2.34.2-py3-none-any.whl", hash = "sha256:2a0d60c172f83ac6ab31e4554906c0f3b3588d37b5cb939b1c061f4907e278e0", size = 73075, upload-time = "2026-05-14T19:25:26.443Z" }, +] + +[[package]] +name = "roman-numerals" +version = "4.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/41dc953bbeb056c17d5f7a519f50fdf010bd0553be2d630bc69d1e022703/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2", size = 9077, upload-time = "2025-12-17T18:25:34.381Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/04/54/6f679c435d28e0a568d8e8a7c0a93a09010818634c3c3907fc98d8983770/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7", size = 7676, upload-time = "2025-12-17T18:25:33.098Z" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.1.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/f8/0a71edf031f03c40db17503cb8ca78a69a171254e568e7db241b0ab57ea1/snowballstemmer-3.1.1.tar.gz", hash = "sha256:e07bbc54a0d798fe6010a12398422e62a8bfbba95c394fd0956ef58cb4d3e260", size = 123314, upload-time = "2026-06-03T00:56:40.194Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4c/07/2ebca9b11fb9be7340a818d8d6f63feaebb146be2c4afbd6061701d6df6e/snowballstemmer-3.1.1-py3-none-any.whl", hash = "sha256:7e207fa178741da09cdee59d3ecec3827ad5f92b1fc5c9ff3755b639f71f5752", size = 104164, upload-time = "2026-06-03T00:56:38.614Z" }, +] + +[[package]] +name = "sphinx" +version = "9.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "alabaster" }, + { name = "babel" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "docutils" }, + { name = "imagesize" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "requests" }, + { name = "roman-numerals" }, + { name = "snowballstemmer" }, + { name = "sphinxcontrib-applehelp" }, + { name = "sphinxcontrib-devhelp" }, + { name = "sphinxcontrib-htmlhelp" }, + { name = "sphinxcontrib-jsmath" }, + { name = "sphinxcontrib-qthelp" }, + { name = "sphinxcontrib-serializinghtml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/64/d4/413466f0be8b1cb0e3e43893a148b96d7462d0923d82b4166b21afc5f30c/sphinx-9.2.0.tar.gz", hash = "sha256:90470459f3cab15d9dfed146c71cf77694b0445df17b2e0e69059cb9f7fc9ee4", size = 8782438, upload-time = "2026-10-21T00:05:15.019Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c4/28/a0c50761cd215b7042f4bc617a6bc5c0cd7be62f75bc908e169e28a4d21e/sphinx-9.2.0-py3-none-any.whl", hash = "sha256:4c3ec13b612712c0d3ce4cbdd9e3eb91e68577e07a8e31f32f21cf178453578c", size = 3925388, upload-time = "2026-10-21T00:05:12.241Z" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ba/6e/b837e84a1a704953c62ef8776d45c3e8d759876b4a84fe14eba2859106fe/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1", size = 20053, upload-time = "2024-07-29T01:09:00.465Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5d/85/9ebeae2f76e9e77b952f4b274c27238156eae7979c5421fba91a28f4970d/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5", size = 119300, upload-time = "2024-07-29T01:08:58.99Z" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f6/d2/5beee64d3e4e747f316bae86b55943f51e82bb86ecd325883ef65741e7da/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad", size = 12967, upload-time = "2024-07-29T01:09:23.417Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/35/7a/987e583882f985fe4d7323774889ec58049171828b58c2217e7f79cdf44e/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2", size = 82530, upload-time = "2024-07-29T01:09:21.945Z" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/93/983afd9aa001e5201eab16b5a444ed5b9b0a7a010541e0ddfbbfd0b2470c/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9", size = 22617, upload-time = "2024-07-29T01:09:37.889Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0a/7b/18a8c0bcec9182c05a0b3ec2a776bba4ead82750a55ff798e8d406dae604/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8", size = 98705, upload-time = "2024-07-29T01:09:36.407Z" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/59/02/4f334c7fc3e54c51d2364575a41cd2fae6847e7f53001949f0be5f32e18b/sphinxcontrib_jsmath-2.0.0.tar.gz", hash = "sha256:551f780cf9687f9c3c74f0cf9f18aca06e0d6958853453f3803fe4d357c5b924", size = 14511, upload-time = "2026-10-20T18:22:05.514Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/c2/2965c35b39587d4b7a397f65a9c7d4b942b031061e7ac1ce91782f394a0d/sphinxcontrib_jsmath-2.0.0-py3-none-any.whl", hash = "sha256:15ca92fe0eec82f0baf91a7efcc51ffacdb605924be6327683a52ebdacb6744c", size = 78095, upload-time = "2026-10-20T18:22:04.42Z" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/68/bc/9104308fc285eb3e0b31b67688235db556cd5b0ef31d96f30e45f2e51cae/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab", size = 17165, upload-time = "2024-07-29T01:09:56.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/83/859ecdd180cacc13b1f7e857abf8582a64552ea7a061057a6c716e790fce/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb", size = 88743, upload-time = "2024-07-29T01:09:54.885Z" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3b/44/6716b257b0aa6bfd51a1b31665d1c205fb12cb5ad56de752dfa15657de2f/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d", size = 16080, upload-time = "2024-07-29T01:10:09.332Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/52/a7/d2782e4e3f77c8450f727ba74a8f12756d5ba823d81b941f1b04da9d033a/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331", size = 92072, upload-time = "2024-07-29T01:10:08.203Z" }, +] + +[[package]] +name = "urllib3" +version = "2.8.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" }, +] + +[[package]] +name = "winloop" +version = "0.8.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8f/48/b49b0d4ec3abc1e20368ccb22c6e04a6e75f5492c9424308e8c432993060/winloop-0.8.2.tar.gz", hash = "sha256:41d0ae9fd4fdd86268efbfb12813f96d3141705ba96a6b413ce86972b6750d82", size = 2810819, upload-time = "2026-11-04T04:30:40.435Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/bb/73/e171c4b7a2f50747c6fba9268d45e392e4dfdcbab6a43ab6cce19d795d70/winloop-0.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:31abeaa2b2faac897ea9ff9a129bcb4c2d8eed11ebc73bed2baf3112e9bf14c3", size = 729408, upload-time = "2026-11-04T04:30:23.805Z" }, + { url = "https://files.pythonhosted.org/packages/a1/12/31259f0bdb311776db623b00abdaca31affb2a86e159c05e3e409c754a8a/winloop-0.8.2-cp312-cp312-win_arm64.whl", hash = "sha256:4aa8f4a1883867c809574fb3d1b12eb15aa35705a896a51520c30efb2e83a7da", size = 630211, upload-time = "2026-11-04T04:30:25.22Z" }, + { url = "https://files.pythonhosted.org/packages/69/59/b197929939ac863bd631d2246ea78a1402af9e1b97b8a393fa587aa381bc/winloop-0.8.2-cp313-cp313-win_amd64.whl", hash = "sha256:7587879fc40e8bbecb3943cd8953baeda61628252ec1a32d7897b1e16fe80aa9", size = 728379, upload-time = "2026-11-04T04:30:26.474Z" }, + { url = "https://files.pythonhosted.org/packages/e3/ca/68b49af3eb1762f12316680c49e242940958169f983c3cb96f2d98f0b908/winloop-0.8.2-cp313-cp313-win_arm64.whl", hash = "sha256:7d8f53a1596ca3379a8de8cb6eed12a0d078f5c66d583f225abe3c8b04220e3c", size = 630353, upload-time = "2026-11-04T04:30:27.735Z" }, + { url = "https://files.pythonhosted.org/packages/a1/8d/bd5d9fdfbf17f28c79d566b62eb6872c5ef9bd662d0d06c7a54aefbca73d/winloop-0.8.2-cp314-cp314-win_amd64.whl", hash = "sha256:c3ea281c781a6d884b237b1a8a9e495ae997b8c6df84d0cf68a27793c959412b", size = 738899, upload-time = "2026-11-04T04:30:28.941Z" }, + { url = "https://files.pythonhosted.org/packages/4a/7c/bef3962b1a1e457ba08a433dae8f779eea945faedd766c7aa565a456d995/winloop-0.8.2-cp314-cp314-win_arm64.whl", hash = "sha256:937d833903e832acb19b0a633c3fb83ad721c7418ce3244ea17ac5a3376bf30a", size = 644124, upload-time = "2026-11-04T04:30:29.993Z" }, + { url = "https://files.pythonhosted.org/packages/8a/03/2b76be0851ee4948fa22d8ea27ceab4e0358c655d1278bea28ed52313f3b/winloop-0.8.2-cp314-cp314t-win_amd64.whl", hash = "sha256:daee0f8e506d8ca27b71bf994649ed6a8bb49583e9d9b38273384bd8d7bdc756", size = 797279, upload-time = "2026-11-04T04:30:31.266Z" }, + { url = "https://files.pythonhosted.org/packages/a1/e5/b2861afc86c955eb9d7a61dc757e1dc978e432f2bb567c7a077ef5553442/winloop-0.8.2-cp314-cp314t-win_arm64.whl", hash = "sha256:dc3c65ed02fac2316dcda2732f1d771d458f32505e625b1f193ebecfbb631c6c", size = 693072, upload-time = "2026-11-04T04:30:32.287Z" }, + { url = "https://files.pythonhosted.org/packages/fd/c4/850edec550004faa72de54418833434c23569749c52f4f095d045274ef8a/winloop-0.8.2-cp315-cp315-win_amd64.whl", hash = "sha256:42fa84501afdb28ca15bfb9ac048426fd763bb041f76ff68137ee22fcdb1e5b9", size = 738315, upload-time = "2026-11-04T04:30:33.331Z" }, + { url = "https://files.pythonhosted.org/packages/82/f1/e5dd56a9549c55a88a3d16fcbd8c74fc04bc30aec77371c35dc5ebf63d9d/winloop-0.8.2-cp315-cp315-win_arm64.whl", hash = "sha256:6e30645f40970e71fb76c1a082a2be85c1aaeecc1e727ae56e35e5e71e6f8e1d", size = 644495, upload-time = "2026-11-04T04:30:34.68Z" }, + { url = "https://files.pythonhosted.org/packages/d5/34/6f797c8824783025f16fcd2d0574a2de80116595571fff2fc90f7f36189e/winloop-0.8.2-cp315-cp315t-win_amd64.whl", hash = "sha256:f749f2290f373ca7d8faf0405f225a400f2ff404166666e531f451d5117e58cd", size = 798138, upload-time = "2026-11-04T04:30:36.066Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e5/6b569541c302bad0000adbef05234546f1a8709fd1d5ad62ca96c6eb0cbb/winloop-0.8.2-cp315-cp315t-win_arm64.whl", hash = "sha256:6c44299318bb058ccff58cc9d105982f0ab3d4de8821f73a412218fcc5554126", size = 691865, upload-time = "2026-11-04T04:30:37.405Z" }, +] From 9f0ee3e79a27fa647f77824f80f7a1126739045a Mon Sep 17 00:00:00 2001 From: Piotr Roszatycki Date: Wed, 4 Nov 2026 15:11:11 +0100 Subject: [PATCH 2/2] Pyjo.Reactor.Winloop: the reactor on the loop of Winloop Pyjo.Reactor.Uvloop for Winloop: _own_loop makes a loop of Winloop in the place of the SelectorEventLoop of Pyjo.Reactor.Asyncio on Windows. Of the workarounds of _Loop of Uvloop, the halt of the readers and the writers after stop and the hook of the finalizer of an async generator in the debug mode are taken; the relay of the wakeup fd, the blocking mode and the watch again after an error are left out, as AGENTS.md explains from the sources of Winloop 0.8.2 and libuv 1.53. Pyright of Linux and macOS takes the stub of typings/winloop, and autodoc a mock of Winloop. t/Reactor_Winloop.py is the port of t/Reactor_Uvloop.py without what does not apply on Windows, with a signal while the loop waits and the writer of a socket whose peer has closed it. t/examples.py stops the server with Ctrl-Break, and runs examples/asyncio_winloop.py, the port of asyncio_uvloop.py. Tests and Build pass the interpreter by its path of Windows, and Build compares the output without the CR of Windows. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/build.yaml | 7 +- .github/workflows/tests.yaml | 4 +- AGENTS.md | 117 ++++-- Pyjo/Reactor/Winloop.py | 115 +++++- README.md | 76 +++- docs/conf.py | 6 +- docs/index.rst | 19 +- examples/asyncio_winloop.py | 41 +++ examples/hello_world_winloop.py | 2 +- t/Reactor_Winloop.py | 617 +++++++++++++++++++++++++++++++- t/examples.py | 25 +- typings/winloop/__init__.pyi | 25 ++ 12 files changed, 997 insertions(+), 57 deletions(-) create mode 100644 examples/asyncio_winloop.py create mode 100644 typings/winloop/__init__.pyi diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml index 4109630..d03914a 100644 --- a/.github/workflows/build.yaml +++ b/.github/workflows/build.yaml @@ -56,17 +56,18 @@ jobs: # nothing comes from it, with the Pyjoyment of PyPI that it depends on. # The first line of the example is the class of the reactor and whether # its loop is one of Winloop, so that Pyjo.Reactor.Asyncio or a loop of asyncio - # in their place fails the step. + # in their place fails the step. Python of Windows ends its lines with + # CRLF, which diff leaves out. - name: Install and run the wheel shell: bash run: |- - uv venv --python "$(command -v python)" "$RUNNER_TEMP/venv" + uv venv --python "$(python -c 'import sys; print(sys.executable)')" "$RUNNER_TEMP/venv" uv pip install --python "$RUNNER_TEMP/venv/Scripts/python" dist/*.whl cp examples/loopback_winloop.py "$RUNNER_TEMP/" cd "$RUNNER_TEMP" venv/Scripts/python -c 'import Pyjo.Reactor.Winloop; print(Pyjo.Reactor.Winloop.__version__)' venv/Scripts/python loopback_winloop.py | tee loopback.txt - diff - loopback.txt <<'EOF' + diff --strip-trailing-cr - loopback.txt <<'EOF' Pyjo_Reactor_Winloop winloop 200 Your Pyjo is working! EOF diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index 097424f..d5a9dd8 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -93,10 +93,12 @@ jobs: with: version: 0.13.6 # datasource=github-releases depName=astral-sh/uv + # The interpreter of setup-python by its path of Windows, as the one of Git + # Bash, from command -v, is a path of MSYS without .exe - name: Install working-directory: Pyjo-Reactor-Winloop shell: bash - run: uv sync --python "$(command -v python)" + run: uv sync --python "$(python -c 'import sys; print(sys.executable)')" # As in Pyjoyment: invalid escape sequences and deprecated APIs fail, and # the ResourceWarning of the development mode of Python, which only goes diff --git a/AGENTS.md b/AGENTS.md index 7dc7478..03239fe 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -13,23 +13,80 @@ Pyjo-Reactor-Uvloop, whose workflows and linters it shares, and whose ## How it works -The reactor is not implemented yet: the module is the stub of the template, -whose constructor raises `NotImplementedError`, so that nothing falls back to -the loop of asyncio in the meantime. What it is to be: - -- `Pyjo.Reactor.Uvloop` for Winloop: a subclass of `Pyjo.Reactor.Asyncio` - that overrides `_own_loop` with a loop of Winloop, `winloop.Loop` or a - subclass of it, in the place of `asyncio.new_event_loop()`. -- `_Loop` of `Pyjo.Reactor.Uvloop` works around the libuv and the uvloop that - Winloop has too: the wakeup fd of the signals, the hook of the finalizer of - an async generator in the debug mode, the poll after `stop`, the blocking - mode of a handle and the error of a handle. Each of them is to be checked on - Winloop, which is libuv on Windows, with its IOCP, and taken, changed or - left out, as found, and written down here; the fork and `POLLERR` of Linux - do not apply. +- It is `Pyjo.Reactor.Uvloop` for Winloop: a subclass of + `Pyjo.Reactor.Asyncio`, as the loop of Winloop is a loop of asyncio, which + overrides `_own_loop`, the loop that the reactor makes for itself: a + subclass of `winloop.Loop` in the place of the `asyncio.SelectorEventLoop` + that `Pyjo.Reactor.Asyncio` makes on Windows. The rest of what the reactor + does with a loop of its own, which `_own_loop` repeats, the set of the loops + that are closed at the exit of the interpreter, the finalizer that closes + the loop with the reactor and its handler of `atexit`, are private members + of `Pyjo.Reactor.Asyncio`, so a change of them in Pyjoyment breaks the + reactor: the suite of Pyjoyment, which CI runs on the reactor, is what + guards them. - What the reactor is for is the servers of Pyjoyment, `daemon` and `prethread`, as Windows has no fork for `prefork`, and its blocking user - agent, where no loop runs and the reactor makes one. + agent, where no loop runs and the reactor makes one. libuv of Windows polls + sockets only, with `uv_poll_init_socket` and the AFD of the I/O completion + port, as `select` of Windows does, without its limit of 512 sockets; a pipe + or a file cannot be watched, and `Pyjo.IOLoop.Stdio` is not available on + Windows anyway. +- `_Loop` of `Pyjo.Reactor.Uvloop` works around five things of libuv and + uvloop, which Winloop shares. They were checked in the sources of Winloop + 0.8.2 and of the libuv that it pins, 1.53, `src/win/core.c` and + `src/win/poll.c`; two are taken, three are left out: + - The hook of the finalizer of an async generator, taken: in the debug mode + of asyncio, which CI runs with `PYTHONDEVMODE=1`, a handle of Winloop + takes the stack where it is made, with `Sys_GetFrame` of its C, which is + `PyThreadState_GetFrame`, the frame that `sys._getframe` of uvloop reads. + The hook of Winloop, `_asyncgen_finalizer_hook`, of Cython, makes a handle + with `call_soon_threadsafe` while CPython clears the frame of another + async generator, as `head` of `Pyjo.Iterator` does, which crashed uvloop + (MagicStack/uvloop#756). `_Loop` overrides the hook in Python, which the + stack starts from then, as the hook of asyncio does, until a fix of it is + released in Winloop. + - The halt of the readers and the writers after `stop`, taken: `uv_run` of + Windows processes the completions of its port, which are the callbacks of + the readers and the writers, after its poll, and the next iteration runs + the idle handle, where Winloop calls `uv_stop`, and polls once more, with + no wait, before it ends. An event of the reactor that stops it, or ends + `one_tick`, would be followed by the same events, as with uvloop on POSIX. + `stop` of `_Loop` schedules a callback, which the idle handle runs before + that poll, and which halts the readers and the writers until the end of + the run. libuv submits the poll of a socket again after its callback, so a + socket that is ready is ready in the next run still. A completion that is + left over after the eight rounds of the processing of the iteration that + stops runs before the idle handle, which is not halted. + - The relay of the wakeup fd of the signals, left out: Winloop sets a socket + of its own as the wakeup fd in `run_forever`, in the main thread, as + uvloop does, but nothing of Pyjoyment on Windows waits for the wakeup fd + of its own with the reactor while it runs. The worker of + `Pyjo.Server.Prefork` that needed it does not exist on Windows; the + manager of `Pyjo.Server.Prethread` waits for it with `select.select`, + where no loop runs; its workers run the reactor in threads, where Winloop + sets no wakeup fd; and the handler of `Pyjo.Server.Daemon` stops the loop + itself, after Winloop, woken by its own socket, calls + `PyErr_CheckSignals`. The relay of uvloop writes with `os.write` too, and + the wakeup fd of Windows is a socket, which needs `send`. + - The blocking mode of a handle, left out: `uv_poll_init_socket` sets a + socket to the non-blocking mode, but the mode of a socket of Windows + cannot be read, as `os.get_blocking` takes a descriptor of the C runtime + and not a socket, and the terminal of `Pyjo.IOLoop.Stdio`, for which + uvloop needed it, is not watched on Windows. The sockets of Pyjoyment are + non-blocking. A `socket.socket` that is blocking, and that the reactor + watches, raises `BlockingIOError` after it, where the loop of asyncio + leaves it blocking; `sock.getblocking()` and `sock.setblocking(True)` + after `add_reader` and `add_writer` would set it back, if a test shows + the need. + - The watch again after an error of a handle, left out: libuv of Windows + reports the reset of a socket and the close of its peer as events of AFD, + `AFD_POLL_ABORT` and `AFD_POLL_DISCONNECT`, which are readable, and keeps + watching the socket, so its callbacks are called for as long as the + error lasts, as with the loop of asyncio. It stops watching only on an + error of the poll itself, as of a socket that is closed, and `select.poll`, + with which uvloop checks `POLLERR` on Linux, does not exist on Windows. +- `PYJO_ASYNCIO_SLOW_CALLBACK` sets the `slow_callback_duration` of a loop of + its own, as for `Pyjo.Reactor.Asyncio`, which the loop of Winloop has too. - Winloop has wheels for CPython on Windows only, with the free-threaded build, not for PyPy, so the matrix of Tests is CPython 3.12 to 3.15 and 3.15t on `windows-2025`. @@ -114,14 +171,22 @@ Biome in `.trunk/trunk.yaml` is the one of Pyjoyment, which explains why it is not the one of the plugin of Trunk. Its pyright needs the environment of `uv sync`, `.venv`, which `tool.pyright` of -`pyproject.toml` names, as the reactor imports Pyjoyment and Winloop, while -Pyjoyment has no dependencies to find; Trunk Check of CI runs `uv sync` first. +`pyproject.toml` names, as the reactor imports Pyjoyment, while Pyjoyment has +no dependencies to find; Trunk Check of CI runs `uv sync` first. Winloop is +not in that environment on Linux and macOS, so pyright takes the stub of +`typings/winloop`, the default `stubPath`, which has what the module uses of +Winloop, with the methods of asyncio that typeshed has abstract in +`asyncio.AbstractEventLoop` and `winloop.Loop` implements; the stub is taken on +Windows too, where it hides the types of Winloop itself. The import of Winloop +ignores `reportMissingModuleSource`, which pyright reports where only the stub +is found. The examples and the tests, and `docs/conf.py`, are not checked by pyright: for them it takes the regular package `Pyjo` of Pyjoyment, which hides `Pyjo.Reactor.Winloop` of the checkout. The documentation is one page, `docs/index.rst`: the docstrings of the -module, which autodoc imports, and the examples from `examples/`, included, +module, which autodoc imports, with a mock of Winloop, `autodoc_mock_imports` +of `docs/conf.py`, as Read the Docs and the workflow Docs build on Linux, and the examples from `examples/`, included, never copied, as in Pyjoyment. Read the Docs installs it with `uv sync` of `uv.lock` and the group `docs`, not with pip and a `docs/requirements.txt` as Pyjoyment does, so that it builds with the versions of the lock, as the workflow Docs does. @@ -136,9 +201,19 @@ Pyjoyment of `uv.lock`: mise exec -- uv run --group docs --with-editable ../Pyjoyment sphinx-build -W --keep-going -b html docs docs/_build/html ``` -`t/Reactor_Winloop.py` is to be `t/Reactor_Uvloop.py` of Pyjo-Reactor-Uvloop, -`t/Pyjo/Reactor_Asyncio.py` of Pyjoyment with subtests of its own, for the -loop of Winloop; it is a stub of the template now. +`t/Reactor_Winloop.py` is `t/Reactor_Uvloop.py` of Pyjo-Reactor-Uvloop, +`t/Pyjo/Reactor_Asyncio.py` of Pyjoyment with subtests of its own for the +loop of Winloop: a loop of its own, a given loop, a loop that is running, of +asyncio, a `SelectorEventLoop`, and of Winloop, a coroutine, +`PYJO_ASYNCIO_SLOW_CALLBACK`, a signal while the loop waits, the finalizer of +an async generator in the debug mode, a stop in a callback of I/O and the +writer of a socket whose peer has closed it. The subtests of Uvloop for the +fork, the wakeup fd of a program and the blocking mode of a pipe are left out, +as they do not apply on Windows. +`t/examples.py` stops the server of `examples/hello_world_winloop.py` with +Ctrl-Break, `CTRL_BREAK_EVENT` to a group of processes of its own, as +`t/lib/ServerProcess.py` of Pyjoyment does, as Windows cannot send INT to +another process. `t/docs/Reactor_Winloop.py` runs the synopsis of the module, in both forms, as `t/docs` of Pyjoyment does. diff --git a/Pyjo/Reactor/Winloop.py b/Pyjo/Reactor/Winloop.py index 3595f6a..af0a599 100644 --- a/Pyjo/Reactor/Winloop.py +++ b/Pyjo/Reactor/Winloop.py @@ -41,19 +41,41 @@ def timeout(reactor): if not reactor.is_running: reactor.start() - :mod:`Pyjo.Reactor.Winloop` is a low-level event reactor based on `Winloop `_, the fork of uvloop for Windows, the implementation of the event loop of :mod:`asyncio` on libuv. It is :mod:`Pyjo.Reactor.Asyncio` with an event loop of its own of Winloop, in -the place of the one of :mod:`asyncio`, so that the servers of Pyjoyment, as -:mod:`Pyjo.Server.Daemon` and :mod:`Pyjo.Server.Prethread`, and the blocking -requests of its user agent run on Winloop on Windows. ``PYJO_REACTOR`` -selects it for :mod:`Pyjo.IOLoop`:: - - PYJO_REACTOR=Pyjo.Reactor.Winloop python myapp.py daemon - -The reactor is not implemented yet. +the place of the :class:`asyncio.SelectorEventLoop` that +:mod:`Pyjo.Reactor.Asyncio` makes on Windows, so that the servers of +Pyjoyment, as :mod:`Pyjo.Server.Daemon` and :mod:`Pyjo.Server.Prethread`, +and the blocking requests of its user agent run on Winloop. ``PYJO_REACTOR`` +selects it for :mod:`Pyjo.IOLoop`, in PowerShell:: + + $env:PYJO_REACTOR = 'Pyjo.Reactor.Winloop' + python myapp.py daemon + +The loop of Winloop is a loop of :mod:`asyncio`, so coroutines, tasks and the +libraries of :mod:`asyncio` run along with the reactor, as with +:mod:`Pyjo.Reactor.Asyncio`. It watches sockets, as the +:class:`asyncio.SelectorEventLoop` of Windows does, not pipes or files, but +with the I/O completion ports of libuv, without the limit of 512 sockets of +:func:`select.select`. A reactor uses the event loop it is given, or else the +loop that is running, as inside :func:`asyncio.run`, which has to be able to +watch handles, as a loop of Winloop or an :class:`asyncio.SelectorEventLoop` +is, and only a loop of its own is one of Winloop. An ASGI server that runs a +loop of Winloop itself, as with ``loop_factory=winloop.new_event_loop``, is +taken by :mod:`Pyjo.Reactor.Asyncio` already, so it needs no reactor of +Winloop. + +A signal handler of Python runs while a loop of its own waits, as on the +Ctrl-C or Ctrl-Break that stops a server, but the wakeup fd that a program +sets with :func:`signal.set_wakeup_fd` is not written to then, as Winloop +sets one of its own while it runs, in the main thread. + +Winloop runs on Windows, and on CPython, not on PyPy. The +``PYJO_ASYNCIO_SLOW_CALLBACK`` environment variable sets the +``slow_callback_duration`` of a loop of its own in seconds, as for +:mod:`Pyjo.Reactor.Asyncio`. Events ------ @@ -71,10 +93,17 @@ def timeout(reactor): import Pyjo.Reactor.Asyncio +import asyncio import importlib.metadata +import os +import weakref +from collections.abc import Callable from typing import Any +# Winloop is installed on Windows only, and pyright of Linux and macOS takes the stub of typings/winloop +import winloop # pyright: ignore[reportMissingModuleSource] + __version__ = importlib.metadata.version('Pyjo-Reactor-Winloop') """The version of the distribution, of its metadata, which the workflow Automated version sets in pyproject.toml.""" @@ -86,10 +115,70 @@ class Pyjo_Reactor_Winloop(Pyjo.Reactor.Asyncio.object): :mod:`Pyjo.Reactor.Asyncio`. """ - # The template of the distribution: the reactor on Winloop is to be written, so that nothing falls back to the loop - # of asyncio in the meantime - def __init__(self, *args: Any, **kwargs: Any) -> None: - raise NotImplementedError('Pyjo.Reactor.Winloop is not implemented yet') + # A loop of its own of Winloop, in the place of the one of asyncio; the rest is what Pyjo.Reactor.Asyncio does with a + # loop of its own, which is closed with the reactor, and at the exit of the interpreter after its tasks + def _own_loop(self) -> asyncio.AbstractEventLoop: + loop = self._own = _new_event_loop() + Pyjo.Reactor.Asyncio._OWN.add(loop) # pyright: ignore[reportPrivateUsage] + self._finalizer = weakref.finalize(self, Pyjo.Reactor.Asyncio._close, loop) # pyright: ignore[reportPrivateUsage] + Pyjo.Reactor.Asyncio._register() # pyright: ignore[reportPrivateUsage] + return loop + + +class _Loop(winloop.Loop): + _halt: asyncio.Handle | None = None + _halted = False + + # After stop, Winloop ends the iteration of libuv, and the iteration that a callback of I/O stops goes on to the poll + # of the next one, where libuv of Windows takes the completions of its I/O completion port and calls the readers and + # the writers that are ready again, as on POSIX, where the loop of asyncio ends with the callbacks of its select. A + # callback that stop schedules runs before that poll, in the idle handle of Winloop, and halts the readers and the + # writers until the end of the run; the poll of a socket is submitted again after its callback, so the socket is + # ready in the next run still. A stop in a ready callback does not halt the poll of its own iteration, as the loop of + # asyncio runs the callbacks of its select along with it, which would starve the I/O of one_tick otherwise + def run_forever(self) -> None: + self._halted = False + try: + return super().run_forever() + finally: + self._halted = False + if (halt := self._halt) is not None: + self._halt = None + halt.cancel() + + def stop(self) -> None: + if self._halt is None and self.is_running(): + self._halt = self.call_soon(self._halting) + super().stop() + + def _halting(self) -> None: + self._halt = None + self._halted = True + + def add_reader(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: + super().add_reader(fd, self._ready, callback, *args) + + def add_writer(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: + super().add_writer(fd, self._ready, callback, *args) + + def _ready(self, callback: Callable[..., Any], *args: Any) -> None: + if not self._halted: + callback(*args) + + # The finalizer of an async generator, which a dealloc calls while CPython clears a frame, in Python, as the one of + # asyncio: the handle of Winloop takes the stack in the debug mode with the current frame of the thread, which + # crashes on the frame that is cleared when the hook of Cython is the top of the stack, as in uvloop + # (MagicStack/uvloop#756) + def _asyncgen_finalizer_hook(self, agen: Any) -> None: + super()._asyncgen_finalizer_hook(agen) + + +# The threshold of a slow callback of PYJO_ASYNCIO_SLOW_CALLBACK, as for a loop of its own of Pyjo.Reactor.Asyncio +def _new_event_loop() -> asyncio.AbstractEventLoop: + loop = _Loop() + if duration := os.environ.get('PYJO_ASYNCIO_SLOW_CALLBACK'): + loop.slow_callback_duration = float(duration) + return loop new = Pyjo_Reactor_Winloop.new diff --git a/README.md b/README.md index 7fd70a1..735c128 100644 --- a/README.md +++ b/README.md @@ -24,8 +24,6 @@ Pyjoyment, `daemon` and `prethread`, and the blocking requests of its user agent run on Winloop, with coroutines, tasks and the libraries of asyncio along with them. -The reactor is not implemented yet: this is the template of the distribution. - ## Installation From [PyPI](https://pypi.org/project/Pyjo-Reactor-Winloop/), with @@ -51,18 +49,26 @@ pip install git+https://github.com/pyjoyment/Pyjo-Reactor-Winloop ## Usage -Select the reactor with `PYJO_REACTOR` before `Pyjo.IOLoop` is loaded: +Select the reactor with `PYJO_REACTOR` before `Pyjo.IOLoop` is loaded, in +PowerShell: + +```powershell +$env:PYJO_REACTOR = 'Pyjo.Reactor.Winloop' +python myapp.py daemon +python myapp.py prethread +``` + +or in Git Bash: ```sh PYJO_REACTOR=Pyjo.Reactor.Winloop python myapp.py daemon -PYJO_REACTOR=Pyjo.Reactor.Winloop python myapp.py prethread ``` ## Examples `examples/hello_world_winloop.py` runs `Pyjo.HelloWorld` on the server of -Pyjoyment on Winloop until the signal `INT` or `TERM`, in a `with` block, -which closes the listen sockets of the server at its end: +Pyjoyment on Winloop until Ctrl-C or Ctrl-Break, in a `with` block, which +closes the listen sockets of the server at its end: ```python import os @@ -75,7 +81,7 @@ import Pyjo.HelloWorld # noqa: E402 import Pyjo.Server.Daemon # noqa: E402 -# The server of Pyjoyment on Winloop, until the signal INT or TERM, which closes its listen sockets at the end of the block +# The server of Pyjoyment on Winloop, until Ctrl-C or Ctrl-Break, which closes its listen sockets at the end of the block with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://*:3000']) as daemon: daemon.run() ``` @@ -90,6 +96,62 @@ $ curl http://127.0.0.1:3000/ Your Pyjo is working! ``` +`examples/asyncio_winloop.py` is a coroutine on the loop of Winloop, which +requests the server of Pyjoyment in the same loop with the streams of asyncio +and with the user agent of Pyjoyment, as the libraries of asyncio run along +with the reactor: + +```python +import os + + +# The reactor of Pyjoyment on Winloop, selected before Pyjo.IOLoop is loaded +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.HelloWorld # noqa: E402 +import Pyjo.IOLoop # noqa: E402 +import Pyjo.Server.Daemon # noqa: E402 +import Pyjo.UserAgent # noqa: E402 + +import asyncio # noqa: E402 + +import winloop # noqa: E402 + + +# A coroutine on the loop of Winloop, with the streams of asyncio and the user agent of Pyjoyment, both requesting the +# server of Pyjoyment in the same loop +async def main(port): + reader, writer = await asyncio.open_connection('127.0.0.1', port) + writer.write(b'GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n') + print(f'asyncio: {(await reader.readline()).decode().strip()}') + writer.close() + await writer.wait_closed() + + with Pyjo.UserAgent.new() as ua: + tx = await ua.get_p(f'http://127.0.0.1:{port}/') + print(f'Pyjo.UserAgent: {tx.res.code} {tx.res.text}') + + return 'winloop' if isinstance(asyncio.get_running_loop(), winloop.Loop) else 'asyncio' + + +# The server, on a port that the system picks, which closes its listen sockets at the end of the block +with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://127.0.0.1'], silent=True) as daemon: + port = daemon.start().ports()[0] + Pyjo.IOLoop.singleton.reactor.run_coroutine( + main(port), + lambda loop: (print(f'loop: {loop}'), Pyjo.IOLoop.stop()), + lambda err: (print(f'error: {err}'), Pyjo.IOLoop.stop()), + ) + Pyjo.IOLoop.start() +``` + +```console +$ python examples/asyncio_winloop.py +asyncio: HTTP/1.1 200 OK +Pyjo.UserAgent: 200 Your Pyjo is working! +loop: winloop +``` + `examples/loopback_winloop.py` is a server of Pyjoyment and its user agent on the loop of Winloop, a blocking request, which runs the event loop until the response, and the class of the reactor and whether its loop is one of diff --git a/docs/conf.py b/docs/conf.py index a8c696f..dc43e2e 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -13,7 +13,7 @@ ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) # The module is imported from the environment of uv sync, where the project is installed in editable mode, with -# Pyjoyment and Winloop, which it imports +# Pyjoyment, which it imports with open(os.path.join(ROOT, 'pyproject.toml'), 'rb') as f: PROJECT = tomllib.load(f)['project'] @@ -24,6 +24,10 @@ extensions = ['sphinx.ext.autodoc', 'sphinx.ext.intersphinx', 'sphinx.ext.linkcode'] +# Winloop is installed on Windows only, and Read the Docs and the workflow Docs build on Linux: autodoc imports the +# module with a mock of it, whose Loop the private loop of the module subclasses +autodoc_mock_imports = ['winloop'] + # The documentation of Pyjoyment of the same version of Read the Docs as this one, stable for stable, and latest for # the others, as a tag or a pull request of this project is no version of Pyjoyment CHANNEL = 'stable' if os.environ.get('READTHEDOCS_VERSION') == 'stable' else 'latest' diff --git a/docs/index.rst b/docs/index.rst index 3a2ebca..d139eda 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -9,8 +9,8 @@ :name: examples ``examples/hello_world_winloop.py`` runs ``Pyjo.HelloWorld`` on the server of -Pyjoyment on Winloop until the signal ``INT`` or ``TERM``, in a ``with`` -block, which closes the listen sockets of the server at its end: +Pyjoyment on Winloop until Ctrl-C or Ctrl-Break, in a ``with`` block, +which closes the listen sockets of the server at its end: .. include:: ../examples/hello_world_winloop.py :code: python @@ -25,6 +25,21 @@ block, which closes the listen sockets of the server at its end: $ curl http://127.0.0.1:3000/ Your Pyjo is working! +``examples/asyncio_winloop.py`` is a coroutine on the loop of Winloop, which +requests the server of Pyjoyment in the same loop with the streams of +:mod:`asyncio` and with the user agent of Pyjoyment, as the libraries of +:mod:`asyncio` run along with the reactor: + + .. include:: ../examples/asyncio_winloop.py + :code: python + +.. code-block:: console + + $ python examples/asyncio_winloop.py + asyncio: HTTP/1.1 200 OK + Pyjo.UserAgent: 200 Your Pyjo is working! + loop: winloop + ``examples/loopback_winloop.py`` is a server of Pyjoyment and its user agent on the loop of Winloop, a blocking request, which runs the event loop until the response, and the class of the reactor and whether its loop is one of diff --git a/examples/asyncio_winloop.py b/examples/asyncio_winloop.py new file mode 100644 index 0000000..996b9bc --- /dev/null +++ b/examples/asyncio_winloop.py @@ -0,0 +1,41 @@ +import os + + +# The reactor of Pyjoyment on Winloop, selected before Pyjo.IOLoop is loaded +os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' + +import Pyjo.HelloWorld # noqa: E402 +import Pyjo.IOLoop # noqa: E402 +import Pyjo.Server.Daemon # noqa: E402 +import Pyjo.UserAgent # noqa: E402 + +import asyncio # noqa: E402 + +import winloop # noqa: E402 + + +# A coroutine on the loop of Winloop, with the streams of asyncio and the user agent of Pyjoyment, both requesting the +# server of Pyjoyment in the same loop +async def main(port): + reader, writer = await asyncio.open_connection('127.0.0.1', port) + writer.write(b'GET / HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n\r\n') + print(f'asyncio: {(await reader.readline()).decode().strip()}') + writer.close() + await writer.wait_closed() + + with Pyjo.UserAgent.new() as ua: + tx = await ua.get_p(f'http://127.0.0.1:{port}/') + print(f'Pyjo.UserAgent: {tx.res.code} {tx.res.text}') + + return 'winloop' if isinstance(asyncio.get_running_loop(), winloop.Loop) else 'asyncio' + + +# The server, on a port that the system picks, which closes its listen sockets at the end of the block +with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://127.0.0.1'], silent=True) as daemon: + port = daemon.start().ports()[0] + Pyjo.IOLoop.singleton.reactor.run_coroutine( + main(port), + lambda loop: (print(f'loop: {loop}'), Pyjo.IOLoop.stop()), + lambda err: (print(f'error: {err}'), Pyjo.IOLoop.stop()), + ) + Pyjo.IOLoop.start() diff --git a/examples/hello_world_winloop.py b/examples/hello_world_winloop.py index b82551c..d9fb18c 100644 --- a/examples/hello_world_winloop.py +++ b/examples/hello_world_winloop.py @@ -8,6 +8,6 @@ import Pyjo.Server.Daemon # noqa: E402 -# The server of Pyjoyment on Winloop, until the signal INT or TERM, which closes its listen sockets at the end of the block +# The server of Pyjoyment on Winloop, until Ctrl-C or Ctrl-Break, which closes its listen sockets at the end of the block with Pyjo.Server.Daemon.new(app=Pyjo.HelloWorld.new(), listen=['http://*:3000']) as daemon: daemon.run() diff --git a/t/Reactor_Winloop.py b/t/Reactor_Winloop.py index 9e1d868..bb57c43 100644 --- a/t/Reactor_Winloop.py +++ b/t/Reactor_Winloop.py @@ -1,20 +1,627 @@ import os -# The template of the test of the reactor, to be t/Reactor_Uvloop.py of Pyjo-Reactor-Uvloop, t/Pyjo/Reactor_Asyncio.py -# of Pyjoyment with subtests of its own, for the loop of Winloop. The reactor of the test is selected before Pyjo.IOLoop -# is loaded, as Pyjo.Reactor.detect() prefers Pyjo.Reactor.Asyncio +# Unlike Mojolicious: the reactor of the test is selected before Pyjo.IOLoop is loaded, as Mojo::Reactor->detect prefers +# Mojo::Reactor::EV where it is installed, and Pyjo.Reactor.detect() prefers Pyjo.Reactor.Asyncio os.environ['PYJO_REACTOR'] = 'Pyjo.Reactor.Winloop' import Pyjo.Reactor # noqa: E402 +import Pyjo.Reactor.Asyncio # noqa: E402 import Pyjo.Reactor.Winloop # noqa: E402 +from Pyjo.Loader import load_class # noqa: E402 from Pyjo.Test import * # noqa: E402 +import asyncio # noqa: E402 +import signal # noqa: E402 +import socket # noqa: E402 +import subprocess # noqa: E402 +import sys # noqa: E402 +import threading # noqa: E402 +import time # noqa: E402 -with subtest('Reactor detection'): - is_ok(Pyjo.Reactor.object.detect(), 'Pyjo.Reactor.Winloop', 'right class') +import winloop # noqa: E402 + + +def eval_(cb): + try: + cb() + except Exception as e: + return e + + +# Shared between subtests, since I/O watchers and timers keep firing across them +readable = writable = 0 + + +def rw_cb(reactor, is_writable): + global readable, writable + if is_writable: + writable += 1 + else: + readable += 1 + + +with subtest('Instantiation'): reactor = Pyjo.Reactor.Winloop.new() is_ok(type(reactor), Pyjo.Reactor.Winloop.object, 'right object') + is_ok(type(Pyjo.Reactor.Winloop.new()), Pyjo.Reactor.Winloop.object, 'right object') + del reactor + is_ok(type(Pyjo.Reactor.Winloop.new()), Pyjo.Reactor.Winloop.object, 'right object') + # Not in Mojolicious: the constructor of Python, as in Pyjoyment, and the reactor of asyncio, which it extends + is_ok(Pyjo.Reactor.Winloop.Winloop, Pyjo.Reactor.Winloop.object, 'right class') + is_ok(type(Pyjo.Reactor.Winloop.Winloop()), Pyjo.Reactor.Winloop.object, 'right object') + ok(issubclass(Pyjo.Reactor.Winloop.object, Pyjo.Reactor.Asyncio.object), 'reactor of asyncio') + ok(not load_class('Pyjo.IOLoop'), 'use Pyjo.IOLoop') + reactor = Pyjo.IOLoop.singleton.reactor + is_ok(type(reactor), Pyjo.Reactor.Winloop.object, 'right object') + +with subtest('Make sure it stops automatically when not watching for events'): + triggered = 0 + + def triggered_cb(loop): + global triggered + triggered += 1 + + Pyjo.IOLoop.next_tick(triggered_cb) + Pyjo.IOLoop.start() + ok(triggered, 'reactor waited for one event') + started = time.time() + Pyjo.IOLoop.start() + Pyjo.IOLoop.one_tick() + ok(time.time() < (started + 10), 'stopped automatically') + +with subtest('Listen'): + listen = socket.create_server(('127.0.0.1', 0), backlog=5) + port = listen.getsockname()[1] + reactor.io(listen, rw_cb).watch(listen, False, False).watch(listen, True, True) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(not readable, 'handle is not readable') + ok(not writable, 'handle is not writable') + +with subtest('Connect'): + client = socket.create_connection(('127.0.0.1', port)) + reactor.timer(1, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable') + ok(not writable, 'handle is not writable') + +with subtest('Accept'): + server = listen.accept()[0] + ok(reactor.remove(listen), 'removed') + ok(not reactor.remove(listen), 'not removed again') + readable = writable = 0 + reactor.io(client, rw_cb) + reactor.again(reactor.timer(0.025, lambda reactor: reactor.stop())) + reactor.start() + ok(not readable, 'handle is not readable') + ok(writable, 'handle is writable') + client.sendall(b'hello!\n') + time.sleep(1) + ok(reactor.remove(client), 'removed') + readable = writable = 0 + reactor.io(server, rw_cb) + reactor.watch(server, True, False) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable') + ok(not writable, 'handle is not writable') + readable = writable = 0 + reactor.watch(server, True, True) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable') + ok(writable, 'handle is writable') + readable = writable = 0 + reactor.watch(server, False, False) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(not readable, 'handle is not readable') + ok(not writable, 'handle is not writable') + readable = writable = 0 + reactor.watch(server, True, False) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable') + ok(not writable, 'handle is not writable') + readable = writable = 0 + reactor.io(server, rw_cb) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable') + ok(writable, 'handle is writable') + +with subtest('Timers'): + timer = recurring = 0 + + def timer_cb(reactor): + global timer + timer += 1 + + def recurring_cb(reactor): + global recurring + recurring += 1 + + reactor.timer(0, timer_cb) + ok(reactor.remove(reactor.timer(0, timer_cb)), 'removed') + id = reactor.recurring(0, recurring_cb) + readable = writable = 0 + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable again') + ok(writable, 'handle is writable again') + ok(timer, 'timer was triggered') + ok(recurring, 'recurring was triggered') + done = False + readable = writable = timer = recurring = 0 + + def done_cb(reactor): + global done + done = reactor.is_running + + reactor.timer(0.025, done_cb) + while not done: + reactor.one_tick() + ok(readable, 'handle is readable again') + ok(writable, 'handle is writable again') + ok(not timer, 'timer was not triggered') + ok(recurring, 'recurring was triggered again') + readable = writable = timer = recurring = 0 + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable again') + ok(writable, 'handle is writable again') + ok(not timer, 'timer was not triggered') + ok(recurring, 'recurring was triggered again') + ok(reactor.remove(id), 'removed') + ok(not reactor.remove(id), 'not removed again') + readable = writable = timer = recurring = 0 + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable again') + ok(writable, 'handle is writable again') + ok(not timer, 'timer was not triggered') + ok(not recurring, 'recurring was not triggered again') + readable = writable = timer = recurring = 0 + next_tick = 0 + + def next_tick_cb(reactor): + global next_tick + next_tick += 1 + + is_ok(reactor.next_tick(next_tick_cb), None, 'returned None') + id = reactor.recurring(0, recurring_cb) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(readable, 'handle is readable again') + ok(writable, 'handle is writable again') + ok(not timer, 'timer was not triggered') + ok(recurring, 'recurring was triggered again') + ok(next_tick, 'next tick was triggered') + +with subtest('Reset'): + + def reset_failed_cb(reactor): + raise Exception('Reset failed') + + reactor.next_tick(reset_failed_cb) + reactor.reset() + readable = writable = recurring = 0 + reactor.next_tick(lambda reactor: reactor.stop()) + reactor.start() + ok(not readable, 'io event was not triggered again') + ok(not writable, 'io event was not triggered again') + ok(not recurring, 'recurring was not triggered again') + reactor2 = Pyjo.Reactor.Winloop.new() + is_ok(type(reactor2), Pyjo.Reactor.Winloop.object, 'right object') + +with subtest('Ordered next_tick'): + result = [] + for i in range(1, 11): + reactor.next_tick(lambda reactor, i=i: result.append(i)) + reactor.start() + is_deeply_ok(result, list(range(1, 11)), 'right result') + +with subtest('Reset while watchers are active'): + writable = 0 + + def reset_cb(reactor, is_writable): + global writable + writable += 1 + reactor.reset() + + for handle in (client, server): + reactor.io(handle, reset_cb).watch(handle, False, True) + reactor.start() + is_ok(writable, 1, 'only one handle was writable') + client.close() + server.close() + +with subtest('Concurrent reactors'): + timer = 0 + reactor.recurring(0, timer_cb) + timer2 = 0 + + def timer2_cb(reactor): + global timer2 + timer2 += 1 + + reactor2.recurring(0, timer2_cb) + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(timer, 'timer was triggered') + ok(not timer2, 'timer was not triggered') + timer = timer2 = 0 + reactor2.timer(0.025, lambda reactor: reactor.stop()) + reactor2.start() + ok(not timer, 'timer was not triggered') + ok(timer2, 'timer was triggered') + timer = timer2 = 0 + reactor.timer(0.025, lambda reactor: reactor.stop()) + reactor.start() + ok(timer, 'timer was triggered') + ok(not timer2, 'timer was not triggered') + timer = timer2 = 0 + reactor2.timer(0.025, lambda reactor: reactor.stop()) + reactor2.start() + ok(not timer, 'timer was not triggered') + ok(timer2, 'timer was triggered') + reactor.reset() + +with subtest('Restart timer'): + single = pair = last = 0 + + def single_cb(reactor): + global single + single += 1 + + def one_cb(reactor): + global pair, last + if single and pair: + last += 1 + pair += 1 + reactor.stop() if pair > 1 else reactor.again(two) + + def two_cb(reactor): + global pair, last + if single and pair: + last += 1 + pair += 1 + reactor.stop() if pair > 1 else reactor.again(one) + + reactor.timer(0.025, single_cb) + one = reactor.timer(0.025, one_cb) + two = reactor.timer(0.025, two_cb) + reactor.start() + is_ok(pair, 2, 'timer pair was triggered') + ok(single, 'single timer was triggered') + ok(last, 'timers were triggered in the right order') + +with subtest('Reset timer'): + before = time.monotonic() + after = None + again = 0 + + def after_cb(reactor): + global after + after = time.monotonic() + + def again_cb(reactor): + global again + again += 1 + if again > 3: + reactor.remove(two) + + def restart_cb(reactor): + reactor.again(one, 0.025) + reactor.again(two, 0.025) + + one = reactor.timer(300, after_cb) + two = reactor.recurring(300, again_cb) + reactor.timer(0.025, restart_cb) + reactor.start() + ok(after, 'timer was triggered') + ok((after - before) < 200, 'less than 200 seconds') + is_ok(again, 4, 'recurring timer triggered four times') + +with subtest('Restart inactive timer'): + id = reactor.timer(0, lambda reactor: None) + ok(reactor.remove(id), 'removed') + err = eval_(lambda: reactor.again(id)) + like_ok(str(err), r'Timer not active', 'right error') + +with subtest('Change inactive I/O watcher'): + ok(not reactor.remove(listen), 'not removed again') + err = eval_(lambda: reactor.watch(listen, True, True)) + like_ok(str(err), r'I/O watcher not active', 'right error') + listen.close() + +with subtest('Error'): + err = None + + def error_cb(reactor, e): + global err + reactor.stop() + err = e + + def die_cb(reactor): + raise Exception('works!\n') + + reactor.unsubscribe('error').on('error', error_cb) + reactor.timer(0, die_cb) + reactor.start() + like_ok(str(err), r'works!', 'right error') + + # Not in Mojolicious: the arguments of a callback, which Perl does not check, as in Pyjo.Reactor.Asyncio + reactor.timer(0, lambda: None) + reactor.start() + like_ok( + str(err), + r'takes 0 positional arguments but 1 was given: the callbacks of a reactor get the reactor first', + 'hint', + ) + +with subtest('Reset events'): + reactor.on('error', lambda reactor, err: None) + ok(reactor.has_subscribers('error'), 'has subscribers') + reactor.reset() + ok(not reactor.has_subscribers('error'), 'no subscribers') + +with subtest('Recursion'): + timer = 0 + + def recursion_cb(reactor): + global timer + timer += 1 + reactor.one_tick() + + reactor = Pyjo.Reactor.Winloop.new() + reactor.timer(0, recursion_cb) + reactor.one_tick() + is_ok(timer, 1, 'timer was triggered once') + +with subtest('Detection'): + is_ok(Pyjo.Reactor.object.detect(), 'Pyjo.Reactor.Winloop', 'right class') + +with subtest('Reactor in control'): + is_ok(type(Pyjo.IOLoop.singleton.reactor), Pyjo.Reactor.Winloop.object, 'right object') + ok(not Pyjo.IOLoop.is_running(), 'loop is not running') + buffer = b'' + server_err = server_running = client_err = client_running = None + + def server_cb(loop, stream, cid): + global server_err, server_running + stream.write(b'test', lambda stream: stream.write(b'321')) + server_running = Pyjo.IOLoop.is_running() + server_err = eval_(lambda: Pyjo.IOLoop.start()) + + id = Pyjo.IOLoop.server(server_cb, address='127.0.0.1') + port = Pyjo.IOLoop.acceptor(id).port + + def client_cb(loop, err, stream): + global client_err, client_running + + def read_cb(stream, chunk): + global buffer + buffer += chunk + if buffer != b'test321': + return + Pyjo.IOLoop.singleton.reactor.stop() + + stream.on('read', read_cb) + client_running = Pyjo.IOLoop.is_running() + client_err = eval_(lambda: Pyjo.IOLoop.start()) + + Pyjo.IOLoop.client(client_cb, port=port) + Pyjo.IOLoop.singleton.reactor.start() + ok(not Pyjo.IOLoop.is_running(), 'loop is not running') + like_ok(str(server_err), r'^Pyjo.IOLoop already running', 'right error') + like_ok(str(client_err), r'^Pyjo.IOLoop already running', 'right error') + ok(server_running, 'loop is running') + ok(client_running, 'loop is running') + +# Left out from Mojolicious: the abstract methods of Mojo::Reactor, which t/Pyjo/Reactor_Asyncio.py of Pyjoyment tests + +# Not in Mojolicious: a callback of next_tick from a signal handler, which Python runs in the middle of what the reactor +# does, as the servers stop gracefully, with enough timers that the handler interrupts the reactor while it handles +# them, as in Pyjo.Reactor.Asyncio +with subtest('next_tick from a signal handler'): + if not hasattr(signal, 'setitimer'): + plan(skip_all='signal.setitimer is required') + reactor = Pyjo.Reactor.Winloop.new() + for _ in range(100000): + reactor.timer(10, lambda reactor: None) + ticks = [] + handler = signal.signal(signal.SIGALRM, lambda signum, frame: reactor.next_tick(lambda reactor: ticks.append(1))) + signal.setitimer(signal.ITIMER_REAL, 0.001, 0.001) + reactor.timer(0.3, lambda reactor: reactor.stop()) + try: + err = eval_(lambda: reactor.start()) + finally: + signal.setitimer(signal.ITIMER_REAL, 0) + signal.signal(signal.SIGALRM, handler) + is_ok(err, None, 'no error') + ok(ticks, 'callbacks of the signal handler') + reactor.reset() + reactor.close() + + +# Not in Mojolicious: the loop of Winloop, which is what the reactor adds to Pyjo.Reactor.Asyncio +with subtest('Loop of its own of Winloop'): + with Pyjo.Reactor.Winloop.new() as reactor: + loop = reactor.loop + ok(isinstance(loop, winloop.Loop), 'loop of Winloop') + ok(isinstance(loop, asyncio.AbstractEventLoop), 'loop of asyncio') + is_ok(reactor.loop, loop, 'same loop') + fired = [] + reactor.timer( + 0, lambda reactor: (fired.append(isinstance(asyncio.get_running_loop(), winloop.Loop)), reactor.stop()) + ) + reactor.start() + is_deeply_ok(fired, [True], 'timer in the loop of Winloop') + ok(loop.is_closed(), 'loop closed at the end of the block') + with Pyjo.Reactor.Asyncio.new() as reactor: + ok(not isinstance(reactor.loop, winloop.Loop), 'the reactor of asyncio keeps the loop of asyncio') + +with subtest('Loop that the reactor is given'): + loop = asyncio.SelectorEventLoop() + reactor = Pyjo.Reactor.Winloop.new(loop=loop) + is_ok(reactor.loop, loop, 'loop of asyncio that it is given') + reactor.close() + ok(not loop.is_closed(), 'loop that it is given not closed') + loop.close() + +# As inside an ASGI server, which runs the loop itself: the reactor takes the loop that is running, of asyncio or of +# Winloop, where the loop of asyncio is a SelectorEventLoop, as the ProactorEventLoop of Windows cannot watch handles +with subtest('Loop that is running'): + + async def running(): + reactor = Pyjo.Reactor.Winloop.new() + return reactor.loop is asyncio.get_running_loop(), isinstance(reactor.loop, winloop.Loop) + + is_deeply_ok( + asyncio.run(running(), loop_factory=asyncio.SelectorEventLoop), + (True, False), + 'loop of asyncio that is running, not one of Winloop', + ) + is_deeply_ok(winloop.run(running()), (True, True), 'loop of Winloop that is running') + +with subtest('Coroutine on the loop of Winloop'): + + async def coroutine(): + await asyncio.sleep(0.01) + return isinstance(asyncio.get_running_loop(), winloop.Loop) + + with Pyjo.Reactor.Winloop.new() as reactor: + result = [] + reactor.run_coroutine( + coroutine(), + lambda value: (result.append(value), reactor.stop()), + lambda err: (result.append(err), reactor.stop()), + ) + reactor.start() + is_deeply_ok(result, [True], 'coroutine of asyncio on the loop of Winloop') + +with subtest('Threshold of a slow callback'): + os.environ['PYJO_ASYNCIO_SLOW_CALLBACK'] = '5' + try: + with Pyjo.Reactor.Winloop.new() as reactor: + is_ok(reactor.loop.slow_callback_duration, 5.0, 'from PYJO_ASYNCIO_SLOW_CALLBACK') + finally: + del os.environ['PYJO_ASYNCIO_SLOW_CALLBACK'] + +# Left out from Pyjo-Reactor-Uvloop: the child of a fork, which Windows does not have, and the wakeup fd of a program, +# which Winloop replaces with its own while it runs, as no server of Pyjoyment on Windows waits for it with the reactor + +# Not in Mojolicious: a signal that comes while the loop waits, as the Ctrl-C or Ctrl-Break that stops a server, wakes it +# up, through the wakeup fd of Winloop, and its handler of Python runs, which stops the reactor; the signal is raised in +# another thread, as a handler of Windows runs, so that the main thread waits for it in the loop +with subtest('Signal while the loop waits'): + noted = [] + + def note(signum, frame): + noted.append(signum) + reactor.stop() + + handler = signal.signal(signal.SIGINT, note) + try: + with Pyjo.Reactor.Winloop.new() as reactor: + reactor.timer(10, lambda reactor: reactor.stop()) + raiser = threading.Timer(0.1, signal.raise_signal, (signal.SIGINT,)) + raiser.start() + started = time.monotonic() + reactor.start() + raiser.join() + ok(time.monotonic() - started < 5, 'woken up before the timer') + finally: + signal.signal(signal.SIGINT, handler) + is_deeply_ok(noted, [signal.SIGINT], 'handler of the signal') + is_ok(signal.set_wakeup_fd(-1), -1, 'wakeup fd of Winloop removed at the end of the run') + +# Not in Mojolicious: an async generator that the end of another one frees, whose finalizer Winloop calls while CPython +# clears the frame, in the debug mode of asyncio, which crashed the interpreter with uvloop, so in a process of its own +with subtest('Finalizer of an async generator in the debug mode'): + code = """ +import Pyjo.Reactor.Winloop + + +async def numbers(): + for i in range(10): + yield i + + +async def head(n): + it = numbers() + while n > 0: + n -= 1 + yield await anext(it) + + +async def main(): + return [[e async for e in head(2)] for _ in range(100)][-1] + + +reactor = Pyjo.Reactor.Winloop.new() +reactor.loop.set_debug(True) +result = [] +reactor.run_coroutine(main(), lambda value: (result.append(value), reactor.stop()), lambda err: (result.append(err), reactor.stop())) +reactor.start() +print(result) +""" + result = subprocess.run([sys.executable, '-c', code], capture_output=True, text=True, timeout=60) + is_ok(result.returncode, 0, 'no crash') + is_ok(result.stdout, '[[0, 1]]\n', 'right result') + +# Not in Mojolicious: after stop, the loop of Winloop polls once more, which would call a writer that stops it again in +# the same run, where the loop of asyncio ends after the callbacks of its select +with subtest('Stop in a callback of I/O'): + a, b = socket.socketpair() + with Pyjo.Reactor.Winloop.new() as reactor: + calls = [] + + def stopping(reactor, writable): + calls.append(writable) + reactor.stop() + + reactor.io(a, stopping).watch(a, False, True) + reactor.start() + is_deeply_ok(calls, [True], 'one event before the stop') + reactor.start() + is_deeply_ok(calls, [True, True], 'one event in the next run') + calls.clear() + reactor.recurring(0, lambda reactor: None) + for _ in range(3): + reactor.one_tick() + ok(len(calls) >= 1, 'no starving of I/O by a timer of no time in one_tick') + reactor.remove(a) + a.close() + b.close() + +# Not in Mojolicious: libuv of Windows reports the reset of a socket as an event, and keeps watching it, so its writer is +# called for as long as the error lasts, as with the loop of asyncio, where libuv of Linux calls it once +with subtest('Writer of a socket whose peer has closed it'): + a, b = socket.socketpair() + a.setblocking(False) + with Pyjo.Reactor.Winloop.new() as reactor: + calls = [] + errors = [] + + def writer(reactor, writable): + calls.append(writable) + if len(calls) == 1: + b.close() + try: + a.send(b'x') + except OSError as e: + errors.append(e) + + reactor.io(a, writer).watch(a, False, True) + reactor.timer(0.1, lambda reactor: reactor.stop()) + reactor.start() + ok(errors, 'error of the socket') + ok(len(errors) > 1, 'writer called again after the error') + reactor.remove(a) + a.close() done_testing() diff --git a/t/examples.py b/t/examples.py index b6b730f..711a755 100644 --- a/t/examples.py +++ b/t/examples.py @@ -44,13 +44,20 @@ def get(port, deadline): with open(script, 'w') as file: file.write(source.replace('3000', str(port))) - process = subprocess.Popen([sys.executable, script], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True) + # Windows has no INT of another process: Ctrl-Break of a group of processes of its own stops the server, as QUIT + process = subprocess.Popen( + [sys.executable, script], + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + text=True, + creationflags=subprocess.CREATE_NEW_PROCESS_GROUP if sys.platform == 'win32' else 0, + ) try: status, body = get(port, time.monotonic() + 30) is_ok(status, 200, 'right status') is_ok(body, b'Your Pyjo is working!', 'right content') finally: - process.send_signal(signal.SIGINT) + process.send_signal(signal.CTRL_BREAK_EVENT if sys.platform == 'win32' else signal.SIGINT) try: process.wait(10) except subprocess.TimeoutExpired: @@ -58,9 +65,21 @@ def get(port, deadline): process.wait() output = process.stdout.read() process.stdout.close() - is_ok(process.returncode, 0, 'stopped by INT') + is_ok(process.returncode, 0, 'stopped by Ctrl-Break') like_ok(output, rf'Web application available at http://127\.0\.0\.1:{port}', 'listening') +with subtest('asyncio_winloop.py'): + result = subprocess.run( + [sys.executable, os.path.join(EXAMPLES, 'asyncio_winloop.py')], capture_output=True, text=True, timeout=60 + ) + is_ok( + result.stdout, + 'asyncio: HTTP/1.1 200 OK\nPyjo.UserAgent: 200 Your Pyjo is working!\nloop: winloop\n', + 'the streams of asyncio and the user agent of Pyjoyment on the loop of Winloop', + ) + is_ok(result.stderr, '', 'nothing on the standard error') + is_ok(result.returncode, 0, 'the server and the user agent closed at the end') + # As the workflow Build runs it with the wheel: its server listens on a port that the system picks, so it needs no free # port of the tests with subtest('loopback_winloop.py'): diff --git a/typings/winloop/__init__.pyi b/typings/winloop/__init__.pyi new file mode 100644 index 0000000..010b97c --- /dev/null +++ b/typings/winloop/__init__.pyi @@ -0,0 +1,25 @@ +import asyncio + +from collections.abc import Callable, Coroutine +from typing import Any + +__version__: str + +# The methods of asyncio that Loop implements, which typeshed has abstract in asyncio.AbstractEventLoop +class Loop(asyncio.AbstractEventLoop): + slow_callback_duration: float + def run_forever(self) -> None: ... + def stop(self) -> None: ... + def is_running(self) -> bool: ... + def call_soon(self, callback: Callable[..., object], *args: Any, context: Any = None) -> asyncio.Handle: ... + def add_reader(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: ... + def add_writer(self, fd: Any, callback: Callable[..., Any], *args: Any) -> None: ... + def _asyncgen_finalizer_hook(self, agen: Any) -> None: ... + +def new_event_loop() -> Loop: ... +def run[T]( + main: Coroutine[Any, Any, T], + *, + loop_factory: Callable[[], Loop] | None = ..., + debug: bool | None = None, +) -> T: ...