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..d03914a --- /dev/null +++ b/.github/workflows/build.yaml @@ -0,0 +1,73 @@ +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. Python of Windows ends its lines with + # CRLF, which diff leaves out. + - name: Install and run the wheel + shell: bash + run: |- + 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 --strip-trailing-cr - 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..d5a9dd8 --- /dev/null +++ b/.github/workflows/tests.yaml @@ -0,0 +1,246 @@ +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 + + # 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 "$(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 + # 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..03239fe --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,255 @@ +# 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 + +- 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. 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`. + +## 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, 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, 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. +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 `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. + +## 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..af0a599 --- /dev/null +++ b/Pyjo/Reactor/Winloop.py @@ -0,0 +1,186 @@ +""" +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 :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 +------ + +: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 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.""" + + +class Pyjo_Reactor_Winloop(Pyjo.Reactor.Asyncio.object): + """ + :mod:`Pyjo.Reactor.Winloop` inherits all methods from + :mod:`Pyjo.Reactor.Asyncio`. + """ + + # 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 +object = Pyjo_Reactor_Winloop +Winloop = Pyjo_Reactor_Winloop diff --git a/README.md b/README.md index 56d2109..735c128 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,203 @@ +[![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. + +## 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, 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 +``` + +## Examples + +`examples/hello_world_winloop.py` runs `Pyjo.HelloWorld` on the server of +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 + + +# 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 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() +``` + +```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/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 +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..dc43e2e --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,120 @@ +# 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, 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'] + +# 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' +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..d139eda --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,55 @@ +.. 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 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 + +.. 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/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 +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/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 new file mode 100644 index 0000000..d9fb18c --- /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 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/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..bb57c43 --- /dev/null +++ b/t/Reactor_Winloop.py @@ -0,0 +1,627 @@ +import os + + +# 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 + +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/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..711a755 --- /dev/null +++ b/t/examples.py @@ -0,0 +1,97 @@ +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))) + + # 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.CTRL_BREAK_EVENT if sys.platform == 'win32' else 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 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'): + 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/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: ... 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" }, +]