diff --git a/.appveyor.yml b/.appveyor.yml
deleted file mode 100644
index ba6c980bb..000000000
--- a/.appveyor.yml
+++ /dev/null
@@ -1,49 +0,0 @@
-environment:
-  matrix:
-  - PYTHON: "C:\\Python37-x64"
-  - PYTHON: "C:\\Python36-x64"
-  - PYTHON: "C:\\Python35-x64"
-
-init:
-- "chcp 65001"
-- ps: >-
-    if($env:APPVEYOR_RDP_DEBUG -eq 'True') {
-      iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
-    }
-
-install:
-# symlink python from a directory with a space
-- "mklink /d \"C:\\Program Files\\Python\" %PYTHON%"
-- "SET PYTHON=\"C:\\Program Files\\Python\""
-- "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
-- "python -m pip install tox"
-- "python -m tox --notest"
-
-
-before_build:
-- "python -m pip install wheel"
-
-build_script:
-- python -m setup bdist_wheel
-
-test_script:
-- tox
-
-on_finish:
-- ps: >-
-    if($env:APPVEYOR_RDP_DEBUG -eq 'True') {
-      $blockRdp = $true
-      iex ((new-object net.webclient).DownloadString('https://raw.githubusercontent.com/appveyor/ci/master/scripts/enable-rdp.ps1'))
-      }
-- ps: |
-    $wc = New-Object 'System.Net.WebClient'
-    $wc.UploadFile("https://ci.appveyor.com/api/testresults/junit/$($env:APPVEYOR_JOB_ID)", (Resolve-Path .\.test-results\pytest\results.xml))
-
-#deploy_script:
-#- ps: >-
-#    if($env:appveyor_repo_tag -eq 'True') {
-#        Invoke-Expression "python -m twine upload dist/* --username $env:PYPI_USERNAME --password $env:PYPI_PASSWORD"
-#    }
-
-artifacts:
-- path: dist\*
diff --git a/.circleci/config.yml b/.circleci/config.yml
deleted file mode 100644
index 9a3a8b380..000000000
--- a/.circleci/config.yml
+++ /dev/null
@@ -1,52 +0,0 @@
-version: 2
-jobs:
-  macos-build:
-    macos:
-      xcode: "12.2.0"
-
-    steps:
-    - run: brew install pyenv readline xz
-
-    - run: |-
-        # https://circleci.com/docs/2.0/env-vars/#interpolating-environment-variables-to-set-other-environment-variables
-        echo '
-          export PYENV_ROOT="$HOME/.pyenv"
-          export PATH="$PYENV_ROOT/bin:$PATH"
-        ' >> $BASH_ENV
-
-    - run: |-
-        for py_ver in 3.7.0 3.6.4 3.5.4 pypy3.5-6.0.0
-        do
-          pyenv install "$py_ver" &
-        done
-        wait
-    - run: pyenv global 3.7.0 3.6.4 3.5.4 pypy3.5-6.0.0
-
-    - run: python3 -m pip install --upgrade pip wheel
-    - run: python3 -m pip install tox tox-pyenv
-    - checkout
-    - run: tox -e py35,py36,py37 -- -p no:sugar  # , pypy3
-    - store_test_results:
-        path: .test-results
-    - store_artifacts:
-        path: .test-results
-
-  linux-build:
-    docker:
-    - image: randomknowledge/docker-pyenv-tox
-
-    steps:
-    - checkout
-    - run: pip install tox
-    - run: tox -e py35,py36,py37
-    - store_test_results:
-        path: .test-results
-    - store_artifacts:
-        path: .test-results
-
-workflows:
-  version: 2
-  test-linux-and-macos:
-    jobs:
-    - macos-build
-    - linux-build
diff --git a/.codecov.yml b/.codecov.yml
index 9fff0529b..9dc7af4a9 100644
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -1,8 +1,13 @@
+---
+
 codecov:
   bot: codecov
   notify:
     require_ci_to_pass: yes
 
+  token: >-  # notsecret  # repo-scoped, upload-only, stability in fork PRs
+    88c87da1-0386-456d-aca6-7cf0580b3f51
+
 coverage:
   precision: 2
   round: down
@@ -26,3 +31,5 @@ comment:
   layout: "header, diff"
   behavior: default
   require_changes: no
+
+...
diff --git a/.flake8 b/.flake8
index 469fed682..cb2364b37 100644
--- a/.flake8
+++ b/.flake8
@@ -1,6 +1,8 @@
 [flake8]
 ignore =
-    # W503 violates spec https://github.com/PyCQA/pycodestyle/issues/513
-    W503
-    # W504 has issues https://github.com/OCA/maintainer-quality-tools/issues/545
-    W504
+  # E203: whitespace before ':', conflicts with `ruff format`
+  E203,
+  # W503 violates spec https://github.com/PyCQA/pycodestyle/issues/513
+  W503
+  # W504 has issues https://github.com/OCA/maintainer-quality-tools/issues/545
+  W504
diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..b650caa02
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,85 @@
+# `git blame` master ignore list.
+#
+# This file contains a list of git hashes of revisions to be ignored
+# by `git blame`. These revisions are considered "unimportant" in
+# that they are unlikely to be what you are interested in when blaming.
+# They are typically expected to be formatting-only changes.
+#
+# It can be used for `git blame` using `--ignore-revs-file` or by
+# setting `blame.ignoreRevsFile` in the `git config`[1].
+#
+# Ignore these commits when reporting with blame. Calling
+#
+#   git blame --ignore-revs-file .git-blame-ignore-revs
+#
+# will tell `git blame` to ignore changes made by these revisions when
+# assigning blame, as if the change never happened.
+#
+# You can enable this as a default for your local repository by
+# running
+#
+#   git config blame.ignoreRevsFile .git-blame-ignore-revs
+#
+# This will probably be automatically picked by your IDE
+# (VSCode+GitLens and JetBrains products are confirmed to do this).
+#
+# Important: if you are switching to a branch without this file,
+# `git blame` will fail with an error.
+#
+# GitHub also excludes the commits listed below from its "Blame"
+# views[2][3].
+#
+# [1]: https://git-scm.com/docs/git-blame#Documentation/git-blame.txt-blameignoreRevsFile
+# [2]: https://github.blog/changelog/2022-03-24-ignore-commits-in-the-blame-view-beta/
+# [3]: https://docs.github.com/en/repositories/working-with-files/using-files/viewing-a-file#ignore-commits-in-the-blame-view
+#
+# Guidelines:
+# - Only large (generally automated) reformatting or renaming PRs
+#   should be added to this list. Do not put things here just because
+#   you feel they are trivial or unimportant. If in doubt, do not put
+#   it on this list.
+# - When adding a single revision, use a comment on top of the line
+#   to link relevant issue/PR. Alternatively, paste the commit title
+#   instead.
+#   Example:
+#     # https://github.com/sanitizers/octomachinery/issues/1
+#     d4a8b7307acc2dc8a8833ccfa65426ad28b3ffc9
+# - When adding multiple revisions (like a bulk of work over many
+#   commits), organize them in blocks. Precede each such block with a
+#   comment starting with the word "START", followed by a link to the
+#   relevant issue or PR. Add a similar comment after the last block
+#   line but use the word "END", followed by the same link.
+#   Alternatively, add or augment the link with a text motivation and
+#   description of work performed in each commit.
+#   Before each individual commit in the block, add an inline comment
+#   with the commit title line.
+#   Example:
+#     # START https://github.com/sanitizers/octomachinery/issues/1
+#     # Bulk-replace smile emojis with unicorns
+#     6f0bd2d8a1e6cd2e794cd39976e9756e0c85ac66
+#     # Replace double with single quotes
+#     d53974df11dbc22cbea9dc7dcbc9896c25979a27
+#     ... <rest of the list>
+#     # END https://github.com/sanitizers/octomachinery/issues/1
+# - Only put full 40-character hashes on this list (not short hashes
+#   or any other revision reference).
+# - Append to the bottom of the file, regardless of the chronological
+#   order of the revisions. Revisions within blocks should be in
+#   chronological order from oldest to newest.
+# - Because you must use a hash, you need to append to this list in a
+#   follow-up PR to the actual reformatting PR that you are trying to
+#   ignore. This approach helps avoid issues with arbitrary rebases
+#   and squashes while the pull request is in progress.
+
+
+# 🤖 Process docstrings with docformatter
+deeb3ae64c8039d136dbe958b2301049d8dfae72
+
+# 👹 Feed the hobgoblins (delint).
+5fe3dcef35d44ab60e32e5130d2e37089820bc4a
+
+# Revert "👹 Feed the hobgoblins (delint)."
+d968aaf8043a81ce4a636268ba8a42cb717ca316
+
+# 🤖 Apply Ruff formatting
+925123b66b5a42e36dc2fe08aae6dd27c8c4bc5b
diff --git a/.git_archival.txt b/.git_archival.txt
new file mode 100644
index 000000000..6acb3b415
--- /dev/null
+++ b/.git_archival.txt
@@ -0,0 +1,3 @@
+node: $Format:%H$
+node-date: $Format:%cI$
+describe-name: $Format:%(describe:tags=true,match=v[0-9]*)$
diff --git a/.gitattributes b/.gitattributes
index 00e5815fd..84cc7a593 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1 +1,7 @@
+# Needed for setuptools-scm-git-archive
+.git_archival.txt  export-subst
+
+# Blame ignore list entries are expected to always be appended, never edited
+.git-blame-ignore-revs  merge=union
+
 /CHANGES.rst merge=union
diff --git a/.github/CONTRIBUTING.rst b/.github/CONTRIBUTING.rst
index dd21f7538..999f1af68 100644
--- a/.github/CONTRIBUTING.rst
+++ b/.github/CONTRIBUTING.rst
@@ -28,5 +28,5 @@ python version, and any other related software versions.
 
 Also
 ----
-See `Contributing <https://docs.cherrypy.org/en/latest/contribute.html>`_ in
+See `Contributing <https://docs.cherrypy.dev/en/latest/contribute.html>`_ in
 the docs.
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 6955eab7e..5ce8b9bd4 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,14 +1,12 @@
-# These are supported funding model platforms
+---
 
-github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+github:
 - jaraco
 - webknjaz
-# patreon: # Replace with a single Patreon username
 # open_collective: # Replace with a single Open Collective username
 # ko_fi: # Replace with a single Ko-fi username
-tidelift: pypi/CherryPy  # A single Tidelift platform-name/package-name e.g., npm/babel
-# community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
+tidelift: pypi/CherryPy
 # liberapay: # Replace with a single Liberapay username
-# issuehunt: # Replace with a single IssueHunt username
-# otechie: # Replace with a single Otechie username
-# custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
+# custom: # Replace with up to 4 custom sponsorship URLs
+
+...
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
index ee3e4b860..af86b79f9 100644
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@@ -1,7 +1,7 @@
 <!--
 **** DELETE THIS BLOCK ****  
 
-Thanks for filing an issue!  Please keep keep issues limited to bug reports,
+Thanks for filing an issue!  Please keep issues limited to bug reports,
 feature requests, and other general issues. For support questions, please feel
 free to reach out on stackoverflow:
 https://stackoverflow.com/questions/tagged/cherrypy
diff --git a/.github/SUPPORT.rst b/.github/SUPPORT.rst
index 1c31c2422..618792f57 100644
--- a/.github/SUPPORT.rst
+++ b/.github/SUPPORT.rst
@@ -9,7 +9,7 @@ I have a question
 -----------------
 
 If you have a question and cannot find an answer for it in issues or the
-the `documentation <http://docs.cherrypy.org/en/latest/>`__, `please
+the `documentation <http://docs.cherrypy.dev/en/latest/>`__, `please
 create an issue <https://github.com/cherrypy/cherrypy/issues/new>`__.
 
 Questions and their answers have great value for the community, and a
diff --git a/.github/actions/cache-keys/action.yml b/.github/actions/cache-keys/action.yml
new file mode 100644
index 000000000..dd88e0741
--- /dev/null
+++ b/.github/actions/cache-keys/action.yml
@@ -0,0 +1,43 @@
+---
+
+outputs:
+  cache-key-for-dep-files:
+    description: >-
+      A cache key string derived from the dependency declaration files.
+    value: ${{ steps.calc-cache-key-files.outputs.files-hash-key }}
+
+runs:
+  using: composite
+  steps:
+  - name: >-
+      Calculate dependency files' combined hash value
+      for use in the cache key
+    id: calc-cache-key-files
+    run: |
+      from os import environ
+      from pathlib import Path
+
+      FILE_APPEND_MODE = 'a'
+
+      files_derived_hash = '${{
+          hashFiles(
+            'tox.ini',
+            'pyproject.toml',
+            '.pre-commit-config.yaml',
+            'pytest.ini',
+            'requirements/**'
+          )
+      }}'
+
+      print(f'Computed file-derived hash is {files_derived_hash}.')
+
+      with Path(environ['GITHUB_OUTPUT']).open(
+              mode=FILE_APPEND_MODE,
+      ) as outputs_file:
+          print(
+              f'files-hash-key={files_derived_hash}',
+              file=outputs_file,
+          )
+    shell: python
+
+...
diff --git a/.github/config.yml b/.github/config.yml
index 390de12bc..20b4d1178 100644
--- a/.github/config.yml
+++ b/.github/config.yml
@@ -1,2 +1,6 @@
+---
+
 rtd:
   project: cherrypy
+
+...
diff --git a/.github/patchback.yml b/.github/patchback.yml
new file mode 100644
index 000000000..18bd840b4
--- /dev/null
+++ b/.github/patchback.yml
@@ -0,0 +1,5 @@
+---
+backport_branch_prefix: patchback/backports/
+backport_label_prefix: backport-
+target_branch_prefix: maint/
+...
diff --git a/.github/reusables/tox-dev/workflow/reusable-tox/hooks/post-src-checkout/action.yml b/.github/reusables/tox-dev/workflow/reusable-tox/hooks/post-src-checkout/action.yml
new file mode 100644
index 000000000..f073a8db3
--- /dev/null
+++ b/.github/reusables/tox-dev/workflow/reusable-tox/hooks/post-src-checkout/action.yml
@@ -0,0 +1,39 @@
+---
+
+inputs:
+  calling-job-context:
+    description: A JSON with the calling job inputs
+    type: string
+  job-dependencies-context:
+    default: >-
+      {}
+    description: >-
+      The `$ {{ needs }}` context passed from the calling workflow
+      encoded as a JSON string. The caller is expected to form this
+      input as follows:
+      `job-dependencies-context: $ {{ toJSON(needs) }}`.
+    required: false
+    type: string
+
+runs:
+  using: composite
+  steps:
+  - name: Log setting up pre-commit cache
+    if: fromJSON(inputs.calling-job-context).toxenv == 'pre-commit'
+    run: >-
+      >&2 echo Caching ~/.cache/pre-commit based on
+      the contents of '.pre-commit-config.yaml'...
+    shell: bash
+  - name: Cache pre-commit.com virtualenvs
+    if: fromJSON(inputs.calling-job-context).toxenv == 'pre-commit'
+    uses: actions/cache@v4
+    with:
+      path: ~/.cache/pre-commit
+      key: >-
+        ${{
+          runner.os
+        }}-pre-commit-${{
+          hashFiles('.pre-commit-config.yaml')
+        }}
+
+...
diff --git a/.github/reusables/tox-dev/workflow/reusable-tox/hooks/post-tox-run/action.yml b/.github/reusables/tox-dev/workflow/reusable-tox/hooks/post-tox-run/action.yml
new file mode 100644
index 000000000..32e88ac95
--- /dev/null
+++ b/.github/reusables/tox-dev/workflow/reusable-tox/hooks/post-tox-run/action.yml
@@ -0,0 +1,75 @@
+---
+
+inputs:
+  calling-job-context:
+    description: A JSON with the calling job inputs
+    type: string
+  job-dependencies-context:
+    default: >-
+      {}
+    description: >-
+      The `$ {{ needs }}` context passed from the calling workflow
+      encoded as a JSON string. The caller is expected to form this
+      input as follows:
+      `job-dependencies-context: $ {{ toJSON(needs) }}`.
+    required: false
+    type: string
+
+runs:
+  using: composite
+  steps:
+  - name: Verify that the artifacts with expected names got created
+    if: fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+    run: >
+      # Verify that the artifacts with expected names got created
+
+
+      ls -1
+      'dist/${{
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.sdist-artifact-name
+      }}'
+      'dist/${{
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.wheel-artifact-name
+      }}'
+    shell: bash
+  - name: Store the distribution packages
+    if: fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+    uses: actions/upload-artifact@v4
+    with:
+      name: >-
+        ${{
+          fromJSON(
+            inputs.job-dependencies-context
+          ).pre-setup.outputs.dists-artifact-name
+        }}
+      # NOTE: Exact expected file names are specified here
+      # NOTE: as a safety measure — if anything weird ends
+      # NOTE: up being in this dir or not all dists will be
+      # NOTE: produced, this will fail the workflow.
+      path: |
+        dist/${{
+          fromJSON(
+            inputs.job-dependencies-context
+          ).pre-setup.outputs.sdist-artifact-name
+        }}
+        dist/${{
+          fromJSON(
+            inputs.job-dependencies-context
+          ).pre-setup.outputs.wheel-artifact-name
+        }}
+      retention-days: >-
+        ${{
+            fromJSON(
+              fromJSON(
+                inputs.job-dependencies-context
+              ).pre-setup.outputs.release-requested
+            )
+            && 90
+            || 30
+        }}
+
+...
diff --git a/.github/reusables/tox-dev/workflow/reusable-tox/hooks/prepare-for-tox-run/action.yml b/.github/reusables/tox-dev/workflow/reusable-tox/hooks/prepare-for-tox-run/action.yml
new file mode 100644
index 000000000..960e50213
--- /dev/null
+++ b/.github/reusables/tox-dev/workflow/reusable-tox/hooks/prepare-for-tox-run/action.yml
@@ -0,0 +1,127 @@
+---
+
+inputs:
+  calling-job-context:
+    description: A JSON with the calling job inputs
+    type: string
+  job-dependencies-context:
+    default: >-
+      {}
+    description: >-
+      The `$ {{ needs }}` context passed from the calling workflow
+      encoded as a JSON string. The caller is expected to form this
+      input as follows:
+      `job-dependencies-context: $ {{ toJSON(needs) }}`.
+    required: false
+    type: string
+
+runs:
+  using: composite
+  steps:
+  - name: Drop Git tags from HEAD for non-tag-create events
+    if: >-
+      fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+      && !fromJSON(
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.release-requested
+      )
+    run: >-
+      git tag --points-at HEAD
+      |
+      xargs git tag --delete
+    shell: bash
+
+  - name: Setup git user as [bot]
+    if: >-
+      fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+      && (
+        fromJSON(
+          fromJSON(
+            inputs.job-dependencies-context
+          ).pre-setup.outputs.release-requested
+        )
+        || fromJSON(
+          fromJSON(
+            inputs.job-dependencies-context
+          ).pre-setup.outputs.is-untagged-devel
+        )
+      )
+    uses: fregante/setup-git-user@v2
+  - name: >-
+      Tag the release in the local Git repo
+      as ${{
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.git-tag
+      }}
+      for setuptools-scm to set the desired version
+    if: >-
+      fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+      && fromJSON(
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.release-requested
+      )
+    run: >-
+      git tag
+      -m '${{
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.git-tag
+      }}'
+      '${{
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.git-tag
+      }}'
+      --
+      ${{ fromJSON(inputs.calling-job-context).checkout-src-git-committish }}
+    shell: bash
+
+  - name: Install tomlkit Python distribution package
+    if: >-
+      fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+      && fromJSON(
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.is-untagged-devel
+      )
+    run: >-
+      python -m pip install --user tomlkit
+    shell: bash
+  - name: Instruct setuptools-scm not to add a local version part
+    if: >-
+      fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+      && fromJSON(
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.is-untagged-devel
+      )
+    run: |
+      from pathlib import Path
+
+      import tomlkit
+
+      pyproject_toml_path = Path.cwd() / 'pyproject.toml'
+      pyproject_toml_txt = pyproject_toml_path.read_text()
+      pyproject_toml = tomlkit.loads(pyproject_toml_txt)
+      setuptools_scm_section = pyproject_toml['tool']['setuptools_scm']
+      setuptools_scm_section['local_scheme'] = 'no-local-version'
+      patched_pyproject_toml_txt = tomlkit.dumps(pyproject_toml)
+      pyproject_toml_path.write_text(patched_pyproject_toml_txt)
+    shell: python
+  - name: Pretend that pyproject.toml is unchanged
+    if: >-
+      fromJSON(inputs.calling-job-context).toxenv == 'build-dists'
+      && fromJSON(
+        fromJSON(
+          inputs.job-dependencies-context
+        ).pre-setup.outputs.is-untagged-devel
+      )
+    run: |
+      git diff --color=always
+      git update-index --assume-unchanged pyproject.toml
+    shell: bash
+
+...
diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
new file mode 100644
index 000000000..17e7c7372
--- /dev/null
+++ b/.github/workflows/ci-cd.yml
@@ -0,0 +1,977 @@
+---
+
+name: 🧪
+
+on:
+  merge_group:
+  push:  # publishes to TestPyPI pushes to the main branch
+    branches-ignore:
+    - dependabot/**  # Dependabot always creates PRs
+    - gh-readonly-queue/**  # Temporary merge queue-related GH-made branches
+    - maintenance/pip-tools-constraint-lockfiles  # Lock files through PRs
+    - maintenance/pip-tools-constraint-lockfiles-**  # Lock files through PRs
+    - patchback/backports/**  # Patchback always creates PRs
+    - pre-commit-ci-update-config  # pre-commit.ci always creates a PR
+  pull_request:
+    paths-ignore:  # changes to the cron workflow are triggered through it
+    - .github/workflows/scheduled-runs.yml
+  workflow_call:  # a way to embed the main tests
+  workflow_dispatch:
+    inputs:
+      release-version:
+        # github.event_name == 'workflow_dispatch'
+        # && github.event.inputs.release-version
+        description: >-
+          Target PEP440-compliant version to release.
+          Please, don't prepend `v`.
+        required: true
+        type: string
+      release-committish:
+        # github.event_name == 'workflow_dispatch'
+        # && github.event.inputs.release-committish
+        default: ''
+        description: >-
+          The commit to be released to PyPI and tagged
+          in Git as `release-version`. Normally, you
+          should keep this empty.
+        type: string
+      YOLO:
+        default: false
+        description: >-
+          Set this flag to disregard the outcome of the
+          test stage. The test results will block the
+          release otherwise. Only use this under
+          extraordinary circumstances to ignore the test
+          failures and cut the release regardless.
+        type: boolean
+
+concurrency:
+  group: >-
+    ${{
+        github.workflow
+    }}-${{
+        github.ref_type
+    }}-${{
+        github.event.pull_request.number || github.sha
+    }}
+  cancel-in-progress: true
+
+env:
+  FORCE_COLOR: 1  # Request colored output from CLI tools supporting it
+  MYPY_FORCE_COLOR: 1  # MyPy's color enforcement
+  PIP_DISABLE_PIP_VERSION_CHECK: 1  # Hide "there's a newer pip" message
+  PIP_NO_PYTHON_VERSION_WARNING: 1  # Hide "this Python is deprecated" message
+  PIP_NO_WARN_SCRIPT_LOCATION: 1  # Hide "script dir is not in $PATH" message
+  PRE_COMMIT_COLOR: always
+  PUBLISHING_TO_TESTPYPI_ENABLED: true
+  PY_COLORS: 1  # Recognized by the `py` package, dependency of `pytest`
+  PYTHONIOENCODING: utf-8
+  PYTHONUTF8: 1
+  TOX_PARALLEL_NO_SPINNER: 1  # Disable tox's parallel run spinner animation
+  TOX_TESTENV_PASSENV: >-  # Make tox-wrapped tools see color requests
+    FORCE_COLOR
+    MYPY_FORCE_COLOR
+    NO_COLOR
+    PIP_DISABLE_PIP_VERSION_CHECK
+    PIP_NO_PYTHON_VERSION_WARNING
+    PIP_NO_WARN_SCRIPT_LOCATION
+    PRE_COMMIT_COLOR
+    PY_COLORS
+    PYTEST_THEME
+    PYTEST_THEME_MODE
+    PYTHONIOENCODING
+    PYTHONLEGACYWINDOWSSTDIO
+    PYTHONUTF8
+  UPSTREAM_REPOSITORY_ID: >-
+    57436777
+
+run-name: >-
+  ${{
+    github.event_name == 'workflow_dispatch'
+    && format('📦 Releasing v{0}...', github.event.inputs.release-version)
+    || ''
+  }}
+  ${{
+      github.event.pull_request.number && '🔀 PR' || ''
+  }}${{
+      !github.event.pull_request.number && '🌱 Commit' || ''
+  }}
+  ${{ github.event.pull_request.number || github.sha }}
+  triggered by: ${{ github.event_name }} of ${{
+    github.ref
+  }} ${{
+    github.ref_type
+  }}
+  (workflow run ID: ${{
+    github.run_id
+  }}; number: ${{
+    github.run_number
+  }}; attempt: ${{
+    github.run_attempt
+  }})
+
+jobs:
+  pre-setup:
+    name: ⚙️  Mode
+
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 1
+
+    defaults:
+      run:
+        shell: python
+
+    outputs:
+      # NOTE: These aren't env vars because the `${{ env }}` context is
+      # NOTE: inaccessible when passing inputs to reusable workflows.
+      dists-artifact-name: python-package-distributions
+      dist-version: >-
+        ${{
+            steps.request-check.outputs.release-requested == 'true'
+            && github.event.inputs.release-version
+            || steps.scm-version.outputs.dist-version
+        }}
+      project-name: ${{ steps.metadata.outputs.project-name }}
+      is-untagged-devel: >-
+        ${{ steps.untagged-check.outputs.is-untagged-devel || false }}
+      release-requested: >-
+        ${{
+            steps.request-check.outputs.release-requested || false
+        }}
+      is-yolo-mode: >-
+        ${{
+          (
+            steps.request-check.outputs.release-requested == 'true'
+            && github.event.inputs.YOLO
+          )
+          && true || false
+        }}
+      cache-key-for-dep-files: >-
+        ${{ steps.calc-cache-key-files.outputs.cache-key-for-dep-files }}
+      git-tag: ${{ steps.git-tag.outputs.tag }}
+      sdist-artifact-name: ${{ steps.artifact-name.outputs.sdist }}
+      wheel-artifact-name: ${{ steps.artifact-name.outputs.wheel }}
+      upstream-repository-id: ${{ env.UPSTREAM_REPOSITORY_ID }}
+      publishing-to-testpypi-enabled: ${{ env.PUBLISHING_TO_TESTPYPI_ENABLED }}
+      is-debug-mode: ${{ toJSON(runner.debug == '1') }}
+
+    steps:
+    - name: Switch to using Python 3.11 by default
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.11
+    - name: >-
+        Mark the build as untagged '${{
+            github.event.repository.default_branch
+        }}' branch build
+      id: untagged-check
+      if: >-
+        github.event_name == 'push' &&
+        github.ref_type == 'branch' &&
+        github.ref_name == github.event.repository.default_branch
+      run: |
+        from os import environ
+        from pathlib import Path
+
+        FILE_APPEND_MODE = 'a'
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print('is-untagged-devel=true', file=outputs_file)
+    - name: Mark the build as "release request"
+      id: request-check
+      if: github.event_name == 'workflow_dispatch'
+      run: |
+        from os import environ
+        from pathlib import Path
+
+        FILE_APPEND_MODE = 'a'
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print('release-requested=true', file=outputs_file)
+    - name: Check out src from Git
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: >-
+          ${{
+            steps.request-check.outputs.release-requested == 'true'
+            && 1 || 0
+          }}
+        ref: ${{ github.event.inputs.release-committish }}
+    - name: Scan static PEP 621 core packaging metadata
+      id: metadata
+      run: |
+        from os import environ
+        from pathlib import Path
+        from tomllib import loads as parse_toml_from_string
+
+        FILE_APPEND_MODE = 'a'
+
+        pyproject_toml_txt = Path('pyproject.toml').read_text()
+        metadata = parse_toml_from_string(pyproject_toml_txt)['project']
+        project_name = metadata["name"]
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print(f'project-name={project_name}', file=outputs_file)
+    - name: >-
+        Calculate dependency files' combined hash value
+        for use in the cache key
+      if: >-
+        steps.request-check.outputs.release-requested != 'true'
+      id: calc-cache-key-files
+      uses: ./.github/actions/cache-keys
+    - name: Set up pip cache
+      if: >-
+        steps.request-check.outputs.release-requested != 'true'
+      uses: re-actors/cache-python-deps@release/v1
+      with:
+        cache-key-for-dependency-files: >-
+          ${{ steps.calc-cache-key-files.outputs.cache-key-for-dep-files }}
+    - name: Drop Git tags from HEAD for non-release requests
+      if: >-
+        steps.request-check.outputs.release-requested != 'true'
+      run: >-
+        git tag --points-at HEAD
+        |
+        xargs git tag --delete
+      shell: bash
+    - name: Set up versioning prerequisites
+      if: >-
+        steps.request-check.outputs.release-requested != 'true'
+      run: >-
+        python -m
+        pip install
+        --user
+        setuptools-scm
+        --constraint=dependencies/lock-files/dist-build-constraints.txt
+      shell: bash
+    - name: Set the current dist version from Git
+      if: steps.request-check.outputs.release-requested != 'true'
+      id: scm-version
+      run: |
+        from os import environ
+        from pathlib import Path
+
+        import setuptools_scm
+
+        FILE_APPEND_MODE = 'a'
+
+        ver = setuptools_scm.get_version(
+          ${{
+              steps.untagged-check.outputs.is-untagged-devel == 'true'
+              && 'local_scheme="no-local-version"' || ''
+          }}
+        )
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print(f'dist-version={ver}', file=outputs_file)
+    - name: Set the target Git tag
+      id: git-tag
+      run: |
+        from os import environ
+        from pathlib import Path
+
+        FILE_APPEND_MODE = 'a'
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print(
+                "tag=v${{
+                    steps.request-check.outputs.release-requested == 'true'
+                    && github.event.inputs.release-version
+                    || steps.scm-version.outputs.dist-version
+                }}",
+                file=outputs_file,
+            )
+    - name: Set the expected dist artifact names
+      id: artifact-name
+      env:
+        PROJECT_NAME: ${{ steps.metadata.outputs.project-name }}
+      run: |
+        from os import environ
+        from pathlib import Path
+
+        FILE_APPEND_MODE = 'a'
+
+        whl_file_prj_base_name = environ['PROJECT_NAME'].replace('-', '_')
+        sdist_file_prj_base_name = (
+            whl_file_prj_base_name.
+            replace('.', '_').
+            lower()
+        )
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print(
+                f"sdist={sdist_file_prj_base_name !s}-${{
+                    steps.request-check.outputs.release-requested == 'true'
+                    && github.event.inputs.release-version
+                    || steps.scm-version.outputs.dist-version
+                }}.tar.gz",
+                file=outputs_file,
+            )
+            print(
+                f"wheel={whl_file_prj_base_name !s}-${{
+                    steps.request-check.outputs.release-requested == 'true'
+                    && github.event.inputs.release-version
+                    || steps.scm-version.outputs.dist-version
+                }}-py3-none-any.whl",
+                file=outputs_file,
+            )
+
+  build:
+    name: >-
+      📦 ${{ needs.pre-setup.outputs.git-tag }}
+      [mode: ${{
+        fromJSON(needs.pre-setup.outputs.is-untagged-devel)
+        && 'test' || ''
+      }}${{
+        fromJSON(needs.pre-setup.outputs.release-requested)
+        && 'release' || ''
+      }}${{
+        (
+          !fromJSON(needs.pre-setup.outputs.is-untagged-devel)
+          && !fromJSON(needs.pre-setup.outputs.release-requested)
+        ) && 'nightly' || ''
+      }}]
+    needs:
+    - pre-setup  # transitive, for accessing settings
+
+    uses: tox-dev/workflow/.github/workflows/reusable-tox.yml@208490c75f7f6b81e2698cc959f24d264c462d57  # yamllint disable-line rule:line-length
+    with:
+      cache-key-for-dependency-files: >-
+        ${{ needs.pre-setup.outputs.cache-key-for-dep-files }}
+      check-name: Build dists under 🐍3.11
+      checkout-src-git-committish: >-
+        ${{ github.event.inputs.release-committish }}
+      checkout-src-git-fetch-depth: >-
+        ${{
+          fromJSON(needs.pre-setup.outputs.release-requested)
+          && 1
+          || 0
+        }}
+      job-dependencies-context: >-  # context for hooks
+        ${{ toJSON(needs) }}
+      # python-version: 3.13
+      python-version: 3.11  # FIXME??
+      runner-vm-os: ubuntu-latest
+      timeout-minutes: 2
+      toxenv: build-dists
+      xfail: false
+
+  lint:
+    name: 🧹 Linters${{ '' }}  # nest jobs under the same sidebar category
+    needs:
+    - build
+    - pre-setup  # transitive, for accessing settings
+
+    strategy:
+      matrix:
+        runner-vm-os:
+        - ubuntu-latest
+        python-version:
+        - |-
+          3.11
+          3.12
+          3.14
+        toxenv:
+        - pre-commit
+        - metadata-validation
+        - dist-check
+        - build-docs
+        # - doctest-docs
+        # - linkcheck-docs
+        # - spellcheck-docs
+        xfail:
+        - false
+      fail-fast: false
+
+    uses: tox-dev/workflow/.github/workflows/reusable-tox.yml@208490c75f7f6b81e2698cc959f24d264c462d57  # yamllint disable-line rule:line-length
+    with:
+      built-wheel-names: >-
+        ${{
+          matrix.toxenv == 'metadata-validation'
+          && needs.pre-setup.outputs.wheel-artifact-name
+          || ''
+        }}
+      cache-key-for-dependency-files: >-
+        ${{ needs.pre-setup.outputs.cache-key-for-dep-files }}
+      checkout-src-git-committish: >-
+        ${{ github.event.inputs.release-committish }}
+      checkout-src-git-fetch-depth: >-
+        ${{
+          fromJSON(needs.pre-setup.outputs.release-requested)
+          && 1
+          || 0
+        }}
+      dists-artifact-name: >-
+        ${{ needs.pre-setup.outputs.dists-artifact-name }}
+      post-toxenv-preparation-command: >-
+        ${{
+          matrix.toxenv == 'pre-commit'
+          && format(
+            '$(pwd)/.tox/{0}/bin/python -Im pre_commit install-hooks',
+            matrix.toxenv
+          )
+          || ''
+        }}
+      python-version: >-
+        ${{ matrix.python-version }}
+      require-successful-codecov-uploads: >-
+        ${{
+          toJSON(
+          needs.pre-setup.outputs.upstream-repository-id
+          == github.repository_id
+          )
+        }}
+      runner-vm-os: >-
+        ${{ matrix.runner-vm-os }}
+      # NOTE: `pre-commit --show-diff-on-failure` and
+      # NOTE: `sphinxcontrib-spellcheck` with Git authors allowlist enabled
+      # NOTE: both depend on the presence of a Git repository.
+      source-tarball-name: >-
+        ${{
+          !contains(
+            fromJSON('["pre-commit", "spellcheck-docs"]'),
+            matrix.toxenv
+          )
+          && needs.pre-setup.outputs.sdist-artifact-name
+          || ''
+        }}
+      timeout-minutes: 3
+      toxenv: >-
+        ${{ matrix.toxenv }}
+      xfail: >-
+        ${{
+          fromJSON(needs.pre-setup.outputs.is-yolo-mode)
+          || fromJSON(matrix.xfail)
+        }}
+    secrets:
+      codecov-token: ${{ secrets.CODECOV_TOKEN }}
+
+  tests:
+    name: 🧪 Tests${{ '' }}  # nest jobs under the same sidebar category
+
+    needs:
+    - build
+    - pre-setup  # transitive, for accessing settings
+
+    strategy:
+      fail-fast: >-  # ${{ runner.debug }} is unavailable in this context
+        ${{
+          fromJSON(needs.pre-setup.outputs.is-debug-mode)
+          && false
+          || true
+        }}
+      matrix:
+        python-version:
+        # NOTE: The latest and the lowest supported Pythons are prioritized
+        # NOTE: to improve the responsiveness. It's nice to see the most
+        # NOTE: important results first.
+        - 3.13
+        - 3.9
+        - pypy-3.11
+        - 3.12
+        - 3.11
+        - >-
+          3.10
+        - ~3.14.0-0
+        runner-vm-os:
+        - ubuntu-24.04-arm
+        - ubuntu-24.04
+        - macos-15
+        - windows-2025
+        - ubuntu-22.04
+        - macos-13
+        - windows-2022
+        toxenv:
+        - py
+        xfail:
+        - false
+        exclude:
+        # NOTE: Windows PyPy 3.11 jobs are excluded because of the lack
+        # NOTE: of the build deps to compile cryptography.
+        # NOTE: They should be re-added once it's fixed.
+        - runner-vm-os: windows-2025
+          python-version: pypy-3.11
+        - runner-vm-os: windows-2022
+          python-version: pypy-3.11
+        # NOTE: macOS PyPy jobs are excluded because installing cryptography
+        # NOTE: needs openssl headers that aren't present at the moment.
+        # TODO: Remove the exclusions once this is addressed.
+        - runner-vm-os: macos-15
+          python-version: pypy-3.11
+        - runner-vm-os: macos-13
+          python-version: pypy-3.11
+        # yamllint disable rule:comments-indentation
+        # include: []  # TODO: include TOXENV=cheroot-master
+        # yamllint enable rule:comments-indentation
+
+    uses: tox-dev/workflow/.github/workflows/reusable-tox.yml@208490c75f7f6b81e2698cc959f24d264c462d57  # yamllint disable-line rule:line-length
+    with:
+      built-wheel-names: >-
+        ${{ needs.pre-setup.outputs.wheel-artifact-name }}
+      cache-key-for-dependency-files: >-
+        ${{ needs.pre-setup.outputs.cache-key-for-dep-files }}
+      check-name: >-
+        🧪 🐍${{
+          matrix.python-version
+        }} @ ${{
+          matrix.runner-vm-os
+        }}
+      dists-artifact-name: >-
+        ${{ needs.pre-setup.outputs.dists-artifact-name }}
+      job-dependencies-context: >-  # context for hooks
+        ${{ toJSON(needs) }}
+      python-version: >-
+        ${{ matrix.python-version }}
+      require-successful-codecov-uploads: >-
+        ${{
+          toJSON(
+          needs.pre-setup.outputs.upstream-repository-id
+          == github.repository_id
+          )
+        }}
+      runner-vm-os: >-
+        ${{ matrix.runner-vm-os }}
+      source-tarball-name: >-
+        ${{ needs.pre-setup.outputs.sdist-artifact-name }}
+      timeout-minutes: 6
+      toxenv: >-
+        ${{ matrix.toxenv }}
+      # tox-provision-args: >-
+      #   --force-dep '...'
+      tox-run-posargs: >-
+        --cov-report=xml:.tox/.tmp/.test-results/pytest-${{
+          matrix.python-version
+        }}/cobertura.xml
+        --junitxml=.tox/.tmp/.test-results/pytest-${{
+          matrix.python-version
+        }}/test.xml
+      tox-rerun-posargs: >-
+        --no-cov
+        -vvvvv
+        --lf
+      xfail: >-
+        ${{
+          fromJSON(needs.pre-setup.outputs.is-yolo-mode)
+          || fromJSON(matrix.xfail)
+        }}
+    secrets:
+      codecov-token: ${{ secrets.CODECOV_TOKEN }}
+
+  check:  # This job does nothing and is only used for the branch protection
+    if: always()
+
+    needs:
+    - lint
+    - pre-setup  # transitive, for accessing settings
+    - tests
+
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 1
+
+    steps:
+    - name: Decide whether the needed jobs succeeded or failed
+      uses: re-actors/alls-green@release/v1
+      with:
+        allowed-failures: >-
+          ${{
+            fromJSON(needs.pre-setup.outputs.is-yolo-mode)
+            && 'lint, tests'
+            || ''
+          }}
+        jobs: ${{ toJSON(needs) }}
+
+  publish-pypi:
+    name: >-
+      📦
+      Publish ${{ needs.pre-setup.outputs.git-tag }} to PyPI
+    needs:
+    - check
+    - pre-setup  # transitive, for accessing settings
+    if: >-
+      always()
+      && needs.check.result == 'success'
+      && fromJSON(needs.pre-setup.outputs.release-requested)
+      && needs.pre-setup.outputs.upstream-repository-id == github.repository_id
+
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 2  # docker+network are slow sometimes
+
+    environment:
+      name: pypi
+      url: >-
+        https://pypi.org/project/${{
+          needs.pre-setup.outputs.project-name
+        }}/${{
+          needs.pre-setup.outputs.dist-version
+        }}
+
+    permissions:
+      contents: read  # This job doesn't need to `git push` anything
+      id-token: write  # PyPI Trusted Publishing (OIDC)
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: >-
+          ${{ needs.pre-setup.outputs.dists-artifact-name }}
+        path: dist/
+    - name: >-
+        📦
+        Publish ${{ needs.pre-setup.outputs.git-tag }} to PyPI
+        🔏
+      uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-testpypi:
+    name: >-
+      📦
+      Publish ${{ needs.pre-setup.outputs.git-tag }} to TestPyPI
+    needs:
+    - check
+    - pre-setup  # transitive, for accessing settings
+    if: >-
+      always()
+      && needs.check.result == 'success'
+      && (
+        fromJSON(needs.pre-setup.outputs.is-untagged-devel)
+        || fromJSON(needs.pre-setup.outputs.release-requested)
+      )
+      && needs.pre-setup.outputs.upstream-repository-id == github.repository_id
+      && fromJSON(needs.pre-setup.outputs.publishing-to-testpypi-enabled)
+
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 2  # docker+network are slow sometimes
+
+    environment:
+      name: testpypi
+      url: >-
+        https://test.pypi.org/project/${{
+          needs.pre-setup.outputs.project-name
+        }}/${{
+          needs.pre-setup.outputs.dist-version
+        }}
+
+    permissions:
+      contents: read  # This job doesn't need to `git push` anything
+      id-token: write  # PyPI Trusted Publishing (OIDC)
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: >-
+          ${{ needs.pre-setup.outputs.dists-artifact-name }}
+        path: dist/
+    - name: >-
+        📦
+        Publish ${{ needs.pre-setup.outputs.git-tag }} to TestPyPI
+        🔏
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        repository-url: https://test.pypi.org/legacy/
+
+  post-release-repo-update:
+    name: >-
+      🏷️
+      Publish post-release Git tag
+      for ${{ needs.pre-setup.outputs.git-tag }}
+    needs:
+    - publish-pypi
+    - pre-setup  # transitive, for accessing settings
+    if: >-
+      always()
+      && needs.publish-pypi.result == 'success'
+
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 1
+
+    permissions:
+      contents: write  # Mandatory for `git push` to work
+
+    steps:
+    - name: >-
+        Check if the requested tag ${{ needs.pre-setup.outputs.git-tag }}
+        is present and is pointing at the required commit ${{
+          github.event.inputs.release-committish
+        }}
+      id: existing-remote-tag-check
+      run: |
+        REMOTE_TAGGED_COMMIT_SHA="$(
+          git ls-remote --tags --refs $(git remote get-url origin) '${{
+            needs.pre-setup.outputs.git-tag
+          }}' | awk '{print $1}'
+        )"
+
+        if [[ "${REMOTE_TAGGED_COMMIT_SHA}" == '${{
+          github.event.inputs.release-committish
+        }}' ]]
+        then
+          echo "already-exists=true" >> "${GITHUB_OUTPUT}"
+        fi
+
+    - name: Fetch the src snapshot
+      if: steps.existing-remote-tag-check.outputs.already-exists != 'true'
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 1
+        ref: ${{ github.event.inputs.release-committish }}
+    - name: Setup git user as [bot]
+      if: steps.existing-remote-tag-check.outputs.already-exists != 'true'
+      # Refs:
+      # * https://github.community/t/github-actions-bot-email-address/17204/6
+      # * https://github.com/actions/checkout/issues/13#issuecomment-724415212
+      uses: fregante/setup-git-user@v2
+
+    - name: >-
+        🏷️
+        Tag the release in the local Git repo
+        as ${{ needs.pre-setup.outputs.git-tag }}
+      if: steps.existing-remote-tag-check.outputs.already-exists != 'true'
+      run: >-
+        git tag
+        -m '${{ needs.pre-setup.outputs.git-tag }}'
+        -m 'Published at https://pypi.org/project/${{
+          needs.pre-setup.outputs.project-name
+        }}/${{
+          needs.pre-setup.outputs.dist-version
+        }}'
+        -m 'This release has been produced by the following workflow run: ${{
+          github.server_url
+        }}/${{
+          github.repository
+        }}/actions/runs/${{
+          github.run_id
+        }}'
+        '${{ needs.pre-setup.outputs.git-tag }}'
+        --
+        ${{ github.event.inputs.release-committish }}
+    - name: >-
+        🏷️
+        Push ${{ needs.pre-setup.outputs.git-tag }} tag corresponding
+        to the just published release back to GitHub
+      if: steps.existing-remote-tag-check.outputs.already-exists != 'true'
+      run: >-
+        git push --atomic origin
+        '${{ needs.pre-setup.outputs.git-tag }}'
+
+  slsa-provenance:
+    name: >-
+      🔏
+      Save in-toto SLSA provenance as a GitHub workflow artifact for
+      ${{ needs.pre-setup.outputs.git-tag }}
+    needs:
+    - build
+    - post-release-repo-update
+    - pre-setup  # transitive, for accessing settings
+    if: >-
+      always()
+      && needs.post-release-repo-update.result == 'success'
+
+    permissions:
+      actions: read
+      id-token: write
+      contents: write
+
+    # Can't pin with hash due to how this workflow works.
+    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.0.0  # yamllint disable-line rule:line-length
+    with:
+      base64-subjects: >-
+        ${{
+          fromJSON(
+            needs.build.outputs.steps
+          ).tox-run.outputs.combined-dists-base64-encoded-sha256-hash
+        }}
+
+  publish-github-attestations:
+    name: >-
+      🔏
+      Produce a GitHub-native Attestations for
+      ${{ needs.pre-setup.outputs.git-tag }}
+    needs:
+    - post-release-repo-update
+    - pre-setup  # transitive, for accessing settings
+    if: >-
+      always()
+      && needs.post-release-repo-update.result == 'success'
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 3
+
+    permissions:
+      attestations: write  # IMPORTANT: needed to persist attestations
+      contents: read
+      id-token: write  # IMPORTANT: mandatory for Sigstore signing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: >-
+          ${{ needs.pre-setup.outputs.dists-artifact-name }}
+        path: dist/
+
+    - name: >-
+        🔏
+        Generate provenance attestations for the dists
+      uses: actions/attest-build-provenance@v1
+      with:
+        subject-path: |
+          dist/${{ needs.pre-setup.outputs.sdist-artifact-name }}
+          dist/${{ needs.pre-setup.outputs.wheel-artifact-name }}
+
+  publish-github-release:
+    name: >-
+      🏷️
+      Publish a GitHub Release for
+      ${{ needs.pre-setup.outputs.git-tag }}
+    needs:
+    - post-release-repo-update
+    - pre-setup  # transitive, for accessing settings
+    - publish-github-attestations
+    - slsa-provenance
+    if: >-
+      always()
+      && needs.post-release-repo-update.result == 'success'
+    runs-on: ubuntu-latest
+
+    timeout-minutes: 3
+
+    permissions:
+      contents: write
+      discussions: write
+      id-token: write  # IMPORTANT: mandatory for Sigstore signing
+
+    steps:
+    - name: Download all the dists
+      uses: actions/download-artifact@v4
+      with:
+        name: >-
+          ${{ needs.pre-setup.outputs.dists-artifact-name }}
+        path: dist/
+    - name: Download SLSA provenance in-toto files
+      uses: actions/download-artifact@v4
+      with:
+        name: >-
+          ${{ needs.slsa-provenance.outputs.provenance-name }}
+        path: >-
+          ${{ needs.slsa-provenance.outputs.provenance-name }}
+
+    - name: Figure out if the current version is a pre-release
+      id: release-maturity-check
+      run: |
+        from os import environ
+        from pathlib import Path
+
+        release_version = '${{
+          needs.pre-setup.outputs.dist-version
+        }}'
+
+        FILE_APPEND_MODE = 'a'
+
+        is_pre_release = any(
+            hint_char in release_version
+            for hint_char in {'a', 'b', 'd', 'r'}
+        )
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+                mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print(
+                f'is-pre-release={is_pre_release !s}'.lower(),
+                file=outputs_file,
+            )
+      shell: python
+    - name: Prepare the release notes file for the GitHub Releases
+      run: |
+        echo '## 📝 Release notes' | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo '📦 PyPI page: https://pypi.org/project/${{
+          needs.pre-setup.outputs.project-name
+        }}/${{
+          needs.pre-setup.outputs.dist-version
+        }}' | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo '${{
+          steps.release-maturity-check.outputs.is-pre-release == 'true'
+          && format(
+            '🚧 {0} is marked as a pre-release.',
+            needs.pre-setup.outputs.git-tag
+          )
+          || format(
+            '🌱 {0} is marked as a stable release.',
+            needs.pre-setup.outputs.git-tag
+          )
+        }}' | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo '🔗 This release has been produced by ' \
+        'the following workflow run: ${{
+          github.server_url
+        }}/${{
+          github.repository
+        }}/actions/runs/${{
+          github.run_id
+        }}' | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        echo | tee -a release-notes.md
+        cat '${{
+            needs.pre-setup.outputs.changelog-draft-name-md
+        }}' | tee -a release-notes.md
+      shell: bash
+
+    - name: Sign the dists with Sigstore
+      uses: sigstore/gh-action-sigstore-python@v3.0.0
+      with:
+        inputs: >-
+          dist/${{ needs.pre-setup.outputs.sdist-artifact-name }}
+          dist/${{ needs.pre-setup.outputs.wheel-artifact-name }}
+
+    - name: >-
+        Publish a GitHub Release for
+        ${{ needs.pre-setup.outputs.git-tag }}
+        with Sigstore-signed artifacts
+      uses: ncipollo/release-action@v1
+      with:
+        allowUpdates: false
+        artifactErrorsFailBuild: false
+        artifacts: |
+          dist/${{ needs.pre-setup.outputs.sdist-artifact-name }}
+          dist/${{ needs.pre-setup.outputs.sdist-artifact-name }}.sigstore.json
+          dist/${{ needs.pre-setup.outputs.wheel-artifact-name }}
+          dist/${{ needs.pre-setup.outputs.wheel-artifact-name }}.sigstore.json
+          ${{ needs.slsa-provenance.outputs.provenance-name }}/*
+        artifactContentType: raw  # Because whl and tgz are of different types
+        bodyFile: release-notes.md
+        commit: ${{ github.event.inputs.release-committish }}
+        discussionCategory: Announcements
+        draft: false
+        name: ${{ needs.pre-setup.outputs.git-tag }}
+        omitBodyDuringUpdate: true
+        omitName: false
+        omitNameDuringUpdate: true
+        omitPrereleaseDuringUpdate: true
+        prerelease: ${{ steps.release-maturity-check.outputs.is-pre-release }}
+        removeArtifacts: false
+        replacesArtifacts: false
+        tag: ${{ needs.pre-setup.outputs.git-tag }}
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+...
diff --git a/.github/workflows/scheduled-runs.yml b/.github/workflows/scheduled-runs.yml
new file mode 100644
index 000000000..ab84be5a4
--- /dev/null
+++ b/.github/workflows/scheduled-runs.yml
@@ -0,0 +1,41 @@
+---
+
+name: ⏳
+
+on:
+  pull_request:
+    paths:  # only changes to this workflow itself trigger PR testing
+    - .github/workflows/scheduled-runs.yml
+  schedule:
+  - cron: 1 0 * * *  # Run daily at 0:01 UTC
+  workflow_dispatch:  # manual trigger
+
+run-name: >-
+  🌃
+  Nightly run of
+  ${{
+      github.event.pull_request.number && 'PR' || ''
+  }}${{
+      !github.event.pull_request.number && 'Commit' || ''
+  }}
+  ${{ github.event.pull_request.number || github.sha }}
+  triggered by: ${{ github.event_name }} of ${{
+    github.ref
+  }} ${{
+    github.ref_type
+  }}
+  (workflow run ID: ${{
+    github.run_id
+  }}; number: ${{
+    github.run_number
+  }}; attempt: ${{
+    github.run_attempt
+  }})
+
+jobs:
+  main-ci-cd-pipeline:
+    name: 🧪 Main CI/CD pipeline
+    uses: ./.github/workflows/ci-cd.yml
+    secrets: inherit
+
+...
diff --git a/.gitignore b/.gitignore
index fbef357e5..6f863a506 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,7 +5,6 @@ build/*
 dist/*
 *.swp
 *.log
-lib
 share
 bin
 *.kdev4
@@ -32,11 +31,9 @@ sphinx/source/_build
 .project
 .pydevproject
 
-# test results in junit format for Appveyor
-/.test-results/
-
 # coverage results
 /.coverage
+/.coverage.*
 /coverage.xml
 
 # test artifacts
diff --git a/.pre-commit-config-pep257.yaml b/.pre-commit-config-pep257.yaml
deleted file mode 100644
index 86bf61ec0..000000000
--- a/.pre-commit-config-pep257.yaml
+++ /dev/null
@@ -1,5 +0,0 @@
-repos:
--   repo: git://github.com/chewse/pre-commit-mirrors-pydocstyle
-    rev: v2.1.1
-    hooks:
-    -   id: pydocstyle
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 9f4d43dce..f29efef10 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -1,61 +1,114 @@
+---
+
 repos:
--   repo: git://github.com/pre-commit/pre-commit-hooks
-    rev: v1.1.1
-    hooks:
-    -   id: trailing-whitespace
-        exclude: cherrypy/test/static/index.html
-    -   id: flake8
-    -   id: check-merge-conflict
-    -   id: double-quote-string-fixer
-    -   id: end-of-file-fixer
-    -   id: name-tests-test
-        include: cherrypy/test/
-        args:
-        - --django
-        exclude: tests/dist-check.py
-    -   id: debug-statements
-    -   id: check-added-large-files
-    -   id: check-ast
-    -   id: check-byte-order-marker
-    -   id: check-case-conflict
-    # disabled due to pre-commit/pre-commit-hooks#159
-    #-   id: check-docstring-first
-    -   id: check-json
-        include: .mention-bot
-    -   id: check-symlinks
-    -   id: check-yaml
-    -   id: detect-private-key
-        exclude: cherrypy/test/test.pem
-    -   id: requirements-txt-fixer
-
--   repo: git://github.com/chewse/pre-commit-mirrors-pydocstyle
-    rev: v2.1.1
-    hooks:
-    -   id: pydocstyle
-        exclude: |
-            (?x)
-            tests/dist|
-            cherrypy/(
-                _cp(
-                    compat|modpy|logging|error|wsgi|dispatch|tools|reqbody|request
-                )|
-                (
-                    lib/(
-                        auth|auth_basic|auth_digest|caching|covercp|
-                        cpstats|cptools|encoding|gctools|httpauth|httputil|
-                        jsontools|lockfile|locking|profiler|reprconf|sessions
-                    )|
-                    process/(plugins|servers|win32)
-                ).py|
-                test|tutorial
-            )
-
--   repo: git://github.com/Lucas-C/pre-commit-hooks
-    rev: v1.1.1
-    hooks:
-    -   id: remove-tabs
-
--   repo: git://github.com/Lucas-C/pre-commit-hooks-lxml
-    rev: v1.0.2
-    hooks:
-    -   id: forbid-html-img-without-alt-text
+# - repo: https://github.com/PyCQA/docformatter.git
+#   rev: v1.7.5
+#   hooks:
+#   - id: docformatter
+#     args:
+#     - --in-place
+
+- repo: https://github.com/Kludex/no-optional
+  rev: 0.4.0
+  hooks:
+  - id: no_optional
+
+- repo: https://github.com/astral-sh/ruff-pre-commit.git
+  rev: v0.11.7
+  hooks:
+  - id: ruff
+    args:
+    # Ref: https://docs.astral.sh/ruff/formatter/#conflicting-lint-rules
+    - --fix  # NOTE: When `--fix` is used, linting should be before ruff-format
+
+- repo: https://github.com/astral-sh/ruff-pre-commit.git
+  rev: v0.11.7
+  hooks:
+  - id: ruff-format
+    alias: ruff-format-first-pass
+    name: ruff-format (first pass)
+
+- repo: https://github.com/asottile/add-trailing-comma.git
+  rev: v3.1.0
+  hooks:
+  - id: add-trailing-comma
+
+- repo: https://github.com/astral-sh/ruff-pre-commit.git
+  rev: v0.11.7
+  hooks:
+  - id: ruff-format
+    alias: ruff-format-second-pass
+    name: ruff-format (second pass)
+
+- repo: https://github.com/python-jsonschema/check-jsonschema.git
+  rev: 0.33.0
+  hooks:
+  - id: check-github-workflows
+    files: ^\.github/workflows/[^/]+$
+    types:
+    - yaml
+  - id: check-jsonschema
+    name: Check GitHub Workflows set timeout-minutes
+    args:
+    - --builtin-schema
+    - github-workflows-require-timeout
+    files: ^\.github/workflows/[^/]+$
+    types:
+    - yaml
+  - id: check-readthedocs
+
+- repo: https://github.com/pre-commit/pre-commit-hooks.git
+  rev: v1.1.1
+  hooks:
+  - id: trailing-whitespace
+    exclude: cherrypy/test/static/index.html
+  - id: check-merge-conflict
+  - id: end-of-file-fixer
+  - id: name-tests-test
+    include: cherrypy/test/
+    args:
+    - --django
+    exclude: tests/dist-check.py
+  - id: debug-statements
+  - id: check-added-large-files
+  - id: check-ast
+  - id: check-byte-order-marker
+  - id: check-case-conflict
+  - id: check-json
+    include: .mention-bot
+  - id: check-symlinks
+  - id: check-yaml
+  - id: detect-private-key
+    exclude: cherrypy/test/test.pem
+  - id: requirements-txt-fixer
+
+- repo: https://github.com/PyCQA/flake8.git
+  rev: 7.1.0
+  hooks:
+  - id: flake8
+    additional_dependencies:
+    # - flake8-docstrings ~= 1.7.0
+    # - flake8-docstrings-complete ~= 1.3.0
+    - flake8-pyi ~= 24.1.0
+    # - flake8-pytest-style ~= 1.7.2
+
+- repo: https://github.com/Lucas-C/pre-commit-hooks.git
+  rev: v1.5.4
+  hooks:
+  - id: remove-tabs
+
+- repo: https://github.com/Lucas-C/pre-commit-hooks-lxml.git
+  rev: v1.1.0
+  hooks:
+  - id: forbid-html-img-without-alt-text
+
+- repo: https://github.com/adrienverge/yamllint.git
+  rev: v1.34.0
+  hooks:
+  - id: yamllint
+    files: \.(yaml|yml)$
+    types: [file, yaml]
+    args:
+    - --strict
+
+...
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
new file mode 100644
index 000000000..ca52e160b
--- /dev/null
+++ b/.readthedocs.yaml
@@ -0,0 +1,26 @@
+---
+
+# Required
+version: 2
+
+# Build documentation in the docs/ directory with Sphinx
+sphinx:
+  builder: html
+  configuration: docs/conf.py
+  # fail_on_warning: true
+
+build:
+  os: ubuntu-22.04
+  tools:
+    python: >-  # PyYAML parses it as float but RTD demands an explicit string
+      3.11
+
+python:
+  install:
+  - method: pip
+    path: .
+    extra_requirements:
+    - docs
+    - testing
+
+...
diff --git a/.readthedocs.yml b/.readthedocs.yml
deleted file mode 100644
index ee2c84c45..000000000
--- a/.readthedocs.yml
+++ /dev/null
@@ -1,8 +0,0 @@
-build:
-  image: latest
-python:
-  version: 3.6
-  extra_requirements:
-    - docs
-    - testing
-  pip_install: true
diff --git a/.ruff.toml b/.ruff.toml
new file mode 100644
index 000000000..dfdac3fdd
--- /dev/null
+++ b/.ruff.toml
@@ -0,0 +1,428 @@
+line-length = 79  # Accessibility-friendly
+
+namespace-packages = [
+  "bin/",
+  "cherrypy/test/",
+  "docs/",
+  "tests/",
+]
+
+[format]
+quote-style = "single"
+
+[lint]
+ignore = [
+  "CPY001",  # Skip copyright notice requirement at top of files
+
+  # Legitimate cases, no need to "fix" these violations:
+  # E501: "line too long", its function is replaced by `flake8-length`
+  "E501",
+  # W505: "doc line too long", its function is replaced by `flake8-length`
+  "W505",
+
+  "A001",  # builtin-variable-shadowing  # FIXME
+  "A002",  # builtin-argument-shadowing  # FIXME / noqa
+
+  # FIXME: These `flake8-annotations` errors need fixing and removal
+  # ANN001: Missing type annotation for function argument 'argv'
+  "ANN001",
+  # ANN002: Missing type annotation for *exceptions
+  "ANN002",
+  # ANN003: Missing type annotation for **kwargs
+  "ANN003",
+  # ANN201: Missing return type annotation for public function
+  "ANN201",
+  # ANN202: Missing return type annotation for protected function
+  "ANN202",
+  # ANN204: Missing return type annotation for special method
+  "ANN204",
+  # ANN205: Missing return type annotation for staticmethod
+  "ANN205",
+  # ANN206: Missing return type annotation for classmethod
+  "ANN206",
+  "ANN401",  # any-type  # FIXME
+
+  "ARG001",  # unused-function-argument  # FIXME
+  "ARG002",  # unused-method-argument  # FIXME
+  "ARG005",  # unused-lambda-argument  # FIXME
+
+  "B004",  # unreliable-callable-check  # FIXME
+  "B006",  # mutable-argument-default  # FIXME
+  "B007",  # unused-loop-control-variable  # FIXME
+  "B008",  # function-call-in-default-argument  # FIXME
+  "B018",  # useless-expression  # FIXME
+  "B028",  # no-explicit-stacklevel  # FIXME
+  "B904",  # raise-without-from-inside-except  # FIXME
+
+  "BLE001",  # blind-except  # FIXME / noqa
+
+  "C402",  # unnecessary-generator-dict  # FIXME
+  "C403",  # unnecessary-list-comprehension-set  # FIXME
+  "C404",  # unnecessary-list-comprehension-dict  # FIXME
+  "C405",  # unnecessary-literal-set  # FIXME
+  "C408",  # unnecessary-collection-call  # FIXME
+  "C409",  # unnecessary-literal-within-tuple-call  # FIXME
+  "C413",  # unnecessary-call-around-sorted  # FIXME
+  "C417",  # unnecessary-map  # FIXME
+  "C901",  # complex-structure  # FIXME
+
+  "COM812",  # missing-trailing-comma  # FIXME
+  "COM818",  # trailing-comma-on-bare-tuple  # FIXME
+  "COM819",  # prohibited-trailing-comma  # FIXME
+
+  "D102",  # undocumented-public-method  # FIXME
+  "D103",  # undocumented-public-function  # FIXME
+  "D401",  # non-imperative-mood  # FIXME
+
+  # Refs:
+  # * https://github.com/astral-sh/ruff/issues/6606
+  # * https://github.com/astral-sh/ruff/pull/13286
+  "DOC201",  # Ruff doesn't understand sphinx-native param lists
+  "DOC402",  # docstring-missing-yields  # Ruff doesn't understand sphinx-native param lists
+  "DOC501",  # docstring-missing-exception  # Ruff doesn't understand sphinx-native param lists
+
+  "DTZ005",  # call-datetime-now-without-tzinfo  # FIXME
+
+  "E721",  # type-comparison  # FIXME
+
+  "EM101",  # raw-string-in-exception  # FIXME
+  "EM102",  # f-string-in-exception  # FIXME
+  "EM103",  # dot-format-in-exception  # FIXME
+
+  "EXE001",  # shebang-not-executable  # FIXME
+  "EXE002",  # shebang-missing-executable-file  # FIXME
+
+  # Ref: https://github.com/astral-sh/ruff/issues/4845#issuecomment-2816845547
+  "ERA001",  # False-positives in commented-out code
+
+  "F823",  # undefined-local  # FIXME
+
+  "FBT002",  # boolean-default-value-positional-argument  # FIXME / noqa
+  "FBT003",  # boolean-positional-value-in-call  # FIXME / noqa
+
+  "FIX001",  # line-contains-fixme  # FIXME
+  "FIX002",  # line-contains-todo  # FIXME / noqa
+  "FIX004",  # line-contains-hack  # FIXME
+
+  "FLY002",  # static-join-to-f-string  # FIXME
+
+  "FURB101",  # read-whole-file  # FIXME
+  "FURB103",  # write-whole-file  # FIXME
+  "FURB116",  # f-string-number-format  # FIXME
+  "FURB118",  # reimplemented-operator  # FIXME
+  "FURB145",  # slice-copy  # FIXME
+  "FURB171",  # single-item-membership-test  # FIXME
+  "FURB189",  # subclass-builtin  # FIXME
+
+  "I001",  # unsorted-imports  # FIXME
+
+  "INP001",  # implicit-namespace-package  # FIXME
+
+  "ISC002",  # multi-line-implicit-string-concatenation  # FIXME
+  "ISC003",  # explicit-string-concatenation  # FIXME
+
+  "N801",  # invalid-class-name  # FIXME / noqa
+  "N802",  # invalid-function-name  # FIXME
+  "N803",  # invalid-argument-name  # FIXME
+  "N804",  # invalid-first-argument-name-for-class-method  # FIXME
+  "N805",  # invalid-first-argument-name-for-method  # FIXME
+  "N806",  # non-lowercase-variable-in-function  # FIXME
+  "N815",  # mixed-case-variable-in-class-scope  # FIXME
+  "N816",  # mixed-case-variable-in-global-scope  # FIXME
+  "N818",  # error-suffix-on-exception-name  # FIXME / noqa
+
+  "PERF102",  # incorrect-dict-iterator  # FIXME
+  "PERF203",  # try-except-in-loop  # FIXME / noqa
+  "PERF401",  # manual-list-comprehension  # FIXME
+  "PERF402",  # manual-list-copy  # FIXME
+  "PERF403",  # manual-dict-comprehension  # FIXME
+
+  "PIE790",  # unnecessary-placeholder  # FIXME
+  "PIE804",  # unnecessary-dict-kwargs  # FIXME
+
+  "PGH004",  # blanket-noqa  # FIXME
+
+  "PLC0415",  # import-outside-top-level  # FIXME
+  "PLC1901",  # compare-to-empty-string  # FIXME
+  "PLC2701",  # import-private-name  # FIXME
+  "PLC2801",  # unnecessary-dunder-call  # FIXME
+
+  "PLR0904",  # too-many-public-methods  # FIXME
+  "PLR0911",  # too-many-return-statements  # FIXME
+  "PLR0912",  # too-many-branches  # FIXME
+  "PLR0913",  # too-many-arguments  # FIXME / noqa
+  "PLR0914",  # too-many-locals  # FIXME / noqa
+  "PLR0915",  # too-many-statements  # FIXME / noqa
+  "PLR0916",  # too-many-boolean-expressions  # FIXME
+  "PLR0917",  # too-many-positional-arguments  # FIXME / noqa
+  "PLR1702",  # too-many-nested-blocks  # FIXME
+  "PLR1714",  # repeated-equality-comparison  # FIXME
+  "PLR1730",  # if-stmt-min-max  # FIXME
+  "PLR2004",  # magic-value-comparison  # FIXME
+  "PLR5501",  # collapsible-else-if  # FIXME
+  "PLR6104",  # non-augmented-assignment  # FIXME
+  "PLR6201",  # literal-membership  # FIXME
+  "PLR6301",  # no-self-use  # FIXME / noqa
+
+  "PLW0120",  # useless-else-on-loop  # FIXME
+  "PLW0602",  # global-variable-not-assigned  # FIXME
+  "PLW0603",  # global-statement  # FIXME
+  "PLW1514",  # unspecified-encoding  # FIXME
+  "PLW2901",  # redefined-loop-name  # FIXME
+  "PLW3201",  # bad-dunder-method-name  # FIXME
+
+  "PTH100",  # os-path-abspath  # FIXME
+  "PTH101",  # os-chmod  # FIXME
+  "PTH103",  # os-makedirs  # FIXME
+  "PTH107",  # os-remove  # FIXME
+  "PTH108",  # os-unlink  # FIXME
+  "PTH109",  # os-getcwd  # FIXME
+  "PTH110",  # os-path-exists  # FIXME
+  "PTH111",  # os-path-expanduser  # FIXME
+  "PTH112",  # os-path-isdir  # FIXME
+  "PTH113",  # os-path-isfile  # FIXME
+  "PTH116",  # os-stat  # FIXME
+  "PTH117",  # os-path-isabs  # FIXME
+  "PTH118",  # os-path-join  # FIXME
+  "PTH119",  # os-path-basename  # FIXME
+  "PTH120",  # os-path-dirname  # FIXME
+  "PTH122",  # os-path-splitext  # FIXME
+  "PTH123",  # builtin-open  # FIXME
+  "PTH206",  # os-sep-split  # FIXME
+  "PTH208",  # os-listdir  # FIXME
+
+  "PYI001",  # unprefixed-type-param  # FIXME
+  "PYI024",  # collections-named-tuple  # FIXME
+  "PYI066",  # bad-version-info-order  # FIXME
+
+  "Q001",  # bad-quotes-multiline-string  # FIXME
+  "Q003",  # avoidable-escaped-quote  # FIXME
+
+  "RET501",  # unnecessary-return-none  # FIXME
+  "RET502",  # implicit-return-value  # FIXME
+  "RET503",  # implicit-return  # FIXME
+  "RET504",  # unnecessary-assign  # FIXME
+  "RET505",  # superfluous-else-return  # FIXME
+  "RET506",  # superfluous-else-raise  # FIXME
+  "RET508",  # superfluous-else-break  # FIXME
+
+  "RSE102",  # unnecessary-paren-on-raise-exception  # FIXME
+
+  "RUF005",  # collection-literal-concatenation  # FIXME
+  "RUF012",  # mutable-class-default  # FIXME
+  "RUF021",  # parenthesize-chained-operators  # FIXME
+  "RUF022",  # unsorted-dunder-all  # FIXME
+  "RUF031",  # incorrectly-parenthesized-tuple-in-subscript  # FIXME
+  "RUF039",  # unraw-re-pattern  # FIXME
+  "RUF043",  # pytest-raises-ambiguous-pattern  # FIXME
+  "RUF046",  # unnecessary-cast-to-int  # FIXME
+  "RUF048",  # map-int-version-parsing  # FIXME
+  "RUF052",  # used-dummy-variable  # FIXME
+  "RUF059",  # unused-unpacked-variable  # FIXME
+  "RUF100",  # Ruff doesn't know about WPS
+  "RUF102",  # Ruff doesn't know about WPS
+
+  "S101",  # assert  # FIXME
+  "S102",  # exec-builtin  # FIXME
+  "S104",  # hardcoded-bind-all-interfaces  # FIXME / noqa
+  "S110",  # try-except-pass  # FIXME
+  "S301",  # suspicious-pickle-usage  # FIXME
+  "S307",  # suspicious-eval-usage  # FIXME
+  "S324",  # hashlib-insecure-hash-function  # FIXME
+  "S403",  # suspicious-pickle-import  # FIXME
+  "S404",  # suspicious-subprocess-import  # FIXME
+  "S406",  # suspicious-xml-sax-import  # FIXME
+  "S602",  # subprocess-popen-with-shell-equals-true  # FIXME
+  "S605",  # start-process-with-a-shell  # FIXME
+  "S606",  # start-process-with-no-shell  # FIXME
+  "S607",  # start-process-with-partial-path  # FIXME
+
+  "SIM102",  # collapsible-if  # FIXME
+  "SIM105",  # suppressible-exception  # FIXME
+  "SIM108",  # if-else-block-instead-of-if-exp  # FIXME
+  "SIM115",  # open-file-with-context-handler  # FIXME
+  "SIM117",  # multiple-with-statements  # FIXME
+  "SIM118",  # in-dict-keys  # FIXME
+  "SIM300",  # yoda-conditions  # FIXME
+  "SIM910",  # dict-get-with-none-default  # FIXME
+
+  "SLF001",  # private-member-access  # FIXME / noqa
+
+  "SLOT000",  # no-slots-in-str-subclass  # FIXME
+
+  "T201",  # print  # FIXME
+  "T203",  # p-print  # FIXME
+
+  "TC002",  # typing-only-third-party-import  # FIXME
+
+  "TD001",   # invalid-todo-tag  # FIXME
+  "TD002",   # missing-todo-author  # FIXME
+  "TD003",   # missing-todo-link  # FIXME
+  "TD004",   # missing-todo-colon  # FIXME
+  "TD005",   # missing-todo-description  # FIXME
+
+  "TID252",  # relative-imports  # TODO: figure this out
+
+  "TRY002",  # raise-vanilla-class  # FIXME
+  "TRY003",  # raise-vanilla-args  # controversial
+  "TRY004",  # type-check-without-type-error  # FIXME
+  "TRY300",  # try-consider-else  # FIXME
+  "TRY301",  # raise-within-try  # FIXME
+
+  "UP004",  # useless-object-inheritance  # FIXME
+  "UP006",  # non-pep585-annotation  # FIXME
+  "UP007",  # non-pep604-annotation-union  # FIXME
+  "UP008",  # super-call-with-parameters  # FIXME
+  "UP009",  # utf8-encoding-declaration  # FIXME
+  "UP015",  # redundant-open-modes  # FIXME
+  "UP018",  # native-literals  # FIXME
+  "UP020",  # open-alias  # FIXME
+  "UP024",  # os-error-alias  # FIXME
+  "UP028",  # yield-in-for-loop  # FIXME
+  "UP030",  # format-literals  # FIXME
+  "UP031",  # printf-string-formatting  # FIXME
+  "UP032",  # f-string  # FIXME
+  "UP036",  # outdated-version-block  # FIXME
+  "UP045",  # non-pep604-annotation-optional  # FIXME
+]
+preview = true  # Live dangerously
+select = [
+  "ALL",
+]
+task-tags = [
+  "FIXME",
+  "NOTE",
+  "Ref",
+  "Refs",
+  "TODO",
+]
+
+[lint.flake8-pytest-style]
+parametrize-values-type = "tuple"
+
+[lint.flake8-quotes]
+inline-quotes = "single"
+
+[lint.isort]
+combine-as-imports = true
+force-wrap-aliases = true
+lines-after-imports = 2
+section-order = [
+  "future",
+  "standard-library",
+  "testing",
+  "frameworks",
+  "platforms",
+  "third-party",
+  "first-party",
+  "local-folder",
+]
+
+[lint.isort.sections]
+frameworks = [
+  # "awx",
+  # "django",
+]
+platforms = [
+  # "awx_plugins.interfaces",
+]
+testing = [
+  "hypothesis",
+  "pytest",
+  "pytest_mock",
+  "pytest_subtests",
+]
+
+
+[lint.per-file-ignores]
+# Exceptions for test files
+"cherrypy/test/**.py" = [
+  "ARG002",  # Allow unused arguments in instance methods (required for test stubs)
+  "ARG003",  # unused-class-method-argument  # FIXME
+  "ARG004",  # unused-static-method-argument (hit in WSGI test apps)
+
+  "B009",  # get-attr-with-constant  # FIXME
+  "B015",  # useless-comparison  # FIXME
+
+  "C401",  # unnecessary-generator-set  # FIXME
+  "C410",  # unnecessary-literal-within-list-call  # FIXME
+
+  "D100",  # undocumented-public-module  # FIXME
+  "D101",  # undocumented-public-class  # FIXME
+  "D105",  # undocumented-magic-method  # FIXME
+  "D107",  # undocumented-public-init  # FIXME
+  "D200",  # unnecessary-multiline-docstring  # FIXME
+  "D202",  # blank-line-after-function  # FIXME
+  "D204",  # incorrect-blank-line-after-class  # FIXME
+  "D205",  # missing-blank-line-after-summary  # FIXME
+  "D209",  # new-line-after-last-paragraph  # FIXME
+  "D300",  # triple-single-quotes  # FIXME
+  "D301",  # escape-sequence-in-docstring  # FIXME
+  "D400",  # missing-trailing-period  # FIXME
+  "D403",  # first-word-uncapitalized  # FIXME
+
+  "DTZ003",  # call-datetime-utcnow  # FIXME
+
+  "FURB105",  # print-empty-string  # FIXME
+  "FURB113",  # repeated-append  # FIXME
+  "FURB152",  # math-constant  # FIXME
+  "FURB156",  # hardcoded-string-charset  # FIXME
+
+  "G002",  # logging-percent-format  # FIXME
+
+  "ICN001",  # unconventional-import-alias  # FIXME
+
+  "PLC2701",  # Allow importing internal files needed for testing
+
+  "PLE1307",  # bad-string-format-type  # FIXME
+
+  # "PLR6301",  # Allow 'self' parameter in method definitions (required for test stubs)
+
+  "PT001",  # pytest-fixture-incorrect-parentheses-style  # FIXME
+  "PT006",  # pytest-parametrize-names-wrong-type  # FIXME
+  "PT007",  # pytest-parametrize-values-wrong-type  # FIXME
+  "PT008",  # pytest-patch-with-lambda  # FIXME
+  "PT009",  # pytest-unittest-assertion  # FIXME
+  "PT011",  # pytest-raises-too-broad  # FIXME
+  "PT018",  # pytest-composite-assertion  # FIXME
+  "PT021",  # pytest-fixture-finalizer-callback  # FIXME
+  "PT027",  # pytest-unittest-raises-assertion  # FIXME
+
+  "PTH124",  # py-path  # FIXME
+  "PTH202",  # os-path-getsize  # FIXME
+
+  "Q002",  # bad-quotes-docstring  # FIXME
+
+  "RUF001",  # ambiguous-unicode-character-string  # FIXME
+  "RUF027",  # missing-f-string-syntax  # FIXME
+
+  "S101",  # Allow use of `assert` in test files
+  "S105",  # hardcoded-password-string  # FIXME
+  "S113",  # request-without-timeout  # FIXME
+  "S310",  # suspicious-url-open-usage  # FIXME
+  "S314",  # suspicious-xml-element-tree-usage  # FIXME
+  "S404",  # Allow importing 'subprocess' module to testing call external tools needed by these hooks
+  "S405",  # suspicious-xml-etree-import  # FIXME
+  "S603",  # subprocess-without-shell-equals-true
+
+  "SIM114",  # if-with-same-arms  # FIXME
+
+  "SLF001",  # Private member accessed
+
+  "UP001",  # useless-metaclass-type  # FIXME
+  "UP012",  # unnecessary-encode-utf8  # FIXME
+  "UP025",  # unicode-kind-prefix  # FIXME
+]
+"tests/**.py" = [
+  "S101",  # Allow use of `assert` in test files
+
+  "B017",  # assert-raises-exception  # FIXME
+  "N999",  # invalid-module-name  # FIXME
+  "PT011",  # pytest-raises-too-broad  # FIXME
+  "PTH110",  # os-path-exists  # FIXME
+  "PTH112",  # os-path-isdir  # FIXME
+  "PTH121",  # os-path-samefile  # FIXME
+]
+
+[lint.pydocstyle]
+convention = "pep257"
diff --git a/.test-results/pytest/.gitignore b/.test-results/pytest/.gitignore
deleted file mode 100644
index 72e8ffc0d..000000000
--- a/.test-results/pytest/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-*
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index c8d50b1f7..000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,181 +0,0 @@
-conditions: v1
-
-language: python
-os: linux
-dist: focal
-services:
-- memcached
-_base_envs:
-- &stage_lint
-  stage: &stage_lint_name lint
-- &stage_test
-  stage: &stage_test_name test
-- &stage_test_priority
-  stage: &stage_test_priority_name test against latest Python versions first (under GNU/Linux)
-- &stage_test_osx
-  stage: &stage_test_osx_name test under OS X (last chance to fail before deploy available)
-- &stage_deploy
-  stage: &stage_deploy_name upload new version of python package to PYPI (only for tagged commits)
-- _conditions:
-  - &condition_api_or_cron
-    if: type IN (api, cron)
-- &no_memcached
-  services: []
-- &pyenv_base
-  <<: *stage_test
-  language: generic
-  env:
-  - &env_pyenv PYENV_ROOT="$HOME/.pyenv"
-  - &env_path PATH="$PYENV_ROOT/bin:$PATH"
-  before_install:
-  - &ensure_pyenv_installed |
-    if [ ! -f "$PYENV_ROOT/bin/pyenv" ]
-    then
-      rm -rf "$PYENV_ROOT"
-      curl -L https://raw.githubusercontent.com/pyenv/pyenv-installer/master/bin/pyenv-installer | bash
-    fi
-    eval "$(pyenv init -)"
-    eval "$(pyenv virtualenv-init -)"
-    pyenv update
-  - &install_python pyenv install --skip-existing --keep --verbose "$PYTHON_VERSION"
-  - &switch_python pyenv shell "$PYTHON_VERSION"
-  - &python_version python --version
-- &osx_python_base
-  <<: *pyenv_base
-  <<: *stage_test_osx
-  os: osx
-  language: generic
-  before_install:
-  - brew update
-  - brew install pyenv || brew upgrade pyenv
-  - &ensure_pyenv_preloaded |
-    eval "$(pyenv init -)"
-    eval "$(pyenv virtualenv-init -)"
-  - *install_python
-  - *switch_python
-  - *python_version
-  before_cache:
-  - brew --cache
-  script:
-  - travis_retry python -m tox
-- &python_3_9_mixture
-  python: &mainstream_python 3.9
-  group:
-- &pure_python_base
-  <<: *stage_test
-  <<: *python_3_9_mixture
-- &pure_python_base_priority
-  <<: *pure_python_base
-  <<: *stage_test_priority
-- &lint_python_base
-  <<: *stage_lint
-  <<: *no_memcached
-  python: 3.9
-  after_failure: skip
-python:
-- 3.5
-- 3.7-dev
-- &pypy3 pypy3.5-5.10.0
-jobs:
-  fast_finish: true
-  allow_failures:
-  # TODO: fix tests
-  - python: *pypy3
-  - env: TOXENV=pre-commit-pep257
-  include:
-  - <<: *lint_python_base
-    env: TOXENV=pre-commit
-  - <<: *lint_python_base
-    env: TOXENV=pre-commit-pep257
-  - <<: *lint_python_base
-    env: TOXENV=dist-check
-  - <<: *lint_python_base
-    env: TOXENV=setup-check
-  - <<: *lint_python_base
-    name: >-
-      Ensure that docs get built
-      (non-strict until \#1797 get fixed)
-    env: TOXENV=build-docs
-  - <<: *pure_python_base_priority
-    # mainstream Python here
-  - <<: *pure_python_base_priority
-    # mainstream Python here
-    # run tests against the bleeding-edge cheroot
-    env: TOXENV=cheroot-master
-  - <<: *pure_python_base_priority
-    python: nightly
-  - <<: *osx_python_base
-    python: 3.5
-    env:
-    - PYTHON_VERSION=3.5.5
-    - *env_pyenv
-    - *env_path
-  - <<: *osx_python_base
-    python: *mainstream_python
-    env:
-    - PYTHON_VERSION=3.6.5
-    - *env_pyenv
-    - *env_path
-  - <<: *osx_python_base
-    python: 3.7-dev
-    env:
-    - PYTHON_VERSION=3.7-dev
-    - *env_pyenv
-    - *env_path
-  - <<: *osx_python_base
-    # mainstream Python here
-    python: *mainstream_python
-    env:
-    - PYTHON_VERSION=3.7.0
-    # run tests against the bleeding-edge cheroot
-    - TOXENV=cheroot-master
-    - *env_pyenv
-    - *env_path
-  - <<: *stage_deploy
-    <<: *python_3_9_mixture
-    <<: *no_memcached
-    install: skip
-    script: skip
-    deploy:
-      provider: pypi
-      skip_cleanup: true
-      on:
-        tags: true
-        all_branches: true
-        python: *mainstream_python
-      user: __token__
-      distributions: dists
-      password:
-        secure: r9jZVhWnwBpbQwkoAQnhcQajV6Hk8WKs53+P20YrNfLSrSfODmJFyljCLsUJH7TnmAdrnQfV19PXPfVXPucK2ZEg2E91/5z6pgADi01NX3QMr7vEpffk6ix0uHBSa3VMBF+VlmhCzAFnNIN0E7M4kjoc5Cr7qBWPwZpqd715axYxBKSIH4Cmt2cyW3ozMftNtbI+ujs+kJTX6m/2UAL8yngau0TWR5bUBaywTZdkfPIKxt2XDfTW5PuOTRgS6QSU+/Va+M1IJhFPthjmTO+t8U/qonSLA34nLkT7vJmME0lyQF0lr+IV41IKxEFz29hmzLY1dyZI5+bs3vEhxU1xGqwr1Hnif6f14TzeiubQrCxt1UP9D3HXguCNI4gGeny1OPJNNt5ezJDNha2HlIy2quLKgtW38TS0PPm7PDqgYhjidZyRXZ8G6A/DAwh00amCNkSN6lG7Lryd1QB44mYHCKm8XdLfBT94EqzSdgQyyoUAA87A8zB5zpHiRD2DGwrTxHkGQo7TTSVr82cYwkRW0nqE6bZkfNTrGLULB8872ZFGpbSbrAft5mDlSnprLRwrEA0SsFUd4O2W64pcvcJENa/NY+vvXAyd9jaHb5v0RpxUyllLrAIFuLEFHeHwyBAlMgq54dtYWqYa8pyJNoUiwOt158qzOE6wnoburP4KA9c=
-cache:
-  pip: true
-  directories:
-  - $HOME/.cache/pre-commit
-  - $HOME/Library/Caches/Homebrew
-install:
-- python -m pip install tox "setuptools>=28.2"
-- python -m tox --notest  # Pre-populate a virtualenv with dependencies
-script:
-- python -m tox
-after_failure:
-- echo "Here's a list of installed Python packages:"
-- pip list --format=columns
-- echo Dumping logs, because tests failed to succeed
-- |
-    for log in `ls cherrypy/test/*.log`
-    do
-      echo Outputting $log
-      cat $log
-    done
-- py_log=/home/travis/build/cherrypy/cherrypy/.tox/python/log/python-0.log
-- echo Outputting python invocation log from $py_log
-- cat $py_log
-stages:
-- *stage_lint_name
-- *stage_test_priority_name
-- name: *stage_test_name
-  <<: *condition_api_or_cron
-- name: *stage_test_osx_name
-  <<: *condition_api_or_cron
-- name: *stage_deploy_name
-  if: tag IS present
diff --git a/.yamllint b/.yamllint
index 97c08cfcd..dd8f073c3 100644
--- a/.yamllint
+++ b/.yamllint
@@ -1,2 +1,17 @@
-indentation:
-  indent-sequences: false
+---
+
+extends: default
+
+rules:
+  indentation:
+    indent-sequences: false
+    level: error
+  truthy:
+    allowed-values:
+    - 'false'
+    - 'no'
+    - 'on'  # Allow "on" key name in GHA CI/CD workflow definitions
+    - 'true'
+    - 'yes'
+
+...
diff --git a/.zuul.yaml b/.zuul.yaml
deleted file mode 100644
index 5f57bc1a8..000000000
--- a/.zuul.yaml
+++ /dev/null
@@ -1,78 +0,0 @@
----
-- job:
-    name: tox-build-docs
-    parent: tox
-    vars:
-      tox_envlist: build-docs
-
-- job:
-    name: tox-dist-check
-    parent: tox
-    vars:
-      tox_envlist: dist-check
-
-- job:
-    name: tox-pre-commit
-    parent: tox
-    vars:
-      tox_envlist: pre-commit
-
-- job:
-    name: tox-pre-commit-pep257
-    parent: tox
-    voting: false
-    vars:
-      tox_envlist: pre-commit-pep257
-
-- job:
-    name: tox-py27-setup-check
-    vars:
-      tox_envlist: setup-check
-      python_version: 2.7
-      python_use_pyenv: false
-    parent: tox
-
-- job:
-    name: tox-py35-setup-check
-    vars:
-      tox_envlist: setup-check
-      python_version: 3.5
-      python_use_pyenv: true
-    parent: tox
-
-- job:
-    name: tox-py36-setup-check
-    vars:
-      tox_envlist: setup-check
-      python_version: 3.6
-      python_use_pyenv: true
-    parent: tox
-
-- job:
-    name: tox-py37-setup-check
-    vars:
-      tox_envlist: setup-check
-      python_version: 3.7
-      python_use_pyenv: false
-    parent: tox
-
-- job:
-    name: tox-py38-setup-check
-    vars:
-      tox_envlist: setup-check
-      python_version: 3.8
-      python_use_pyenv: true
-    parent: tox
-
-- project:
-    check:
-      jobs:
-      - tox-build-docs
-      - tox-dist-check
-      - tox-pre-commit
-      - tox-pre-commit-pep257
-      - tox-py27-setup-check
-      - tox-py35-setup-check
-      - tox-py36-setup-check
-      - tox-py37-setup-check
-      - tox-py38-setup-check
diff --git a/CHANGES.rst b/CHANGES.rst
index d78475b46..b24b142fa 100644
--- a/CHANGES.rst
+++ b/CHANGES.rst
@@ -1,3 +1,40 @@
+v(next)
+-------
+
+* Dropped support for Python 3.6, 3.7 and 3.8
+  -- by :user:`webknjaz`.
+
+* Deprecated the accidentally exposed ``cherrypy.lib.headers``
+  -- by :user:`webknjaz`.
+
+v18.10.0
+--------
+
+* Removed the use of :mod:`cgi` deprecated in Python 3.11
+  -- by :user:`radez`.
+* Various `changes <https://github.com/cherrypy/cherrypy/compare/v18.9.0...7104cfb3cfc6e6582f0773529142d777b1aff1bd>`_.
+
+v18.9.0
+-------
+
+* Various
+  `changes <https://github.com/cherrypy/cherrypy/compare/v18.8.0...v18.9.0>`_.
+
+v18.8.0
+-------
+
+* :issue:`1974`: Dangerous characters received in a host header
+  encoded using RFC 2047 are now elided by default. Currently,
+  dangerous characters are defined as CR and LF. The original
+  value is still available as ``cherrypy.request.headers['Host'].raw``
+  if needed.
+
+v18.7.0
+-------
+
+* :pr:`1923`: Drop support for Python 3.5.
+* :pr:`1945`: Fixed compatibility on Python 3.11.
+
 v18.6.1
 -------
 
@@ -9,6 +46,9 @@ v18.6.1
   CPython so that it won't get pulled-in under PyPy
   -- by :user:`webknjaz`.
 
+* :issue:`1920`: Bumped minimum version of PyWin32 to 227.
+  Block pywin32 install on Python 3.10 and later.
+
 v18.6.0
 -------
 
diff --git a/LICENSE.md b/LICENSE.md
index 96b866459..ce28cf8f2 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -1,4 +1,4 @@
-Copyright © 2004-2019, CherryPy Team (team@cherrypy.org)
+Copyright © 2004-2019, CherryPy Team (team@cherrypy.dev)
 
 All rights reserved.
 
diff --git a/README.rst b/README.rst
index 75a2f5323..908ae13de 100644
--- a/README.rst
+++ b/README.rst
@@ -1,3 +1,7 @@
+.. image:: https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner-direct.svg
+   :target: https://github.com/vshymanskyy/StandWithUkraine/blob/main/docs/README.md
+   :alt: SWUbanner
+
 .. image:: https://img.shields.io/pypi/v/cherrypy.svg
    :target: https://pypi.org/project/cherrypy
 
@@ -14,7 +18,7 @@
 
 
 .. image:: https://readthedocs.org/projects/cherrypy/badge/?version=latest
-  :target: https://docs.cherrypy.org/en/latest/?badge=latest
+  :target: https://docs.cherrypy.dev/en/latest/?badge=latest
 
 .. image:: https://img.shields.io/badge/StackOverflow-CherryPy-blue.svg
    :target: https://stackoverflow.com/questions/tagged/cheroot+or+cherrypy
@@ -25,15 +29,6 @@
 .. image:: https://img.shields.io/gitter/room/cherrypy/cherrypy.svg
    :target: https://gitter.im/cherrypy/cherrypy
 
-.. image:: https://img.shields.io/travis/cherrypy/cherrypy/master.svg?label=Linux%20build%20%40%20Travis%20CI
-   :target: https://travis-ci.org/cherrypy/cherrypy
-
-.. image:: https://circleci.com/gh/cherrypy/cherrypy/tree/master.svg?style=svg
-   :target: https://circleci.com/gh/cherrypy/cherrypy/tree/master
-
-.. image:: https://img.shields.io/appveyor/ci/CherryPy/cherrypy/master.svg?label=Windows%20build%20%40%20Appveyor
-   :target: https://ci.appveyor.com/project/CherryPy/cherrypy/branch/master
-
 .. image:: https://img.shields.io/badge/license-BSD-blue.svg?maxAge=3600
    :target: https://pypi.org/project/cheroot
 
@@ -51,13 +46,13 @@
    :target: https://codecov.io/gh/cherrypy/cherrypy
    :alt: codecov
 
-Welcome to the GitHub repository of `CherryPy <https://cherrypy.org/>`_!
+Welcome to the GitHub repository of `CherryPy <https://cherrypy.dev>`_!
 
 CherryPy is a pythonic, object-oriented HTTP framework.
 
 1. It allows building web applications in much the same way one would
    build any other object-oriented program.
-2. This design results in less and more readable code being developed faster.
+2. This design results in more concise and readable code developed faster.
    It's all just properties and methods.
 3. It is now more than ten years old and has proven fast and very
    stable.
@@ -79,12 +74,12 @@ Here's how easy it is to write "Hello World" in CherryPy:
     cherrypy.quickstart(HelloWorld())
 
 And it continues to work that intuitively when systems grow, allowing
-for the Python object model to be dynamically presented as a web site
+for the Python object model to be dynamically presented as a website
 and/or API.
 
 While CherryPy is one of the easiest and most intuitive frameworks out
 there, the prerequisite for understanding the `CherryPy
-documentation <https://docs.cherrypy.org/en/latest/>`_ is that you have
+documentation <https://docs.cherrypy.dev>`_ is that you have
 a general understanding of Python and web development.
 Additionally:
 
@@ -95,7 +90,7 @@ Additionally:
 
 If the docs are insufficient to address your needs, the CherryPy
 community has several `avenues for support
-<https://docs.cherrypy.org/en/latest/support.html>`_.
+<https://docs.cherrypy.dev/en/latest/support.html>`_.
 
 For Enterprise
 --------------
@@ -112,6 +107,6 @@ Contributing
 ------------
 
 Please follow the `contribution guidelines
-<https://docs.cherrypy.org/en/latest/contribute.html>`_.
+<https://docs.cherrypy.dev/en/latest/contribute.html>`_.
 And by all means, absorb the `Zen of
 CherryPy <https://github.com/cherrypy/cherrypy/wiki/The-Zen-of-CherryPy>`_.
diff --git a/cherrypy/__init__.py b/cherrypy/__init__.py
index 8e27c8121..af02e2a8f 100644
--- a/cherrypy/__init__.py
+++ b/cherrypy/__init__.py
@@ -56,16 +56,16 @@
 <https://github.com/cherrypy/cherrypy/wiki/CherryPySpec>`_.
 """
 
-try:
-    import pkg_resources
-except ImportError:
-    pass
+import importlib.metadata as importlib_metadata
 
 from threading import local as _local
 
 from ._cperror import (
-    HTTPError, HTTPRedirect, InternalRedirect,
-    NotFound, CherryPyException,
+    HTTPError,
+    HTTPRedirect,
+    InternalRedirect,
+    NotFound,
+    CherryPyException,
 )
 
 from . import _cpdispatch as dispatch
@@ -81,8 +81,10 @@
 from . import _cpwsgi as wsgi
 
 from . import process
+
 try:
     from .process import win32
+
     engine = win32.Win32Bus()
     engine.console_control_handler = win32.ConsoleCtrlHandler(engine)
     del win32
@@ -92,12 +94,29 @@
 from . import _cpchecker
 
 __all__ = (
-    'HTTPError', 'HTTPRedirect', 'InternalRedirect',
-    'NotFound', 'CherryPyException',
-    'dispatch', 'tools', 'Tool', 'Application',
-    'wsgi', 'process', 'tree', 'engine',
-    'quickstart', 'serving', 'request', 'response', 'thread_data',
-    'log', 'expose', 'popargs', 'url', 'config',
+    'HTTPError',
+    'HTTPRedirect',
+    'InternalRedirect',
+    'NotFound',
+    'CherryPyException',
+    'dispatch',
+    'tools',
+    'Tool',
+    'Application',
+    'wsgi',
+    'process',
+    'tree',
+    'engine',
+    'quickstart',
+    'serving',
+    'request',
+    'response',
+    'thread_data',
+    'log',
+    'expose',
+    'popargs',
+    'url',
+    'config',
 )
 
 
@@ -109,7 +128,7 @@
 
 
 try:
-    __version__ = pkg_resources.require('cherrypy')[0].version
+    __version__ = importlib_metadata.version('cherrypy')
 except Exception:
     __version__ = 'unknown'
 
@@ -181,24 +200,30 @@ def quickstart(root=None, script_name='', config=None):
 class _Serving(_local):
     """An interface for registering request and response objects.
 
-    Rather than have a separate "thread local" object for the request and
-    the response, this class works as a single threadlocal container for
-    both objects (and any others which developers wish to define). In this
-    way, we can easily dump those objects when we stop/start a new HTTP
-    conversation, yet still refer to them as module-level globals in a
-    thread-safe way.
+    Rather than have a separate "thread local" object for the request
+    and the response, this class works as a single threadlocal container
+    for both objects (and any others which developers wish to define).
+    In this way, we can easily dump those objects when we stop/start a
+    new HTTP conversation, yet still refer to them as module-level
+    globals in a thread-safe way.
     """
 
-    request = _cprequest.Request(_httputil.Host('127.0.0.1', 80),
-                                 _httputil.Host('127.0.0.1', 1111))
+    request = _cprequest.Request(
+        _httputil.Host('127.0.0.1', 80),
+        _httputil.Host('127.0.0.1', 1111),
+    )
+    """The request object for the current thread.
+
+    In the main thread, and any threads which are not receiving HTTP
+    requests, this is None.
     """
-    The request object for the current thread. In the main thread,
-    and any threads which are not receiving HTTP requests, this is None."""
 
     response = _cprequest.Response()
+    """The response object for the current thread.
+
+    In the main thread, and any threads which are not receiving HTTP
+    requests, this is None.
     """
-    The response object for the current thread. In the main thread,
-    and any threads which are not receiving HTTP requests, this is None."""
 
     def load(self, request, response):
         self.request = request
@@ -213,7 +238,6 @@ def clear(self):
 
 
 class _ThreadLocalProxy(object):
-
     __slots__ = ['__attrname__', '__dict__']
 
     def __init__(self, attrname):
@@ -224,7 +248,7 @@ def __getattr__(self, name):
         return getattr(child, name)
 
     def __setattr__(self, name, value):
-        if name in ('__attrname__', ):
+        if name in ('__attrname__',):
             object.__setattr__(self, name, value)
         else:
             child = getattr(serving, self.__attrname__)
@@ -264,6 +288,7 @@ def __len__(self):
     def __nonzero__(self):
         child = getattr(serving, self.__attrname__)
         return bool(child)
+
     # Python 3
     __bool__ = __nonzero__
 
@@ -297,6 +322,7 @@ def _cherrypy_pydoc_resolve(thing, forceload=0):
 
 try:
     import pydoc as _pydoc
+
     _pydoc._builtin_resolve = _pydoc.resolve
     _pydoc.resolve = _cherrypy_pydoc_resolve
 except ImportError:
@@ -316,8 +342,8 @@ class _GlobalLogManager(_cplogging.LogManager):
     def __call__(self, *args, **kwargs):
         """Log the given message to the app.log or global log.
 
-        Log the given message to the app.log or global
-        log as appropriate.
+        Log the given message to the app.log or global log as
+        appropriate.
         """
         # Do NOT use try/except here. See
         # https://github.com/cherrypy/cherrypy/issues/945
@@ -330,8 +356,8 @@ def __call__(self, *args, **kwargs):
     def access(self):
         """Log an access message to the app.log or global log.
 
-        Log the given message to the app.log or global
-        log as appropriate.
+        Log the given message to the app.log or global log as
+        appropriate.
         """
         try:
             return request.app.log.access()
@@ -359,7 +385,7 @@ def _buslog(msg, level):
     'tools.log_tracebacks.on': True,
     'tools.log_headers.on': True,
     'tools.trailing_slash.on': True,
-    'tools.encode.on': True
+    'tools.encode.on': True,
 }
 config.namespaces['log'] = lambda k, v: setattr(log, k, v)
 config.namespaces['checker'] = lambda k, v: setattr(checker, k, v)
diff --git a/cherrypy/__main__.py b/cherrypy/__main__.py
index 6674f7cb4..0a8b65a01 100755
--- a/cherrypy/__main__.py
+++ b/cherrypy/__main__.py
@@ -1,4 +1,5 @@
 """CherryPy'd cherryd daemon runner."""
+
 from cherrypy.daemon import run
 
 
diff --git a/cherrypy/_cpchecker.py b/cherrypy/_cpchecker.py
index f26f319cf..8882dcb6b 100644
--- a/cherrypy/_cpchecker.py
+++ b/cherrypy/_cpchecker.py
@@ -1,4 +1,5 @@
 """Checker for CherryPy sites and mounted apps."""
+
 import os
 import warnings
 import builtins
@@ -60,11 +61,12 @@ def check_app_config_entries_dont_start_with_script_name(self):
             sn_atoms = sn.strip('/').split('/')
             for key in app.config.keys():
                 key_atoms = key.strip('/').split('/')
-                if key_atoms[:len(sn_atoms)] == sn_atoms:
+                if key_atoms[: len(sn_atoms)] == sn_atoms:
                     warnings.warn(
                         'The application mounted at %r has config '
-                        'entries that start with its script name: %r' % (sn,
-                                                                         key))
+                        'entries that start with its script name: %r'
+                        % (sn, key),
+                    )
 
     def check_site_config_entries_in_app_config(self):
         """Check for mounted Applications that have site-scoped config."""
@@ -78,15 +80,18 @@ def check_site_config_entries_in_app_config(self):
                     for key, value in entries.items():
                         for n in ('engine.', 'server.', 'tree.', 'checker.'):
                             if key.startswith(n):
-                                msg.append('[%s] %s = %s' %
-                                           (section, key, value))
+                                msg.append(
+                                    '[%s] %s = %s' % (section, key, value),
+                                )
             if msg:
-                msg.insert(0,
-                           'The application mounted at %r contains the '
-                           'following config entries, which are only allowed '
-                           'in site-wide config. Move them to a [global] '
-                           'section and pass them to cherrypy.config.update() '
-                           'instead of tree.mount().' % sn)
+                msg.insert(
+                    0,
+                    'The application mounted at %r contains the '
+                    'following config entries, which are only allowed '
+                    'in site-wide config. Move them to a [global] '
+                    'section and pass them to cherrypy.config.update() '
+                    'instead of tree.mount().' % sn,
+                )
                 warnings.warn(os.linesep.join(msg))
 
     def check_skipped_app_config(self):
@@ -97,11 +102,13 @@ def check_skipped_app_config(self):
             if not app.config:
                 msg = 'The Application mounted at %r has an empty config.' % sn
                 if self.global_config_contained_paths:
-                    msg += (' It looks like the config you passed to '
-                            'cherrypy.config.update() contains application-'
-                            'specific sections. You must explicitly pass '
-                            'application config via '
-                            'cherrypy.tree.mount(..., config=app_config)')
+                    msg += (
+                        ' It looks like the config you passed to '
+                        'cherrypy.config.update() contains application-'
+                        'specific sections. You must explicitly pass '
+                        'application config via '
+                        'cherrypy.tree.mount(..., config=app_config)'
+                    )
                 warnings.warn(msg)
                 return
 
@@ -118,7 +125,8 @@ def check_app_config_brackets(self):
                         'The application mounted at %r has config '
                         'section names with extraneous brackets: %r. '
                         'Config *files* need brackets; config *dicts* '
-                        '(e.g. passed to tree.mount) do not.' % (sn, key))
+                        '(e.g. passed to tree.mount) do not.' % (sn, key),
+                    )
 
     def check_static_paths(self):
         """Check Application config for incorrect static paths."""
@@ -144,34 +152,43 @@ def check_static_paths(self):
                         if os.path.isabs(dir):
                             fulldir = dir
                             if root:
-                                msg = ('dir is an absolute path, even '
-                                       'though a root is provided.')
+                                msg = (
+                                    'dir is an absolute path, even '
+                                    'though a root is provided.'
+                                )
                                 testdir = os.path.join(root, dir[1:])
                                 if os.path.exists(testdir):
                                     msg += (
                                         '\nIf you meant to serve the '
                                         'filesystem folder at %r, remove the '
-                                        'leading slash from dir.' % (testdir,))
+                                        'leading slash from dir.' % (testdir,)
+                                    )
                         else:
                             if not root:
                                 msg = (
                                     'dir is a relative path and '
-                                    'no root provided.')
+                                    'no root provided.'
+                                )
                             else:
                                 fulldir = os.path.join(root, dir)
                                 if not os.path.isabs(fulldir):
-                                    msg = ('%r is not an absolute path.' % (
-                                        fulldir,))
+                                    msg = '%r is not an absolute path.' % (
+                                        fulldir,
+                                    )
 
                         if fulldir and not os.path.exists(fulldir):
                             if msg:
                                 msg += '\n'
-                            msg += ('%r (root + dir) is not an existing '
-                                    'filesystem path.' % fulldir)
+                            msg += (
+                                '%r (root + dir) is not an existing '
+                                'filesystem path.' % fulldir
+                            )
 
                     if msg:
-                        warnings.warn('%s\nsection: [%s]\nroot: %r\ndir: %r'
-                                      % (msg, section, root, dir))
+                        warnings.warn(
+                            '%s\nsection: [%s]\nroot: %r\ndir: %r'
+                            % (msg, section, root, dir),
+                        )
 
     # -------------------------- Compatibility -------------------------- #
     obsolete = {
@@ -184,8 +201,10 @@ def check_static_paths(self):
         'log_to_screen': 'log.screen',
         'show_tracebacks': 'request.show_tracebacks',
         'throw_errors': 'request.throw_errors',
-        'profiler.on': ('cherrypy.tree.mount(profiler.make_app('
-                        'cherrypy.Application(Root())))'),
+        'profiler.on': (
+            'cherrypy.tree.mount(profiler.make_app('
+            'cherrypy.Application(Root())))'
+        ),
     }
 
     deprecated = {}
@@ -196,20 +215,26 @@ def _compat(self, config):
             if isinstance(conf, dict):
                 for k in conf:
                     if k in self.obsolete:
-                        warnings.warn('%r is obsolete. Use %r instead.\n'
-                                      'section: [%s]' %
-                                      (k, self.obsolete[k], section))
+                        warnings.warn(
+                            '%r is obsolete. Use %r instead.\n'
+                            'section: [%s]' % (k, self.obsolete[k], section),
+                        )
                     elif k in self.deprecated:
-                        warnings.warn('%r is deprecated. Use %r instead.\n'
-                                      'section: [%s]' %
-                                      (k, self.deprecated[k], section))
+                        warnings.warn(
+                            '%r is deprecated. Use %r instead.\n'
+                            'section: [%s]' % (k, self.deprecated[k], section),
+                        )
             else:
                 if section in self.obsolete:
-                    warnings.warn('%r is obsolete. Use %r instead.'
-                                  % (section, self.obsolete[section]))
+                    warnings.warn(
+                        '%r is obsolete. Use %r instead.'
+                        % (section, self.obsolete[section]),
+                    )
                 elif section in self.deprecated:
-                    warnings.warn('%r is deprecated. Use %r instead.'
-                                  % (section, self.deprecated[section]))
+                    warnings.warn(
+                        '%r is deprecated. Use %r instead.'
+                        % (section, self.deprecated[section]),
+                    )
 
     def check_compatibility(self):
         """Process config and warn on each obsolete or deprecated entry."""
@@ -243,20 +268,23 @@ def _known_ns(self, app):
                                 msg = (
                                     'The config entry %r is invalid; '
                                     'try %r instead.\nsection: [%s]'
-                                    % (k, '.'.join(atoms[1:]), section))
+                                    % (k, '.'.join(atoms[1:]), section)
+                                )
                             else:
                                 msg = (
                                     'The config entry %r is invalid, '
                                     'because the %r config namespace '
                                     'is unknown.\n'
-                                    'section: [%s]' % (k, atoms[0], section))
+                                    'section: [%s]' % (k, atoms[0], section)
+                                )
                             warnings.warn(msg)
                         elif atoms[0] == 'tools':
                             if atoms[1] not in dir(cherrypy.tools):
                                 msg = (
                                     'The config entry %r may be invalid, '
                                     'because the %r tool was not found.\n'
-                                    'section: [%s]' % (k, atoms[1], section))
+                                    'section: [%s]' % (k, atoms[1], section)
+                                )
                                 warnings.warn(msg)
 
     def check_config_namespaces(self):
@@ -270,8 +298,7 @@ def check_config_namespaces(self):
     known_config_types = {}
 
     def _populate_known_types(self):
-        b = [x for x in vars(builtins).values()
-             if type(x) is type(str)]
+        b = [x for x in vars(builtins).values() if type(x) is type(str)]
 
         def traverse(obj, namespace):
             for name in dir(obj):
@@ -289,8 +316,10 @@ def traverse(obj, namespace):
         traverse(cherrypy.log, 'log')
 
     def _known_types(self, config):
-        msg = ('The config entry %r in section %r is of type %r, '
-               'which does not match the expected type %r.')
+        msg = (
+            'The config entry %r in section %r is of type %r, '
+            'which does not match the expected type %r.'
+        )
 
         for section, conf in config.items():
             if not isinstance(conf, dict):
@@ -300,8 +329,15 @@ def _known_types(self, config):
                     expected_type = self.known_config_types.get(k, None)
                     vtype = type(v)
                     if expected_type and vtype != expected_type:
-                        warnings.warn(msg % (k, section, vtype.__name__,
-                                             expected_type.__name__))
+                        warnings.warn(
+                            msg
+                            % (
+                                k,
+                                section,
+                                vtype.__name__,
+                                expected_type.__name__,
+                            ),
+                        )
 
     def check_config_types(self):
         """Assert that config values are of the same type as default values."""
@@ -313,11 +349,16 @@ def check_config_types(self):
 
     # -------------------- Specific config warnings -------------------- #
     def check_localhost(self):
-        """Warn if any socket_host is 'localhost'. See #711."""
+        """Warn if any socket_host is 'localhost'.
+
+        See #711.
+        """
         for k, v in cherrypy.config.items():
             if k == 'server.socket_host' and v == 'localhost':
-                warnings.warn("The use of 'localhost' as a socket host can "
-                              'cause problems on newer systems, since '
-                              "'localhost' can map to either an IPv4 or an "
-                              "IPv6 address. You should use '127.0.0.1' "
-                              "or '[::1]' instead.")
+                warnings.warn(
+                    "The use of 'localhost' as a socket host can "
+                    'cause problems on newer systems, since '
+                    "'localhost' can map to either an IPv4 or an "
+                    "IPv6 address. You should use '127.0.0.1' "
+                    "or '[::1]' instead.",
+                )
diff --git a/cherrypy/_cpcompat.py b/cherrypy/_cpcompat.py
index a43f6d369..96fcc68c4 100644
--- a/cherrypy/_cpcompat.py
+++ b/cherrypy/_cpcompat.py
@@ -19,11 +19,20 @@
 """
 
 import http.client
+import platform
+
+
+IS_PYPY = platform.python_implementation() == 'PyPy'
+
+
+SYS_PLATFORM = platform.system()
+IS_WINDOWS = SYS_PLATFORM == 'Windows'
 
 
 def ntob(n, encoding='ISO-8859-1'):
-    """Return the given native string as a byte string in the given
-    encoding.
+    """Convert a native :class:`str` to a :class:`bytes` instance.
+
+    The encoding can be changed to non-ASCII optionally.
     """
     assert_native(n)
     # In Python 3, the native string type is unicode
@@ -31,8 +40,9 @@ def ntob(n, encoding='ISO-8859-1'):
 
 
 def ntou(n, encoding='ISO-8859-1'):
-    """Return the given native string as a unicode string with the given
-    encoding.
+    """Convert a native :class:`str` to a :class:`str` instance.
+
+    This doesn't actually do anything.
     """
     assert_native(n)
     # In Python 3, the native string type is unicode
@@ -48,6 +58,7 @@ def tonative(n, encoding='ISO-8859-1'):
 
 
 def assert_native(n):
+    """Ensure that input is a native :class:`str`."""
     if not isinstance(n, str):
         raise TypeError('n must be a native str (got %s)' % type(n).__name__)
 
diff --git a/cherrypy/_cpconfig.py b/cherrypy/_cpconfig.py
index 8e3fd6120..3110b5e84 100644
--- a/cherrypy/_cpconfig.py
+++ b/cherrypy/_cpconfig.py
@@ -1,5 +1,4 @@
-"""
-Configuration system for CherryPy.
+"""Configuration system for CherryPy.
 
 Configuration in CherryPy is implemented via dictionaries. Keys are strings
 which name the mapped value, which may be of any type.
@@ -114,8 +113,7 @@ def index(self):
 You can define your own namespaces to be called at the Global, Application,
 or Request level, by adding a named handler to cherrypy.config.namespaces,
 app.namespaces, or app.request_class.namespaces. The name can
-be any string, and the handler must be either a callable or a (Python 2.5
-style) context manager.
+be any string, and the handler must be either a callable or a context manager.
 """
 
 import cherrypy
@@ -132,8 +130,8 @@ def _if_filename_register_autoreload(ob):
 def merge(base, other):
     """Merge one app config (from a dict, file, or filename) into another.
 
-    If the given config is a filename, it will be appended to
-    the list of files to monitor for "autoreload" changes.
+    If the given config is a filename, it will be appended to the list
+    of files to monitor for "autoreload" changes.
     """
     _if_filename_register_autoreload(other)
 
@@ -144,7 +142,8 @@ def merge(base, other):
                 'Application config must include section headers, but the '
                 "config you tried to merge doesn't have any sections. "
                 'Wrap your config in another dict with paths as section '
-                "headers, for example: {'/': config}.")
+                "headers, for example: {'/': config}.",
+            )
         base.setdefault(section, {}).update(value_map)
 
 
@@ -169,9 +168,11 @@ def _apply(self, config):
     @staticmethod
     def __call__(**kwargs):
         """Decorate for page handlers to set _cp_config."""
+
         def tool_decorator(f):
             _Vars(f).setdefault('_cp_config', {}).update(kwargs)
             return f
+
         return tool_decorator
 
 
@@ -239,6 +240,7 @@ def _server_namespace_handler(k, v):
         servername, k = atoms
         if servername not in cherrypy.servers:
             from cherrypy import _cpserver
+
             cherrypy.servers[servername] = _cpserver.Server()
             # On by default, but 'on = False' can unsubscribe it (see below).
             cherrypy.servers[servername].subscribe()
diff --git a/cherrypy/_cpdispatch.py b/cherrypy/_cpdispatch.py
index 83eb79cbe..1c4503e8b 100644
--- a/cherrypy/_cpdispatch.py
+++ b/cherrypy/_cpdispatch.py
@@ -1,9 +1,10 @@
 """CherryPy dispatchers.
 
 A 'dispatcher' is the object which looks up the 'page handler' callable
-and collects config for the current request based on the path_info, other
-request attributes, and the application architecture. The core calls the
-dispatcher as early as possible, passing it a 'path_info' argument.
+and collects config for the current request based on the path_info,
+other request attributes, and the application architecture. The core
+calls the dispatcher as early as possible, passing it a 'path_info'
+argument.
 
 The default dispatcher discovers the page handler by matching path_info
 to a hierarchical arrangement of objects, starting at request.app.root.
@@ -12,6 +13,7 @@
 import string
 import sys
 import types
+
 try:
     classtype = (type, types.ClassType)
 except AttributeError:
@@ -21,10 +23,10 @@
 
 
 class PageHandler(object):
-
     """Callable which sets response.body."""
 
     def __init__(self, callable, *args, **kwargs):
+        """Initialize the page handler."""
         self.callable = callable
         self.args = args
         self.kwargs = kwargs
@@ -36,6 +38,7 @@ def args(self):
 
     @args.setter
     def args(self, args):
+        """Set the request arguments in order."""
         cherrypy.serving.request.args = args
         return cherrypy.serving.request.args
 
@@ -46,10 +49,12 @@ def kwargs(self):
 
     @kwargs.setter
     def kwargs(self, kwargs):
+        """Set the named request keyword arguments as :class:`dict`."""
         cherrypy.serving.request.kwargs = kwargs
         return cherrypy.serving.request.kwargs
 
     def __call__(self):
+        """Invoke an HTTP handler callable for :class:`PageHandler`."""
         try:
             return self.callable(*self.args, **self.kwargs)
         except TypeError:
@@ -64,8 +69,7 @@ def __call__(self):
 
 
 def test_callable_spec(callable, callable_args, callable_kwargs):
-    """
-    Inspect callable and test to see if the given args are suitable for it.
+    """Inspect callable and test to see if the given args are suitable for it.
 
     When an error occurs during the handler's invoking stage there are 2
     erroneous cases:
@@ -84,28 +88,39 @@ def test_callable_spec(callable, callable_args, callable_kwargs):
     parameters are part of the request; if they are invalid a 400 Bad Request.
     """
     show_mismatched_params = getattr(
-        cherrypy.serving.request, 'show_mismatched_params', False)
+        cherrypy.serving.request,
+        'show_mismatched_params',
+        False,
+    )
     try:
         (args, varargs, varkw, defaults) = getargspec(callable)
     except TypeError:
         if isinstance(callable, object) and hasattr(callable, '__call__'):
-            (args, varargs, varkw,
-             defaults) = getargspec(callable.__call__)
+            (args, varargs, varkw, defaults) = getargspec(callable.__call__)
         else:
             # If it wasn't one of our own types, re-raise
             # the original error
             raise
 
     if args and (
-            # For callable objects, which have a __call__(self) method
-            hasattr(callable, '__call__') or
-            # For normal methods
-            inspect.ismethod(callable)
+        # For callable objects, which have a __call__(self) method
+        hasattr(callable, '__call__')
+        or
+        # For normal methods
+        inspect.ismethod(callable)
     ):
         # Strip 'self'
         args = args[1:]
 
-    arg_usage = dict([(arg, 0,) for arg in args])
+    arg_usage = dict(
+        [
+            (
+                arg,
+                0,
+            )
+            for arg in args
+        ],
+    )
     vararg_usage = 0
     varkw_usage = 0
     extra_kwargs = set()
@@ -124,7 +139,7 @@ def test_callable_spec(callable, callable_args, callable_kwargs):
             extra_kwargs.add(key)
 
     # figure out which args have defaults.
-    args_with_defaults = args[-len(defaults or []):]
+    args_with_defaults = args[-len(defaults or []) :]
     for i, val in enumerate(defaults or []):
         # Defaults take effect only when the arg hasn't been used yet.
         if arg_usage[args_with_defaults[i]] == 0:
@@ -175,19 +190,20 @@ def test_callable_spec(callable, callable_args, callable_kwargs):
 
         message = None
         if show_mismatched_params:
-            message = 'Multiple values for parameters: '\
-                '%s' % ','.join(multiple_args)
+            message = 'Multiple values for parameters: %s' % ','.join(
+                multiple_args,
+            )
         raise cherrypy.HTTPError(error, message=message)
 
     if not varkw and varkw_usage > 0:
-
         # If there were extra query string parameters, it's a 404 Not Found
         extra_qs_params = set(qs_params).intersection(extra_kwargs)
         if extra_qs_params:
             message = None
             if show_mismatched_params:
-                message = 'Unexpected query string '\
-                    'parameters: %s' % ', '.join(extra_qs_params)
+                message = 'Unexpected query string parameters: %s' % ', '.join(
+                    extra_qs_params,
+                )
             raise cherrypy.HTTPError(404, message=message)
 
         # If there were any extra body parameters, it's a 400 Not Found
@@ -195,28 +211,30 @@ def test_callable_spec(callable, callable_args, callable_kwargs):
         if extra_body_params:
             message = None
             if show_mismatched_params:
-                message = 'Unexpected body parameters: '\
-                    '%s' % ', '.join(extra_body_params)
+                message = 'Unexpected body parameters: %s' % ', '.join(
+                    extra_body_params,
+                )
             raise cherrypy.HTTPError(400, message=message)
 
 
 try:
     import inspect
 except ImportError:
+
     def test_callable_spec(callable, args, kwargs):  # noqa: F811
+        """Do nothing as a no-op."""
         return None
 else:
-    getargspec = inspect.getargspec
-    # Python 3 requires using getfullargspec if
-    # keyword-only arguments are present
-    if hasattr(inspect, 'getfullargspec'):
-        def getargspec(callable):
-            return inspect.getfullargspec(callable)[:4]
+
+    def getargspec(callable):
+        """Get argument specification using :mod:`inspect`."""
+        return inspect.getfullargspec(callable)[:4]
 
 
 class LateParamPageHandler(PageHandler):
+    """Page handler callable with delayed request parameters binding.
 
-    """When passing cherrypy.request.params to the page handler, we do not
+    When passing ``cherrypy.request.params`` to the page handler, we do not
     want to capture that dict too early; we want to give tools like the
     decoding tool a chance to modify the params dict in-between the lookup
     of the handler and the actual calling of the handler. This subclass
@@ -226,7 +244,11 @@ class LateParamPageHandler(PageHandler):
 
     @property
     def kwargs(self):
-        """Page handler kwargs (with cherrypy.request.params copied in)."""
+        """Page handler keyword arguments.
+
+        The returned value contains data merged in
+        from ``cherrypy.request.params``.
+        """
         kwargs = cherrypy.serving.request.params.copy()
         if self._kwargs:
             kwargs.update(self._kwargs)
@@ -234,38 +256,46 @@ def kwargs(self):
 
     @kwargs.setter
     def kwargs(self, kwargs):
+        """Set the named request keyword arguments as :class:`dict`."""
         cherrypy.serving.request.kwargs = kwargs
         self._kwargs = kwargs
 
 
 if sys.version_info < (3, 0):
     punctuation_to_underscores = string.maketrans(
-        string.punctuation, '_' * len(string.punctuation))
+        string.punctuation,
+        '_' * len(string.punctuation),
+    )
 
     def validate_translator(t):
+        """Ensure the translator is of the correct length and size."""
         if not isinstance(t, str) or len(t) != 256:
             raise ValueError(
-                'The translate argument must be a str of len 256.')
+                'The translate argument must be a str of len 256.',
+            )
 else:
     punctuation_to_underscores = str.maketrans(
-        string.punctuation, '_' * len(string.punctuation))
+        string.punctuation,
+        '_' * len(string.punctuation),
+    )
 
     def validate_translator(t):
+        """Ensure the translator is of the correct length and size."""
         if not isinstance(t, dict):
             raise ValueError('The translate argument must be a dict.')
 
 
 class Dispatcher(object):
-
     """CherryPy Dispatcher which walks a tree of objects to find a handler.
 
-    The tree is rooted at cherrypy.request.app.root, and each hierarchical
-    component in the path_info argument is matched to a corresponding nested
-    attribute of the root object. Matching handlers must have an 'exposed'
-    attribute which evaluates to True. The special method name "index"
-    matches a URI which ends in a slash ("/"). The special method name
-    "default" may match a portion of the path_info (but only when no longer
-    substring of the path_info matches some other object).
+    The tree is rooted at cherrypy.request.app.root, and each
+    hierarchical component in the path_info argument is matched to a
+    corresponding nested attribute of the root object. Matching handlers
+    must have an 'exposed' attribute which evaluates to True. The
+    special method name "index" matches a URI which ends in a slash
+    ("/"). The special method name "default" may match a portion of the
+    path_info (but only when no longer substring of the path_info
+    matches some other object).
 
     This is the default, built-in dispatcher for CherryPy.
     """
@@ -276,8 +306,12 @@ class Dispatcher(object):
     to provide their own dynamic dispatch algorithm.
     """
 
-    def __init__(self, dispatch_method_name=None,
-                 translate=punctuation_to_underscores):
+    def __init__(
+        self,
+        dispatch_method_name=None,
+        translate=punctuation_to_underscores,
+    ):
+        """Initialize the HTTP request dispatcher."""
         validate_translator(translate)
         self.translate = translate
         if dispatch_method_name:
@@ -310,9 +344,9 @@ def find_handler(self, path):
 
         The second object returned will be a list of names which are
         'virtual path' components: parts of the URL which are dynamic,
-        and were not used when looking up the handler.
-        These virtual path components are passed to the handler as
-        positional arguments.
+        and were not used when looking up the handler. These virtual
+        path components are passed to the handler as positional
+        arguments.
         """
         request = cherrypy.serving.request
         app = request.app
@@ -342,9 +376,12 @@ def find_handler(self, path):
             pre_len = len(iternames)
             if subnode is None:
                 dispatch = getattr(node, dispatch_name, None)
-                if dispatch and hasattr(dispatch, '__call__') and not \
-                        getattr(dispatch, 'exposed', False) and \
-                        pre_len > 1:
+                if (
+                    dispatch
+                    and hasattr(dispatch, '__call__')
+                    and not getattr(dispatch, 'exposed', False)
+                    and pre_len > 1
+                ):
                     # Don't expose the hidden 'index' token to _cp_dispatch
                     # We skip this if pre_len == 1 since it makes no sense
                     # to call a dispatcher when we have no tokens left.
@@ -364,7 +401,7 @@ def find_handler(self, path):
                 raise cherrypy.CherryPyException(
                     'A vpath segment was added.  Custom dispatchers may only '
                     'remove elements.  While trying to process '
-                    '{0} in {1}'.format(name, fullpath)
+                    '{0} in {1}'.format(name, fullpath),
                 )
             elif segleft == pre_len:
                 # Assume that the handler used the current path segment, but
@@ -385,7 +422,9 @@ def find_handler(self, path):
                 curpath = '/' + '/'.join(fullpath[0:existing_len])
             else:
                 curpath = ''
-            new_segs = fullpath[fullpath_len - pre_len:fullpath_len - segleft]
+            new_segs = fullpath[
+                fullpath_len - pre_len : fullpath_len - segleft
+            ]
             for seg in new_segs:
                 curpath += '/' + seg
                 if curpath in app.config:
@@ -394,7 +433,9 @@ def find_handler(self, path):
             object_trail.append([name, node, nodeconf, segleft])
 
         def set_conf():
-            """Collapse all object_trail config into cherrypy.request.config.
+            """Collapse all ``object_trail`` conf into config.
+
+            The config being ``cherrypy.request.config``.
             """
             base = cherrypy.config.copy()
             # Note that we merge the config from each node
@@ -402,14 +443,14 @@ def set_conf():
             for name, obj, conf, segleft in object_trail:
                 base.update(conf)
                 if 'tools.staticdir.dir' in conf:
-                    base['tools.staticdir.section'] = '/' + \
-                        '/'.join(fullpath[0:fullpath_len - segleft])
+                    base['tools.staticdir.section'] = '/' + '/'.join(
+                        fullpath[0 : fullpath_len - segleft],
+                    )
             return base
 
         # Try successive objects (reverse order)
         num_candidates = len(object_trail) - 1
         for i in range(num_candidates, -1, -1):
-
             name, candidate, nodeconf, segleft = object_trail[i]
             if candidate is None:
                 continue
@@ -421,11 +462,13 @@ def set_conf():
                     # Insert any extra _cp_config from the default handler.
                     conf = getattr(defhandler, '_cp_config', {})
                     object_trail.insert(
-                        i + 1, ['default', defhandler, conf, segleft])
+                        i + 1,
+                        ['default', defhandler, conf, segleft],
+                    )
                     request.config = set_conf()
                     # See https://github.com/cherrypy/cherrypy/issues/613
                     request.is_index = path.endswith('/')
-                    return defhandler, fullpath[fullpath_len - segleft:-1]
+                    return defhandler, fullpath[fullpath_len - segleft : -1]
 
             # Uncomment the next line to restrict positional params to
             # "default".
@@ -444,7 +487,7 @@ def set_conf():
                     # Note that this also includes handlers which take
                     # positional parameters (virtual paths).
                     request.is_index = False
-                return candidate, fullpath[fullpath_len - segleft:-1]
+                return candidate, fullpath[fullpath_len - segleft : -1]
 
         # We didn't find anything
         request.config = set_conf()
@@ -452,13 +495,11 @@ def set_conf():
 
 
 class MethodDispatcher(Dispatcher):
-
     """Additional dispatch based on cherrypy.request.method.upper().
 
-    Methods named GET, POST, etc will be called on an exposed class.
-    The method names must be all caps; the appropriate Allow header
-    will be output showing all capitalized method names as allowable
-    HTTP verbs.
+    Methods named GET, POST, etc will be called on an exposed class. The
+    method names must be all caps; the appropriate Allow header will be
+    output showing all capitalized method names as allowable HTTP verbs.
 
     Note that the containing class must be exposed, not the methods.
     """
@@ -496,28 +537,29 @@ def __call__(self, path_info):
 
 
 class RoutesDispatcher(object):
-
     """A Routes based dispatcher for CherryPy."""
 
     def __init__(self, full_result=False, **mapper_options):
-        """
-        Routes dispatcher
+        """Routes dispatcher.
 
-        Set full_result to True if you wish the controller
-        and the action to be passed on to the page handler
-        parameters. By default they won't be.
+        Set full_result to True if you wish the controller and the
+        action to be passed on to the page handler parameters. By
+        default they won't be.
         """
         import routes
+
         self.full_result = full_result
         self.controllers = {}
         self.mapper = routes.Mapper(**mapper_options)
         self.mapper.controller_scan = self.controllers.keys
 
     def connect(self, name, route, controller, **kwargs):
+        """Mount an HTTP handler into the router."""
         self.controllers[name] = controller
         self.mapper.connect(name, route, controller=name, **kwargs)
 
     def redirect(self, url):
+        """Perform an HTTP redirect to the given URL."""
         raise cherrypy.HTTPRedirect(url)
 
     def __call__(self, path_info):
@@ -611,18 +653,22 @@ def merge(nodeconf):
 
 
 def XMLRPCDispatcher(next_dispatcher=Dispatcher()):
+    """Chain an HTTP dispatcher variant implementing XML-RPC."""
     from cherrypy.lib import xmlrpcutil
 
     def xmlrpc_dispatch(path_info):
         path_info = xmlrpcutil.patched_path(path_info)
         return next_dispatcher(path_info)
+
     return xmlrpc_dispatch
 
 
-def VirtualHost(next_dispatcher=Dispatcher(), use_x_forwarded_host=True,
-                **domains):
-    """
-    Select a different handler based on the Host header.
+def VirtualHost(
+    next_dispatcher=Dispatcher(),
+    use_x_forwarded_host=True,
+    **domains,
+):
+    """Select a different handler based on the Host header.
 
     This can be useful when running multiple sites within one CP server.
     It allows several domains to point to different parts of a single
@@ -679,8 +725,9 @@ def vhost_dispatch(path_info):
         # https://github.com/cherrypy/cherrypy/issues/614.
         section = request.config.get('tools.staticdir.section')
         if section:
-            section = section[len(prefix):]
+            section = section[len(prefix) :]
             request.config['tools.staticdir.section'] = section
 
         return result
+
     return vhost_dispatch
diff --git a/cherrypy/_cperror.py b/cherrypy/_cperror.py
index 4e7276827..85c449b3e 100644
--- a/cherrypy/_cperror.py
+++ b/cherrypy/_cperror.py
@@ -136,22 +136,20 @@ class Root:
 
 
 class CherryPyException(Exception):
-
     """A base class for CherryPy exceptions."""
-    pass
 
 
 class InternalRedirect(CherryPyException):
-
     """Exception raised to switch to the handler for a different URL.
 
-    This exception will redirect processing to another path within the site
-    (without informing the client). Provide the new path as an argument when
-    raising the exception. Provide any params in the querystring for the new
-    URL.
+    This exception will redirect processing to another path within the
+    site (without informing the client). Provide the new path as an
+    argument when raising the exception. Provide any params in the
+    querystring for the new URL.
     """
 
     def __init__(self, path, query_string=''):
+        """Initialize the internal redirect exception."""
         self.request = cherrypy.serving.request
 
         self.query_string = query_string
@@ -173,7 +171,6 @@ def __init__(self, path, query_string=''):
 
 
 class HTTPRedirect(CherryPyException):
-
     """Exception raised when the request should be redirected.
 
     This exception will force a HTTP redirect to the URL or URL's you give it.
@@ -202,9 +199,10 @@ class HTTPRedirect(CherryPyException):
     """The list of URL's to emit."""
 
     encoding = 'utf-8'
-    """The encoding when passed urls are not native strings"""
+    """The encoding when passed urls are not native strings."""
 
     def __init__(self, urls, status=None, encoding=None):
+        """Initialize the HTTP redirect exception."""
         self.urls = abs_urls = [
             # Note that urljoin will "do the right thing" whether url is:
             #  1. a complete URL with host (e.g. "http://www.example.com/test")
@@ -218,11 +216,7 @@ def __init__(self, urls, status=None, encoding=None):
             for url in always_iterable(urls)
         ]
 
-        status = (
-            int(status)
-            if status is not None
-            else self.default_status
-        )
+        status = int(status) if status is not None else self.default_status
         if not 300 <= status <= 399:
             raise ValueError('status must be between 300 and 399.')
 
@@ -230,8 +224,9 @@ def __init__(self, urls, status=None, encoding=None):
 
     @classproperty
     def default_status(cls):
-        """
-        The default redirect status for the request.
+        """Redirect status for the request.
+
+        This is the default handler.
 
         RFC 2616 indicates a 301 response code fits our goal; however,
         browser support for 301 is quite messy. Use 302/303 instead. See
@@ -246,11 +241,13 @@ def status(self):
         return status
 
     def set_response(self):
-        """Modify cherrypy.response status, headers, and body to represent
-        self.
+        """Modify ``cherrypy.response`` to represent ``self``.
 
-        CherryPy uses this internally, but you can also use it to create an
-        HTTPRedirect object and set its output without *raising* the exception.
+        Modifies status, headers, and body.
+
+        CherryPy uses this internally, but you can also use it to create
+        an HTTPRedirect object and set its output without *raising* the
+        exception.
         """
         response = cherrypy.serving.response
         response.status = status = self.status
@@ -288,10 +285,18 @@ def set_response(self):
             # The "Date" header should have been set in Response.__init__
 
             # "...the response SHOULD NOT include other entity-headers."
-            for key in ('Allow', 'Content-Encoding', 'Content-Language',
-                        'Content-Length', 'Content-Location', 'Content-MD5',
-                        'Content-Range', 'Content-Type', 'Expires',
-                        'Last-Modified'):
+            for key in (
+                'Allow',
+                'Content-Encoding',
+                'Content-Language',
+                'Content-Length',
+                'Content-Location',
+                'Content-MD5',
+                'Content-Range',
+                'Content-Type',
+                'Expires',
+                'Last-Modified',
+            ):
                 if key in response.headers:
                     del response.headers[key]
 
@@ -321,9 +326,20 @@ def clean_headers(status):
     # Remove headers which applied to the original content,
     # but do not apply to the error page.
     respheaders = response.headers
-    for key in ['Accept-Ranges', 'Age', 'ETag', 'Location', 'Retry-After',
-                'Vary', 'Content-Encoding', 'Content-Length', 'Expires',
-                'Content-Location', 'Content-MD5', 'Last-Modified']:
+    for key in [
+        'Accept-Ranges',
+        'Age',
+        'ETag',
+        'Location',
+        'Retry-After',
+        'Vary',
+        'Content-Encoding',
+        'Content-Length',
+        'Expires',
+        'Content-Location',
+        'Content-MD5',
+        'Last-Modified',
+    ]:
         if key in respheaders:
             del respheaders[key]
 
@@ -339,7 +355,6 @@ def clean_headers(status):
 
 
 class HTTPError(CherryPyException):
-
     """Exception used to return an HTTP error code (4xx-5xx) to the client.
 
     This exception can be used to automatically send a response using a
@@ -358,7 +373,9 @@ class HTTPError(CherryPyException):
     """
 
     status = None
-    """The HTTP status code. May be of type int or str (with a Reason-Phrase).
+    """The HTTP status code.
+
+    May be of type int or str (with a Reason-Phrase).
     """
 
     code = None
@@ -368,6 +385,7 @@ class HTTPError(CherryPyException):
     """The HTTP Reason-Phrase string."""
 
     def __init__(self, status=500, message=None):
+        """Initialize an HTTP error."""
         self.status = status
         try:
             self.code, self.reason, defaultmsg = _httputil.valid_status(status)
@@ -383,11 +401,13 @@ def __init__(self, status=500, message=None):
         CherryPyException.__init__(self, status, message)
 
     def set_response(self):
-        """Modify cherrypy.response status, headers, and body to represent
-        self.
+        """Modify ``cherrypy.response`` to represent ``self``.
+
+        Modifies status, headers, and body.
 
-        CherryPy uses this internally, but you can also use it to create an
-        HTTPError object and set its output without *raising* the exception.
+        CherryPy uses this internally, but you can also use it to create
+        an HTTPError object and set its output without *raising* the
+        exception.
         """
         response = cherrypy.serving.response
 
@@ -402,13 +422,17 @@ def set_response(self):
 
         response.headers.pop('Content-Length', None)
 
-        content = self.get_error_page(self.status, traceback=tb,
-                                      message=self._message)
+        content = self.get_error_page(
+            self.status,
+            traceback=tb,
+            message=self._message,
+        )
         response.body = content
 
         _be_ie_unfriendly(self.code)
 
     def get_error_page(self, *args, **kwargs):
+        """Compose an HTML page with error information."""
         return get_error_page(*args, **kwargs)
 
     def __call__(self):
@@ -426,14 +450,14 @@ def handle(cls, exception, status=500, message=''):
 
 
 class NotFound(HTTPError):
-
     """Exception raised when a URL could not be mapped to any handler (404).
 
-    This is equivalent to raising
-    :class:`HTTPError("404 Not Found") <cherrypy._cperror.HTTPError>`.
+    This is equivalent to raising :class:`HTTPError("404 Not Found")
+    <cherrypy._cperror.HTTPError>`.
     """
 
     def __init__(self, path=None):
+        """Initialize an HTTP Not Found error."""
         if path is None:
             request = cherrypy.serving.request
             path = request.script_name + request.path_info
@@ -441,7 +465,7 @@ def __init__(self, path=None):
         HTTPError.__init__(self, 404, "The path '%s' was not found." % path)
 
 
-_HTTPErrorTemplate = '''<!DOCTYPE html PUBLIC
+_HTTPErrorTemplate = """<!DOCTYPE html PUBLIC
 "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html>
@@ -466,19 +490,19 @@ def __init__(self, path=None):
         <pre id="traceback">%(traceback)s</pre>
     <div id="powered_by">
       <span>
-        Powered by <a href="http://www.cherrypy.org">CherryPy %(version)s</a>
+        Powered by <a href="http://www.cherrypy.dev">CherryPy %(version)s</a>
       </span>
     </div>
     </body>
 </html>
-'''
+"""
 
 
 def get_error_page(status, **kwargs):
     """Return an HTML page, containing a pretty error response.
 
-    status should be an int or a str.
-    kwargs will be interpolated into the page template.
+    status should be an int or a str. kwargs will be interpolated into
+    the page template.
     """
     try:
         code, reason, message = _httputil.valid_status(status)
@@ -519,6 +543,7 @@ def get_error_page(status, **kwargs):
                 result = error_page(**kwargs)
                 if cherrypy.lib.is_iterator(result):
                     from cherrypy.lib.encoding import UTF8StreamEncoder
+
                     return UTF8StreamEncoder(result)
                 elif isinstance(result, str):
                     return result.encode('utf-8')
@@ -528,11 +553,13 @@ def get_error_page(status, **kwargs):
                             'error page function did not '
                             'return a bytestring, str or an '
                             'iterator - returned object of type %s.'
-                            % (type(result).__name__))
+                            % (type(result).__name__),
+                        )
                     return result
             else:
                 # Load the template from this path.
-                template = io.open(error_page, newline='').read()
+                with io.open(error_page, newline='') as f:
+                    template = f.read()
         except Exception:
             e = _format_exception(*_exc_info())[-1]
             m = kwargs['message']
@@ -548,9 +575,17 @@ def get_error_page(status, **kwargs):
 
 
 _ie_friendly_error_sizes = {
-    400: 512, 403: 256, 404: 512, 405: 256,
-    406: 512, 408: 512, 409: 512, 410: 256,
-    500: 512, 501: 512, 505: 512,
+    400: 512,
+    403: 256,
+    404: 512,
+    405: 256,
+    406: 512,
+    408: 512,
+    409: 512,
+    410: 256,
+    500: 512,
+    501: 512,
+    505: 512,
 }
 
 
@@ -585,6 +620,7 @@ def format_exc(exc=None):
         if exc == (None, None, None):
             return ''
         import traceback
+
         return ''.join(traceback.format_exception(*exc))
     finally:
         del exc
@@ -594,14 +630,13 @@ def bare_error(extrabody=None):
     """Produce status, headers, body for a critical error.
 
     Returns a triple without calling any other questionable functions,
-    so it should be as error-free as possible. Call it from an HTTP server
-    if you get errors outside of the request.
+    so it should be as error-free as possible. Call it from an HTTP
+    server if you get errors outside of the request.
 
     If extrabody is None, a friendly but rather unhelpful error message
     is set in the body. If extrabody is a string, it will be appended
     as-is to the body.
     """
-
     # The whole point of this function is to be a last line-of-defense
     # in handling errors. That is, it must not raise any errors itself;
     # it cannot be allowed to fail. Therefore, don't add to it!
@@ -613,7 +648,11 @@ def bare_error(extrabody=None):
             extrabody = extrabody.encode('utf-8')
         body += b'\n' + extrabody
 
-    return (b'500 Internal Server Error',
-            [(b'Content-Type', b'text/plain'),
-             (b'Content-Length', ntob(str(len(body)), 'ISO-8859-1'))],
-            [body])
+    return (
+        b'500 Internal Server Error',
+        [
+            (b'Content-Type', b'text/plain'),
+            (b'Content-Length', ntob(str(len(body)), 'ISO-8859-1')),
+        ],
+        [body],
+    )
diff --git a/cherrypy/_cplogging.py b/cherrypy/_cplogging.py
index 151d3b407..05b3eee70 100644
--- a/cherrypy/_cplogging.py
+++ b/cherrypy/_cplogging.py
@@ -1,4 +1,6 @@
 """
+CherryPy logging module.
+
 Simple config
 =============
 
@@ -123,29 +125,32 @@
 
 
 class NullHandler(logging.Handler):
-
     """A no-op logging handler to silence the logging.lastResort handler."""
 
     def handle(self, record):
+        """Handle a log record doing no-op."""
         pass
 
     def emit(self, record):
+        """Emit  a log record doing no-op."""
         pass
 
     def createLock(self):
+        """Lock log write with no-op."""
         self.lock = None
 
 
 class LogManager(object):
-
     """An object to assist both simple and advanced logging.
 
     ``cherrypy.log`` is an instance of this class.
     """
 
     appid = None
-    """The id() of the Application object which owns this log manager. If this
-    is a global log manager, appid is None."""
+    """The id() of the Application object which owns this log manager.
+
+    If this is a global log manager, appid is None.
+    """
 
     error_log = None
     """The actual :class:`logging.Logger` instance for error messages."""
@@ -167,6 +172,7 @@ class LogManager(object):
     """
 
     def __init__(self, appid=None, logger_root='cherrypy'):
+        """Initialize a CherryPy log manager."""
         self.logger_root = logger_root
         self.appid = appid
         if appid is None:
@@ -174,9 +180,11 @@ def __init__(self, appid=None, logger_root='cherrypy'):
             self.access_log = logging.getLogger('%s.access' % logger_root)
         else:
             self.error_log = logging.getLogger(
-                '%s.error.%s' % (logger_root, appid))
+                '%s.error.%s' % (logger_root, appid),
+            )
             self.access_log = logging.getLogger(
-                '%s.access.%s' % (logger_root, appid))
+                '%s.access.%s' % (logger_root, appid),
+            )
         self.error_log.setLevel(logging.INFO)
         self.access_log.setLevel(logging.INFO)
 
@@ -196,8 +204,13 @@ def reopen_files(self):
                     h.stream = open(h.baseFilename, h.mode)
                     h.release()
 
-    def error(self, msg='', context='', severity=logging.INFO,
-              traceback=False):
+    def error(
+        self,
+        msg='',
+        context='',
+        severity=logging.INFO,
+        traceback=False,
+    ):
         """Write the given ``msg`` to the error log.
 
         This is not just for errors! Applications may call this at any time
@@ -217,11 +230,11 @@ def error(self, msg='', context='', severity=logging.INFO,
         )
 
     def __call__(self, *args, **kwargs):
-        """An alias for ``error``."""
+        """Record an error log entry."""
         return self.error(*args, **kwargs)
 
     def access(self):
-        """Write to the access log (in Apache/NCSA Combined Log format).
+        r"""Write to the access log (in Apache/NCSA Combined Log format).
 
         See the
         `apache documentation
@@ -250,19 +263,20 @@ def access(self):
             status = response.output_status.split(b' ', 1)[0]
             status = status.decode('ISO-8859-1')
 
-        atoms = {'h': remote.name or remote.ip,
-                 'l': '-',
-                 'u': getattr(request, 'login', None) or '-',
-                 't': self.time(),
-                 'r': request.request_line,
-                 's': status,
-                 'b': dict.get(outheaders, 'Content-Length', '') or '-',
-                 'f': dict.get(inheaders, 'Referer', ''),
-                 'a': dict.get(inheaders, 'User-Agent', ''),
-                 'o': dict.get(inheaders, 'Host', '-'),
-                 'i': request.unique_id,
-                 'z': LazyRfc3339UtcTime(),
-                 }
+        atoms = {
+            'h': remote.name or remote.ip,
+            'l': '-',
+            'u': getattr(request, 'login', None) or '-',
+            't': self.time(),
+            'r': request.request_line,
+            's': status,
+            'b': dict.get(outheaders, 'Content-Length', '') or '-',
+            'f': dict.get(inheaders, 'Referer', ''),
+            'a': dict.get(inheaders, 'User-Agent', ''),
+            'o': dict.get(inheaders, 'Host', '-'),
+            'i': request.unique_id,
+            'z': LazyRfc3339UtcTime(),
+        }
         for k, v in atoms.items():
             if not isinstance(v, str):
                 v = str(v)
@@ -281,18 +295,38 @@ def access(self):
 
         try:
             self.access_log.log(
-                logging.INFO, self.access_log_format.format(**atoms))
+                logging.INFO,
+                self.access_log_format.format(**atoms),
+            )
         except Exception:
             self(traceback=True)
 
     def time(self):
         """Return now() in Apache Common Log Format (no timezone)."""
         now = datetime.datetime.now()
-        monthnames = ['jan', 'feb', 'mar', 'apr', 'may', 'jun',
-                      'jul', 'aug', 'sep', 'oct', 'nov', 'dec']
+        monthnames = [
+            'jan',
+            'feb',
+            'mar',
+            'apr',
+            'may',
+            'jun',
+            'jul',
+            'aug',
+            'sep',
+            'oct',
+            'nov',
+            'dec',
+        ]
         month = monthnames[now.month - 1].capitalize()
-        return ('[%02d/%s/%04d:%02d:%02d:%02d]' %
-                (now.day, month, now.year, now.hour, now.minute, now.second))
+        return '[%02d/%s/%04d:%02d:%02d:%02d]' % (
+            now.day,
+            month,
+            now.year,
+            now.hour,
+            now.minute,
+            now.second,
+        )
 
     def _get_builtin_handler(self, log, key):
         for h in log.handlers:
@@ -317,8 +351,8 @@ def _set_screen_handler(self, log, enable, stream=None):
     def screen(self):
         """Turn stderr/stdout logging on or off.
 
-        If you set this to True, it'll add the appropriate StreamHandler for
-        you. If you set it to False, it will remove the handler.
+        If you set this to True, it'll add the appropriate StreamHandler
+        for you. If you set it to False, it will remove the handler.
         """
         h = self._get_builtin_handler
         has_h = h(self.error_log, 'screen') or h(self.access_log, 'screen')
@@ -414,8 +448,10 @@ def wsgi(self, newvalue):
 
 
 class WSGIErrorHandler(logging.Handler):
+    """A handler class writing logs to WSGI env.
 
-    "A handler class which writes logging records to environ['wsgi.errors']."
+    Specifically, the target is ``environ['wsgi.errors']``.
+    """
 
     def flush(self):
         """Flushes the stream."""
@@ -437,6 +473,7 @@ def emit(self, record):
                 msg = self.format(record)
                 fs = '%s\n'
                 import types
+
                 # if no unicode support...
                 if not hasattr(types, 'UnicodeType'):
                     stream.write(fs % msg)
@@ -451,7 +488,11 @@ def emit(self, record):
 
 
 class LazyRfc3339UtcTime(object):
+    """A postponed timestamp string retrieval class."""
+
     def __str__(self):
-        """Return now() in RFC3339 UTC Format."""
-        now = datetime.datetime.now()
-        return now.isoformat('T') + 'Z'
+        """Return datetime in RFC3339 UTC Format."""
+        iso_formatted_now = datetime.datetime.now(
+            datetime.timezone.utc,
+        ).isoformat('T')
+        return f'{iso_formatted_now!s}Z'
diff --git a/cherrypy/_cpmodpy.py b/cherrypy/_cpmodpy.py
index 0e608c48a..45797b3ef 100644
--- a/cherrypy/_cpmodpy.py
+++ b/cherrypy/_cpmodpy.py
@@ -1,4 +1,4 @@
-"""Native adapter for serving CherryPy via mod_python
+"""Native adapter for serving CherryPy via mod_python.
 
 Basic usage:
 
@@ -72,6 +72,7 @@ def setup_server():
 
 
 def setup(req):
+    """Execute pre-initialization functions."""
     from mod_python import apache
 
     # Run any setup functions defined by a "PythonOption cherrypy.setup"
@@ -88,10 +89,13 @@ def setup(req):
                 func = getattr(mod, fname)
                 func()
 
-    cherrypy.config.update({'log.screen': False,
-                            'tools.ignore_headers.on': True,
-                            'tools.ignore_headers.headers': ['Range'],
-                            })
+    cherrypy.config.update(
+        {
+            'log.screen': False,
+            'tools.ignore_headers.on': True,
+            'tools.ignore_headers.headers': ['Range'],
+        },
+    )
 
     engine = cherrypy.engine
     if hasattr(engine, 'signal_handler'):
@@ -119,6 +123,7 @@ def _log(msg, level):
 
     def cherrypy_cleanup(data):
         engine.exit()
+
     try:
         # apache.register_cleanup wasn't available until 3.1.4.
         apache.register_cleanup(cherrypy_cleanup)
@@ -140,7 +145,9 @@ def __init__(self, req):
 
 
 def handler(req):
+    """Invoke the HTTP handler."""
     from mod_python import apache
+
     try:
         global _isSetUp
         if not _isSetUp:
@@ -150,10 +157,16 @@ def handler(req):
         # Obtain a Request object from CherryPy
         local = req.connection.local_addr
         local = httputil.Host(
-            local[0], local[1], req.connection.local_host or '')
+            local[0],
+            local[1],
+            req.connection.local_host or '',
+        )
         remote = req.connection.remote_addr
         remote = httputil.Host(
-            remote[0], remote[1], req.connection.remote_host or '')
+            remote[0],
+            remote[1],
+            req.connection.remote_host or '',
+        )
 
         scheme = req.parsed_uri[0] or 'http'
         req.get_basic_auth_pw()
@@ -164,9 +177,11 @@ def handler(req):
             threaded = q(apache.AP_MPMQ_IS_THREADED)
             forked = q(apache.AP_MPMQ_IS_FORKED)
         except AttributeError:
-            bad_value = ("You must provide a PythonOption '%s', "
-                         "either 'on' or 'off', when running a version "
-                         'of mod_python < 3.1')
+            bad_value = (
+                "You must provide a PythonOption '%s', "
+                "either 'on' or 'off', when running a version "
+                'of mod_python < 3.1'
+            )
 
             options = req.get_options()
 
@@ -202,8 +217,12 @@ def handler(req):
             try:
                 redirections = []
                 while True:
-                    request, response = app.get_serving(local, remote, scheme,
-                                                        'HTTP/1.1')
+                    request, response = app.get_serving(
+                        local,
+                        remote,
+                        scheme,
+                        'HTTP/1.1',
+                    )
                     request.login = req.user
                     request.multithread = bool(threaded)
                     request.multiprocess = bool(forked)
@@ -223,7 +242,8 @@ def handler(req):
                             if ir.path in redirections:
                                 raise RuntimeError(
                                     'InternalRedirector visited the same URL '
-                                    'twice: %r' % ir.path)
+                                    'twice: %r' % ir.path,
+                                )
                             else:
                                 # Add the *previous* path_info + qs to
                                 # redirections.
@@ -238,8 +258,12 @@ def handler(req):
                         rfile = io.BytesIO()
 
                 send_response(
-                    req, response.output_status, response.header_list,
-                    response.body, response.stream)
+                    req,
+                    response.output_status,
+                    response.header_list,
+                    response.body,
+                    response.stream,
+                )
             finally:
                 app.release_serving()
     except Exception:
@@ -251,6 +275,7 @@ def handler(req):
 
 
 def send_response(req, status, headers, body, stream=False):
+    """Send the HTTP response to the client."""
     # Set response status
     req.status = int(status[:3])
 
@@ -276,17 +301,25 @@ def send_response(req, status, headers, body, stream=False):
     import subprocess
 
     def popen(fullcmd):
-        p = subprocess.Popen(fullcmd, shell=True,
-                             stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-                             close_fds=True)
+        """Invoke a subprocess via :mod:`subprocess`."""
+        p = subprocess.Popen(
+            fullcmd,
+            shell=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            close_fds=True,
+        )
         return p.stdout
 except ImportError:
+
     def popen(fullcmd):
+        """Invoke a subprocess via :mod:`os`."""
         pipein, pipeout = os.popen4(fullcmd)
         return pipeout
 
 
 def read_process(cmd, args=''):
+    """Return a subprocess standard output."""
     fullcmd = '%s %s' % (cmd, args)
     pipeout = popen(fullcmd)
     try:
@@ -294,7 +327,7 @@ def read_process(cmd, args=''):
         cmd_not_found = re.search(
             b'(not recognized|No such file|not found)',
             firstline,
-            re.IGNORECASE
+            re.IGNORECASE,
         )
         if cmd_not_found:
             raise IOError('%s must be on your system path.' % cmd)
@@ -305,6 +338,7 @@ def read_process(cmd, args=''):
 
 
 class ModPythonServer(object):
+    """A server wrapper for ``mod_python``."""
 
     template = """
 # Apache2 server configuration file for running CherryPy with mod_python.
@@ -321,8 +355,15 @@ class ModPythonServer(object):
 </Location>
 """
 
-    def __init__(self, loc='/', port=80, opts=None, apache_path='apache',
-                 handler='cherrypy._cpmodpy::handler'):
+    def __init__(
+        self,
+        loc='/',
+        port=80,
+        opts=None,
+        apache_path='apache',
+        handler='cherrypy._cpmodpy::handler',
+    ):
+        """Initialize a ``mod_python`` server."""
         self.loc = loc
         self.port = port
         self.opts = opts
@@ -330,25 +371,26 @@ def __init__(self, loc='/', port=80, opts=None, apache_path='apache',
         self.handler = handler
 
     def start(self):
-        opts = ''.join(['    PythonOption %s %s\n' % (k, v)
-                        for k, v in self.opts])
-        conf_data = self.template % {'port': self.port,
-                                     'loc': self.loc,
-                                     'opts': opts,
-                                     'handler': self.handler,
-                                     }
+        """Start an Apache2/httpd server."""
+        opts = ''.join(
+            ['    PythonOption %s %s\n' % (k, v) for k, v in self.opts],
+        )
+        conf_data = self.template % {
+            'port': self.port,
+            'loc': self.loc,
+            'opts': opts,
+            'handler': self.handler,
+        }
 
         mpconf = os.path.join(os.path.dirname(__file__), 'cpmodpy.conf')
-        f = open(mpconf, 'wb')
-        try:
+        with open(mpconf, 'wb') as f:
             f.write(conf_data)
-        finally:
-            f.close()
 
         response = read_process(self.apache_path, '-k start -f %s' % mpconf)
         self.ready = True
         return response
 
     def stop(self):
+        """Stop an Apache2/httpd server."""
         os.popen('apache -k stop')
         self.ready = False
diff --git a/cherrypy/_cpnative_server.py b/cherrypy/_cpnative_server.py
index e9671d289..daa1ef79a 100644
--- a/cherrypy/_cpnative_server.py
+++ b/cherrypy/_cpnative_server.py
@@ -48,7 +48,11 @@ def respond(self):
                     redirections = []
                     while True:
                         request, response = app.get_serving(
-                            local, remote, scheme, 'HTTP/1.1')
+                            local,
+                            remote,
+                            scheme,
+                            'HTTP/1.1',
+                        )
                         request.multithread = True
                         request.multiprocess = False
                         request.app = app
@@ -58,9 +62,12 @@ def respond(self):
                         # response
                         try:
                             request.run(
-                                method, path, qs,
+                                method,
+                                path,
+                                qs,
                                 tonative(req.request_protocol),
-                                headers, rfile,
+                                headers,
+                                rfile,
                             )
                             break
                         except cherrypy.InternalRedirect:
@@ -72,7 +79,8 @@ def respond(self):
                                 if ir.path in redirections:
                                     raise RuntimeError(
                                         'InternalRedirector visited the same '
-                                        'URL twice: %r' % ir.path)
+                                        'URL twice: %r' % ir.path,
+                                    )
                                 else:
                                     # Add the *previous* path_info + qs to
                                     # redirections.
@@ -87,8 +95,10 @@ def respond(self):
                             rfile = io.BytesIO()
 
                     self.send_response(
-                        response.output_status, response.header_list,
-                        response.body)
+                        response.output_status,
+                        response.header_list,
+                        response.body,
+                    )
                 finally:
                     app.release_serving()
         except Exception:
@@ -108,7 +118,7 @@ def send_response(self, status, headers, body):
         # Set response headers
         for header, value in headers:
             req.outheaders.append((header, value))
-        if (req.ready and not req.sent_headers):
+        if req.ready and not req.sent_headers:
             req.sent_headers = True
             req.send_headers()
 
@@ -120,30 +130,37 @@ def send_response(self, status, headers, body):
 class CPHTTPServer(cheroot.server.HTTPServer):
     """Wrapper for cheroot.server.HTTPServer.
 
-    cheroot has been designed to not reference CherryPy in any way,
-    so that it can be used in other frameworks and applications.
-    Therefore, we wrap it here, so we can apply some attributes
-    from config -> cherrypy.server -> HTTPServer.
+    cheroot has been designed to not reference CherryPy in any way, so
+    that it can be used in other frameworks and applications. Therefore,
+    we wrap it here, so we can apply some attributes from config ->
+    cherrypy.server -> HTTPServer.
     """
 
     def __init__(self, server_adapter=cherrypy.server):
         """Initialize CPHTTPServer."""
         self.server_adapter = server_adapter
 
-        server_name = (self.server_adapter.socket_host or
-                       self.server_adapter.socket_file or
-                       None)
+        server_name = (
+            self.server_adapter.socket_host
+            or self.server_adapter.socket_file
+            or None
+        )
 
         cheroot.server.HTTPServer.__init__(
-            self, server_adapter.bind_addr, NativeGateway,
+            self,
+            server_adapter.bind_addr,
+            NativeGateway,
             minthreads=server_adapter.thread_pool,
             maxthreads=server_adapter.thread_pool_max,
-            server_name=server_name)
+            server_name=server_name,
+        )
 
         self.max_request_header_size = (
-            self.server_adapter.max_request_header_size or 0)
+            self.server_adapter.max_request_header_size or 0
+        )
         self.max_request_body_size = (
-            self.server_adapter.max_request_body_size or 0)
+            self.server_adapter.max_request_body_size or 0
+        )
         self.request_queue_size = self.server_adapter.socket_queue_size
         self.timeout = self.server_adapter.socket_timeout
         self.shutdown_timeout = self.server_adapter.shutdown_timeout
@@ -157,7 +174,8 @@ def __init__(self, server_adapter=cherrypy.server):
                 self.server_adapter.ssl_certificate,
                 self.server_adapter.ssl_private_key,
                 self.server_adapter.ssl_certificate_chain,
-                self.server_adapter.ssl_ciphers)
+                self.server_adapter.ssl_ciphers,
+            )
             self.ssl_adapter.context = self.server_adapter.ssl_context
         elif self.server_adapter.ssl_certificate:
             adapter_class = cheroot.server.get_ssl_adapter_class(ssl_module)
@@ -165,4 +183,5 @@ def __init__(self, server_adapter=cherrypy.server):
                 self.server_adapter.ssl_certificate,
                 self.server_adapter.ssl_private_key,
                 self.server_adapter.ssl_certificate_chain,
-                self.server_adapter.ssl_ciphers)
+                self.server_adapter.ssl_ciphers,
+            )
diff --git a/cherrypy/_cpreqbody.py b/cherrypy/_cpreqbody.py
index 4d3cefe76..f5ff2a526 100644
--- a/cherrypy/_cpreqbody.py
+++ b/cherrypy/_cpreqbody.py
@@ -140,6 +140,7 @@ def unquote_plus(bs):
 
 # ------------------------------- Processors -------------------------------- #
 
+
 def process_urlencoded(entity):
     """Read application/x-www-form-urlencoded data into entity.params."""
     qs = entity.fp.read()
@@ -171,8 +172,10 @@ def process_urlencoded(entity):
             break
     else:
         raise cherrypy.HTTPError(
-            400, 'The request entity could not be decoded. The following '
-            'charsets were attempted: %s' % repr(entity.attempt_charsets))
+            400,
+            'The request entity could not be decoded. The following '
+            'charsets were attempted: %s' % repr(entity.attempt_charsets),
+        )
 
     # Now that all values have been successfully parsed and decoded,
     # apply them to the entity.params dict.
@@ -220,7 +223,9 @@ def process_multipart(entity):
 
 
 def process_multipart_form_data(entity):
-    """Read all multipart/form-data parts into entity.parts or entity.params.
+    """Read ``multipart/form-data`` parts.
+
+    This function saves them into ``entity.parts`` or ``entity.params``.
     """
     process_multipart(entity)
 
@@ -248,7 +253,10 @@ def process_multipart_form_data(entity):
 
 
 def _old_process_multipart(entity):
-    """The behavior of 3.2 and lower. Deprecated and will be changed in 3.3."""
+    """Behavior of 3.2 and lower.
+
+    Deprecated and will be changed in 3.3.
+    """
     process_multipart(entity)
 
     params = entity.params
@@ -277,7 +285,6 @@ def _old_process_multipart(entity):
 
 # -------------------------------- Entities --------------------------------- #
 class Entity(object):
-
     """An HTTP request body, or MIME multipart body.
 
     This class collects information about the HTTP request entity. When a
@@ -346,13 +353,15 @@ class Entity(object):
     content_type = None
     """The value of the Content-Type request header.
 
-    If the Entity is part of a multipart payload, this will be the Content-Type
-    given in the MIME headers for this part.
+    If the Entity is part of a multipart payload, this will be the
+    Content-Type given in the MIME headers for this part.
     """
 
     default_content_type = 'application/x-www-form-urlencoded'
     """This defines a default ``Content-Type`` to use if no Content-Type header
-    is given. The empty string is used for RequestBody, which results in the
+    is given.
+
+    The empty string is used for RequestBody, which results in the
     request body not being read or parsed at all. This is by design; a missing
     ``Content-Type`` header in the HTTP request entity is an error at best,
     and a security hole at worst. For multipart parts, however, the MIME spec
@@ -389,10 +398,11 @@ class Entity(object):
     the 'before_request_body' and 'before_handler' hooks (assuming that
     process_request_body is True)."""
 
-    processors = {'application/x-www-form-urlencoded': process_urlencoded,
-                  'multipart/form-data': process_multipart_form_data,
-                  'multipart': process_multipart,
-                  }
+    processors = {
+        'application/x-www-form-urlencoded': process_urlencoded,
+        'multipart/form-data': process_multipart_form_data,
+        'multipart': process_multipart,
+    }
     """A dict of Content-Type names to processor methods."""
 
     parts = None
@@ -402,11 +412,12 @@ class Entity(object):
     part_class = None
     """The class used for multipart parts.
 
-    You can replace this with custom subclasses to alter the processing of
-    multipart parts.
+    You can replace this with custom subclasses to alter the processing
+    of multipart parts.
     """
 
     def __init__(self, fp, headers, params=None, parts=None):
+        """Initialize an HTTP entity."""
         # Make an instance-specific copy of the class processors
         # so Tools, etc. can replace them per-request.
         self.processors = self.processors.copy()
@@ -428,14 +439,16 @@ def __init__(self, fp, headers, params=None, parts=None):
             self.content_type = self.content_type[0]
         else:
             self.content_type = httputil.HeaderElement.from_str(
-                self.default_content_type)
+                self.default_content_type,
+            )
 
         # Copy the class 'attempt_charsets', prepending any Content-Type
         # charset
         dec = self.content_type.params.get('charset', None)
         if dec:
-            self.attempt_charsets = [dec] + [c for c in self.attempt_charsets
-                                             if c != dec]
+            self.attempt_charsets = [dec] + [
+                c for c in self.attempt_charsets if c != dec
+            ]
         else:
             self.attempt_charsets = self.attempt_charsets[:]
 
@@ -443,9 +456,9 @@ def __init__(self, fp, headers, params=None, parts=None):
         self.length = None
         clen = headers.get('Content-Length', None)
         # If Transfer-Encoding is 'chunked', ignore any Content-Length.
-        if (
-            clen is not None and
-            'chunked' not in headers.get('Transfer-Encoding', '')
+        if clen is not None and 'chunked' not in headers.get(
+            'Transfer-Encoding',
+            '',
         ):
             try:
                 self.length = int(clen)
@@ -464,9 +477,8 @@ def __init__(self, fp, headers, params=None, parts=None):
                     self.name = self.name[1:-1]
             if 'filename' in disp.params:
                 self.filename = disp.params['filename']
-                if (
-                    self.filename.startswith('"') and
-                    self.filename.endswith('"')
+                if self.filename.startswith('"') and self.filename.endswith(
+                    '"',
                 ):
                     self.filename = self.filename[1:-1]
             if 'filename*' in disp.params:
@@ -475,24 +487,30 @@ def __init__(self, fp, headers, params=None, parts=None):
                 self.filename = unquote(str(filename), encoding)
 
     def read(self, size=None, fp_out=None):
+        """Read bytes from the connection."""
         return self.fp.read(size, fp_out)
 
     def readline(self, size=None):
+        """Read a line of bytes from the connection."""
         return self.fp.readline(size)
 
     def readlines(self, sizehint=None):
+        """Read some byte lines from the connection."""
         return self.fp.readlines(sizehint)
 
     def __iter__(self):
+        """Set up the iterator."""
         return self
 
     def __next__(self):
+        """Return the next line of bytes."""
         line = self.readline()
         if not line:
             raise StopIteration
         return line
 
     def next(self):
+        """Return the next line of bytes."""  # FIXME: python 2?
         return self.__next__()
 
     def read_into_file(self, fp_out=None):
@@ -509,7 +527,8 @@ def make_file(self):
         """Return a file-like object into which the request body will be read.
 
         By default, this will return a TemporaryFile. Override as needed.
-        See also :attr:`cherrypy._cpreqbody.Part.maxrambytes`."""
+        See also :attr:`cherrypy._cpreqbody.Part.maxrambytes`.
+        """
         return tempfile.TemporaryFile()
 
     def fullvalue(self):
@@ -525,7 +544,7 @@ def fullvalue(self):
         return value
 
     def decode_entity(self, value):
-        """Return a given byte encoded value as a string"""
+        """Return a given byte encoded value as a string."""
         for charset in self.attempt_charsets:
             try:
                 value = value.decode(charset)
@@ -538,7 +557,7 @@ def decode_entity(self, value):
             raise cherrypy.HTTPError(
                 400,
                 'The request entity could not be decoded. The following '
-                'charsets were attempted: %s' % repr(self.attempt_charsets)
+                'charsets were attempted: %s' % repr(self.attempt_charsets),
             )
 
     def process(self):
@@ -559,7 +578,9 @@ def process(self):
             proc(self)
 
     def default_proc(self):
-        """Called if a more-specific processor is not found for the
+        """Process unknown data as a fallback.
+
+        Called if a more-specific processor is not found for the
         ``Content-Type``.
         """
         # Leave the fp alone for someone else to read. This works fine
@@ -569,7 +590,6 @@ def default_proc(self):
 
 
 class Part(Entity):
-
     """A MIME part entity, part of a multipart entity."""
 
     # "The default character set, which must be assumed in the absence of a
@@ -610,6 +630,7 @@ class Part(Entity):
     """
 
     def __init__(self, fp, headers, boundary):
+        """Initialize an entity part."""
         Entity.__init__(self, fp, headers)
         self.boundary = boundary
         self.file = None
@@ -617,11 +638,13 @@ def __init__(self, fp, headers, boundary):
 
     @classmethod
     def from_fp(cls, fp, boundary):
+        """Initialize an entity part from a file handle."""
         headers = cls.read_headers(fp)
         return cls(fp, headers, boundary)
 
     @classmethod
     def read_headers(cls, fp):
+        """Read HTTP headers from a file handle."""
         headers = httputil.HeaderMap()
         while True:
             line = fp.readline()
@@ -653,8 +676,8 @@ def read_headers(cls, fp):
     def read_lines_to_boundary(self, fp_out=None):
         """Read bytes from self.fp and return or write them to a file.
 
-        If the 'fp_out' argument is None (the default), all bytes read are
-        returned in a single byte string.
+        If the 'fp_out' argument is None (the default), all bytes read
+        are returned in a single byte string.
 
         If the 'fp_out' argument is not None, it must be a file-like
         object that supports the 'write' method; all bytes read will be
@@ -709,7 +732,9 @@ def read_lines_to_boundary(self, fp_out=None):
             return fp_out
 
     def default_proc(self):
-        """Called if a more-specific processor is not found for the
+        """Process unknown data as a fallback.
+
+        Called if a more-specific processor is not found for the
         ``Content-Type``.
         """
         if self.filename:
@@ -739,9 +764,17 @@ def read_into_file(self, fp_out=None):
 
 
 class SizedReader:
-
-    def __init__(self, fp, length, maxbytes, bufsize=DEFAULT_BUFFER_SIZE,
-                 has_trailers=False):
+    """A buffered/sized reader."""
+
+    def __init__(
+        self,
+        fp,
+        length,
+        maxbytes,
+        bufsize=DEFAULT_BUFFER_SIZE,
+        has_trailers=False,
+    ):
+        """Initialize buffered file handle reader."""
         # Wrap our fp in a buffer so peek() works
         self.fp = fp
         self.length = length
@@ -755,21 +788,20 @@ def __init__(self, fp, length, maxbytes, bufsize=DEFAULT_BUFFER_SIZE,
     def read(self, size=None, fp_out=None):
         """Read bytes from the request body and return or write them to a file.
 
-        A number of bytes less than or equal to the 'size' argument are read
-        off the socket. The actual number of bytes read are tracked in
-        self.bytes_read. The number may be smaller than 'size' when 1) the
-        client sends fewer bytes, 2) the 'Content-Length' request header
-        specifies fewer bytes than requested, or 3) the number of bytes read
-        exceeds self.maxbytes (in which case, 413 is raised).
+        A number of bytes less than or equal to the 'size' argument are
+        read off the socket. The actual number of bytes read are tracked
+        in self.bytes_read. The number may be smaller than 'size' when
+        1) the client sends fewer bytes, 2) the 'Content-Length' request
+        header specifies fewer bytes than requested, or 3) the number of
+        bytes read exceeds self.maxbytes (in which case, 413 is raised).
 
-        If the 'fp_out' argument is None (the default), all bytes read are
-        returned in a single byte string.
+        If the 'fp_out' argument is None (the default), all bytes read
+        are returned in a single byte string.
 
         If the 'fp_out' argument is not None, it must be a file-like
         object that supports the 'write' method; all bytes read will be
         written to the fp, and None is returned.
         """
-
         if self.length is None:
             if size is None:
                 remaining = inf
@@ -820,7 +852,9 @@ def read(self, size=None, fp_out=None):
                 if e.__class__.__name__ == 'MaxSizeExceeded':
                     # Post data is too big
                     raise cherrypy.HTTPError(
-                        413, 'Maximum request length: %r' % e.args[1])
+                        413,
+                        'Maximum request length: %r' % e.args[1],
+                    )
                 else:
                     raise
             if not data:
@@ -885,6 +919,7 @@ def readlines(self, sizehint=None):
         return lines
 
     def finish(self):
+        """Finalize reading the HTTP trailer headers."""
         self.done = True
         if self.has_trailers and hasattr(self.fp, 'read_trailer_lines'):
             self.trailers = {}
@@ -912,13 +947,14 @@ def finish(self):
                 if e.__class__.__name__ == 'MaxSizeExceeded':
                     # Post data is too big
                     raise cherrypy.HTTPError(
-                        413, 'Maximum request length: %r' % e.args[1])
+                        413,
+                        'Maximum request length: %r' % e.args[1],
+                    )
                 else:
                     raise
 
 
 class RequestBody(Entity):
-
     """The entity of the HTTP request."""
 
     bufsize = 8 * 1024
@@ -943,6 +979,7 @@ class RequestBody(Entity):
     """
 
     def __init__(self, fp, headers, params=None, request_params=None):
+        """Initialize a request body entity."""
         Entity.__init__(self, fp, headers, params)
 
         # http://www.w3.org/Protocols/rfc2616/rfc2616-sec3.html#sec3.7.1
@@ -976,9 +1013,13 @@ def process(self):
         if 'Content-Length' not in h and 'Transfer-Encoding' not in h:
             raise cherrypy.HTTPError(411)
 
-        self.fp = SizedReader(self.fp, self.length,
-                              self.maxbytes, bufsize=self.bufsize,
-                              has_trailers='Trailer' in h)
+        self.fp = SizedReader(
+            self.fp,
+            self.length,
+            self.maxbytes,
+            bufsize=self.bufsize,
+            has_trailers='Trailer' in h,
+        )
         super(RequestBody, self).process()
 
         # Body params should also be a part of the request_params
diff --git a/cherrypy/_cprequest.py b/cherrypy/_cprequest.py
index 9b86bd674..b9e080b7c 100644
--- a/cherrypy/_cprequest.py
+++ b/cherrypy/_cprequest.py
@@ -16,7 +16,6 @@
 
 
 class Hook(object):
-
     """A callback and its metadata: failsafe, priority, and kwargs."""
 
     callback = None
@@ -30,10 +29,12 @@ class Hook(object):
     from the same call point raise exceptions."""
 
     priority = 50
+    """Defines the order of execution for a list of Hooks.
+
+    Priority numbers should be limited to the closed interval [0, 100],
+    but values outside this range are acceptable, as are fractional
+    values.
     """
-    Defines the order of execution for a list of Hooks. Priority numbers
-    should be limited to the closed interval [0, 100], but values outside
-    this range are acceptable, as are fractional values."""
 
     kwargs = {}
     """
@@ -41,6 +42,7 @@ class Hook(object):
     callable on each call."""
 
     def __init__(self, callback, failsafe=None, priority=None, **kwargs):
+        """Initialize the hook instance."""
         self.callback = callback
 
         if failsafe is None:
@@ -54,7 +56,14 @@ def __init__(self, callback, failsafe=None, priority=None, **kwargs):
         self.kwargs = kwargs
 
     def __lt__(self, other):
-        """
+        """Check if this hook's priority is lower than the other's.
+
+        :param other: Another object to compare priority with.
+        :type other: Hook
+
+        :returns: Whether the other Hook's priority is higher than this one's.
+        :rtype: bool
+
         Hooks sort by priority, ascending, such that
         hooks of lower priority are run first.
         """
@@ -65,25 +74,30 @@ def __call__(self):
         return self.callback(**self.kwargs)
 
     def __repr__(self):
+        """Render a string representation of :class:`Hook` instance."""
         cls = self.__class__
-        return ('%s.%s(callback=%r, failsafe=%r, priority=%r, %s)'
-                % (cls.__module__, cls.__name__, self.callback,
-                   self.failsafe, self.priority,
-                   ', '.join(['%s=%r' % (k, v)
-                              for k, v in self.kwargs.items()])))
+        return '%s.%s(callback=%r, failsafe=%r, priority=%r, %s)' % (
+            cls.__module__,
+            cls.__name__,
+            self.callback,
+            self.failsafe,
+            self.priority,
+            ', '.join(['%s=%r' % (k, v) for k, v in self.kwargs.items()]),
+        )
 
 
 class HookMap(dict):
-
     """A map of call points to lists of callbacks (Hook objects)."""
 
     def __new__(cls, points=None):
+        """Construct a fresh hook map instance."""
         d = dict.__new__(cls)
         for p in points or []:
             d[p] = []
         return d
 
     def __init__(self, *a, **kw):
+        """Initialize a hook map instance post-construction."""
         pass
 
     def attach(self, point, callback, failsafe=None, priority=None, **kwargs):
@@ -124,25 +138,25 @@ def run_hooks(cls, hooks):
                 raise
 
     def __copy__(self):
+        """Duplicate object per the copy protocol."""
         newmap = self.__class__()
         # We can't just use 'update' because we want copies of the
         # mutable values (each is a list) as well.
         for k, v in self.items():
             newmap[k] = v[:]
         return newmap
+
     copy = __copy__
 
     def __repr__(self):
+        """Render a string representation of :class:`HookMap`."""
         cls = self.__class__
-        return '%s.%s(points=%r)' % (
-            cls.__module__,
-            cls.__name__,
-            list(self)
-        )
+        return '%s.%s(points=%r)' % (cls.__module__, cls.__name__, list(self))
 
 
 # Config namespace handlers
 
+
 def hooks_namespace(k, v):
     """Attach bare hooks declared in config."""
     # Use split again to allow multiple hooks for a single
@@ -169,7 +183,7 @@ def request_namespace(k, v):
 def response_namespace(k, v):
     """Attach response attributes declared in config."""
     # Provides config entries to set default response headers
-    # http://cherrypy.org/ticket/889
+    # http://cherrypy.dev/ticket/889
     if k[:8] == 'headers.':
         cherrypy.serving.response.headers[k.split('.', 1)[1]] = v
     else:
@@ -183,30 +197,36 @@ def error_page_namespace(k, v):
     cherrypy.serving.request.error_page[k] = v
 
 
-hookpoints = ['on_start_resource', 'before_request_body',
-              'before_handler', 'before_finalize',
-              'on_end_resource', 'on_end_request',
-              'before_error_response', 'after_error_response']
+hookpoints = [
+    'on_start_resource',
+    'before_request_body',
+    'before_handler',
+    'before_finalize',
+    'on_end_resource',
+    'on_end_request',
+    'before_error_response',
+    'after_error_response',
+]
 
 
 class Request(object):
-
     """An HTTP request.
 
-    This object represents the metadata of an HTTP request message;
-    that is, it contains attributes which describe the environment
-    in which the request URL, headers, and body were sent (if you
-    want tools to interpret the headers and body, those are elsewhere,
-    mostly in Tools). This 'metadata' consists of socket data,
-    transport characteristics, and the Request-Line. This object
-    also contains data regarding the configuration in effect for
-    the given URL, and the execution plan for generating a response.
+    This object represents the metadata of an HTTP request message; that
+    is, it contains attributes which describe the environment in which
+    the request URL, headers, and body were sent (if you want tools to
+    interpret the headers and body, those are elsewhere, mostly in
+    Tools). This 'metadata' consists of socket data, transport
+    characteristics, and the Request-Line. This object also contains
+    data regarding the configuration in effect for the given URL, and
+    the execution plan for generating a response.
     """
 
     prev = None
+    """The previous Request object (if any).
+
+    This should be None unless we are processing an InternalRedirect.
     """
-    The previous Request object (if any). This should be None
-    unless we are processing an InternalRedirect."""
 
     # Conversation/connection attributes
     local = httputil.Host('127.0.0.1', 80)
@@ -216,9 +236,10 @@ class Request(object):
     'An httputil.Host(ip, port, hostname) object for the client socket.'
 
     scheme = 'http'
+    """The protocol used between client and server.
+
+    In most cases, this will be either 'http' or 'https'.
     """
-    The protocol used between client and server. In most cases,
-    this will be either 'http' or 'https'."""
 
     server_protocol = 'HTTP/1.1'
     """
@@ -227,32 +248,37 @@ class Request(object):
 
     base = ''
     """The (scheme://host) portion of the requested URL.
+
     In some cases (e.g. when proxying via mod_rewrite), this may contain
     path segments which cherrypy.url uses when constructing url's, but
-    which otherwise are ignored by CherryPy. Regardless, this value
-    MUST NOT end in a slash."""
+    which otherwise are ignored by CherryPy. Regardless, this value MUST
+    NOT end in a slash.
+    """
 
     # Request-Line attributes
     request_line = ''
+    """The complete Request-Line received from the client.
+
+    This is a single string consisting of the request method, URI, and
+    protocol version (joined by spaces). Any final CRLF is removed.
     """
-    The complete Request-Line received from the client. This is a
-    single string consisting of the request method, URI, and protocol
-    version (joined by spaces). Any final CRLF is removed."""
 
     method = 'GET'
+    """Indicates the HTTP method to be performed on the resource identified by
+    the Request-URI.
+
+    Common methods include GET, HEAD, POST, PUT, and DELETE. CherryPy
+    allows any extension method; however, various HTTP servers and
+    gateways may restrict the set of allowable methods. CherryPy
+    applications SHOULD restrict the set (on a per-URI basis).
     """
-    Indicates the HTTP method to be performed on the resource identified
-    by the Request-URI. Common methods include GET, HEAD, POST, PUT, and
-    DELETE. CherryPy allows any extension method; however, various HTTP
-    servers and gateways may restrict the set of allowable methods.
-    CherryPy applications SHOULD restrict the set (on a per-URI basis)."""
 
     query_string = ''
     """
     The query component of the Request-URI, a string of information to be
     interpreted by the resource. The query portion of a URI follows the
     path component, and is separated by a '?'. For example, the URI
-    'http://www.cherrypy.org/wiki?a=3&b=4' has the query component,
+    'http://www.cherrypy.dev/wiki?a=3&b=4' has the query component,
     'a=3&b=4'."""
 
     query_string_encoding = 'utf8'
@@ -277,22 +303,26 @@ class Request(object):
     A dict which combines query string (GET) and request entity (POST)
     variables. This is populated in two stages: GET params are added
     before the 'on_start_resource' hook, and POST params are added
-    between the 'before_request_body' and 'before_handler' hooks."""
+    between the 'before_request_body' and 'before_handler' hooks.
+    """
 
     # Message attributes
     header_list = []
+    """A list of the HTTP request headers as (name, value) tuples.
+
+    In general, you should use request.headers (a dict) instead.
     """
-    A list of the HTTP request headers as (name, value) tuples.
-    In general, you should use request.headers (a dict) instead."""
 
     headers = httputil.HeaderMap()
-    """
-    A dict-like object containing the request headers. Keys are header
+    """A dict-like object containing the request headers.
+
+    Keys are header
     names (in Title-Case format); however, you may get and set them in
     a case-insensitive manner. That is, headers['Content-Type'] and
     headers['content-type'] refer to the same value. Values are header
     values (decoded according to :rfc:`2047` if necessary). See also:
-    httputil.HeaderMap, httputil.HeaderElement."""
+    httputil.HeaderMap, httputil.HeaderElement.
+    """
 
     cookie = SimpleCookie()
     """See help(Cookie)."""
@@ -336,7 +366,8 @@ class Request(object):
     or multipart, this will be None. Otherwise, this will be an instance
     of :class:`RequestBody<cherrypy._cpreqbody.RequestBody>` (which you
     can .read()); this value is set between the 'before_request_body' and
-    'before_handler' hooks (assuming that process_request_body is True)."""
+    'before_handler' hooks (assuming that process_request_body is True).
+    """
 
     # Dispatch attributes
     dispatch = cherrypy.dispatch.Dispatcher()
@@ -347,23 +378,24 @@ class Request(object):
     calls the dispatcher as early as possible, passing it a 'path_info'
     argument.
 
-    The default dispatcher discovers the page handler by matching path_info
-    to a hierarchical arrangement of objects, starting at request.app.root.
-    See help(cherrypy.dispatch) for more information."""
+    The default dispatcher discovers the page handler by matching
+    path_info to a hierarchical arrangement of objects, starting at
+    request.app.root. See help(cherrypy.dispatch) for more information.
+    """
 
     script_name = ''
-    """
-    The 'mount point' of the application which is handling this request.
+    """The 'mount point' of the application which is handling this request.
 
     This attribute MUST NOT end in a slash. If the script_name refers to
     the root of the URI, it MUST be an empty string (not "/").
     """
 
     path_info = '/'
+    """The 'relative path' portion of the Request-URI.
+
+    This is relative to the script_name ('mount point') of the
+    application which is handling this request.
     """
-    The 'relative path' portion of the Request-URI. This is relative
-    to the script_name ('mount point') of the application which is
-    handling this request."""
 
     login = None
     """
@@ -391,14 +423,16 @@ class Request(object):
     of the form: {Toolbox.namespace: {Tool.name: config dict}}."""
 
     config = None
+    """A flat dict of all configuration entries which apply to the current
+    request.
+
+    These entries are collected from global config, application config
+    (based on request.path_info), and from handler config (exactly how
+    is governed by the request.dispatch object in effect for this
+    request; by default, handler config can be attached anywhere in the
+    tree between request.app.root and the final handler, and inherits
+    downward).
     """
-    A flat dict of all configuration entries which apply to the
-    current request. These entries are collected from global config,
-    application config (based on request.path_info), and from handler
-    config (exactly how is governed by the request.dispatch object in
-    effect for this request; by default, handler config can be attached
-    anywhere in the tree between request.app.root and the final handler,
-    and inherits downward)."""
 
     is_index = None
     """
@@ -409,13 +443,14 @@ class Request(object):
     the trailing slash. See cherrypy.tools.trailing_slash."""
 
     hooks = HookMap(hookpoints)
-    """
-    A HookMap (dict-like object) of the form: {hookpoint: [hook, ...]}.
+    """A HookMap (dict-like object) of the form: {hookpoint: [hook, ...]}.
+
     Each key is a str naming the hook point, and each value is a list
     of hooks which will be called at that hook point during this request.
     The list of hooks is generally populated as early as possible (mostly
     from Tools specified in config), but may be extended at any time.
-    See also: _cprequest.Hook, _cprequest.HookMap, and cherrypy.tools."""
+    See also: _cprequest.Hook, _cprequest.HookMap, and cherrypy.tools.
+    """
 
     error_response = cherrypy.HTTPError(500).set_response
     """
@@ -428,12 +463,11 @@ class Request(object):
     error response to the user-agent."""
 
     error_page = {}
-    """
-    A dict of {error code: response filename or callable} pairs.
+    """A dict of {error code: response filename or callable} pairs.
 
     The error code must be an int representing a given HTTP error code,
-    or the string 'default', which will be used if no matching entry
-    is found for a given numeric code.
+    or the string 'default', which will be used if no matching entry is
+    found for a given numeric code.
 
     If a filename is provided, the file should contain a Python string-
     formatting template, and can expect by default to receive format
@@ -447,8 +481,8 @@ class Request(object):
     iterable of strings which will be set to response.body. It may also
     override headers or perform any other processing.
 
-    If no entry is given for an error code, and no 'default' entry exists,
-    a default template will be used.
+    If no entry is given for an error code, and no 'default' entry
+    exists, a default template will be used.
     """
 
     show_tracebacks = True
@@ -473,28 +507,37 @@ class Request(object):
     """True once the close method has been called, False otherwise."""
 
     stage = None
+    """A string containing the stage reached in the request-handling process.
+
+    This is useful when debugging a live server with hung requests.
     """
-    A string containing the stage reached in the request-handling process.
-    This is useful when debugging a live server with hung requests."""
 
     unique_id = None
     """A lazy object generating and memorizing UUID4 on ``str()`` render."""
 
     namespaces = reprconf.NamespaceSet(
-        **{'hooks': hooks_namespace,
-           'request': request_namespace,
-           'response': response_namespace,
-           'error_page': error_page_namespace,
-           'tools': cherrypy.tools,
-           })
-
-    def __init__(self, local_host, remote_host, scheme='http',
-                 server_protocol='HTTP/1.1'):
+        **{
+            'hooks': hooks_namespace,
+            'request': request_namespace,
+            'response': response_namespace,
+            'error_page': error_page_namespace,
+            'tools': cherrypy.tools,
+        },
+    )
+
+    def __init__(
+        self,
+        local_host,
+        remote_host,
+        scheme='http',
+        server_protocol='HTTP/1.1',
+    ):
         """Populate a new Request object.
 
-        local_host should be an httputil.Host object with the server info.
-        remote_host should be an httputil.Host object with the client info.
-        scheme should be a string, either "http" or "https".
+        local_host should be an httputil.Host object with the server
+        info. remote_host should be an httputil.Host object with the
+        client info. scheme should be a string, either "http" or
+        "https".
         """
         self.local = local_host
         self.remote = remote_host
@@ -514,7 +557,10 @@ def __init__(self, local_host, remote_host, scheme='http',
         self.unique_id = LazyUUID4()
 
     def close(self):
-        """Run cleanup code. (Core)"""
+        """Run cleanup code.
+
+        (Core)
+        """
         if not self.closed:
             self.closed = True
             self.stage = 'on_end_request'
@@ -522,7 +568,9 @@ def close(self):
             self.stage = 'close'
 
     def run(self, method, path, query_string, req_protocol, headers, rfile):
-        r"""Process the Request. (Core)
+        r"""Process the request.
+
+        *(core)*
 
         method, path, query_string, and req_protocol should be pulled directly
         from the Request-Line (e.g. "GET /path?key=val HTTP/1.0").
@@ -551,7 +599,6 @@ def run(self, method, path, query_string, req_protocol, headers, rfile):
 
         Consumer code (HTTP servers) should then access these response
         attributes to build the outbound stream.
-
         """
         response = cherrypy.serving.response
         self.stage = 'run'
@@ -598,7 +645,7 @@ def run(self, method, path, query_string, req_protocol, headers, rfile):
             # path_info should be the path from the
             # app root (script_name) to the handler.
             self.script_name = self.app.script_name
-            self.path_info = pi = path[len(self.script_name):]
+            self.path_info = pi = path[len(self.script_name) :]
 
             self.stage = 'respond'
             self.respond(pi)
@@ -631,7 +678,10 @@ def run(self, method, path, query_string, req_protocol, headers, rfile):
         return response
 
     def respond(self, path_info):
-        """Generate a response for the resource at self.path_info. (Core)"""
+        """Generate a response for the resource at self.path_info.
+
+        (Core)
+        """
         try:
             try:
                 try:
@@ -669,7 +719,10 @@ def _do_respond(self, path_info):
         self.get_resource(path_info)
 
         self.body = _cpreqbody.RequestBody(
-            self.rfile, self.headers, request_params=self.params)
+            self.rfile,
+            self.headers,
+            request_params=self.params,
+        )
 
         self.namespaces(self.config)
 
@@ -702,20 +755,30 @@ def _do_respond(self, path_info):
         response.finalize()
 
     def process_query_string(self):
-        """Parse the query string into Python structures. (Core)"""
+        """Parse the query string into Python structures.
+
+        (Core)
+        """
         try:
             p = httputil.parse_query_string(
-                self.query_string, encoding=self.query_string_encoding)
+                self.query_string,
+                encoding=self.query_string_encoding,
+            )
         except UnicodeDecodeError:
             raise cherrypy.HTTPError(
-                404, 'The given query string could not be processed. Query '
-                'strings for this resource must be encoded with %r.' %
-                self.query_string_encoding)
+                404,
+                'The given query string could not be processed. Query '
+                'strings for this resource must be encoded with %r.'
+                % self.query_string_encoding,
+            )
 
         self.params.update(p)
 
     def process_headers(self):
-        """Parse HTTP header data into Python structures. (Core)"""
+        """Parse HTTP header data into Python structures.
+
+        (Core)
+        """
         # Process the headers into self.headers
         headers = self.headers
         for name, value in self.header_list:
@@ -742,24 +805,36 @@ def process_headers(self):
             if self.protocol >= (1, 1):
                 msg = "HTTP/1.1 requires a 'Host' request header."
                 raise cherrypy.HTTPError(400, msg)
+        else:
+            headers['Host'] = httputil.SanitizedHost(dict.get(headers, 'Host'))
+
         host = dict.get(headers, 'Host')
         if not host:
             host = self.local.name or self.local.ip
         self.base = '%s://%s' % (self.scheme, host)
 
     def get_resource(self, path):
-        """Call a dispatcher (which sets self.handler and .config). (Core)"""
+        """Call a dispatcher (which sets self.handler and .config).
+
+        (Core)
+        """
         # First, see if there is a custom dispatch at this URI. Custom
         # dispatchers can only be specified in app.config, not in _cp_config
         # (since custom dispatchers may not even have an app.root).
         dispatch = self.app.find_config(
-            path, 'request.dispatch', self.dispatch)
+            path,
+            'request.dispatch',
+            self.dispatch,
+        )
 
         # dispatch() should set self.handler and self.config
         dispatch(path)
 
     def handle_error(self):
-        """Handle the last unanticipated exception. (Core)"""
+        """Handle the last unanticipated exception.
+
+        (Core)
+        """
         try:
             self.hooks.run('before_error_response')
             if self.error_response:
@@ -773,13 +848,15 @@ def handle_error(self):
 
 
 class ResponseBody(object):
-
     """The body of the HTTP response (the response entity)."""
 
-    unicode_err = ('Page handlers MUST return bytes. Use tools.encode '
-                   'if you wish to return unicode.')
+    unicode_err = (
+        'Page handlers MUST return bytes. Use tools.encode '
+        'if you wish to return unicode.'
+    )
 
     def __get__(self, obj, objclass=None):
+        """Return a response body through the descriptor protocol."""
         if obj is None:
             # When calling on the class instead of an instance...
             return self
@@ -787,7 +864,10 @@ def __get__(self, obj, objclass=None):
             return obj._body
 
     def __set__(self, obj, value):
-        # Convert the given value to an iterable object.
+        """Set a response body through the descriptor protocol.
+
+        Convert the given value to an iterable object.
+        """
         if isinstance(value, str):
             raise ValueError(self.unicode_err)
         elif isinstance(value, list):
@@ -799,18 +879,18 @@ def __set__(self, obj, value):
 
 
 class Response(object):
-
     """An HTTP Response, including status, headers, and body."""
 
     status = ''
     """The HTTP Status-Code and Reason-Phrase."""
 
     header_list = []
-    """
-    A list of the HTTP response headers as (name, value) tuples.
+    """A list of the HTTP response headers as (name, value) tuples.
+
     In general, you should use response.headers (a dict) instead. This
     attribute is generated from response.headers and is not valid until
-    after the finalize phase."""
+    after the finalize phase.
+    """
 
     headers = httputil.HeaderMap()
     """
@@ -830,12 +910,16 @@ class Response(object):
     """The body (entity) of the HTTP response."""
 
     time = None
-    """The value of time.time() when created. Use in HTTP dates."""
+    """The value of time.time() when created.
+
+    Use in HTTP dates.
+    """
 
     stream = False
     """If False, buffer the response body."""
 
     def __init__(self):
+        """Intialize the HTTP response instance."""
         self.status = None
         self.header_list = None
         self._body = []
@@ -844,11 +928,14 @@ def __init__(self):
         self.headers = httputil.HeaderMap()
         # Since we know all our keys are titled strings, we can
         # bypass HeaderMap.update and get a big speed boost.
-        dict.update(self.headers, {
-            'Content-Type': 'text/html',
-            'Server': 'CherryPy/' + cherrypy.__version__,
-            'Date': httputil.HTTPDate(self.time),
-        })
+        dict.update(
+            self.headers,
+            {
+                'Content-Type': 'text/html',
+                'Server': 'CherryPy/' + cherrypy.__version__,
+                'Date': httputil.HTTPDate(self.time),
+            },
+        )
         self.cookie = SimpleCookie()
 
     def collapse_body(self):
@@ -858,15 +945,21 @@ def collapse_body(self):
         return new_body
 
     def _flush_body(self):
-        """
-        Discard self.body but consume any generator such that
-        any finalization can occur, such as is required by
-        caching.tee_output().
+        """Exhaust the body iterator.
+
+        :rtype: None
+
+        Discard ``self.body`` but consume any generator such that any
+        finalization can occur, such as is required by
+        ``caching.tee_output()``.
         """
         consume(iter(self.body))
 
     def finalize(self):
-        """Transform headers (and cookies) into self.header_list. (Core)"""
+        """Transform headers (and cookies) into self.header_list.
+
+        (Core)
+        """
         try:
             code, reason, _ = httputil.valid_status(self.status)
         except ValueError:
@@ -875,8 +968,9 @@ def finalize(self):
         headers = self.headers
 
         self.status = '%s %s' % (code, reason)
-        self.output_status = ntob(str(code), 'ascii') + \
-            b' ' + headers.encode(reason)
+        self.output_status = (
+            ntob(str(code), 'ascii') + b' ' + headers.encode(reason)
+        )
 
         if self.stream:
             # The upshot: wsgiserver will chunk the response if
@@ -913,6 +1007,8 @@ def finalize(self):
 
 
 class LazyUUID4(object):
+    """A delayed UUID4 string maker."""
+
     def __str__(self):
         """Return UUID4 and keep it for future calls."""
         return str(self.uuid4)
diff --git a/cherrypy/_cpserver.py b/cherrypy/_cpserver.py
index 5f8d98fa3..ba166913d 100644
--- a/cherrypy/_cpserver.py
+++ b/cherrypy/_cpserver.py
@@ -6,7 +6,7 @@
 from cherrypy.process.servers import ServerAdapter
 
 
-__all__ = ('Server', )
+__all__ = ('Server',)
 
 
 class Server(ServerAdapter):
@@ -41,16 +41,19 @@ def socket_host(self):  # noqa: D401; irrelevant for properties
     @socket_host.setter
     def socket_host(self, value):
         if value == '':
-            raise ValueError("The empty string ('') is not an allowed value. "
-                             "Use '0.0.0.0' instead to listen on all active "
-                             'interfaces (INADDR_ANY).')
+            raise ValueError(
+                "The empty string ('') is not an allowed value. "
+                "Use '0.0.0.0' instead to listen on all active "
+                'interfaces (INADDR_ANY).',
+            )
         self._socket_host = value
 
     socket_file = None
     """If given, the name of the UNIX socket to use instead of TCP/IP.
 
     When this option is not None, the `socket_host` and `socket_port` options
-    are ignored."""
+    are ignored.
+    """
 
     socket_queue_size = 5
     """The 'backlog' argument to socket.listen(); specifies the maximum number
@@ -79,17 +82,24 @@ def socket_host(self, value):
     """The number of worker threads to start up in the pool."""
 
     thread_pool_max = -1
-    """The maximum size of the worker-thread pool. Use -1 to indicate no limit.
+    """The maximum size of the worker-thread pool.
+
+    Use -1 to indicate no limit.
     """
 
     max_request_header_size = 500 * 1024
     """The maximum number of bytes allowable in the request headers.
-    If exceeded, the HTTP server should return "413 Request Entity Too Large".
+
+    If exceeded, the HTTP server should return "413 Request Entity Too
+    Large".
     """
 
     max_request_body_size = 100 * 1024 * 1024
-    """The maximum number of bytes allowable in the request body. If exceeded,
-    the HTTP server should return "413 Request Entity Too Large"."""
+    """The maximum number of bytes allowable in the request body.
+
+    If exceeded, the HTTP server should return "413 Request Entity Too
+    Large".
+    """
 
     instance = None
     """If not None, this should be an HTTP server instance (such as
@@ -119,7 +129,8 @@ def socket_host(self, value):
     the builtin WSGI server. Builtin options are: 'builtin' (to
     use the SSL library built into recent versions of Python).
     You may also register your own classes in the
-    cheroot.server.ssl_adapters dict."""
+    cheroot.server.ssl_adapters dict.
+    """
 
     statistics = False
     """Turns statistics-gathering on or off for aware HTTP servers."""
@@ -129,11 +140,13 @@ def socket_host(self, value):
 
     wsgi_version = (1, 0)
     """The WSGI version tuple to use with the builtin WSGI server.
-    The provided options are (1, 0) [which includes support for PEP 3333,
-    which declares it covers WSGI version 1.0.1 but still mandates the
-    wsgi.version (1, 0)] and ('u', 0), an experimental unicode version.
-    You may create and register your own experimental versions of the WSGI
-    protocol by adding custom classes to the cheroot.server.wsgi_gateways dict.
+
+    The provided options are (1, 0) [which includes support for PEP
+    3333, which declares it covers WSGI version 1.0.1 but still mandates
+    the wsgi.version (1, 0)] and ('u', 0), an experimental unicode
+    version. You may create and register your own experimental versions
+    of the WSGI protocol by adding custom classes to the
+    cheroot.server.wsgi_gateways dict.
     """
 
     peercreds = False
@@ -167,6 +180,7 @@ def httpserver_from_self(self, httpserver=None):
             httpserver = self.instance
         if httpserver is None:
             from cherrypy import _cpwsgi_server
+
             httpserver = _cpwsgi_server.CPWSGIServer(self)
         if isinstance(httpserver, text_or_bytes):
             # Is anyone using this? Can I add an arg?
@@ -178,13 +192,15 @@ def start(self):
         if not self.httpserver:
             self.httpserver, self.bind_addr = self.httpserver_from_self()
         super(Server, self).start()
+
     start.priority = 75
 
     @property
     def bind_addr(self):
         """Return bind address.
 
-        A (host, port) tuple for TCP sockets or a str for Unix domain sockts.
+        A (host, port) tuple for TCP sockets or a str for Unix domain
+        sockets.
         """
         if self.socket_file:
             return self.socket_file
@@ -207,9 +223,11 @@ def bind_addr(self, value):
                 self.socket_host, self.socket_port = value
                 self.socket_file = None
             except ValueError:
-                raise ValueError('bind_addr must be a (host, port) tuple '
-                                 '(for TCP sockets) or a string (for Unix '
-                                 'domain sockets), not %r' % value)
+                raise ValueError(
+                    'bind_addr must be a (host, port) tuple '
+                    '(for TCP sockets) or a string (for Unix '
+                    'domain sockets), not %r' % value,
+                )
 
     def base(self):
         """Return the base for this server.
@@ -225,6 +243,7 @@ def base(self):
             # Look up the host name, which should be the
             # safest thing to spit out in a URL.
             import socket
+
             host = socket.gethostname()
 
         port = self.socket_port
diff --git a/cherrypy/_cptools.py b/cherrypy/_cptools.py
index 716f99a49..e2f2b106b 100644
--- a/cherrypy/_cptools.py
+++ b/cherrypy/_cptools.py
@@ -1,7 +1,7 @@
 """CherryPy tools. A "tool" is any helper, adapted to CP.
 
-Tools are usually designed to be used in a variety of ways (although some
-may only offer one if they choose):
+Tools are usually designed to be used in a variety of ways (although
+some may only offer one if they choose):
 
     Library calls
         All tools are callables that can be used wherever needed.
@@ -35,10 +35,11 @@ def _getargs(func):
     """Return the names of all static arguments to the given function."""
     # Use this instead of importing inspect for less mem overhead.
     import types
+
     if isinstance(func, types.MethodType):
         func = func.__func__
     co = func.__code__
-    return co.co_varnames[:co.co_argcount]
+    return co.co_varnames[: co.co_argcount]
 
 
 _attr_error = (
@@ -48,15 +49,16 @@ def _getargs(func):
 
 
 class Tool(object):
-
     """A registered function for use with CherryPy request-processing hooks.
 
-    help(tool.callable) should give you more information about this Tool.
+    help(tool.callable) should give you more information about this
+    Tool.
     """
 
     namespace = 'tools'
 
     def __init__(self, point, callable, name=None, priority=50):
+        """Initialize a CherryPy tool instance."""
         self._point = point
         self.callable = callable
         self._name = name
@@ -66,10 +68,12 @@ def __init__(self, point, callable, name=None, priority=50):
 
     @property
     def on(self):
+        """Flag whether the tool is enabled."""
         raise AttributeError(_attr_error)
 
     @on.setter
     def on(self, value):
+        """Set a flag for whether the tool is enabled."""
         raise AttributeError(_attr_error)
 
     def _setargs(self):
@@ -118,9 +122,10 @@ def whats_my_base(self):
                 return cherrypy.request.base
         """
         if args:
-            raise TypeError('The %r Tool does not accept positional '
-                            'arguments; you must use keyword arguments.'
-                            % self._name)
+            raise TypeError(
+                'The %r Tool does not accept positional '
+                'arguments; you must use keyword arguments.' % self._name,
+            )
 
         def tool_decorator(f):
             if not hasattr(f, '_cp_config'):
@@ -130,35 +135,41 @@ def tool_decorator(f):
             for k, v in kwargs.items():
                 f._cp_config[subspace + k] = v
             return f
+
         return tool_decorator
 
     def _setup(self):
-        """Hook this tool into cherrypy.request.
+        """Wire this tool into ``cherrypy.request``.
 
-        The standard CherryPy request object will automatically call this
-        method when the tool is "turned on" in config.
+        The standard CherryPy request object will automatically call
+        this method when the tool is "turned on" in config.
         """
         conf = self._merged_args()
         p = conf.pop('priority', None)
         if p is None:
             p = getattr(self.callable, 'priority', self._priority)
-        cherrypy.serving.request.hooks.attach(self._point, self.callable,
-                                              priority=p, **conf)
+        cherrypy.serving.request.hooks.attach(
+            self._point,
+            self.callable,
+            priority=p,
+            **conf,
+        )
 
 
 class HandlerTool(Tool):
-
     """Tool which is called 'before main', that may skip normal handlers.
 
-    If the tool successfully handles the request (by setting response.body),
-    if should return True. This will cause CherryPy to skip any 'normal' page
-    handler. If the tool did not handle the request, it should return False
-    to tell CherryPy to continue on and call the normal page handler. If the
-    tool is declared AS a page handler (see the 'handler' method), returning
-    False will raise NotFound.
+    If the tool successfully handles the request (by setting
+    response.body), if should return True. This will cause CherryPy to
+    skip any 'normal' page handler. If the tool did not handle the
+    request, it should return False to tell CherryPy to continue on and
+    call the normal page handler. If the tool is declared AS a page
+    handler (see the 'handler' method), returning False will raise
+    NotFound.
     """
 
     def __init__(self, callable, name=None):
+        """Initialize a handler tool."""
         Tool.__init__(self, 'before_handler', callable, name)
 
     def handler(self, *args, **kwargs):
@@ -170,12 +181,14 @@ class Root:
                 nav = tools.staticdir.handler(section="/nav", dir="nav",
                                               root=absDir)
         """
+
         @expose
         def handle_func(*a, **kw):
             handled = self.callable(*args, **self._merged_args(kwargs))
             if not handled:
                 raise cherrypy.NotFound()
             return cherrypy.serving.response.body
+
         return handle_func
 
     def _wrapper(self, **kwargs):
@@ -183,21 +196,24 @@ def _wrapper(self, **kwargs):
             cherrypy.serving.request.handler = None
 
     def _setup(self):
-        """Hook this tool into cherrypy.request.
+        """Wire this tool into ``cherrypy.request``.
 
-        The standard CherryPy request object will automatically call this
-        method when the tool is "turned on" in config.
+        The standard CherryPy request object will automatically call
+        this method when the tool is "turned on" in config.
         """
         conf = self._merged_args()
         p = conf.pop('priority', None)
         if p is None:
             p = getattr(self.callable, 'priority', self._priority)
-        cherrypy.serving.request.hooks.attach(self._point, self._wrapper,
-                                              priority=p, **conf)
+        cherrypy.serving.request.hooks.attach(
+            self._point,
+            self._wrapper,
+            priority=p,
+            **conf,
+        )
 
 
 class HandlerWrapperTool(Tool):
-
     """Tool which wraps request.handler in a provided wrapper function.
 
     The 'newhandler' arg must be a handler wrapper function that takes a
@@ -216,36 +232,44 @@ def interpolator(next_handler, *args, **kwargs):
         cherrypy.tools.jinja = HandlerWrapperTool(interpolator)
     """
 
-    def __init__(self, newhandler, point='before_handler', name=None,
-                 priority=50):
+    def __init__(
+        self,
+        newhandler,
+        point='before_handler',
+        name=None,
+        priority=50,
+    ):
+        """Initialize a handler wrapper tool."""
         self.newhandler = newhandler
         self._point = point
         self._name = name
         self._priority = priority
 
     def callable(self, *args, **kwargs):
+        """Decorate a request handler with a handler tool callable."""
         innerfunc = cherrypy.serving.request.handler
 
         def wrap(*args, **kwargs):
             return self.newhandler(innerfunc, *args, **kwargs)
+
         cherrypy.serving.request.handler = wrap
 
 
 class ErrorTool(Tool):
-
     """Tool which is used to replace the default request.error_response."""
 
     def __init__(self, callable, name=None):
+        """Initialize an error tool."""
         Tool.__init__(self, None, callable, name)
 
     def _wrapper(self):
         self.callable(**self._merged_args())
 
     def _setup(self):
-        """Hook this tool into cherrypy.request.
+        """Wire this tool into ``cherrypy.request``.
 
-        The standard CherryPy request object will automatically call this
-        method when the tool is "turned on" in config.
+        The standard CherryPy request object will automatically call
+        this method when the tool is "turned on" in config.
         """
         cherrypy.serving.request.error_response = self._wrapper
 
@@ -254,7 +278,6 @@ def _setup(self):
 
 
 class SessionTool(Tool):
-
     """Session Tool for CherryPy.
 
     sessions.locking
@@ -273,6 +296,7 @@ class SessionTool(Tool):
     """
 
     def __init__(self):
+        """Initialize a session tool."""
         # _sessions.init must be bound after headers are read
         Tool.__init__(self, 'before_request_body', _sessions.init)
 
@@ -280,10 +304,10 @@ def _lock_session(self):
         cherrypy.serving.session.acquire_lock()
 
     def _setup(self):
-        """Hook this tool into cherrypy.request.
+        """Wire this tool into ``cherrypy.request``.
 
-        The standard CherryPy request object will automatically call this
-        method when the tool is "turned on" in config.
+        The standard CherryPy request object will automatically call
+        this method when the tool is "turned on" in config.
         """
         hooks = cherrypy.serving.request.hooks
 
@@ -300,8 +324,11 @@ def _setup(self):
             hooks.attach('before_handler', self._lock_session)
         elif locking == 'early':
             # Lock before the request body (but after _sessions.init runs!)
-            hooks.attach('before_request_body', self._lock_session,
-                         priority=60)
+            hooks.attach(
+                'before_request_body',
+                self._lock_session,
+                priority=60,
+            )
         else:
             # Don't lock
             pass
@@ -317,15 +344,12 @@ def regenerate(self):
         # Grab cookie-relevant tool args
         relevant = 'path', 'path_header', 'name', 'timeout', 'domain', 'secure'
         conf = dict(
-            (k, v)
-            for k, v in self._merged_args().items()
-            if k in relevant
+            (k, v) for k, v in self._merged_args().items() if k in relevant
         )
         _sessions.set_response_cookie(**conf)
 
 
 class XMLRPCController(object):
-
     """A Controller (page handler collection) for XML-RPC.
 
     To use it, have your controllers subclass this base class (it will
@@ -364,6 +388,7 @@ class XMLRPCController(object):
 
     @expose
     def default(self, *vpath, **params):
+        """Process the unhandled XML-RPC methods."""
         rpcparams, rpcmethod = _xmlrpc.process_body()
 
         subhandler = self
@@ -381,18 +406,19 @@ def default(self, *vpath, **params):
             raise Exception('method "%s" is not supported' % attr)
 
         conf = cherrypy.serving.request.toolmaps['tools'].get('xmlrpc', {})
-        _xmlrpc.respond(body,
-                        conf.get('encoding', 'utf-8'),
-                        conf.get('allow_none', 0))
+        _xmlrpc.respond(
+            body,
+            conf.get('encoding', 'utf-8'),
+            conf.get('allow_none', 0),
+        )
         return cherrypy.serving.response.body
 
 
 class SessionAuthTool(HandlerTool):
-    pass
+    """An HTTP session authentication tool."""
 
 
 class CachingTool(Tool):
-
     """Caching Tool for CherryPy."""
 
     def _wrapper(self, **kwargs):
@@ -402,31 +428,41 @@ def _wrapper(self, **kwargs):
         else:
             if request.cacheable:
                 # Note the devious technique here of adding hooks on the fly
-                request.hooks.attach('before_finalize', _caching.tee_output,
-                                     priority=100)
+                request.hooks.attach(
+                    'before_finalize',
+                    _caching.tee_output,
+                    priority=100,
+                )
+
     _wrapper.priority = 90
 
     def _setup(self):
-        """Hook caching into cherrypy.request."""
+        """Wire caching into ``cherrypy.request``."""
         conf = self._merged_args()
 
         p = conf.pop('priority', None)
-        cherrypy.serving.request.hooks.attach('before_handler', self._wrapper,
-                                              priority=p, **conf)
+        cherrypy.serving.request.hooks.attach(
+            'before_handler',
+            self._wrapper,
+            priority=p,
+            **conf,
+        )
 
 
 class Toolbox(object):
-
     """A collection of Tools.
 
     This object also functions as a config namespace handler for itself.
-    Custom toolboxes should be added to each Application's toolboxes dict.
+    Custom toolboxes should be added to each Application's toolboxes
+    dict.
     """
 
     def __init__(self, namespace):
+        """Initialize a toolbox instance."""
         self.namespace = namespace
 
     def __setattr__(self, name, value):
+        """Set an attribute on this :class:`Toolbox` instance."""
         # If the Tool._name is None, supply it from the attribute name.
         if isinstance(value, Tool):
             if value._name is None:
@@ -442,6 +478,7 @@ def populate(k, v):
             toolname, arg = k.split('.', 1)
             bucket = map.setdefault(toolname, {})
             bucket[arg] = v
+
         return populate
 
     def __exit__(self, exc_type, exc_val, exc_tb):
@@ -454,15 +491,18 @@ def __exit__(self, exc_type, exc_val, exc_tb):
                     tool._setup()
 
     def register(self, point, **kwargs):
-        """
+        """Register a hook point handler in the toolbox.
+
         Return a decorator which registers the function
         at the given hook point.
         """
+
         def decorator(func):
             attr_name = kwargs.get('name', func.__name__)
             tool = Tool(point, func, **kwargs)
             setattr(self, attr_name, tool)
             return func
+
         return decorator
 
 
diff --git a/cherrypy/_cptree.py b/cherrypy/_cptree.py
index 917c5b1aa..e58344a82 100644
--- a/cherrypy/_cptree.py
+++ b/cherrypy/_cptree.py
@@ -10,19 +10,22 @@
 class Application(object):
     """A CherryPy Application.
 
-    Servers and gateways should not instantiate Request objects directly.
-    Instead, they should ask an Application object for a request object.
+    Servers and gateways should not instantiate Request objects
+    directly. Instead, they should ask an Application object for a
+    request object.
 
-    An instance of this class may also be used as a WSGI callable
-    (WSGI application object) for itself.
+    An instance of this class may also be used as a WSGI callable (WSGI
+    application object) for itself.
     """
 
     root = None
-    """The top-most container of page handlers for this app. Handlers should
-    be arranged in a hierarchy of attributes, matching the expected URI
-    hierarchy; the default dispatcher then searches this hierarchy for a
-    matching handler. When using a dispatcher other than the default,
-    this value may be None."""
+    """The top-most container of page handlers for this app.
+
+    Handlers should be arranged in a hierarchy of attributes, matching
+    the expected URI hierarchy; the default dispatcher then searches
+    this hierarchy for a matching handler. When using a dispatcher other
+    than the default, this value may be None.
+    """
 
     config = {}
     """A dict of {path: pathconf} pairs, where 'pathconf' is itself a dict
@@ -32,10 +35,16 @@ class Application(object):
     toolboxes = {'tools': cherrypy.tools}
 
     log = None
-    """A LogManager instance. See _cplogging."""
+    """A LogManager instance.
+
+    See _cplogging.
+    """
 
     wsgiapp = None
-    """A CPWSGIApp instance. See _cpwsgi."""
+    """A CPWSGIApp instance.
+
+    See _cpwsgi.
+    """
 
     request_class = _cprequest.Request
     response_class = _cprequest.Response
@@ -59,8 +68,12 @@ def __init__(self, root, script_name='', config=None):
 
     def __repr__(self):
         """Generate a representation of the Application instance."""
-        return '%s.%s(%r, %r)' % (self.__module__, self.__class__.__name__,
-                                  self.root, self.script_name)
+        return '%s.%s(%r, %r)' % (
+            self.__module__,
+            self.__class__.__name__,
+            self.root,
+            self.script_name,
+        )
 
     script_name_doc = """The URI "mount point" for this app. A mount point
     is that portion of the URI which is constant for all URIs that are
@@ -82,12 +95,15 @@ def __repr__(self):
     def script_name(self):  # noqa: D401; irrelevant for properties
         """The URI "mount point" for this app.
 
-        A mount point is that portion of the URI which is constant for all URIs
-        that are serviced by this application; it does not include scheme,
-        host, or proxy ("virtual host") portions of the URI.
+        A mount point is that portion of the URI which is constant for
+        all URIs that are serviced by this application; it does not
+        include scheme, host, or proxy ("virtual host") portions of the
+        URI.
+
+        For example, if script_name is "/my/cool/app", then the URL "
 
-        For example, if script_name is "/my/cool/app", then the URL
-        "http://www.example.com/my/cool/app/page1" might be handled by a
+        http://www.example.com/my/cool/app/page1"
+        might be handled by a
         "page1" method on the root object.
 
         The value of script_name MUST NOT end in a slash. If the script_name
@@ -171,9 +187,9 @@ def __call__(self, environ, start_response):
 class Tree(object):
     """A registry of CherryPy applications, mounted at diverse points.
 
-    An instance of this class may also be used as a WSGI callable
-    (WSGI application object), in which case it dispatches to all
-    mounted apps.
+    An instance of this class may also be used as a WSGI callable (WSGI
+    application object), in which case it dispatches to all mounted
+    apps.
     """
 
     apps = {}
@@ -215,7 +231,8 @@ def mount(self, root, script_name='', config=None):
                 'objects may, however, possess a script_name of None (in '
                 'order to inpect the WSGI environ for SCRIPT_NAME upon each '
                 'request). You cannot mount such Applications on this Tree; '
-                'you must pass them to a WSGI server interface directly.')
+                'you must pass them to a WSGI server interface directly.',
+            )
 
         # Next line both 1) strips trailing slash and 2) maps "/" -> "".
         script_name = script_name.rstrip('/')
@@ -225,7 +242,8 @@ def mount(self, root, script_name='', config=None):
             if script_name != '' and script_name != app.script_name:
                 raise ValueError(
                     'Cannot specify a different script name and pass an '
-                    'Application instance to cherrypy.mount')
+                    'Application instance to cherrypy.mount',
+                )
             script_name = app.script_name
         else:
             app = Application(root, script_name)
@@ -265,8 +283,7 @@ def script_name(self, path=None):
         if path is None:
             try:
                 request = cherrypy.serving.request
-                path = httputil.urljoin(request.script_name,
-                                        request.path_info)
+                path = httputil.urljoin(request.script_name, request.path_info)
             except AttributeError:
                 return None
 
@@ -278,7 +295,7 @@ def script_name(self, path=None):
                 return None
 
             # Move one node up the tree and try again.
-            path = path[:path.rfind('/')]
+            path = path[: path.rfind('/')]
 
     def __call__(self, environ, start_response):
         """Pre-initialize WSGI env and call WSGI-callable."""
@@ -286,8 +303,10 @@ def __call__(self, environ, start_response):
         # to '' (some WSGI servers always set SCRIPT_NAME to '').
         # Try to look up the app using the full path.
         env1x = environ
-        path = httputil.urljoin(env1x.get('SCRIPT_NAME', ''),
-                                env1x.get('PATH_INFO', ''))
+        path = httputil.urljoin(
+            env1x.get('SCRIPT_NAME', ''),
+            env1x.get('PATH_INFO', ''),
+        )
         sn = self.script_name(path or '/')
         if sn is None:
             start_response('404 Not Found', [])
@@ -298,5 +317,5 @@ def __call__(self, environ, start_response):
         # Correct the SCRIPT_NAME and PATH_INFO environ entries.
         environ = environ.copy()
         environ['SCRIPT_NAME'] = sn
-        environ['PATH_INFO'] = path[len(sn.rstrip('/')):]
+        environ['PATH_INFO'] = path[len(sn.rstrip('/')) :]
         return app(environ, start_response)
diff --git a/cherrypy/_cpwsgi.py b/cherrypy/_cpwsgi.py
index b4f55fd6a..e38c7f56d 100644
--- a/cherrypy/_cpwsgi.py
+++ b/cherrypy/_cpwsgi.py
@@ -1,10 +1,10 @@
 """WSGI interface (see PEP 333 and 3333).
 
 Note that WSGI environ keys and values are 'native strings'; that is,
-whatever the type of "" is. For Python 2, that's a byte string; for Python 3,
-it's a unicode string. But PEP 3333 says: "even if Python's str type is
-actually Unicode "under the hood", the content of native strings must
-still be translatable to bytes via the Latin-1 encoding!"
+whatever the type of "" is. For Python 2, that's a byte string; for
+Python 3, it's a unicode string. But PEP 3333 says: "even if Python's
+str type is actually Unicode "under the hood", the content of native
+strings must still be translatable to bytes via the Latin-1 encoding!"
 """
 
 import sys as _sys
@@ -18,8 +18,7 @@
 
 
 def downgrade_wsgi_ux_to_1x(environ):
-    """Return a new environ dict for WSGI 1.x from the given WSGI u.x environ.
-    """
+    """Return new environ dict for WSGI 1.x from provided WSGI u.x environ."""
     env1x = {}
 
     url_encoding = environ[ntou('wsgi.url_encoding')]
@@ -34,7 +33,6 @@ def downgrade_wsgi_ux_to_1x(environ):
 
 
 class VirtualHost(object):
-
     """Select a different WSGI application based on the Host header.
 
     This can be useful when running multiple sites within one CP server.
@@ -55,8 +53,12 @@ class VirtualHost(object):
 
         cherrypy.tree.graft(vhost)
     """
+
     default = None
-    """Required. The default WSGI application."""
+    """The default WSGI application.
+
+    Required.
+    """
 
     use_x_forwarded_host = True
     """If True (the default), any "X-Forwarded-Host"
@@ -65,19 +67,38 @@ class VirtualHost(object):
 
     domains = {}
     """A dict of {host header value: application} pairs.
-    The incoming "Host" request header is looked up in this dict,
-    and, if a match is found, the corresponding WSGI application
-    will be called instead of the default. Note that you often need
-    separate entries for "example.com" and "www.example.com".
-    In addition, "Host" headers may contain the port number.
+    The incoming "Host" request header is looked up in this dict, and,
+    if a match is found, the corresponding WSGI application will be
+    called instead of the default. Note that you often need separate
+    entries for "example.com" and "www.example.com". In addition, "Host"
+    headers may contain the port number.
     """
 
     def __init__(self, default, domains=None, use_x_forwarded_host=True):
+        """
+        Initialize a virtual host app.
+
+        :param default: The default WSGI application
+        :type default: WSGI application
+        :param use_x_forwarded_host: If True (the default), any
+            "X-Forwarded-Host" request header will be used instead of the
+            "Host" header. This is commonly added by HTTP servers (such as
+            Apache) when proxying.
+        :type use_x_forwarded_host: Bool, optional
+        :param domains: A dict of {host header value: application} pairs.
+            The incoming "Host" request header is looked up in this dict, and,
+            if a match is found, the corresponding WSGI application will be
+            called instead of the default. Note that you often need separate
+            entries for "example.com" and "www.example.com". In addition,
+            "Host" headers may contain the port number.
+        :type domains: Dict, optional
+        """
         self.default = default
         self.domains = domains or {}
         self.use_x_forwarded_host = use_x_forwarded_host
 
     def __call__(self, environ, start_response):
+        """Route WSGI requests based on host names."""
         domain = environ.get('HTTP_HOST', '')
         if self.use_x_forwarded_host:
             domain = environ.get('HTTP_X_FORWARDED_HOST', domain)
@@ -89,14 +110,15 @@ def __call__(self, environ, start_response):
 
 
 class InternalRedirector(object):
-
     """WSGI middleware that handles raised cherrypy.InternalRedirect."""
 
     def __init__(self, nextapp, recursive=False):
+        """Initialize an internal redirector."""
         self.nextapp = nextapp
         self.recursive = recursive
 
     def __call__(self, environ, start_response):
+        """Process internal WSGI request redirects."""
         redirections = []
         while True:
             environ = environ.copy()
@@ -137,24 +159,24 @@ def __call__(self, environ, start_response):
 
 
 class ExceptionTrapper(object):
-
     """WSGI middleware that traps exceptions."""
 
     def __init__(self, nextapp, throws=(KeyboardInterrupt, SystemExit)):
+        """Initialize exception trapper."""
         self.nextapp = nextapp
         self.throws = throws
 
     def __call__(self, environ, start_response):
+        """Handle exceptions while processing a WSGI request."""
         return _TrappedResponse(
             self.nextapp,
             environ,
             start_response,
-            self.throws
+            self.throws,
         )
 
 
 class _TrappedResponse(object):
-
     response = iter([])
 
     def __init__(self, nextapp, environ, start_response, throws):
@@ -164,7 +186,9 @@ def __init__(self, nextapp, environ, start_response, throws):
         self.throws = throws
         self.started_response = False
         self.response = self.trap(
-            self.nextapp, self.environ, self.start_response,
+            self.nextapp,
+            self.environ,
+            self.start_response,
         )
         self.iter_response = iter(self.response)
 
@@ -226,10 +250,10 @@ def trap(self, func, *args, **kwargs):
 
 
 class AppResponse(object):
-
     """WSGI response iterable for CherryPy applications."""
 
     def __init__(self, environ, start_response, cpapp):
+        """Initialize the WSGI app response."""
         self.cpapp = cpapp
         try:
             self.environ = environ
@@ -271,13 +295,18 @@ def __init__(self, environ, start_response, cpapp):
             raise
 
     def __iter__(self):
+        """Make an app response iterator."""
         return self
 
     def __next__(self):
+        """Iterate over the app response."""
         return next(self.iter_response)
 
     def close(self):
-        """Close and de-reference the current request and response. (Core)"""
+        """Close and de-reference the current request and response.
+
+        (Core)
+        """
         streaming = _cherrypy.serving.response.stream
         self.cpapp.release_serving()
 
@@ -343,13 +372,15 @@ def run(self):
     }
 
     def recode_path_qs(self, path, qs):
+        """Recode app response path query string."""
         # This isn't perfect; if the given PATH_INFO is in the
         # wrong encoding, it may fail to match the appropriate config
         # section URI. But meh.
         old_enc = self.environ.get('wsgi.url_encoding', 'ISO-8859-1')
         new_enc = self.cpapp.find_config(
             self.environ.get('PATH_INFO', ''),
-            'request.uri_encoding', 'utf-8',
+            'request.uri_encoding',
+            'utf-8',
         )
         if new_enc.lower() == old_enc.lower():
             return
@@ -380,18 +411,20 @@ def translate_headers(self, environ):
 
 
 class CPWSGIApp(object):
-
     """A WSGI application object for a CherryPy Application."""
 
     pipeline = [
         ('ExceptionTrapper', ExceptionTrapper),
         ('InternalRedirector', InternalRedirector),
     ]
-    """A list of (name, wsgiapp) pairs. Each 'wsgiapp' MUST be a
-    constructor that takes an initial, positional 'nextapp' argument,
-    plus optional keyword arguments, and returns a WSGI application
-    (that takes environ and start_response arguments). The 'name' can
-    be any you choose, and will correspond to keys in self.config."""
+    """A list of (name, wsgiapp) pairs.
+
+    Each 'wsgiapp' MUST be a constructor that takes an initial,
+    positional 'nextapp' argument, plus optional keyword arguments, and
+    returns a WSGI application (that takes environ and start_response
+    arguments). The 'name' can be any you choose, and will correspond to
+    keys in self.config.
+    """
 
     head = None
     """Rather than nest all apps in the pipeline on each call, it's only
@@ -399,15 +432,19 @@ class CPWSGIApp(object):
     this to None again if you change self.pipeline after calling self."""
 
     config = {}
-    """A dict whose keys match names listed in the pipeline. Each
-    value is a further dict which will be passed to the corresponding
-    named WSGI callable (from the pipeline) as keyword arguments."""
+    """A dict whose keys match names listed in the pipeline.
+
+    Each value is a further dict which will be passed to the
+    corresponding named WSGI callable (from the pipeline) as keyword
+    arguments.
+    """
 
     response_class = AppResponse
     """The class to instantiate and return as the next app in the WSGI chain.
     """
 
     def __init__(self, cpapp, pipeline=None):
+        """Initialize a framework WSGI app wrapper."""
         self.cpapp = cpapp
         self.pipeline = self.pipeline[:]
         if pipeline:
@@ -417,12 +454,13 @@ def __init__(self, cpapp, pipeline=None):
     def tail(self, environ, start_response):
         """WSGI application callable for the actual CherryPy application.
 
-        You probably shouldn't call this; call self.__call__ instead,
-        so that any WSGI middleware in self.pipeline can run first.
+        You probably shouldn't call this; call self.__call__ instead, so
+        that any WSGI middleware in self.pipeline can run first.
         """
         return self.response_class(environ, start_response, self.cpapp)
 
     def __call__(self, environ, start_response):
+        """Process a WSGI request."""
         head = self.head
         if head is None:
             # Create and nest the WSGI apps in our pipeline (in reverse order).
diff --git a/cherrypy/_cpwsgi_server.py b/cherrypy/_cpwsgi_server.py
index 11dd846af..75e4e96cd 100644
--- a/cherrypy/_cpwsgi_server.py
+++ b/cherrypy/_cpwsgi_server.py
@@ -1,8 +1,9 @@
-"""
-WSGI server interface (see PEP 333).
+"""WSGI server interface (see PEP 333).
 
-This adds some CP-specific bits to the framework-agnostic cheroot package.
+This adds some CP-specific bits to the framework-agnostic cheroot
+package.
 """
+
 import sys
 
 import cheroot.wsgi
@@ -27,18 +28,17 @@ def __init__(self, server, conn):
             conn (cheroot.server.HTTPConnection):
                 HTTP connection object for this request
         """
-        super(CPWSGIHTTPRequest, self).__init__(
-            server, conn, proxy_mode=True
-        )
+        super(CPWSGIHTTPRequest, self).__init__(server, conn, proxy_mode=True)
 
 
 class CPWSGIServer(cheroot.wsgi.Server):
     """Wrapper for cheroot.wsgi.Server.
 
-    cheroot has been designed to not reference CherryPy in any way,
-    so that it can be used in other frameworks and applications. Therefore,
-    we wrap it here, so we can set our own mount points from cherrypy.tree
-    and apply some attributes from config -> cherrypy.server -> wsgi.Server.
+    cheroot has been designed to not reference CherryPy in any way, so
+    that it can be used in other frameworks and applications. Therefore,
+    we wrap it here, so we can set our own mount points from
+    cherrypy.tree and apply some attributes from config ->
+    cherrypy.server -> wsgi.Server.
     """
 
     fmt = 'CherryPy/{cherrypy.__version__} {cheroot.wsgi.Server.version}'
@@ -58,14 +58,17 @@ def __init__(self, server_adapter=cherrypy.server):
             self.server_adapter.max_request_body_size or 0
         )
 
-        server_name = (self.server_adapter.socket_host or
-                       self.server_adapter.socket_file or
-                       None)
+        server_name = (
+            self.server_adapter.socket_host
+            or self.server_adapter.socket_file
+            or None
+        )
 
         self.wsgi_version = self.server_adapter.wsgi_version
 
         super(CPWSGIServer, self).__init__(
-            server_adapter.bind_addr, cherrypy.tree,
+            server_adapter.bind_addr,
+            cherrypy.tree,
             self.server_adapter.thread_pool,
             server_name,
             max=self.server_adapter.thread_pool_max,
@@ -92,7 +95,8 @@ def __init__(self, server_adapter=cherrypy.server):
                 self.server_adapter.ssl_certificate,
                 self.server_adapter.ssl_private_key,
                 self.server_adapter.ssl_certificate_chain,
-                self.server_adapter.ssl_ciphers)
+                self.server_adapter.ssl_ciphers,
+            )
             self.ssl_adapter.context = self.server_adapter.ssl_context
         elif self.server_adapter.ssl_certificate:
             adapter_class = cheroot.server.get_ssl_adapter_class(ssl_module)
@@ -100,10 +104,14 @@ def __init__(self, server_adapter=cherrypy.server):
                 self.server_adapter.ssl_certificate,
                 self.server_adapter.ssl_private_key,
                 self.server_adapter.ssl_certificate_chain,
-                self.server_adapter.ssl_ciphers)
+                self.server_adapter.ssl_ciphers,
+            )
 
         self.stats['Enabled'] = getattr(
-            self.server_adapter, 'statistics', False)
+            self.server_adapter,
+            'statistics',
+            False,
+        )
 
     def error_log(self, msg='', level=20, traceback=False):
         """Write given message to the error log."""
diff --git a/cherrypy/_helper.py b/cherrypy/_helper.py
index d57cd1f96..2daca0087 100644
--- a/cherrypy/_helper.py
+++ b/cherrypy/_helper.py
@@ -12,6 +12,7 @@ def expose(func=None, alias=None):
 
     Optionally provide an alias or set of aliases.
     """
+
     def expose_(func):
         func.exposed = True
         if alias is not None:
@@ -24,7 +25,12 @@ def expose_(func):
 
     import sys
     import types
-    decoratable_types = types.FunctionType, types.MethodType, type,
+
+    decoratable_types = (
+        types.FunctionType,
+        types.MethodType,
+        type,
+    )
     if isinstance(func, decoratable_types):
         if alias is None:
             # @expose
@@ -137,7 +143,6 @@ def index(self, year):
         class Root:
             def index(self):
                 #...
-
     """
     # Since keyword arg comes after *args, we have to process it ourselves
     # for lower versions of python.
@@ -153,8 +158,9 @@ def index(self):
 
     import inspect
 
-    if handler is not None \
-            and (hasattr(handler, '__call__') or inspect.isclass(handler)):
+    if handler is not None and (
+        hasattr(handler, '__call__') or inspect.isclass(handler)
+    ):
         handler_call = True
 
     def decorated(cls_or_self=None, vpath=None):
@@ -201,16 +207,17 @@ def url(path='', qs='', script_name=None, base=None, relative=None):
     If it does not start with a slash, this returns
         (base + script_name [+ request.path_info] + path + qs).
 
-    If script_name is None, cherrypy.request will be used
-    to find a script_name, if available.
+    If script_name is None, cherrypy.request will be used to find a
+    script_name, if available.
 
     If base is None, cherrypy.request.base will be used (if available).
     Note that you can use cherrypy.tools.proxy to change this.
 
-    Finally, note that this function can be used to obtain an absolute URL
-    for the current request path (minus the querystring) by passing no args.
-    If you call url(qs=cherrypy.request.query_string), you should get the
-    original browser URL (assuming no internal redirections).
+    Finally, note that this function can be used to obtain an absolute
+    URL for the current request path (minus the querystring) by passing
+    no args. If you call url(qs=cherrypy.request.query_string), you
+    should get the original browser URL (assuming no internal
+    redirections).
 
     If relative is None or not provided, request.app.relative_urls will
     be used (if available, else False). If False, the output will be an
@@ -320,8 +327,8 @@ def normalize_path(path):
 class _ClassPropertyDescriptor(object):
     """Descript for read-only class-based property.
 
-    Turns a classmethod-decorated func into a read-only property of that class
-    type (means the value cannot be set).
+    Turns a classmethod-decorated func into a read-only property of that
+    class type (means the value cannot be set).
     """
 
     def __init__(self, fget, fset=None):
@@ -345,4 +352,6 @@ def classproperty(func):  # noqa: D401; irrelevant for properties
         func = classmethod(func)
 
     return _ClassPropertyDescriptor(func)
+
+
 ####
diff --git a/cherrypy/_json.py b/cherrypy/_json.py
index 0c2a0f0e0..4ef85580f 100644
--- a/cherrypy/_json.py
+++ b/cherrypy/_json.py
@@ -1,5 +1,4 @@
-"""
-JSON support.
+"""JSON support.
 
 Expose preferred json module as json and provide encode/decode
 convenience functions.
diff --git a/cherrypy/_private_api/compat/headers.py b/cherrypy/_private_api/compat/headers.py
new file mode 100644
index 000000000..a818a9f1b
--- /dev/null
+++ b/cherrypy/_private_api/compat/headers.py
@@ -0,0 +1,39 @@
+"""HTTP header parsing helpers."""
+
+
+def _parse_param(s):
+    while s[:1] == ';':
+        s = s[1:]
+        end = s.find(';')
+        while end > 0 and (s.count('"', 0, end) - s.count('\\"', 0, end)) % 2:
+            end = s.find(';', end + 1)
+        if end < 0:
+            end = len(s)
+        f = s[:end]
+        yield f.strip()
+        s = s[end:]
+
+
+def parse_header(line):
+    """Parse a ``Content-Type`` like header.
+
+    Return the main ``Content-Type`` and a dictionary of options.
+
+    Copied from removed stdlib :mod:`cgi` module. See
+    `cherrypy/cherrypy#2014 (comment)
+    <https://github.com/cherrypy/cherrypy/issues/2014#issuecomment-1883774891>`_
+    for background.
+    """
+    parts = _parse_param(';' + line)
+    key = parts.__next__()
+    pdict = {}
+    for p in parts:
+        i = p.find('=')
+        if i >= 0:
+            name = p[:i].strip().lower()
+            value = p[i + 1 :].strip()
+            if len(value) >= 2 and value[0] == value[-1] == '"':
+                value = value[1:-1]
+                value = value.replace('\\\\', '\\').replace('\\"', '"')
+            pdict[name] = value
+    return key, pdict
diff --git a/cherrypy/daemon.py b/cherrypy/daemon.py
index 74488c06b..af8168dca 100755
--- a/cherrypy/daemon.py
+++ b/cherrypy/daemon.py
@@ -7,9 +7,16 @@
 from cherrypy import Application
 
 
-def start(configfiles=None, daemonize=False, environment=None,
-          fastcgi=False, scgi=False, pidfile=None, imports=None,
-          cgi=False):
+def start(
+    configfiles=None,
+    daemonize=False,
+    environment=None,
+    fastcgi=False,
+    scgi=False,
+    pidfile=None,
+    imports=None,
+    cgi=False,
+):
     """Subscribe all engine plugins and start the engine."""
     sys.path = [''] + sys.path
     for i in imports or []:
@@ -43,8 +50,10 @@ def start(configfiles=None, daemonize=False, environment=None,
         engine.console_control_handler.subscribe()
 
     if (fastcgi and (scgi or cgi)) or (scgi and cgi):
-        cherrypy.log.error('You may only specify one of the cgi, fastcgi, and '
-                           'scgi options.', 'ENGINE')
+        cherrypy.log.error(
+            'You may only specify one of the cgi, fastcgi, and scgi options.',
+            'ENGINE',
+        )
         sys.exit(1)
     elif fastcgi or scgi or cgi:
         # Turn off autoreload when using *cgi.
@@ -54,9 +63,11 @@ def start(configfiles=None, daemonize=False, environment=None,
 
         addr = cherrypy.server.bind_addr
         cls = (
-            servers.FlupFCGIServer if fastcgi else
-            servers.FlupSCGIServer if scgi else
-            servers.FlupCGIServer
+            servers.FlupFCGIServer
+            if fastcgi
+            else servers.FlupSCGIServer
+            if scgi
+            else servers.FlupCGIServer
         )
         f = cls(application=cherrypy.tree, bindAddress=addr)
         s = servers.ServerAdapter(engine, httpserver=f, bind_addr=addr)
@@ -77,31 +88,78 @@ def run():
     from optparse import OptionParser
 
     p = OptionParser()
-    p.add_option('-c', '--config', action='append', dest='config',
-                 help='specify config file(s)')
-    p.add_option('-d', action='store_true', dest='daemonize',
-                 help='run the server as a daemon')
-    p.add_option('-e', '--environment', dest='environment', default=None,
-                 help='apply the given config environment')
-    p.add_option('-f', action='store_true', dest='fastcgi',
-                 help='start a fastcgi server instead of the default HTTP '
-                      'server')
-    p.add_option('-s', action='store_true', dest='scgi',
-                 help='start a scgi server instead of the default HTTP server')
-    p.add_option('-x', action='store_true', dest='cgi',
-                 help='start a cgi server instead of the default HTTP server')
-    p.add_option('-i', '--import', action='append', dest='imports',
-                 help='specify modules to import')
-    p.add_option('-p', '--pidfile', dest='pidfile', default=None,
-                 help='store the process id in the given file')
-    p.add_option('-P', '--Path', action='append', dest='Path',
-                 help='add the given paths to sys.path')
+    p.add_option(
+        '-c',
+        '--config',
+        action='append',
+        dest='config',
+        help='specify config file(s)',
+    )
+    p.add_option(
+        '-d',
+        action='store_true',
+        dest='daemonize',
+        help='run the server as a daemon',
+    )
+    p.add_option(
+        '-e',
+        '--environment',
+        dest='environment',
+        default=None,
+        help='apply the given config environment',
+    )
+    p.add_option(
+        '-f',
+        action='store_true',
+        dest='fastcgi',
+        help='start a fastcgi server instead of the default HTTP server',
+    )
+    p.add_option(
+        '-s',
+        action='store_true',
+        dest='scgi',
+        help='start a scgi server instead of the default HTTP server',
+    )
+    p.add_option(
+        '-x',
+        action='store_true',
+        dest='cgi',
+        help='start a cgi server instead of the default HTTP server',
+    )
+    p.add_option(
+        '-i',
+        '--import',
+        action='append',
+        dest='imports',
+        help='specify modules to import',
+    )
+    p.add_option(
+        '-p',
+        '--pidfile',
+        dest='pidfile',
+        default=None,
+        help='store the process id in the given file',
+    )
+    p.add_option(
+        '-P',
+        '--Path',
+        action='append',
+        dest='Path',
+        help='add the given paths to sys.path',
+    )
     options, args = p.parse_args()
 
     if options.Path:
         for p in options.Path:
             sys.path.insert(0, p)
 
-    start(options.config, options.daemonize,
-          options.environment, options.fastcgi, options.scgi,
-          options.pidfile, options.imports, options.cgi)
+    start(
+        options.config,
+        options.daemonize,
+        options.environment,
+        options.fastcgi,
+        options.scgi,
+        options.pidfile,
+        options.imports,
+        options.cgi,
+    )
diff --git a/cherrypy/lib/__init__.py b/cherrypy/lib/__init__.py
index f815f76ad..7abb75a01 100644
--- a/cherrypy/lib/__init__.py
+++ b/cherrypy/lib/__init__.py
@@ -6,10 +6,11 @@ def is_iterator(obj):
 
     (i.e. like a generator).
 
-    This will return False for objects which are iterable,
-    but not iterators themselves.
+    This will return False for objects which are iterable, but not
+    iterators themselves.
     """
     from types import GeneratorType
+
     if isinstance(obj, GeneratorType):
         return True
     elif not hasattr(obj, '__iter__'):
@@ -28,6 +29,7 @@ def is_closable_iterator(obj):
 
     # A generator - the easiest thing to deal with.
     import inspect
+
     if inspect.isgenerator(obj):
         return True
 
@@ -68,8 +70,14 @@ def __next__(self):
             if hasattr(self.input, 'close'):
                 self.input.close()
             raise StopIteration()
+
     next = __next__
 
+    def __del__(self):
+        """Close input on descturct."""
+        if hasattr(self.input, 'close'):
+            self.input.close()
+
 
 def file_generator_limited(fileobj, count, chunk_size=65536):
     """Yield the given file object in chunks.
diff --git a/cherrypy/lib/auth_basic.py b/cherrypy/lib/auth_basic.py
index ad379a260..41f2eeea2 100644
--- a/cherrypy/lib/auth_basic.py
+++ b/cherrypy/lib/auth_basic.py
@@ -1,4 +1,4 @@
-# This file is part of CherryPy <http://www.cherrypy.org/>
+# This file is part of CherryPy <http://www.cherrypy.dev/>
 # -*- coding: utf-8 -*-
 # vim:ts=4:sw=4:expandtab:fileencoding=utf-8
 """HTTP Basic Authentication tool.
@@ -18,7 +18,6 @@
                   'tools.auth_basic.accept_charset': 'UTF-8',
     }
     app_config = { '/' : basic_auth }
-
 """
 
 import binascii
@@ -34,13 +33,16 @@
 
 
 def checkpassword_dict(user_password_dict):
-    """Returns a checkpassword function which checks credentials
+    """Check credentials against a dictionary.
+
+    Returns a checkpassword function which checks credentials
     against a dictionary of the form: {username : password}.
 
     If you want a simple dictionary-based authentication scheme, use
     checkpassword_dict(my_credentials_dict) as the value for the
     checkpassword argument to basic_auth().
     """
+
     def checkpassword(realm, user, password):
         p = user_password_dict.get(user)
         return p and p == password or False
@@ -49,7 +51,9 @@ def checkpassword(realm, user, password):
 
 
 def basic_auth(realm, checkpassword, debug=False, accept_charset='utf-8'):
-    """A CherryPy tool which hooks at before_handler to perform
+    """Perform basic auth.
+
+    A CherryPy tool which hooks at before_handler to perform
     HTTP Basic Access Authentication, as specified in :rfc:`2617`
     and :rfc:`7617`.
 
@@ -70,7 +74,6 @@ def basic_auth(realm, checkpassword, debug=False, accept_charset='utf-8'):
         returns True, else it returns False.
 
     """
-
     fallback_charset = 'ISO-8859-1'
 
     if '"' in realm:
@@ -99,16 +102,16 @@ def basic_auth(realm, checkpassword, debug=False, accept_charset='utf-8'):
 
     charset = accept_charset.upper()
     charset_declaration = (
-        (', charset="%s"' % charset)
-        if charset != fallback_charset
-        else ''
+        (', charset="%s"' % charset) if charset != fallback_charset else ''
     )
     # Respond with 401 status and a WWW-Authenticate header
     cherrypy.serving.response.headers['www-authenticate'] = (
         'Basic realm="%s"%s' % (realm, charset_declaration)
     )
     raise cherrypy.HTTPError(
-        401, 'You are not authorized to access that resource')
+        401,
+        'You are not authorized to access that resource',
+    )
 
 
 def _try_decode(subject, charsets):
diff --git a/cherrypy/lib/auth_digest.py b/cherrypy/lib/auth_digest.py
index fbb5df64a..790bf96c9 100644
--- a/cherrypy/lib/auth_digest.py
+++ b/cherrypy/lib/auth_digest.py
@@ -1,4 +1,4 @@
-# This file is part of CherryPy <http://www.cherrypy.org/>
+# This file is part of CherryPy <http://www.cherrypy.dev/>
 # -*- coding: utf-8 -*-
 # vim:ts=4:sw=4:expandtab:fileencoding=utf-8
 """HTTP Digest Authentication tool.
@@ -34,6 +34,7 @@
 
 
 def md5_hex(s):
+    """Return hexdigest of md5sum."""
     return md5(ntob(s, 'utf-8')).hexdigest()
 
 
@@ -48,20 +49,24 @@ def md5_hex(s):
 
 
 def TRACE(msg):
+    """Log message in TOOLS.AUTH_DIGEST context."""
     cherrypy.log(msg, context='TOOLS.AUTH_DIGEST')
 
+
 # Three helper functions for users of the tool, providing three variants
 # of get_ha1() functions for three different kinds of credential stores.
 
 
 def get_ha1_dict_plain(user_password_dict):
-    """Returns a get_ha1 function which obtains a plaintext password from a
-    dictionary of the form: {username : password}.
+    """Return a get_ha1 function which obtains a plaintext password.
+
+    user_password_dict is a dictionary of the form: {username : password}.
 
     If you want a simple dictionary-based authentication scheme, with plaintext
     passwords, use get_ha1_dict_plain(my_userpass_dict) as the value for the
     get_ha1 argument to digest_auth().
     """
+
     def get_ha1(realm, username):
         password = user_password_dict.get(username)
         if password:
@@ -72,14 +77,16 @@ def get_ha1(realm, username):
 
 
 def get_ha1_dict(user_ha1_dict):
-    """Returns a get_ha1 function which obtains a HA1 password hash from a
-    dictionary of the form: {username : HA1}.
+    """Return a get_ha1 function which obtains a HA1 password hash.
+
+    user_ha1_dict is a dictionary of the form: {username : HA1}.
 
     If you want a dictionary-based authentication scheme, but with
     pre-computed HA1 hashes instead of plain-text passwords, use
     get_ha1_dict(my_userha1_dict) as the value for the get_ha1
     argument to digest_auth().
     """
+
     def get_ha1(realm, username):
         return user_ha1_dict.get(username)
 
@@ -87,7 +94,9 @@ def get_ha1(realm, username):
 
 
 def get_ha1_file_htdigest(filename):
-    """Returns a get_ha1 function which obtains a HA1 password hash from a
+    """Return a get_ha1 function.
+
+    The returned function obtains a HA1 password hash from a
     flat file with lines of the same format as that produced by the Apache
     htdigest utility. For example, for realm 'wonderland', username 'alice',
     and password '4x5istwelve', the htdigest line would be::
@@ -99,22 +108,24 @@ def get_ha1_file_htdigest(filename):
     get_ha1 argument to digest_auth().  It is recommended that the filename
     argument be an absolute path, to avoid problems.
     """
+
     def get_ha1(realm, username):
         result = None
-        f = open(filename, 'r')
-        for line in f:
-            u, r, ha1 = line.rstrip().split(':')
-            if u == username and r == realm:
-                result = ha1
-                break
-        f.close()
+        with open(filename, 'r') as f:
+            for line in f:
+                u, r, ha1 = line.rstrip().split(':')
+                if u == username and r == realm:
+                    result = ha1
+                    break
         return result
 
     return get_ha1
 
 
 def synthesize_nonce(s, key, timestamp=None):
-    """Synthesize a nonce value which resists spoofing and can be checked
+    """Synthesize a nonce value.
+
+    A nonce value resists spoofing and can be checked
     for staleness. Returns a string suitable as the value for 'nonce' in
     the www-authenticate header.
 
@@ -136,7 +147,7 @@ def synthesize_nonce(s, key, timestamp=None):
 
 
 def H(s):
-    """The hash function H"""
+    """Return an ``md5`` HEX hash."""
     return md5_hex(s)
 
 
@@ -153,7 +164,8 @@ def _try_decode_header(header, charset):
 
 
 class HttpDigestAuthorization(object):
-    """
+    """Digest Authorization implementation.
+
     Parses a Digest Authorization header and performs
     re-calculation of the digest.
     """
@@ -161,17 +173,23 @@ class HttpDigestAuthorization(object):
     scheme = 'digest'
 
     def errmsg(self, s):
+        """Make an error message for HTTP Digest Authorization."""
         return 'Digest Authorization header: %s' % s
 
     @classmethod
     def matches(cls, header):
+        """Check if header scheme matches auth implementation."""
         scheme, _, _ = header.partition(' ')
         return scheme.lower() == cls.scheme
 
     def __init__(
-        self, auth_header, http_method,
-        debug=False, accept_charset=DEFAULT_CHARSET[:],
+        self,
+        auth_header,
+        http_method,
+        debug=False,
+        accept_charset=DEFAULT_CHARSET[:],
     ):
+        """Initialize an HTTP Digest Authorization parser."""
         self.http_method = http_method
         self.debug = debug
 
@@ -201,39 +219,50 @@ def __init__(
         # perform some correctness checks
         if self.algorithm not in valid_algorithms:
             raise ValueError(
-                self.errmsg("Unsupported value for algorithm: '%s'" %
-                            self.algorithm))
+                self.errmsg(
+                    "Unsupported value for algorithm: '%s'" % self.algorithm,
+                ),
+            )
 
         has_reqd = (
-            self.username and
-            self.realm and
-            self.nonce and
-            self.uri and
-            self.response
+            self.username
+            and self.realm
+            and self.nonce
+            and self.uri
+            and self.response
         )
         if not has_reqd:
             raise ValueError(
-                self.errmsg('Not all required parameters are present.'))
+                self.errmsg('Not all required parameters are present.'),
+            )
 
         if self.qop:
             if self.qop not in valid_qops:
                 raise ValueError(
-                    self.errmsg("Unsupported value for qop: '%s'" % self.qop))
+                    self.errmsg("Unsupported value for qop: '%s'" % self.qop),
+                )
             if not (self.cnonce and self.nc):
                 raise ValueError(
-                    self.errmsg('If qop is sent then '
-                                'cnonce and nc MUST be present'))
+                    self.errmsg(
+                        'If qop is sent then cnonce and nc MUST be present',
+                    ),
+                )
         else:
             if self.cnonce or self.nc:
                 raise ValueError(
-                    self.errmsg('If qop is not sent, '
-                                'neither cnonce nor nc can be present'))
+                    self.errmsg(
+                        'If qop is not sent, '
+                        'neither cnonce nor nc can be present',
+                    ),
+                )
 
     def __str__(self):
+        """Render an HTTP  Digest Auth header as a string."""
         return 'authorization : %s' % self.auth_header
 
     def validate_nonce(self, s, key):
         """Validate the nonce.
+
         Returns True if nonce was generated by synthesize_nonce() and the
         timestamp is not spoofed, else returns False.
 
@@ -250,7 +279,10 @@ def validate_nonce(self, s, key):
         try:
             timestamp, hashpart = self.nonce.split(':', 1)
             s_timestamp, s_hashpart = synthesize_nonce(
-                s, key, timestamp).split(':', 1)
+                s,
+                key,
+                timestamp,
+            ).split(':', 1)
             is_valid = s_hashpart == hashpart
             if self.debug:
                 TRACE('validate_nonce: %s' % is_valid)
@@ -260,10 +292,11 @@ def validate_nonce(self, s, key):
         return False
 
     def is_nonce_stale(self, max_age_seconds=600):
-        """Returns True if a validated nonce is stale. The nonce contains a
-        timestamp in plaintext and also a secure hash of the timestamp.
-        You should first validate the nonce to ensure the plaintext
-        timestamp is not spoofed.
+        """Return True if a validated nonce is stale.
+
+        The nonce contains a timestamp in plaintext and also a secure
+        hash of the timestamp. You should first validate the nonce to
+        ensure the plaintext timestamp is not spoofed.
         """
         try:
             timestamp, hashpart = self.nonce.split(':', 1)
@@ -276,7 +309,10 @@ def is_nonce_stale(self, max_age_seconds=600):
         return True
 
     def HA2(self, entity_body=''):
-        """Returns the H(A2) string. See :rfc:`2617` section 3.2.2.3."""
+        """Return the H(A2) string.
+
+        See :rfc:`2617` section 3.2.2.3.
+        """
         # RFC 2617 3.2.2.3
         # If the "qop" directive's value is "auth" or is unspecified,
         # then A2 is:
@@ -295,7 +331,7 @@ def HA2(self, entity_body=''):
         return H(a2)
 
     def request_digest(self, ha1, entity_body=''):
-        """Calculates the Request-Digest. See :rfc:`2617` section 3.2.2.1.
+        """Calculate the Request-Digest. See :rfc:`2617` section 3.2.2.1.
 
         ha1
             The HA1 string obtained from the credentials store.
@@ -307,13 +343,17 @@ def request_digest(self, ha1, entity_body=''):
             4.3.  This refers to the entity the user agent sent in the
             request which has the Authorization header. Typically GET
             requests don't have an entity, and POST requests do.
-
         """
         ha2 = self.HA2(entity_body)
         # Request-Digest -- RFC 2617 3.2.2.1
         if self.qop:
             req = '%s:%s:%s:%s:%s' % (
-                self.nonce, self.nc, self.cnonce, self.qop, ha2)
+                self.nonce,
+                self.nc,
+                self.cnonce,
+                self.qop,
+                ha2,
+            )
         else:
             req = '%s:%s' % (self.nonce, ha2)
 
@@ -338,18 +378,19 @@ def request_digest(self, ha1, entity_body=''):
 def _get_charset_declaration(charset):
     global FALLBACK_CHARSET
     charset = charset.upper()
-    return (
-        (', charset="%s"' % charset)
-        if charset != FALLBACK_CHARSET
-        else ''
-    )
+    return (', charset="%s"' % charset) if charset != FALLBACK_CHARSET else ''
 
 
 def www_authenticate(
-    realm, key, algorithm='MD5', nonce=None, qop=qop_auth,
-    stale=False, accept_charset=DEFAULT_CHARSET[:],
+    realm,
+    key,
+    algorithm='MD5',
+    nonce=None,
+    qop=qop_auth,
+    stale=False,
+    accept_charset=DEFAULT_CHARSET[:],
 ):
-    """Constructs a WWW-Authenticate header for Digest authentication."""
+    """Construct a WWW-Authenticate header for Digest authentication."""
     if qop not in valid_qops:
         raise ValueError("Unsupported value for qop: '%s'" % qop)
     if algorithm not in valid_algorithms:
@@ -367,12 +408,19 @@ def www_authenticate(
     charset_declaration = _get_charset_declaration(accept_charset)
 
     return HEADER_PATTERN % (
-        realm, nonce, algorithm, qop, stale_param, charset_declaration,
+        realm,
+        nonce,
+        algorithm,
+        qop,
+        stale_param,
+        charset_declaration,
     )
 
 
 def digest_auth(realm, get_ha1, key, debug=False, accept_charset='utf-8'):
-    """A CherryPy tool that hooks at before_handler to perform
+    """Perform HTTP Digest Access Authentication.
+
+    A CherryPy tool that hooks at ``before_handler`` to perform
     HTTP Digest Access Authentication, as specified in :rfc:`2617`.
 
     If the request has an 'authorization' header with a 'Digest' scheme,
@@ -396,14 +444,18 @@ def digest_auth(realm, get_ha1, key, debug=False, accept_charset='utf-8'):
     key
         A secret string known only to the server, used in the synthesis
         of nonces.
-
     """
     request = cherrypy.serving.request
 
     auth_header = request.headers.get('authorization')
 
     respond_401 = functools.partial(
-        _respond_401, realm, key, accept_charset, debug)
+        _respond_401,
+        realm,
+        key,
+        accept_charset,
+        debug,
+    )
 
     if not HttpDigestAuthorization.matches(auth_header or ''):
         respond_401()
@@ -411,8 +463,10 @@ def digest_auth(realm, get_ha1, key, debug=False, accept_charset='utf-8'):
     msg = 'The Authorization header could not be parsed.'
     with cherrypy.HTTPError.handle(ValueError, 400, msg):
         auth = HttpDigestAuthorization(
-            auth_header, request.method,
-            debug=debug, accept_charset=accept_charset,
+            auth_header,
+            request.method,
+            debug=debug,
+            accept_charset=accept_charset,
         )
 
     if debug:
@@ -448,16 +502,17 @@ def digest_auth(realm, get_ha1, key, debug=False, accept_charset='utf-8'):
 
 
 def _respond_401(realm, key, accept_charset, debug, **kwargs):
-    """
-    Respond with 401 status and a WWW-Authenticate header
-    """
+    """Respond with 401 status and a WWW-Authenticate header."""
     header = www_authenticate(
-        realm, key,
+        realm,
+        key,
         accept_charset=accept_charset,
-        **kwargs
+        **kwargs,
     )
     if debug:
         TRACE(header)
     cherrypy.serving.response.headers['WWW-Authenticate'] = header
     raise cherrypy.HTTPError(
-        401, 'You are not authorized to access that resource')
+        401,
+        'You are not authorized to access that resource',
+    )
diff --git a/cherrypy/lib/caching.py b/cherrypy/lib/caching.py
index 08d2d8e4a..61176fee9 100644
--- a/cherrypy/lib/caching.py
+++ b/cherrypy/lib/caching.py
@@ -1,4 +1,6 @@
 """
+CherryPy cache tooling.
+
 CherryPy implements a simple caching system as a pluggable Tool. This tool
 tries to be an (in-process) HTTP/1.1-compliant cache. It's not quite there
 yet, but it's probably good enough for most sites.
@@ -42,7 +44,6 @@
 
 
 class Cache(object):
-
     """Base class for Cache implementations."""
 
     def get(self):
@@ -64,17 +65,16 @@ def clear(self):
 
 # ------------------------------ Memory Cache ------------------------------- #
 class AntiStampedeCache(dict):
-
     """A storage system for cached items which reduces stampede collisions."""
 
     def wait(self, key, timeout=5, debug=False):
         """Return the cached value for the given key, or None.
 
-        If timeout is not None, and the value is already
-        being calculated by another thread, wait until the given timeout has
-        elapsed. If the value is available before the timeout expires, it is
-        returned. If not, None is returned, and a sentinel placed in the cache
-        to signal other threads to wait.
+        If timeout is not None, and the value is already being
+        calculated by another thread, wait until the given timeout has
+        elapsed. If the value is available before the timeout expires,
+        it is returned. If not, None is returned, and a sentinel placed
+        in the cache to signal other threads to wait.
 
         If timeout is None, no waiting is performed nor sentinels used.
         """
@@ -88,8 +88,10 @@ def wait(self, key, timeout=5, debug=False):
 
             # Wait until it's done or times out.
             if debug:
-                cherrypy.log('Waiting up to %s seconds' %
-                             timeout, 'TOOLS.CACHING')
+                cherrypy.log(
+                    'Waiting up to %s seconds' % timeout,
+                    'TOOLS.CACHING',
+                )
             value.wait(timeout)
             if value.result is not None:
                 # The other thread finished its calculation. Use it.
@@ -127,7 +129,6 @@ def __setitem__(self, key, value):
 
 
 class MemoryCache(Cache):
-
     """An in-memory cache for varying response content.
 
     Each key in self.store is a URI, and each value is an AntiStampedeCache.
@@ -164,6 +165,7 @@ class MemoryCache(Cache):
     debug = False
 
     def __init__(self):
+        """Initialize in-memory cache store."""
         self.clear()
 
         # Run self.expire_cache in a separate daemon thread.
@@ -219,11 +221,14 @@ def get(self):
         if uricache is None:
             return None
 
-        header_values = [request.headers.get(h, '')
-                         for h in uricache.selecting_headers]
-        variant = uricache.wait(key=tuple(sorted(header_values)),
-                                timeout=self.antistampede_timeout,
-                                debug=self.debug)
+        header_values = [
+            request.headers.get(h, '') for h in uricache.selecting_headers
+        ]
+        variant = uricache.wait(
+            key=tuple(sorted(header_values)),
+            timeout=self.antistampede_timeout,
+            debug=self.debug,
+        )
         if variant is not None:
             self.tot_hist += 1
         return variant
@@ -238,22 +243,25 @@ def put(self, variant, size):
         if uricache is None:
             uricache = AntiStampedeCache()
             uricache.selecting_headers = [
-                e.value for e in response.headers.elements('Vary')]
+                e.value for e in response.headers.elements('Vary')
+            ]
             self.store[uri] = uricache
 
         if len(self.store) < self.maxobjects:
             total_size = self.cursize + size
 
             # checks if there's space for the object
-            if (size < self.maxobj_size and total_size < self.maxsize):
+            if size < self.maxobj_size and total_size < self.maxsize:
                 # add to the expirations list
                 expiration_time = response.time + self.delay
                 bucket = self.expirations.setdefault(expiration_time, [])
                 bucket.append((size, uri, uricache.selecting_headers))
 
                 # add to the cache
-                header_values = [request.headers.get(h, '')
-                                 for h in uricache.selecting_headers]
+                header_values = [
+                    request.headers.get(h, '')
+                    for h in uricache.selecting_headers
+                ]
                 uricache[tuple(sorted(header_values))] = variant
                 self.tot_puts += 1
                 self.cursize = total_size
@@ -303,8 +311,11 @@ def get(invalid_methods=('POST', 'PUT', 'DELETE'), debug=False, **kwargs):
     # See http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.10.
     if request.method in invalid_methods:
         if debug:
-            cherrypy.log('request.method %r in invalid_methods %r' %
-                         (request.method, invalid_methods), 'TOOLS.CACHING')
+            cherrypy.log(
+                'request.method %r in invalid_methods %r'
+                % (request.method, invalid_methods),
+                'TOOLS.CACHING',
+            )
         cherrypy._cache.delete()
         request.cached = False
         request.cacheable = False
@@ -327,14 +338,17 @@ def get(invalid_methods=('POST', 'PUT', 'DELETE'), debug=False, **kwargs):
             if directive == 'max-age':
                 if len(atoms) != 1 or not atoms[0].isdigit():
                     raise cherrypy.HTTPError(
-                        400, 'Invalid Cache-Control header')
+                        400,
+                        'Invalid Cache-Control header',
+                    )
                 max_age = int(atoms[0])
                 break
             elif directive == 'no-cache':
                 if debug:
                     cherrypy.log(
                         'Ignoring cache due to Cache-Control: no-cache',
-                        'TOOLS.CACHING')
+                        'TOOLS.CACHING',
+                    )
                 request.cached = False
                 request.cacheable = True
                 return False
@@ -343,10 +357,12 @@ def get(invalid_methods=('POST', 'PUT', 'DELETE'), debug=False, **kwargs):
             cherrypy.log('Reading response from cache', 'TOOLS.CACHING')
         s, h, b, create_time = cache_data
         age = int(response.time - create_time)
-        if (age > max_age):
+        if age > max_age:
             if debug:
-                cherrypy.log('Ignoring cache due to age > %d' % max_age,
-                             'TOOLS.CACHING')
+                cherrypy.log(
+                    'Ignoring cache due to age > %d' % max_age,
+                    'TOOLS.CACHING',
+                )
             request.cached = False
             request.cacheable = True
             return False
@@ -381,7 +397,10 @@ def get(invalid_methods=('POST', 'PUT', 'DELETE'), debug=False, **kwargs):
 
 
 def tee_output():
-    """Tee response output to cache storage. Internal."""
+    """Tee response output to cache storage.
+
+    Internal.
+    """
     # Used by CachingTool by attaching to request.hooks
 
     request = cherrypy.serving.request
@@ -390,8 +409,9 @@ def tee_output():
 
     def tee(body):
         """Tee response.body into a list."""
-        if ('no-cache' in response.headers.values('Pragma') or
-                'no-store' in response.headers.values('Cache-Control')):
+        if 'no-cache' in response.headers.values(
+            'Pragma',
+        ) or 'no-store' in response.headers.values('Cache-Control'):
             for chunk in body:
                 yield chunk
             return
@@ -412,8 +432,10 @@ def tee(body):
         if not body:
             cherrypy._cache.delete()
         else:
-            cherrypy._cache.put((response.status, response.headers or {},
-                                 body, response.time), len(body))
+            cherrypy._cache.put(
+                (response.status, response.headers or {}, body, response.time),
+                len(body),
+            )
 
     response = cherrypy.serving.response
     response.body = tee(response.body)
@@ -441,9 +463,7 @@ def expires(secs=0, force=False, debug=False):
             * Expires
 
         If any are already present, none of the above response headers are set.
-
     """
-
     response = cherrypy.serving.response
     headers = response.headers
 
diff --git a/cherrypy/lib/covercp.py b/cherrypy/lib/covercp.py
index 3e2197137..03b96b857 100644
--- a/cherrypy/lib/covercp.py
+++ b/cherrypy/lib/covercp.py
@@ -2,7 +2,8 @@
 
 To use this module, or the coverage tools in the test suite,
 you need to download 'coverage.py', either Gareth Rees' `original
-implementation <http://www.garethrees.org/2001/12/04/python-coverage/>`_
+implementation
+<https://web.archive.org/web/20231108042640/https://garethrees.org/2001/12/04/python-coverage/>`_
 or Ned Batchelder's `enhanced version:
 <http://www.nedbatchelder.com/code/modules/coverage.html>`_
 
@@ -22,7 +23,7 @@
 
 import re
 import sys
-import cgi
+import html
 import os
 import os.path
 import urllib.parse
@@ -35,9 +36,11 @@
 the_coverage = None
 try:
     from coverage import coverage
+
     the_coverage = coverage(data_file=localFile)
 
     def start():
+        """Start collecting coverage."""
         the_coverage.start()
 except ImportError:
     # Setting the_coverage to None will raise errors
@@ -45,12 +48,17 @@ def start():
     the_coverage = None
 
     import warnings
+
     warnings.warn(
         'No code coverage will be performed; '
-        'coverage.py could not be imported.')
+        'coverage.py could not be imported.',
+    )
 
     def start():
+        """Start collecting coverage."""
         pass
+
+
 start.priority = 20
 
 TEMPLATE_MENU = """<html>
@@ -197,9 +205,15 @@ def _percent(statements, missing):
     return 0
 
 
-def _show_branch(root, base, path, pct=0, showpct=False, exclude='',
-                 coverage=the_coverage):
-
+def _show_branch(
+    root,
+    base,
+    path,
+    pct=0,
+    showpct=False,
+    exclude='',
+    coverage=the_coverage,
+):
     # Show the directory name and any of our children
     dirs = [k for k, v in root.items() if v]
     dirs.sort()
@@ -207,23 +221,28 @@ def _show_branch(root, base, path, pct=0, showpct=False, exclude='',
         newpath = os.path.join(path, name)
 
         if newpath.lower().startswith(base):
-            relpath = newpath[len(base):]
+            relpath = newpath[len(base) :]
             yield '| ' * relpath.count(os.sep)
             yield (
                 "<a class='directory' "
-                "href='menu?base=%s&exclude=%s'>%s</a>\n" %
-                (newpath, urllib.parse.quote_plus(exclude), name)
+                "href='menu?base=%s&exclude=%s'>%s</a>\n"
+                % (newpath, urllib.parse.quote_plus(exclude), name)
             )
 
         for chunk in _show_branch(
-            root[name], base, newpath, pct, showpct,
-            exclude, coverage=coverage
+            root[name],
+            base,
+            newpath,
+            pct,
+            showpct,
+            exclude,
+            coverage=coverage,
         ):
             yield chunk
 
     # Now list the files
     if path.lower().startswith(base):
-        relpath = path[len(base):]
+        relpath = path[len(base) :]
         files = [k for k, v in root.items() if not v]
         files.sort()
         for name in files:
@@ -244,8 +263,12 @@ def _show_branch(root, base, path, pct=0, showpct=False, exclude='',
                     else:
                         pc_str = "<span class='pass'>%s</span>" % pc_str
 
-            yield TEMPLATE_ITEM % ('| ' * (relpath.count(os.sep) + 1),
-                                   pc_str, newpath, name)
+            yield TEMPLATE_ITEM % (
+                '| ' * (relpath.count(os.sep) + 1),
+                pc_str,
+                newpath,
+                name,
+            )
 
 
 def _skip_file(path, exclude):
@@ -284,8 +307,10 @@ def get_tree(base, exclude, coverage=the_coverage):
 
 
 class CoverStats(object):
+    """HTTP handler for the coverage stats."""
 
     def __init__(self, coverage, root=None):
+        """Initialize the coverage stats application."""
         self.coverage = coverage
         if root is None:
             # Guess initial depth. Files outside this path will not be
@@ -295,12 +320,18 @@ def __init__(self, coverage, root=None):
 
     @cherrypy.expose
     def index(self):
+        """Render the coverage stats index page."""
         return TEMPLATE_FRAMESET % self.root.lower()
 
     @cherrypy.expose
-    def menu(self, base='/', pct='50', showpct='',
-             exclude=r'python\d\.\d|test|tut\d|tutorial'):
-
+    def menu(
+        self,
+        base='/',
+        pct='50',
+        showpct='',
+        exclude=r'python\d\.\d|test|tut\d|tutorial',
+    ):
+        """Render HTML menu web page."""
         # The coverage module uses all-lower-case names.
         base = base.lower().rstrip(os.sep)
 
@@ -314,8 +345,10 @@ def menu(self, base='/', pct='50', showpct='',
         atoms.pop()
         for atom in atoms:
             path += atom + os.sep
-            yield ("<a href='menu?base=%s&exclude=%s'>%s</a> %s"
-                   % (path, urllib.parse.quote_plus(exclude), atom, os.sep))
+            yield (
+                "<a href='menu?base=%s&exclude=%s'>%s</a> %s"
+                % (path, urllib.parse.quote_plus(exclude), atom, os.sep)
+            )
         yield '</div>'
 
         yield "<div id='tree'>"
@@ -325,18 +358,26 @@ def menu(self, base='/', pct='50', showpct='',
         if not tree:
             yield '<p>No modules covered.</p>'
         else:
-            for chunk in _show_branch(tree, base, '/', pct,
-                                      showpct == 'checked', exclude,
-                                      coverage=self.coverage):
+            for chunk in _show_branch(
+                tree,
+                base,
+                '/',
+                pct,
+                showpct == 'checked',
+                exclude,
+                coverage=self.coverage,
+            ):
                 yield chunk
 
         yield '</div>'
         yield '</body></html>'
 
     def annotated_file(self, filename, statements, excluded, missing):
-        source = open(filename, 'r')
+        """Annotate given file with coverage information."""
+        with open(filename, 'r') as source:
+            lines = source.readlines()
         buffer = []
-        for lineno, line in enumerate(source.readlines()):
+        for lineno, line in enumerate(lines):
             lineno += 1
             line = line.strip('\n\r')
             empty_the_buffer = True
@@ -351,21 +392,29 @@ def annotated_file(self, filename, statements, excluded, missing):
                 buffer.append((lineno, line))
             if empty_the_buffer:
                 for lno, pastline in buffer:
-                    yield template % (lno, cgi.escape(pastline))
+                    yield template % (lno, html.escape(pastline))
                 buffer = []
-                yield template % (lineno, cgi.escape(line))
+                yield template % (lineno, html.escape(line))
 
     @cherrypy.expose
     def report(self, name):
+        """Render coverage stats as HTML."""
         filename, statements, excluded, missing, _ = self.coverage.analysis2(
-            name)
+            name,
+        )
         pc = _percent(statements, missing)
-        yield TEMPLATE_COVERAGE % dict(name=os.path.basename(name),
-                                       fullpath=name,
-                                       pc=pc)
+        yield TEMPLATE_COVERAGE % dict(
+            name=os.path.basename(name),
+            fullpath=name,
+            pc=pc,
+        )
         yield '<table>\n'
-        for line in self.annotated_file(filename, statements, excluded,
-                                        missing):
+        for line in self.annotated_file(
+            filename,
+            statements,
+            excluded,
+            missing,
+        ):
             yield line
         yield '</table>'
         yield '</body>'
@@ -373,16 +422,21 @@ def report(self, name):
 
 
 def serve(path=localFile, port=8080, root=None):
+    """Serve the coverage app over HTTP."""
     if coverage is None:
         raise ImportError('The coverage module could not be imported.')
     from coverage import coverage
+
     cov = coverage(data_file=path)
     cov.load()
 
-    cherrypy.config.update({'server.socket_port': int(port),
-                            'server.thread_pool': 10,
-                            'environment': 'production',
-                            })
+    cherrypy.config.update(
+        {
+            'server.socket_port': int(port),
+            'server.thread_pool': 10,
+            'environment': 'production',
+        },
+    )
     cherrypy.quickstart(CoverStats(cov, root))
 
 
diff --git a/cherrypy/lib/cpstats.py b/cherrypy/lib/cpstats.py
index 111af0632..6c9e17d52 100644
--- a/cherrypy/lib/cpstats.py
+++ b/cherrypy/lib/cpstats.py
@@ -184,7 +184,6 @@
 To format statistics reports::
 
     See 'Reporting', above.
-
 """
 
 import logging
@@ -219,59 +218,66 @@ def extrapolate_statistics(scope):
 # -------------------- CherryPy Applications Statistics --------------------- #
 
 appstats = logging.statistics.setdefault('CherryPy Applications', {})
-appstats.update({
-    'Enabled': True,
-    'Bytes Read/Request': lambda s: (
-        s['Total Requests'] and
-        (s['Total Bytes Read'] / float(s['Total Requests'])) or
-        0.0
-    ),
-    'Bytes Read/Second': lambda s: s['Total Bytes Read'] / s['Uptime'](s),
-    'Bytes Written/Request': lambda s: (
-        s['Total Requests'] and
-        (s['Total Bytes Written'] / float(s['Total Requests'])) or
-        0.0
-    ),
-    'Bytes Written/Second': lambda s: (
-        s['Total Bytes Written'] / s['Uptime'](s)
-    ),
-    'Current Time': lambda s: time.time(),
-    'Current Requests': 0,
-    'Requests/Second': lambda s: float(s['Total Requests']) / s['Uptime'](s),
-    'Server Version': cherrypy.__version__,
-    'Start Time': time.time(),
-    'Total Bytes Read': 0,
-    'Total Bytes Written': 0,
-    'Total Requests': 0,
-    'Total Time': 0,
-    'Uptime': lambda s: time.time() - s['Start Time'],
-    'Requests': {},
-})
+appstats.update(
+    {
+        'Enabled': True,
+        'Bytes Read/Request': lambda s: (
+            s['Total Requests']
+            and (s['Total Bytes Read'] / float(s['Total Requests']))
+            or 0.0
+        ),
+        'Bytes Read/Second': lambda s: s['Total Bytes Read'] / s['Uptime'](s),
+        'Bytes Written/Request': lambda s: (
+            s['Total Requests']
+            and (s['Total Bytes Written'] / float(s['Total Requests']))
+            or 0.0
+        ),
+        'Bytes Written/Second': lambda s: (
+            s['Total Bytes Written'] / s['Uptime'](s)
+        ),
+        'Current Time': lambda s: time.time(),
+        'Current Requests': 0,
+        'Requests/Second': lambda s: float(s['Total Requests'])
+        / s['Uptime'](s),
+        'Server Version': cherrypy.__version__,
+        'Start Time': time.time(),
+        'Total Bytes Read': 0,
+        'Total Bytes Written': 0,
+        'Total Requests': 0,
+        'Total Time': 0,
+        'Uptime': lambda s: time.time() - s['Start Time'],
+        'Requests': {},
+    },
+)
 
 
 def proc_time(s):
+    """Compute current HTTP request processing time."""
     return time.time() - s['Start Time']
 
 
 class ByteCountWrapper(object):
-
     """Wraps a file-like object, counting the number of bytes read."""
 
     def __init__(self, rfile):
+        """Initialize a read byte counter."""
         self.rfile = rfile
         self.bytes_read = 0
 
     def read(self, size=-1):
+        """Read from file, counting bytes."""
         data = self.rfile.read(size)
         self.bytes_read += len(data)
         return data
 
     def readline(self, size=-1):
+        """Read a line from file, counting bytes."""
         data = self.rfile.readline(size)
         self.bytes_read += len(data)
         return data
 
     def readlines(self, sizehint=0):
+        """Read a list of lines from file, counting bytes."""
         # Shamelessly stolen from StringIO
         total = 0
         lines = []
@@ -285,39 +291,44 @@ def readlines(self, sizehint=0):
         return lines
 
     def close(self):
+        """Close the underlying file object."""
         self.rfile.close()
 
     def __iter__(self):
+        """Make a file reader iterator."""
         return self
 
     def next(self):
+        """Return next portion of bytes from the iterated file."""
         data = self.rfile.next()
         self.bytes_read += len(data)
         return data
 
 
 def average_uriset_time(s):
+    """Compute average request processing time within a URI set."""
     return s['Count'] and (s['Sum'] / s['Count']) or 0
 
 
 def _get_threading_ident():
+    """Discover the current thread identifier."""
     if sys.version_info >= (3, 3):
         return threading.get_ident()
     return threading._get_ident()
 
 
 class StatsTool(cherrypy.Tool):
-
     """Record various information about the current request."""
 
     def __init__(self):
+        """Initialize the statistics gathering tool."""
         cherrypy.Tool.__init__(self, 'on_end_request', self.record_stop)
 
     def _setup(self):
-        """Hook this tool into cherrypy.request.
+        """Plug this tool into ``cherrypy.request``.
 
-        The standard CherryPy request object will automatically call this
-        method when the tool is "turned on" in config.
+        The standard CherryPy request object will automatically call
+        this method when the tool is "turned on" in config.
         """
         if appstats.get('Enabled', False):
             cherrypy.Tool._setup(self)
@@ -347,8 +358,13 @@ def record_start(self):
         }
 
     def record_stop(
-            self, uriset=None, slow_queries=1.0, slow_queries_count=100,
-            debug=False, **kwargs):
+        self,
+        uriset=None,
+        slow_queries=1.0,
+        slow_queries_count=100,
+        debug=False,
+        **kwargs,
+    ):
         """Record the end of a request."""
         resp = cherrypy.serving.response
         w = appstats['Requests'][_get_threading_ident()]
@@ -364,8 +380,11 @@ def record_stop(
             w['Bytes Written'] = cl
             appstats['Total Bytes Written'] += cl
 
-        w['Response Status'] = \
-            getattr(resp, 'output_status', resp.status).decode()
+        w['Response Status'] = getattr(
+            resp,
+            'output_status',
+            resp.status,
+        ).decode()
 
         w['End Time'] = time.time()
         p = w['End Time'] - w['Start Time']
@@ -379,9 +398,16 @@ def record_stop(
 
         if uriset:
             rs = appstats.setdefault('URI Set Tracking', {})
-            r = rs.setdefault(uriset, {
-                'Min': None, 'Max': None, 'Count': 0, 'Sum': 0,
-                'Avg': average_uriset_time})
+            r = rs.setdefault(
+                uriset,
+                {
+                    'Min': None,
+                    'Max': None,
+                    'Count': 0,
+                    'Sum': 0,
+                    'Avg': average_uriset_time,
+                },
+            )
             if r['Min'] is None or p < r['Min']:
                 r['Min'] = p
             if r['Max'] is None or p > r['Max']:
@@ -407,14 +433,18 @@ def record_stop(
 
 
 def locale_date(v):
+    """Format given date per current locale."""
     return time.strftime('%c', time.gmtime(v))
 
 
 def iso_format(v):
+    """Format given date as ISO string."""
     return time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(v))
 
 
 def pause_resume(ns):
+    """Produce pause or resume HTML form maker."""
+
     def _pause_resume(enabled):
         pause_disabled = ''
         resume_disabled = ''
@@ -432,10 +462,12 @@ def _pause_resume(enabled):
             <input type="submit" value="Resume" %s/>
             </form>
             """ % (ns, pause_disabled, ns, resume_disabled)
+
     return _pause_resume
 
 
 class StatsPage(object):
+    """An app rendering the gathered statistics."""
 
     formatting = {
         'CherryPy Applications': {
@@ -477,6 +509,7 @@ class StatsPage(object):
 
     @cherrypy.expose
     def index(self):
+        """Render the app stats index page."""
         # Transform the raw data into pretty output for HTML
         yield """
 <html>
@@ -518,12 +551,15 @@ def index(self):
 <body>
 """
         for title, scalars, collections in self.get_namespaces():
-            yield """
+            yield (
+                """
 <h1>%s</h1>
 
 <table class='stats1'>
     <tbody>
-""" % title
+"""
+                % title
+            )
             for i, (key, value) in enumerate(scalars):
                 colnum = i % 3
                 if colnum == 0:
@@ -531,8 +567,8 @@ def index(self):
         <tr>"""
                 yield (
                     """
-            <th>%(key)s</th><td id='%(title)s-%(key)s'>%(value)s</td>""" %
-                    vars()
+            <th>%(key)s</th><td id='%(title)s-%(key)s'>%(value)s</td>"""
+                    % vars()
                 )
                 if colnum == 2:
                     yield """
@@ -552,14 +588,20 @@ def index(self):
 </table>"""
 
             for subtitle, headers, subrows in collections:
-                yield """
+                yield (
+                    """
 <h2>%s</h2>
 <table class='stats2'>
     <thead>
-        <tr>""" % subtitle
+        <tr>"""
+                    % subtitle
+                )
                 for key in headers:
-                    yield """
-            <th>%s</th>""" % key
+                    yield (
+                        """
+            <th>%s</th>"""
+                        % key
+                    )
                 yield """
         </tr>
     </thead>
@@ -568,8 +610,11 @@ def index(self):
                     yield """
         <tr>"""
                     for value in subrow:
-                        yield """
-            <td>%s</td>""" % value
+                        yield (
+                            """
+            <td>%s</td>"""
+                            % value
+                        )
                     yield """
         </tr>"""
                 yield """
@@ -673,22 +718,29 @@ def get_list_collection(self, v, formatting):
         return headers, subrows
 
     if json is not None:
+
         @cherrypy.expose
         def data(self):
+            """Render statistics as JSON."""
             s = extrapolate_statistics(logging.statistics)
             cherrypy.response.headers['Content-Type'] = 'application/json'
             return json.dumps(s, sort_keys=True, indent=4).encode('utf-8')
 
     @cherrypy.expose
     def pause(self, namespace):
+        """Pause gathering the statistics."""
         logging.statistics.get(namespace, {})['Enabled'] = False
         raise cherrypy.HTTPRedirect('./')
-    pause.cp_config = {'tools.allow.on': True,
-                       'tools.allow.methods': ['POST']}
+
+    pause.cp_config = {'tools.allow.on': True, 'tools.allow.methods': ['POST']}
 
     @cherrypy.expose
     def resume(self, namespace):
+        """Resume gathering the statistics."""
         logging.statistics.get(namespace, {})['Enabled'] = True
         raise cherrypy.HTTPRedirect('./')
-    resume.cp_config = {'tools.allow.on': True,
-                        'tools.allow.methods': ['POST']}
+
+    resume.cp_config = {
+        'tools.allow.on': True,
+        'tools.allow.methods': ['POST'],
+    }
diff --git a/cherrypy/lib/cptools.py b/cherrypy/lib/cptools.py
index 613a89951..b4fd6ee53 100644
--- a/cherrypy/lib/cptools.py
+++ b/cherrypy/lib/cptools.py
@@ -13,6 +13,7 @@
 
 #                     Conditional HTTP request support                     #
 
+
 def validate_etags(autotags=False, debug=False):
     """Validate the current ETag against If-Match, If-None-Match headers.
 
@@ -69,33 +70,45 @@ def validate_etags(autotags=False, debug=False):
         conditions = request.headers.elements('If-Match') or []
         conditions = [str(x) for x in conditions]
         if debug:
-            cherrypy.log('If-Match conditions: %s' % repr(conditions),
-                         'TOOLS.ETAGS')
+            cherrypy.log(
+                'If-Match conditions: %s' % repr(conditions),
+                'TOOLS.ETAGS',
+            )
         if conditions and not (conditions == ['*'] or etag in conditions):
-            raise cherrypy.HTTPError(412, 'If-Match failed: ETag %r did '
-                                     'not match %r' % (etag, conditions))
+            raise cherrypy.HTTPError(
+                412,
+                'If-Match failed: ETag %r did '
+                'not match %r' % (etag, conditions),
+            )
 
         conditions = request.headers.elements('If-None-Match') or []
         conditions = [str(x) for x in conditions]
         if debug:
-            cherrypy.log('If-None-Match conditions: %s' % repr(conditions),
-                         'TOOLS.ETAGS')
+            cherrypy.log(
+                'If-None-Match conditions: %s' % repr(conditions),
+                'TOOLS.ETAGS',
+            )
         if conditions == ['*'] or etag in conditions:
             if debug:
-                cherrypy.log('request.method: %s' %
-                             request.method, 'TOOLS.ETAGS')
+                cherrypy.log(
+                    'request.method: %s' % request.method,
+                    'TOOLS.ETAGS',
+                )
             if request.method in ('GET', 'HEAD'):
                 raise cherrypy.HTTPRedirect([], 304)
             else:
-                raise cherrypy.HTTPError(412, 'If-None-Match failed: ETag %r '
-                                         'matched %r' % (etag, conditions))
+                raise cherrypy.HTTPError(
+                    412,
+                    'If-None-Match failed: ETag %r '
+                    'matched %r' % (etag, conditions),
+                )
 
 
 def validate_since():
     """Validate the current Last-Modified against If-Modified-Since headers.
 
-    If no code has set the Last-Modified response header, then no validation
-    will be performed.
+    If no code has set the Last-Modified response header, then no
+    validation will be performed.
     """
     response = cherrypy.serving.response
     lastmod = response.headers.get('Last-Modified')
@@ -120,12 +133,13 @@ def validate_since():
 
 #                                Tool code                                #
 
+
 def allow(methods=None, debug=False):
     """Raise 405 if request.method not in methods (default ['GET', 'HEAD']).
 
-    The given methods are case-insensitive, and may be in any order.
-    If only one method is allowed, you may supply a single string;
-    if more than one, supply a list of strings.
+    The given methods are case-insensitive, and may be in any order. If
+    only one method is allowed, you may supply a single string; if more
+    than one, supply a list of strings.
 
     Regardless of whether the current method is allowed or not, this
     also emits an 'Allow' response header, containing the given methods.
@@ -141,37 +155,48 @@ def allow(methods=None, debug=False):
     cherrypy.response.headers['Allow'] = ', '.join(methods)
     if cherrypy.request.method not in methods:
         if debug:
-            cherrypy.log('request.method %r not in methods %r' %
-                         (cherrypy.request.method, methods), 'TOOLS.ALLOW')
+            cherrypy.log(
+                'request.method %r not in methods %r'
+                % (cherrypy.request.method, methods),
+                'TOOLS.ALLOW',
+            )
         raise cherrypy.HTTPError(405)
     else:
         if debug:
-            cherrypy.log('request.method %r in methods %r' %
-                         (cherrypy.request.method, methods), 'TOOLS.ALLOW')
+            cherrypy.log(
+                'request.method %r in methods %r'
+                % (cherrypy.request.method, methods),
+                'TOOLS.ALLOW',
+            )
 
 
-def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For',
-          scheme='X-Forwarded-Proto', debug=False):
+def proxy(
+    base=None,
+    local='X-Forwarded-Host',
+    remote='X-Forwarded-For',
+    scheme='X-Forwarded-Proto',
+    debug=False,
+):
     """Change the base URL (scheme://host[:port][/path]).
 
-    For running a CP server behind Apache, lighttpd, or other HTTP server.
+    For running a CP server behind Apache, lighttpd, or other HTTP
+    server.
 
-    For Apache and lighttpd, you should leave the 'local' argument at the
-    default value of 'X-Forwarded-Host'. For Squid, you probably want to set
-    tools.proxy.local = 'Origin'.
+    For Apache and lighttpd, you should leave the 'local' argument at
+    the default value of 'X-Forwarded-Host'. For Squid, you probably
+    want to set tools.proxy.local = 'Origin'.
 
-    If you want the new request.base to include path info (not just the host),
-    you must explicitly set base to the full base path, and ALSO set 'local'
-    to '', so that the X-Forwarded-Host request header (which never includes
-    path info) does not override it. Regardless, the value for 'base' MUST
-    NOT end in a slash.
+    If you want the new request.base to include path info (not just the
+    host), you must explicitly set base to the full base path, and ALSO
+    set 'local' to '', so that the X-Forwarded-Host request header
+    (which never includes path info) does not override it. Regardless,
+    the value for 'base' MUST NOT end in a slash.
 
     cherrypy.request.remote.ip (the IP address of the client) will be
-    rewritten if the header specified by the 'remote' arg is valid.
-    By default, 'remote' is set to 'X-Forwarded-For'. If you do not
-    want to rewrite remote.ip, set the 'remote' arg to an empty string.
+    rewritten if the header specified by the 'remote' arg is valid. By
+    default, 'remote' is set to 'X-Forwarded-For'. If you do not want to
+    rewrite remote.ip, set the 'remote' arg to an empty string.
     """
-
     request = cherrypy.serving.request
 
     if scheme:
@@ -185,7 +210,7 @@ def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For',
             # This is for lighttpd/pound/Mongrel's 'X-Forwarded-Proto: https'
             scheme = s
     if not scheme:
-        scheme = request.base[:request.base.find('://')]
+        scheme = request.base[: request.base.find('://')]
 
     if local:
         lbase = request.headers.get(local, None)
@@ -217,33 +242,43 @@ def proxy(base=None, local='X-Forwarded-Host', remote='X-Forwarded-For',
 def ignore_headers(headers=('Range',), debug=False):
     """Delete request headers whose field names are included in 'headers'.
 
-    This is a useful tool for working behind certain HTTP servers;
-    for example, Apache duplicates the work that CP does for 'Range'
+    This is a useful tool for working behind certain HTTP servers; for
+    example, Apache duplicates the work that CP does for 'Range'
     headers, and will doubly-truncate the response.
     """
     request = cherrypy.serving.request
     for name in headers:
         if name in request.headers:
             if debug:
-                cherrypy.log('Ignoring request header %r' % name,
-                             'TOOLS.IGNORE_HEADERS')
+                cherrypy.log(
+                    'Ignoring request header %r' % name,
+                    'TOOLS.IGNORE_HEADERS',
+                )
             del request.headers[name]
 
 
 def response_headers(headers=None, debug=False):
     """Set headers on the response."""
     if debug:
-        cherrypy.log('Setting response headers: %s' % repr(headers),
-                     'TOOLS.RESPONSE_HEADERS')
-    for name, value in (headers or []):
+        cherrypy.log(
+            'Setting response headers: %s' % repr(headers),
+            'TOOLS.RESPONSE_HEADERS',
+        )
+    for name, value in headers or []:
         cherrypy.serving.response.headers[name] = value
 
 
 response_headers.failsafe = True
 
 
-def referer(pattern, accept=True, accept_missing=False, error=403,
-            message='Forbidden Referer header.', debug=False):
+def referer(
+    pattern,
+    accept=True,
+    accept_missing=False,
+    error=403,
+    message='Forbidden Referer header.',
+    debug=False,
+):
     """Raise HTTPError if Referer header does/does not match the given pattern.
 
     pattern
@@ -267,8 +302,10 @@ def referer(pattern, accept=True, accept_missing=False, error=403,
         ref = cherrypy.serving.request.headers['Referer']
         match = bool(re.match(pattern, ref))
         if debug:
-            cherrypy.log('Referer %r matches %r' % (ref, pattern),
-                         'TOOLS.REFERER')
+            cherrypy.log(
+                'Referer %r matches %r' % (ref, pattern),
+                'TOOLS.REFERER',
+            )
         if accept == match:
             return
     except KeyError:
@@ -281,31 +318,58 @@ def referer(pattern, accept=True, accept_missing=False, error=403,
 
 
 class SessionAuth(object):
-
     """Assert that the user is logged in."""
 
     session_key = 'username'
     debug = False
 
     def check_username_and_password(self, username, password):
-        pass
+        """Assert the login credentials.
+
+        :param username: A user name sent from the login form.
+        :type username: str
+        :param password: A pass word sent from the login form.
+        :type password: str
+
+        :returns: A non-empty error string if the authentication fails.
+        :rtype: str
+        """
 
     def anonymous(self):
         """Provide a temporary user name for anonymous users."""
         pass
 
     def on_login(self, username):
-        pass
+        """Process a successful login event.
+
+        :param username: The logged in user name.
+        :type username: str
+        """
 
     def on_logout(self, username):
-        pass
+        """Process a successful logout event.
+
+        :param username: The logged out user name.
+        :type username: str
+        """
 
     def on_check(self, username):
-        pass
+        """Process a successful check event.
 
-    def login_screen(self, from_page='..', username='', error_msg='',
-                     **kwargs):
-        return (str("""<html><body>
+        :param username: The checked user name.
+        :type username: str
+        """
+
+    def login_screen(
+        self,
+        from_page='..',
+        username='',
+        error_msg='',
+        **kwargs,
+    ):
+        """Render the login HTML page."""
+        return (
+            str("""<html><body>
 Message: %(error_msg)s
 <form method="post" action="do_login">
     Login: <input type="text" name="username" value="%(username)s" size="10" />
@@ -316,10 +380,15 @@ def login_screen(self, from_page='..', username='', error_msg='',
     <br />
     <input type="submit" />
 </form>
-</body></html>""") % vars()).encode('utf-8')
+</body></html>""")
+            % vars()
+        ).encode('utf-8')
 
     def do_login(self, username, password, from_page='..', **kwargs):
-        """Login. May raise redirect, or return True if request handled."""
+        """Login.
+
+        May raise redirect, or return True if request handled.
+        """
         response = cherrypy.serving.response
         error_msg = self.check_username_and_password(username, password)
         if error_msg:
@@ -336,7 +405,10 @@ def do_login(self, username, password, from_page='..', **kwargs):
             raise cherrypy.HTTPRedirect(from_page or '/')
 
     def do_logout(self, from_page='..', **kwargs):
-        """Logout. May raise redirect, or return True if request handled."""
+        """Logout.
+
+        May raise redirect, or return True if request handled.
+        """
         sess = cherrypy.session
         username = sess.get(self.session_key)
         sess[self.session_key] = None
@@ -346,7 +418,9 @@ def do_logout(self, from_page='..', **kwargs):
         raise cherrypy.HTTPRedirect(from_page)
 
     def do_check(self):
-        """Assert username. Raise redirect, or return True if request handled.
+        """Assert username.
+
+        Raise redirect, or return True if request handled.
         """
         sess = cherrypy.session
         request = cherrypy.serving.request
@@ -377,6 +451,7 @@ def _debug_message(self, template, context={}):
         cherrypy.log(template % context, 'TOOLS.SESSAUTH')
 
     def run(self):
+        """Perform session authentication."""
         request = cherrypy.serving.request
         response = cherrypy.serving.response
 
@@ -404,15 +479,18 @@ def run(self):
 
 
 def session_auth(**kwargs):
-    """Session authentication hook.
+    (
+        """Session authentication hook.
 
     Any attribute of the SessionAuth class may be overridden
     via a keyword arg to this function:
-
-    """ + '\n    '.join(
-        '{!s}: {!s}'.format(k, type(getattr(SessionAuth, k)).__name__)
-        for k in dir(SessionAuth)
-        if not k.startswith('__')
+    """
+        + '\n'
+        + '\n    '.join(
+            '{!s}: {!s}'.format(k, type(getattr(SessionAuth, k)).__name__)
+            for k in dir(SessionAuth)
+            if not k.startswith('__')
+        )
     )
     sa = SessionAuth()
     for k, v in kwargs.items():
@@ -438,6 +516,7 @@ def log_hooks(debug=False):
     msg = []
     # Sort by the standard points if possible.
     from cherrypy import _cprequest
+
     points = _cprequest.hookpoints
     for k in request.hooks.keys():
         if k not in points:
@@ -449,16 +528,20 @@ def log_hooks(debug=False):
         v.sort()
         for h in v:
             msg.append('        %r' % h)
-    cherrypy.log('\nRequest Hooks for ' + cherrypy.url() +
-                 ':\n' + '\n'.join(msg), 'HTTP')
+    cherrypy.log(
+        '\nRequest Hooks for ' + cherrypy.url() + ':\n' + '\n'.join(msg),
+        'HTTP',
+    )
 
 
 def redirect(url='', internal=True, debug=False):
     """Raise InternalRedirect or HTTPRedirect to the given url."""
     if debug:
-        cherrypy.log('Redirecting %sto: %s' %
-                     ({True: 'internal ', False: ''}[internal], url),
-                     'TOOLS.REDIRECT')
+        cherrypy.log(
+            'Redirecting %sto: %s'
+            % ({True: 'internal ', False: ''}[internal], url),
+            'TOOLS.REDIRECT',
+        )
     if internal:
         raise cherrypy.InternalRedirect(url)
     else:
@@ -471,9 +554,11 @@ def trailing_slash(missing=True, extra=False, status=None, debug=False):
     pi = request.path_info
 
     if debug:
-        cherrypy.log('is_index: %r, missing: %r, extra: %r, path_info: %r' %
-                     (request.is_index, missing, extra, pi),
-                     'TOOLS.TRAILING_SLASH')
+        cherrypy.log(
+            'is_index: %r, missing: %r, extra: %r, path_info: %r'
+            % (request.is_index, missing, extra, pi),
+            'TOOLS.TRAILING_SLASH',
+        )
     if request.is_index is True:
         if missing:
             if not pi.endswith('/'):
@@ -490,9 +575,10 @@ def trailing_slash(missing=True, extra=False, status=None, debug=False):
 def flatten(debug=False):
     """Wrap response.body in a generator that recursively iterates over body.
 
-    This allows cherrypy.response.body to consist of 'nested generators';
-    that is, a set of generators that yield generators.
+    This allows cherrypy.response.body to consist of 'nested
+    generators'; that is, a set of generators that yield generators.
     """
+
     def flattener(input):
         numchunks = 0
         for x in input:
@@ -505,6 +591,7 @@ def flattener(input):
                     yield y
         if debug:
             cherrypy.log('Flattened %d chunks' % numchunks, 'TOOLS.FLATTEN')
+
     response = cherrypy.serving.response
     response.body = flattener(response.body)
 
@@ -562,15 +649,19 @@ def accept(media=None, debug=False):
                     for m in media:
                         if m.startswith(mtype):
                             if debug:
-                                cherrypy.log('Match due to %s' % element.value,
-                                             'TOOLS.ACCEPT')
+                                cherrypy.log(
+                                    'Match due to %s' % element.value,
+                                    'TOOLS.ACCEPT',
+                                )
                             return m
                 else:
                     # Matches exact value
                     if element.value in media:
                         if debug:
-                            cherrypy.log('Match due to %s' % element.value,
-                                         'TOOLS.ACCEPT')
+                            cherrypy.log(
+                                'Match due to %s' % element.value,
+                                'TOOLS.ACCEPT',
+                            )
                         return element.value
 
     # No suitable media-range found.
@@ -579,25 +670,28 @@ def accept(media=None, debug=False):
         msg = 'Your client did not send an Accept header.'
     else:
         msg = 'Your client sent this Accept header: %s.' % ah
-    msg += (' But this resource only emits these media types: %s.' %
-            ', '.join(media))
+    msg += ' But this resource only emits these media types: %s.' % ', '.join(
+        media,
+    )
     raise cherrypy.HTTPError(406, msg)
 
 
 class MonitoredHeaderMap(_httputil.HeaderMap):
+    """An access-tracked HTTP header mapping."""
 
     def transform_key(self, key):
+        """Normalize and track an HTTP header name."""
         self.accessed_headers.add(key)
         return super(MonitoredHeaderMap, self).transform_key(key)
 
     def __init__(self):
+        """Initialize a monitored HTTP header mapping."""
         self.accessed_headers = set()
         super(MonitoredHeaderMap, self).__init__()
 
 
 def autovary(ignore=None, debug=False):
-    """Auto-populate the Vary response header based on request.header access.
-    """
+    """Populate ``Vary`` response header based on ``request.header`` access."""
     request = cherrypy.serving.request
 
     req_h = request.headers
@@ -612,23 +706,27 @@ def set_response_header():
         if debug:
             cherrypy.log(
                 'Accessed headers: %s' % request.headers.accessed_headers,
-                'TOOLS.AUTOVARY')
+                'TOOLS.AUTOVARY',
+            )
         v = v.union(request.headers.accessed_headers)
         v = v.difference(ignore)
         v = list(v)
         v.sort()
         resp_h['Vary'] = ', '.join(v)
+
     request.hooks.attach('before_finalize', set_response_header, 95)
 
 
 def convert_params(exception=ValueError, error=400):
-    """Convert request params based on function annotations, with error handling.
+    """Convert request params based on function annotations.
 
-    exception
-        Exception class to catch.
+    This function also processes errors that are subclasses of ``exception``.
 
-    status
-        The HTTP error code to return to the client on failure.
+    :param BaseException exception: Exception class to catch.
+    :type exception: BaseException
+
+    :param error: The HTTP status code to return to the client on failure.
+    :type error: int
     """
     request = cherrypy.serving.request
     types = request.handler.callable.__annotations__
diff --git a/cherrypy/lib/encoding.py b/cherrypy/lib/encoding.py
index c2c478a50..7a913a980 100644
--- a/cherrypy/lib/encoding.py
+++ b/cherrypy/lib/encoding.py
@@ -1,3 +1,5 @@
+"""Encoding module."""
+
 import struct
 import time
 import io
@@ -41,32 +43,41 @@ def decode(encoding=None, default_encoding='utf-8'):
 
 
 class UTF8StreamEncoder:
+    """UTF8 Stream Encoder."""
+
     def __init__(self, iterator):
+        """Initialize a UTF-8 stream encoder instance."""
         self._iterator = iterator
 
     def __iter__(self):
+        """Make a UTF-8-encoded stream iterator."""
         return self
 
     def next(self):
+        """UTF-8-encode the next chunk of the stream."""
         return self.__next__()
 
     def __next__(self):
+        """UTF-8-encode the next chunk of the stream."""
         res = next(self._iterator)
         if isinstance(res, str):
             res = res.encode('utf-8')
         return res
 
     def close(self):
+        """Close the underlying byte stream."""
         if is_closable_iterator(self._iterator):
             self._iterator.close()
 
     def __getattr__(self, attr):
+        """Return the underlying byte stream attribute value."""
         if attr.startswith('__'):
             raise AttributeError(self, attr)
         return getattr(self._iterator, attr)
 
 
 class ResponseEncoder:
+    """An HTTP response payload encoder."""
 
     default_encoding = 'utf-8'
     failmsg = 'Response body could not be encoded with %r.'
@@ -77,6 +88,7 @@ class ResponseEncoder:
     debug = False
 
     def __init__(self, **kwargs):
+        """Initialize HTTP response payload encoder."""
         for k, v in kwargs.items():
             setattr(self, k, v)
 
@@ -104,6 +116,7 @@ def encoder(body):
                 if isinstance(chunk, str):
                     chunk = chunk.encode(encoding, self.errors)
                 yield chunk
+
         self.body = encoder(self.body)
         return True
 
@@ -124,12 +137,15 @@ def encode_string(self, encoding):
         return True
 
     def find_acceptable_charset(self):
+        """Deduce acceptable charset for HTTP response."""
         request = cherrypy.serving.request
         response = cherrypy.serving.response
 
         if self.debug:
-            cherrypy.log('response.stream %r' %
-                         response.stream, 'TOOLS.ENCODE')
+            cherrypy.log(
+                'response.stream %r' % response.stream,
+                'TOOLS.ENCODE',
+            )
         if response.stream:
             encoder = self.encode_stream
         else:
@@ -158,40 +174,55 @@ def find_acceptable_charset(self):
             # If specified, force this encoding to be used, or fail.
             encoding = self.encoding.lower()
             if self.debug:
-                cherrypy.log('Specified encoding %r' %
-                             encoding, 'TOOLS.ENCODE')
+                cherrypy.log(
+                    'Specified encoding %r' % encoding,
+                    'TOOLS.ENCODE',
+                )
             if (not charsets) or '*' in charsets or encoding in charsets:
                 if self.debug:
-                    cherrypy.log('Attempting encoding %r' %
-                                 encoding, 'TOOLS.ENCODE')
+                    cherrypy.log(
+                        'Attempting encoding %r' % encoding,
+                        'TOOLS.ENCODE',
+                    )
                 if encoder(encoding):
                     return encoding
         else:
             if not encs:
                 if self.debug:
-                    cherrypy.log('Attempting default encoding %r' %
-                                 self.default_encoding, 'TOOLS.ENCODE')
+                    cherrypy.log(
+                        'Attempting default encoding %r'
+                        % self.default_encoding,
+                        'TOOLS.ENCODE',
+                    )
                 # Any character-set is acceptable.
                 if encoder(self.default_encoding):
                     return self.default_encoding
                 else:
-                    raise cherrypy.HTTPError(500, self.failmsg %
-                                             self.default_encoding)
+                    raise cherrypy.HTTPError(
+                        500,
+                        self.failmsg % self.default_encoding,
+                    )
             else:
                 for element in encs:
                     if element.qvalue > 0:
                         if element.value == '*':
                             # Matches any charset. Try our default.
                             if self.debug:
-                                cherrypy.log('Attempting default encoding due '
-                                             'to %r' % element, 'TOOLS.ENCODE')
+                                cherrypy.log(
+                                    'Attempting default encoding due '
+                                    'to %r' % element,
+                                    'TOOLS.ENCODE',
+                                )
                             if encoder(self.default_encoding):
                                 return self.default_encoding
                         else:
                             encoding = element.value
                             if self.debug:
-                                cherrypy.log('Attempting encoding %s (qvalue >'
-                                             '0)' % element, 'TOOLS.ENCODE')
+                                cherrypy.log(
+                                    'Attempting encoding %s (qvalue >'
+                                    '0)' % element,
+                                    'TOOLS.ENCODE',
+                                )
                             if encoder(encoding):
                                 return encoding
 
@@ -203,8 +234,10 @@ def find_acceptable_charset(self):
                     iso = 'iso-8859-1'
                     if iso not in charsets:
                         if self.debug:
-                            cherrypy.log('Attempting ISO-8859-1 encoding',
-                                         'TOOLS.ENCODE')
+                            cherrypy.log(
+                                'Attempting ISO-8859-1 encoding',
+                                'TOOLS.ENCODE',
+                            )
                         if encoder(iso):
                             return iso
 
@@ -219,6 +252,7 @@ def find_acceptable_charset(self):
         raise cherrypy.HTTPError(406, msg)
 
     def __call__(self, *args, **kwargs):
+        """Set up encoding for the HTTP response."""
         response = cherrypy.serving.response
         self.body = self.oldhandler(*args, **kwargs)
 
@@ -226,8 +260,10 @@ def __call__(self, *args, **kwargs):
 
         ct = response.headers.elements('Content-Type')
         if self.debug:
-            cherrypy.log('Content-Type: %r' % [str(h)
-                         for h in ct], 'TOOLS.ENCODE')
+            cherrypy.log(
+                'Content-Type: %r' % [str(h) for h in ct],
+                'TOOLS.ENCODE',
+            )
         if ct and self.add_charset:
             ct = ct[0]
             if self.text_only:
@@ -235,35 +271,40 @@ def __call__(self, *args, **kwargs):
                     if self.debug:
                         cherrypy.log(
                             'Content-Type %s starts with "text/"' % ct,
-                            'TOOLS.ENCODE')
+                            'TOOLS.ENCODE',
+                        )
                     do_find = True
                 else:
                     if self.debug:
-                        cherrypy.log('Not finding because Content-Type %s '
-                                     'does not start with "text/"' % ct,
-                                     'TOOLS.ENCODE')
+                        cherrypy.log(
+                            'Not finding because Content-Type %s '
+                            'does not start with "text/"' % ct,
+                            'TOOLS.ENCODE',
+                        )
                     do_find = False
             else:
                 if self.debug:
-                    cherrypy.log('Finding because not text_only',
-                                 'TOOLS.ENCODE')
+                    cherrypy.log(
+                        'Finding because not text_only',
+                        'TOOLS.ENCODE',
+                    )
                 do_find = True
 
             if do_find:
                 # Set "charset=..." param on response Content-Type header
                 ct.params['charset'] = self.find_acceptable_charset()
                 if self.debug:
-                    cherrypy.log('Setting Content-Type %s' % ct,
-                                 'TOOLS.ENCODE')
+                    cherrypy.log(
+                        'Setting Content-Type %s' % ct,
+                        'TOOLS.ENCODE',
+                    )
                 response.headers['Content-Type'] = str(ct)
 
         return self.body
 
 
 def prepare_iter(value):
-    """
-    Ensure response body is iterable and resolves to False when empty.
-    """
+    """Ensure response body is iterable and resolves to False when empty."""
     if isinstance(value, text_or_bytes):
         # strings get wrapped in a list because iterating over a single
         # item list is much faster than iterating over every character
@@ -290,9 +331,9 @@ def compress(body, compress_level):
     import zlib
 
     # See https://tools.ietf.org/html/rfc1952
-    yield b'\x1f\x8b'       # ID1 and ID2: gzip marker
-    yield b'\x08'           # CM: compression method
-    yield b'\x00'           # FLG: none set
+    yield b'\x1f\x8b'  # ID1 and ID2: gzip marker
+    yield b'\x08'  # CM: compression method
+    yield b'\x00'  # FLG: none set
     # MTIME: 4 bytes
     yield struct.pack('<L', int(time.time()) & int('FFFFFFFF', 16))
 
@@ -307,18 +348,22 @@ def compress(body, compress_level):
     #                 slowest algorithm
     #       XFL = 4 - compressor used fastest algorithm
     if compress_level == _COMPRESSION_LEVEL_BEST:
-        yield b'\x02'       # XFL: max compression, slowest algo
+        yield b'\x02'  # XFL: max compression, slowest algo
     elif compress_level == _COMPRESSION_LEVEL_FAST:
-        yield b'\x04'       # XFL: min compression, fastest algo
+        yield b'\x04'  # XFL: min compression, fastest algo
     else:
-        yield b'\x00'       # XFL: compression unset/tradeoff
-    yield b'\xff'           # OS: unknown
+        yield b'\x00'  # XFL: compression unset/tradeoff
+    yield b'\xff'  # OS: unknown
 
     crc = zlib.crc32(b'')
     size = 0
-    zobj = zlib.compressobj(compress_level,
-                            zlib.DEFLATED, -zlib.MAX_WBITS,
-                            zlib.DEF_MEM_LEVEL, 0)
+    zobj = zlib.compressobj(
+        compress_level,
+        zlib.DEFLATED,
+        -zlib.MAX_WBITS,
+        zlib.DEF_MEM_LEVEL,
+        0,
+    )
     for line in body:
         size += len(line)
         crc = zlib.crc32(line, crc)
@@ -332,6 +377,7 @@ def compress(body, compress_level):
 
 
 def decompress(body):
+    """Decompress a blob of bytes."""
     import gzip
 
     zbuf = io.BytesIO()
@@ -343,8 +389,11 @@ def decompress(body):
     return data
 
 
-def gzip(compress_level=5, mime_types=['text/html', 'text/plain'],
-         debug=False):
+def gzip(
+    compress_level=5,
+    mime_types=['text/html', 'text/plain'],
+    debug=False,
+):
     """Try to gzip the response body if Content-Type in mime_types.
 
     cherrypy.response.headers['Content-Type'] must be set to one of the
@@ -360,7 +409,6 @@ def gzip(compress_level=5, mime_types=['text/html', 'text/plain'],
         * No 'gzip' or 'x-gzip' is present in the Accept-Encoding header
         * No 'gzip' or 'x-gzip' with a qvalue > 0 is present
         * The 'identity' value is given with a qvalue > 0.
-
     """
     request = cherrypy.serving.request
     response = cherrypy.serving.response
@@ -397,14 +445,18 @@ def gzip(compress_level=5, mime_types=['text/html', 'text/plain'],
     for coding in acceptable:
         if coding.value == 'identity' and coding.qvalue != 0:
             if debug:
-                cherrypy.log('Non-zero identity qvalue: %s' % coding,
-                             context='TOOLS.GZIP')
+                cherrypy.log(
+                    'Non-zero identity qvalue: %s' % coding,
+                    context='TOOLS.GZIP',
+                )
             return
         if coding.value in ('gzip', 'x-gzip'):
             if coding.qvalue == 0:
                 if debug:
-                    cherrypy.log('Zero gzip qvalue: %s' % coding,
-                                 context='TOOLS.GZIP')
+                    cherrypy.log(
+                        'Zero gzip qvalue: %s' % coding,
+                        context='TOOLS.GZIP',
+                    )
                 return
 
             if ct not in mime_types:
@@ -434,8 +486,11 @@ def gzip(compress_level=5, mime_types=['text/html', 'text/plain'],
 
                 if not found:
                     if debug:
-                        cherrypy.log('Content-Type %s not in mime_types %r' %
-                                     (ct, mime_types), context='TOOLS.GZIP')
+                        cherrypy.log(
+                            'Content-Type %s not in mime_types %r'
+                            % (ct, mime_types),
+                            context='TOOLS.GZIP',
+                        )
                     return
 
             if debug:
diff --git a/cherrypy/lib/gctools.py b/cherrypy/lib/gctools.py
index 26746d78b..941575b92 100644
--- a/cherrypy/lib/gctools.py
+++ b/cherrypy/lib/gctools.py
@@ -1,3 +1,5 @@
+"""Garbage collection inspection tooling."""
+
 import gc
 import inspect
 import sys
@@ -14,12 +16,12 @@
 
 
 class ReferrerTree(object):
-
     """An object which gathers all referrers of an object to a given depth."""
 
     peek_length = 40
 
     def __init__(self, ignore=None, maxdepth=2, maxparents=10):
+        """Initialize a referrer tree structure."""
         self.ignore = ignore or []
         self.ignore.append(inspect.currentframe().f_back)
         self.maxdepth = maxdepth
@@ -71,15 +73,36 @@ def _format(self, obj, descend=True):
             return self.peek(repr(obj))
 
         if isinstance(obj, dict):
-            return '{' + ', '.join(['%s: %s' % (self._format(k, descend=False),
-                                                self._format(v, descend=False))
-                                    for k, v in obj.items()]) + '}'
+            return (
+                '{'
+                + ', '.join(
+                    [
+                        '%s: %s'
+                        % (
+                            self._format(k, descend=False),
+                            self._format(v, descend=False),
+                        )
+                        for k, v in obj.items()
+                    ],
+                )
+                + '}'
+            )
         elif isinstance(obj, list):
-            return '[' + ', '.join([self._format(item, descend=False)
-                                    for item in obj]) + ']'
+            return (
+                '['
+                + ', '.join(
+                    [self._format(item, descend=False) for item in obj],
+                )
+                + ']'
+            )
         elif isinstance(obj, tuple):
-            return '(' + ', '.join([self._format(item, descend=False)
-                                    for item in obj]) + ')'
+            return (
+                '('
+                + ', '.join(
+                    [self._format(item, descend=False) for item in obj],
+                )
+                + ')'
+            )
 
         r = self.peek(repr(obj))
         if isinstance(obj, (str, int, float)):
@@ -95,23 +118,29 @@ def ascend(branch, depth=1):
                 output.append(('    ' * depth) + self._format(parent))
                 if grandparents:
                     ascend(grandparents, depth + 1)
+
         ascend(tree)
         return output
 
 
 def get_instances(cls):
+    """Return GC instances."""
     return [x for x in gc.get_objects() if isinstance(x, cls)]
 
 
 class RequestCounter(SimplePlugin):
+    """An HTTP request counter plugin."""
 
     def start(self):
+        """Initialize the internal counter."""
         self.count = 0
 
     def before_request(self):
+        """Increment the counter before HTTP request."""
         self.count += 1
 
     def after_request(self):
+        """Decrement the counter after HTTP request."""
         self.count -= 1
 
 
@@ -120,6 +149,7 @@ def after_request(self):
 
 
 def get_context(obj):
+    """Compute object's runtime context information."""
     if isinstance(obj, _cprequest.Request):
         return 'path=%s;stage=%s' % (obj.path_info, obj.stage)
     elif isinstance(obj, _cprequest.Response):
@@ -132,24 +162,37 @@ def get_context(obj):
 
 
 class GCRoot(object):
-
     """A CherryPy page handler for testing reference leaks."""
 
     classes = [
-        (_cprequest.Request, 2, 2,
-         'Should be 1 in this request thread and 1 in the main thread.'),
-        (_cprequest.Response, 2, 2,
-         'Should be 1 in this request thread and 1 in the main thread.'),
-        (_cpwsgi.AppResponse, 1, 1,
-         'Should be 1 in this request thread only.'),
+        (
+            _cprequest.Request,
+            2,
+            2,
+            'Should be 1 in this request thread and 1 in the main thread.',
+        ),
+        (
+            _cprequest.Response,
+            2,
+            2,
+            'Should be 1 in this request thread and 1 in the main thread.',
+        ),
+        (
+            _cpwsgi.AppResponse,
+            1,
+            1,
+            'Should be 1 in this request thread only.',
+        ),
     ]
 
     @cherrypy.expose
     def index(self):
+        """Render the index page HTML content."""
         return 'Hello, world!'
 
     @cherrypy.expose
     def stats(self):
+        """Render garbage collection statistics page HTML content."""
         output = ['Statistics:']
 
         for trial in range(10):
@@ -195,22 +238,31 @@ def stats(self):
             if lenobj < minobj or lenobj > maxobj:
                 if minobj == maxobj:
                     output.append(
-                        '\nExpected %s %r references, got %s.' %
-                        (minobj, cls, lenobj))
+                        '\nExpected %s %r references, got %s.'
+                        % (minobj, cls, lenobj),
+                    )
                 else:
                     output.append(
-                        '\nExpected %s to %s %r references, got %s.' %
-                        (minobj, maxobj, cls, lenobj))
+                        '\nExpected %s to %s %r references, got %s.'
+                        % (minobj, maxobj, cls, lenobj),
+                    )
 
                 for obj in objs:
                     if objgraph is not None:
                         ig = [id(objs), id(inspect.currentframe())]
                         fname = 'graph_%s_%s.png' % (cls.__name__, id(obj))
                         objgraph.show_backrefs(
-                            obj, extra_ignore=ig, max_depth=4, too_many=20,
-                            filename=fname, extra_info=get_context)
-                    output.append('\nReferrers for %s (refcount=%s):' %
-                                  (repr(obj), sys.getrefcount(obj)))
+                            obj,
+                            extra_ignore=ig,
+                            max_depth=4,
+                            too_many=20,
+                            filename=fname,
+                            extra_info=get_context,
+                        )
+                    output.append(
+                        '\nReferrers for %s (refcount=%s):'
+                        % (repr(obj), sys.getrefcount(obj)),
+                    )
                     t = ReferrerTree(ignore=[objs], maxdepth=3)
                     tree = t.ascend(obj)
                     output.extend(t.format(tree))
diff --git a/cherrypy/lib/headers.py b/cherrypy/lib/headers.py
new file mode 100644
index 000000000..a00b24b4a
--- /dev/null
+++ b/cherrypy/lib/headers.py
@@ -0,0 +1,14 @@
+"""Deprecated HTTP header parsing helpers."""
+
+# for compatibility, expose accidentally here
+import warnings
+
+from .._private_api.compat.headers import _parse_param, parse_header  # noqa
+
+
+warnings.warn(
+    'Import `cherrypy._private_api.compat.headers` '
+    'instead of `cherrypy.lib.headers`',
+    DeprecationWarning,
+    stacklevel=2,
+)
diff --git a/cherrypy/lib/httputil.py b/cherrypy/lib/httputil.py
index eedf8d89c..52e29d490 100644
--- a/cherrypy/lib/httputil.py
+++ b/cherrypy/lib/httputil.py
@@ -12,7 +12,6 @@
 import re
 import builtins
 from binascii import b2a_base64
-from cgi import parse_header
 from email.header import decode_header
 from http.server import BaseHTTPRequestHandler
 from urllib.parse import unquote_plus
@@ -22,16 +21,23 @@
 import cherrypy
 from cherrypy._cpcompat import ntob, ntou
 
+from .._private_api.compat.headers import parse_header
+
+
 response_codes = BaseHTTPRequestHandler.responses.copy()
 
 # From https://github.com/cherrypy/cherrypy/issues/361
-response_codes[500] = ('Internal Server Error',
-                       'The server encountered an unexpected condition '
-                       'which prevented it from fulfilling the request.')
-response_codes[503] = ('Service Unavailable',
-                       'The server is currently unable to handle the '
-                       'request due to a temporary overloading or '
-                       'maintenance of the server.')
+response_codes[500] = (
+    'Internal Server Error',
+    'The server encountered an unexpected condition '
+    'which prevented it from fulfilling the request.',
+)
+response_codes[503] = (
+    'Service Unavailable',
+    'The server is currently unable to handle the '
+    'request due to a temporary overloading or '
+    'maintenance of the server.',
+)
 
 
 HTTPDate = functools.partial(email.utils.formatdate, usegmt=True)
@@ -71,14 +77,13 @@ def protocol_from_http(protocol_str):
 def get_ranges(headervalue, content_length):
     """Return a list of (start, stop) indices from a Range header, or None.
 
-    Each (start, stop) tuple will be composed of two ints, which are suitable
-    for use in a slicing operation. That is, the header "Range: bytes=3-6",
-    if applied against a Python string, is requesting resource[3:7]. This
-    function will return the list [(3, 7)].
+    Each (start, stop) tuple will be composed of two ints, which are
+    suitable for use in a slicing operation. That is, the header "Range:
+    bytes=3-6", if applied against a Python string, is requesting
+    resource[3:7]. This function will return the list [(3, 7)].
 
     If this function returns an empty list, you should return HTTP 416.
     """
-
     if not headervalue:
         return None
 
@@ -127,29 +132,34 @@ def get_ranges(headervalue, content_length):
 
 
 class HeaderElement(object):
-
     """An element (with parameters) from an HTTP header's element list."""
 
     def __init__(self, value, params=None):
+        """Initialize an HTTP header value representation."""
         self.value = value
         if params is None:
             params = {}
         self.params = params
 
     def __cmp__(self, other):
+        """Compare current HTTP header to another by value only."""
         return builtins.cmp(self.value, other.value)
 
     def __lt__(self, other):
+        """Check if this header value is less than the other."""
         return self.value < other.value
 
     def __str__(self):
+        """Render the HTTP header value as a string."""
         p = [';%s=%s' % (k, v) for k, v in self.params.items()]
         return str('%s%s' % (self.value, ''.join(p)))
 
     def __bytes__(self):
+        """Turn the HTTP header value string representation to bytes."""
         return ntob(self.__str__())
 
     def __unicode__(self):
+        """Render the HTTP header value as a string."""
         return ntou(self.__str__())
 
     @staticmethod
@@ -169,18 +179,19 @@ def from_str(cls, elementstr):
 
 
 class AcceptElement(HeaderElement):
-
     """An element (with parameters) from an Accept* header's element list.
 
-    AcceptElement objects are comparable; the more-preferred object will be
-    "less than" the less-preferred object. They are also therefore sortable;
-    if you sort a list of AcceptElement objects, they will be listed in
-    priority order; the most preferred value will be first. Yes, it should
-    have been the other way around, but it's too late to fix now.
+    AcceptElement objects are comparable; the more-preferred object will
+    be "less than" the less-preferred object. They are also therefore
+    sortable; if you sort a list of AcceptElement objects, they will be
+    listed in priority order; the most preferred value will be first.
+    Yes, it should have been the other way around, but it's too late to
+    fix now.
     """
 
     @classmethod
     def from_str(cls, elementstr):
+        """Make an :class:`AcceptElement` instance from a string."""
         qvalue = None
         # The first "q" parameter (if any) separates the initial
         # media-range parameter(s) (if any) from the accept-params.
@@ -198,7 +209,7 @@ def from_str(cls, elementstr):
 
     @property
     def qvalue(self):
-        'The qvalue, or priority, of this value.'
+        """The qvalue, or priority, of this value."""
         val = self.params.get('q', '1')
         if isinstance(val, HeaderElement):
             val = val.value
@@ -211,17 +222,21 @@ def qvalue(self):
             """
             raise cherrypy.HTTPError(
                 400,
-                'Malformed HTTP header: `{}`'.
-                format(str(self)),
+                'Malformed HTTP header: `{}`'.format(str(self)),
             ) from val_err
 
     def __cmp__(self, other):
+        """Compare current header to another by qvalues then strings."""
         diff = builtins.cmp(self.qvalue, other.qvalue)
         if diff == 0:
             diff = builtins.cmp(str(self), str(other))
         return diff
 
     def __lt__(self, other):
+        """Check if this header qvalue is less than the other.
+
+        This method uses string comparison as the second factor.
+        """
         if self.qvalue == other.qvalue:
             return str(self) < str(other)
         else:
@@ -232,7 +247,9 @@ def __lt__(self, other):
 
 
 def header_elements(fieldname, fieldvalue):
-    """Return a sorted HeaderElement list from a comma-separated header string.
+    """Return a sorted :class:`HeaderElement` list.
+
+    Constucted from a comma-separated header string.
     """
     if not fieldvalue:
         return []
@@ -249,8 +266,7 @@ def header_elements(fieldname, fieldvalue):
 
 
 def decode_TEXT(value):
-    r"""
-    Decode :rfc:`2047` TEXT
+    r"""Decode :rfc:`2047` TEXT.
 
     >>> decode_TEXT("=?utf-8?q?f=C3=BCr?=") == b'f\xfcr'.decode('latin-1')
     True
@@ -265,9 +281,7 @@ def decode_TEXT(value):
 
 
 def decode_TEXT_maybe(value):
-    """
-    Decode the text but only if '=?' appears in it.
-    """
+    """Decode the text but only if '=?' appears in it."""
     return decode_TEXT(value) if '=?' in value else value
 
 
@@ -287,7 +301,6 @@ def valid_status(status):
     ... ) + BaseHTTPRequestHandler.responses[http.client.ACCEPTED]
     True
     """
-
     if not status:
         status = 200
 
@@ -299,12 +312,16 @@ def valid_status(status):
     try:
         code = int(code)
     except (TypeError, ValueError):
-        raise ValueError('Illegal response status from server '
-                         '(%s is non-numeric).' % repr(code))
+        raise ValueError(
+            'Illegal response status from server '
+            '(%s is non-numeric).' % repr(code),
+        )
 
     if code < 100 or code > 599:
-        raise ValueError('Illegal response status from server '
-                         '(%s is out of range).' % repr(code))
+        raise ValueError(
+            'Illegal response status from server '
+            '(%s is out of range).' % repr(code),
+        )
 
     if code not in response_codes:
         # code is unknown but not illegal
@@ -322,11 +339,11 @@ def valid_status(status):
 # in the python3.0 source - we need to pass through an encoding to the unquote
 # method, but the default parse_qs function doesn't allow us to.  These do.
 
+
 def _parse_qs(qs, keep_blank_values=0, strict_parsing=0, encoding='utf-8'):
     """Parse a query given as a string argument.
 
     Arguments:
-
     qs: URL-encoded query string to be parsed
 
     keep_blank_values: flag indicating whether blank values in
@@ -388,7 +405,6 @@ def parse_query_string(query_string, keep_blank_values=True, encoding='utf-8'):
 
 
 class CaseInsensitiveDict(jaraco.collections.KeyTransformingDict):
-
     """A case-insensitive dict subclass.
 
     Each key is changed on entry to title case.
@@ -396,6 +412,7 @@ class CaseInsensitiveDict(jaraco.collections.KeyTransformingDict):
 
     @staticmethod
     def transform_key(key):
+        """Title-case an HTTP header name."""
         if key is None:
             # TODO(#1830): why?
             return 'None'
@@ -409,15 +426,15 @@ def transform_key(key):
 # replaced with a single SP before interpretation of the TEXT value."
 if str == bytes:
     header_translate_table = ''.join([chr(i) for i in range(256)])
-    header_translate_deletechars = ''.join(
-        [chr(i) for i in range(32)]) + chr(127)
+    header_translate_deletechars = ''.join([chr(i) for i in range(32)]) + chr(
+        127,
+    )
 else:
     header_translate_table = None
     header_translate_deletechars = bytes(range(32)) + bytes([127])
 
 
 class HeaderMap(CaseInsensitiveDict):
-
     """A dict subclass for HTTP request and response headers.
 
     Each key is changed on entry to str(key).title(). This allows headers
@@ -450,7 +467,8 @@ def output(self):
 
     @classmethod
     def encode_header_items(cls, header_items):
-        """
+        """Emit tuples of wire-ready HTTP headers.
+
         Prepare the sequence of name, value tuples into a form suitable for
         transmitting on the wire for HTTP.
         """
@@ -462,13 +480,16 @@ def encode_header_items(cls, header_items):
 
     @classmethod
     def encode_header_item(cls, item):
+        """Encode an HTTP header for sending over the wire."""
         if isinstance(item, str):
             item = cls.encode(item)
 
         # See header_translate_* constants above.
         # Replace only if you really know what you're doing.
         return item.translate(
-            header_translate_table, header_translate_deletechars)
+            header_translate_table,
+            header_translate_deletechars,
+        )
 
     @classmethod
     def encode(cls, v):
@@ -486,15 +507,15 @@ def encode(cls, v):
             # because we never want to fold lines--folding has
             # been deprecated by the HTTP working group.
             v = b2a_base64(v.encode('utf-8'))
-            return (b'=?utf-8?b?' + v.strip(b'\n') + b'?=')
+            return b'=?utf-8?b?' + v.strip(b'\n') + b'?='
 
-        raise ValueError('Could not encode header part %r using '
-                         'any of the encodings %r.' %
-                         (v, cls.encodings))
+        raise ValueError(
+            'Could not encode header part %r using '
+            'any of the encodings %r.' % (v, cls.encodings),
+        )
 
 
 class Host(object):
-
     """An internet address.
 
     name
@@ -508,6 +529,7 @@ class Host(object):
     name = 'unknown.tld'
 
     def __init__(self, ip, port, name=None):
+        """Initialize a TCP service representation."""
         self.ip = ip
         self.port = port
         if name is None:
@@ -515,4 +537,39 @@ def __init__(self, ip, port, name=None):
         self.name = name
 
     def __repr__(self):
+        """Render a :class:`Host` instance representation."""
         return 'httputil.Host(%r, %r, %r)' % (self.ip, self.port, self.name)
+
+
+class SanitizedHost(str):
+    r"""A normalized host header value.
+
+    Wraps a raw host header received from the network in
+    a sanitized version that elides dangerous characters.
+
+    >>> SanitizedHost('foo\nbar')
+    'foobar'
+    >>> SanitizedHost('foo\nbar').raw
+    'foo\nbar'
+
+    A SanitizedInstance is only returned if sanitization was performed.
+
+    >>> isinstance(SanitizedHost('foobar'), SanitizedHost)
+    False
+    """
+
+    dangerous = re.compile(r'[\n\r]')
+
+    def __new__(cls, raw):
+        """Construct a new :class:`SanitizedHost` instance."""
+        sanitized = cls._sanitize(raw)
+        if sanitized == raw:
+            return raw
+        instance = super().__new__(cls, sanitized)
+        instance.raw = raw
+        return instance
+
+    @classmethod
+    def _sanitize(cls, raw):
+        """Clean up the CR LF chars from input."""
+        return cls.dangerous.sub('', raw)
diff --git a/cherrypy/lib/jsontools.py b/cherrypy/lib/jsontools.py
index 9ca75a8f3..a43f36f91 100644
--- a/cherrypy/lib/jsontools.py
+++ b/cherrypy/lib/jsontools.py
@@ -1,3 +1,5 @@
+"""JSON tools."""
+
 import cherrypy
 from cherrypy import _json as json
 from cherrypy._cpcompat import text_or_bytes, ntou
@@ -13,9 +15,14 @@ def json_processor(entity):
         cherrypy.serving.request.json = json.decode(body.decode('utf-8'))
 
 
-def json_in(content_type=[ntou('application/json'), ntou('text/javascript')],
-            force=True, debug=False, processor=json_processor):
-    """Add a processor to parse JSON request entities:
+def json_in(
+    content_type=[ntou('application/json'), ntou('text/javascript')],
+    force=True,
+    debug=False,
+    processor=json_processor,
+):
+    """Add a processor to parse JSON request entities.
+
     The default processor places the parsed data into request.json.
 
     Incoming request entities which match the given content_type(s) will
@@ -42,12 +49,16 @@ def json_in(content_type=[ntou('application/json'), ntou('text/javascript')],
 
     if force:
         if debug:
-            cherrypy.log('Removing body processors %s' %
-                         repr(request.body.processors.keys()), 'TOOLS.JSON_IN')
+            cherrypy.log(
+                'Removing body processors %s'
+                % repr(request.body.processors.keys()),
+                'TOOLS.JSON_IN',
+            )
         request.body.processors.clear()
         request.body.default_proc = cherrypy.HTTPError(
-            415, 'Expected an entity of content type %s' %
-            ', '.join(content_type))
+            415,
+            'Expected an entity of content type %s' % ', '.join(content_type),
+        )
 
     for ct in content_type:
         if debug:
@@ -56,12 +67,16 @@ def json_in(content_type=[ntou('application/json'), ntou('text/javascript')],
 
 
 def json_handler(*args, **kwargs):
+    """Convert decorated HTTP handler-returned object to JSON string."""
     value = cherrypy.serving.request._json_inner_handler(*args, **kwargs)
     return json.encode(value)
 
 
-def json_out(content_type='application/json', debug=False,
-             handler=json_handler):
+def json_out(
+    content_type='application/json',
+    debug=False,
+    handler=json_handler,
+):
     """Wrap request.handler to serialize its output to JSON. Sets Content-Type.
 
     If the given content_type is None, the Content-Type response header
@@ -78,12 +93,16 @@ def json_out(content_type='application/json', debug=False,
     if request.handler is None:
         return
     if debug:
-        cherrypy.log('Replacing %s with JSON handler' % request.handler,
-                     'TOOLS.JSON_OUT')
+        cherrypy.log(
+            'Replacing %s with JSON handler' % request.handler,
+            'TOOLS.JSON_OUT',
+        )
     request._json_inner_handler = request.handler
     request.handler = handler
     if content_type is not None:
         if debug:
-            cherrypy.log('Setting Content-Type to %s' %
-                         content_type, 'TOOLS.JSON_OUT')
+            cherrypy.log(
+                'Setting Content-Type to %s' % content_type,
+                'TOOLS.JSON_OUT',
+            )
         cherrypy.serving.response.headers['Content-Type'] = content_type
diff --git a/cherrypy/lib/locking.py b/cherrypy/lib/locking.py
index 317fb58c9..7bd7f194e 100644
--- a/cherrypy/lib/locking.py
+++ b/cherrypy/lib/locking.py
@@ -1,39 +1,49 @@
+"""Lock acquisition helpers."""
+
 import datetime
 
 
 class NeverExpires(object):
+    """A representation of a never expiring object."""
+
     def expired(self):
+        """Communicate that the object hasn't expired."""
         return False
 
 
 class Timer(object):
-    """
-    A simple timer that will indicate when an expiration time has passed.
-    """
+    """A simple timer that will indicate when an expiration time has passed."""
+
     def __init__(self, expiration):
-        'Create a timer that expires at `expiration` (UTC datetime)'
+        """Create a timer that expires at `expiration` (UTC datetime)."""
         self.expiration = expiration
 
     @classmethod
     def after(cls, elapsed):
-        """
-        Return a timer that will expire after `elapsed` passes.
-        """
-        return cls(datetime.datetime.utcnow() + elapsed)
+        """Return a timer that will expire after `elapsed` passes."""
+        return cls(
+            datetime.datetime.now(datetime.timezone.utc) + elapsed,
+        )
 
     def expired(self):
-        return datetime.datetime.utcnow() >= self.expiration
+        """Check whether the timer has expired."""
+        return (
+            datetime.datetime.now(
+                datetime.timezone.utc,
+            )
+            >= self.expiration
+        )
 
 
 class LockTimeout(Exception):
-    'An exception when a lock could not be acquired before a timeout period'
+    """Exception when a lock could not be acquired before a timeout period."""
 
 
 class LockChecker(object):
-    """
-    Keep track of the time and detect if a timeout has expired
-    """
+    """Keep track of the time and detect if a timeout has expired."""
+
     def __init__(self, session_id, timeout):
+        """Initialize a lock acquisition tracker."""
         self.session_id = session_id
         if timeout:
             self.timer = Timer.after(timeout)
@@ -41,7 +51,9 @@ def __init__(self, session_id, timeout):
             self.timer = NeverExpires()
 
     def expired(self):
+        """Check whether the lock checker has expired."""
         if self.timer.expired():
             raise LockTimeout(
-                'Timeout acquiring lock for %(session_id)s' % vars(self))
+                'Timeout acquiring lock for %(session_id)s' % vars(self),
+            )
         return False
diff --git a/cherrypy/lib/profiler.py b/cherrypy/lib/profiler.py
index fccf2eb85..659df56cb 100644
--- a/cherrypy/lib/profiler.py
+++ b/cherrypy/lib/profiler.py
@@ -30,7 +30,6 @@ def _index(self):
 ``--profile`` flag when running the test suite. Then, use the ``serve()``
 function to browse the results in a web browser. If you run this
 module from the command line, it will call ``serve()`` for you.
-
 """
 
 import io
@@ -47,7 +46,9 @@ def _index(self):
     import pstats
 
     def new_func_strip_path(func_name):
-        """Make profiler output more readable by adding `__init__` modules' parents
+        """Add ``__init__`` modules' parents.
+
+        This makes the profiler output more readable.
         """
         filename, line, name = func_name
         if filename.endswith('__init__.py'):
@@ -68,8 +69,10 @@ def new_func_strip_path(func_name):
 
 
 class Profiler(object):
+    """A profiling app."""
 
     def __init__(self, path=None):
+        """Prepare the profiling app resources."""
         if not path:
             path = os.path.join(os.path.dirname(__file__), 'profile')
         self.path = path
@@ -87,38 +90,35 @@ def run(self, func, *args, **params):
         return result
 
     def statfiles(self):
-        """:rtype: list of available profiles.
+        """Compose a list of statistics file names.
+
+        :returns: A list of available profiles.
+        :rtype: list[str]
         """
-        return [f for f in os.listdir(self.path)
-                if f.startswith('cp_') and f.endswith('.prof')]
+        return [
+            f
+            for f in os.listdir(self.path)
+            if f.startswith('cp_') and f.endswith('.prof')
+        ]
 
     def stats(self, filename, sortby='cumulative'):
-        """:rtype stats(index): output of print_stats() for the given profile.
+        """Generate statistics from given profile.
+
+        :returns: The sorted stats index printout.
+        :rtype: str
         """
         sio = io.StringIO()
-        if sys.version_info >= (2, 5):
-            s = pstats.Stats(os.path.join(self.path, filename), stream=sio)
-            s.strip_dirs()
-            s.sort_stats(sortby)
-            s.print_stats()
-        else:
-            # pstats.Stats before Python 2.5 didn't take a 'stream' arg,
-            # but just printed to stdout. So re-route stdout.
-            s = pstats.Stats(os.path.join(self.path, filename))
-            s.strip_dirs()
-            s.sort_stats(sortby)
-            oldout = sys.stdout
-            try:
-                sys.stdout = sio
-                s.print_stats()
-            finally:
-                sys.stdout = oldout
+        s = pstats.Stats(os.path.join(self.path, filename), stream=sio)
+        s.strip_dirs()
+        s.sort_stats(sortby)
+        s.print_stats()
         response = sio.getvalue()
         sio.close()
         return response
 
     @cherrypy.expose
     def index(self):
+        """Render the profiling viewer index page."""
         return """<html>
         <head><title>CherryPy profile data</title></head>
         <frameset cols='200, 1*'>
@@ -130,29 +130,36 @@ def index(self):
 
     @cherrypy.expose
     def menu(self):
+        """Render the profiler menu page html layout."""
         yield '<h2>Profiling runs</h2>'
         yield '<p>Click on one of the runs below to see profiling data.</p>'
         runs = self.statfiles()
         runs.sort()
         for i in runs:
             yield "<a href='report?filename=%s' target='main'>%s</a><br />" % (
-                i, i)
+                i,
+                i,
+            )
 
     @cherrypy.expose
     def report(self, filename):
+        """Render a statistics report."""
         cherrypy.response.headers['Content-Type'] = 'text/plain'
         return self.stats(filename)
 
 
 class ProfileAggregator(Profiler):
+    """A profiling aggregator app."""
 
     def __init__(self, path=None):
+        """Prepare the profiling aggregator app resources."""
         Profiler.__init__(self, path)
         global _count
         self.count = _count = _count + 1
         self.profiler = profile.Profile()
 
     def run(self, func, *args, **params):
+        """Dump aggeregated profile data into ``self.path``."""
         path = os.path.join(self.path, 'cp_%04d.prof' % self.count)
         result = self.profiler.runcall(func, *args, **params)
         self.profiler.dump_stats(path)
@@ -160,6 +167,7 @@ def run(self, func, *args, **params):
 
 
 class make_app:
+    """Profiling WSGI middleware wrapper."""
 
     def __init__(self, nextapp, path=None, aggregate=False):
         """Make a WSGI middleware app which wraps 'nextapp' with profiling.
@@ -178,11 +186,13 @@ def __init__(self, nextapp, path=None, aggregate=False):
 
         """
         if profile is None or pstats is None:
-            msg = ('Your installation of Python does not have a profile '
-                   "module. If you're on Debian, try "
-                   '`sudo apt-get install python-profiler`. '
-                   'See http://www.cherrypy.org/wiki/ProfilingOnDebian '
-                   'for details.')
+            msg = (
+                'Your installation of Python does not have a profile '
+                "module. If you're on Debian, try "
+                '`sudo apt-get install python-profiler`. '
+                'See https://web.archive.org/web/20111016122921/'
+                'http://www.cherrypy.org/wiki/ProfilingOnDebian for details.'
+            )
             warnings.warn(msg)
 
         self.nextapp = nextapp
@@ -193,27 +203,36 @@ def __init__(self, nextapp, path=None, aggregate=False):
             self.profiler = Profiler(path)
 
     def __call__(self, environ, start_response):
+        """Process a WSGI request."""
+
         def gather():
             result = []
             for line in self.nextapp(environ, start_response):
                 result.append(line)
             return result
+
         return self.profiler.run(gather)
 
 
 def serve(path=None, port=8080):
+    """Serve the web app with profiler activated."""
     if profile is None or pstats is None:
-        msg = ('Your installation of Python does not have a profile module. '
-               "If you're on Debian, try "
-               '`sudo apt-get install python-profiler`. '
-               'See http://www.cherrypy.org/wiki/ProfilingOnDebian '
-               'for details.')
+        msg = (
+            'Your installation of Python does not have a profile module. '
+            "If you're on Debian, try "
+            '`sudo apt-get install python-profiler`. '
+            'See https://web.archive.org/web/20111016122921/'
+            'http://www.cherrypy.org/wiki/ProfilingOnDebian for details.'
+        )
         warnings.warn(msg)
 
-    cherrypy.config.update({'server.socket_port': int(port),
-                            'server.thread_pool': 10,
-                            'environment': 'production',
-                            })
+    cherrypy.config.update(
+        {
+            'server.socket_port': int(port),
+            'server.thread_pool': 10,
+            'environment': 'production',
+        },
+    )
     cherrypy.quickstart(Profiler(path))
 
 
diff --git a/cherrypy/lib/reprconf.py b/cherrypy/lib/reprconf.py
index 3976652e1..e8d9d6df0 100644
--- a/cherrypy/lib/reprconf.py
+++ b/cherrypy/lib/reprconf.py
@@ -27,18 +27,17 @@
 
 
 class NamespaceSet(dict):
-
     """A dict of config namespace names and handlers.
 
-    Each config entry should begin with a namespace name; the corresponding
-    namespace handler will be called once for each config entry in that
-    namespace, and will be passed two arguments: the config key (with the
-    namespace removed) and the config value.
+    Each config entry should begin with a namespace name; the
+    corresponding namespace handler will be called once for each config
+    entry in that namespace, and will be passed two arguments: the
+    config key (with the namespace removed) and the config value.
 
     Namespace handlers may be any Python callable; they may also be
-    context managers, in which case their __enter__
-    method should return a callable to be used as the handler.
-    See cherrypy.tools (the Toolbox class) for an example.
+    context managers, in which case their __enter__ method should return
+    a callable to be used as the handler. See cherrypy.tools (the
+    Toolbox class) for an example.
     """
 
     def __call__(self, config):
@@ -48,9 +47,10 @@ def __call__(self, config):
             A flat dict, where keys use dots to separate
             namespaces, and values are arbitrary.
 
-        The first name in each config key is used to look up the corresponding
-        namespace handler. For example, a config entry of {'tools.gzip.on': v}
-        will call the 'tools' namespace handler with the args: ('gzip.on', v)
+        The first name in each config key is used to look up the
+        corresponding namespace handler. For example, a config entry of
+        {'tools.gzip.on': v} will call the 'tools' namespace handler
+        with the args: ('gzip.on', v)
         """
         # Separate the given config into namespaces
         ns_confs = {}
@@ -92,18 +92,23 @@ def __call__(self, config):
                     handler(k, v)
 
     def __repr__(self):
-        return '%s.%s(%s)' % (self.__module__, self.__class__.__name__,
-                              dict.__repr__(self))
+        """Render representation of a :class:`NamespaceSet` instance."""
+        return '%s.%s(%s)' % (
+            self.__module__,
+            self.__class__.__name__,
+            dict.__repr__(self),
+        )
 
     def __copy__(self):
+        """Make a copy of this instance."""
         newobj = self.__class__()
         newobj.update(self)
         return newobj
+
     copy = __copy__
 
 
 class Config(dict):
-
     """A dict-like set of configuration data, with defaults and namespaces.
 
     May take a file, filename, or dict.
@@ -114,6 +119,7 @@ class Config(dict):
     namespaces = NamespaceSet()
 
     def __init__(self, file=None, **kwargs):
+        """Initialize a CherryPy :class:`Config`."""
         self.reset()
         if file is not None:
             self.update(file)
@@ -142,20 +148,24 @@ def _apply(self, config):
         self.namespaces(config)
 
     def __setitem__(self, k, v):
+        """Assign a config setting."""
         dict.__setitem__(self, k, v)
         self.namespaces({k: v})
 
 
 class Parser(configparser.ConfigParser):
+    """A parser for the INI-style config file.
 
-    """Sub-class of ConfigParser that keeps the case of options and that
+    Sub-class of ConfigParser that keeps the case of options and that
     raises an exception if the file cannot be read.
     """
 
     def optionxform(self, optionstr):
+        """Keep the option names unedited."""
         return optionstr
 
     def read(self, filenames):
+        """Read the config from files on disk."""
         if isinstance(filenames, text_or_bytes):
             filenames = [filenames]
         for filename in filenames:
@@ -163,14 +173,11 @@ def read(self, filenames):
             #     fp = open(filename)
             # except IOError:
             #     continue
-            fp = open(filename)
-            try:
+            with open(filename) as fp:
                 self._read(fp, filename)
-            finally:
-                fp.close()
 
     def as_dict(self, raw=False, vars=None):
-        """Convert an INI file to a dictionary"""
+        """Convert an INI file to a dictionary."""
         # Load INI file into a dict
         result = {}
         for section in self.sections():
@@ -182,16 +189,19 @@ def as_dict(self, raw=False, vars=None):
                     value = unrepr(value)
                 except Exception:
                     x = sys.exc_info()[1]
-                    msg = ('Config error in section: %r, option: %r, '
-                           'value: %r. Config values must be valid Python.' %
-                           (section, option, value))
+                    msg = (
+                        'Config error in section: %r, option: %r, '
+                        'value: %r. Config values must be valid Python.'
+                        % (section, option, value)
+                    )
                     raise ValueError(msg, x.__class__.__name__, x.args)
                 result[section][option] = value
         return result
 
     def dict_from_file(self, file):
+        """Generate a dict from a file."""
         if hasattr(file, 'read'):
-            self.readfp(file)
+            self.read_file(file)
         else:
             self.read(file)
         return self.as_dict()
@@ -212,12 +222,12 @@ def load(self, input):
 
 
 class _Builder:
-
     def build(self, o):
         m = getattr(self, 'build_' + o.__class__.__name__, None)
         if m is None:
-            raise TypeError('unrepr does not recognize %s' %
-                            repr(o.__class__.__name__))
+            raise TypeError(
+                'unrepr does not recognize %s' % repr(o.__class__.__name__),
+            )
         return m(o)
 
     def astnode(self, s):
@@ -238,12 +248,12 @@ def build_Subscript(self, o):
     def build_Index(self, o):
         return self.build(o.value)
 
-    def _build_call35(self, o):
-        """
-        Workaround for python 3.5 _ast.Call signature, docs found here
-        https://greentreesnakes.readthedocs.org/en/latest/nodes.html
-        """
+    def build_Call(self, o):
+        """Emulate ``build_Call`` under Python 3.5+."""
+        # Workaround for python 3.5. _ast.Call signature, docs found at
+        # https://greentreesnakes.readthedocs.org/en/latest/nodes.html
         import ast
+
         callee = self.build(o.func)
         args = []
         if o.args is not None:
@@ -257,8 +267,9 @@ def _build_call35(self, o):
             if kw.arg is None:  # double asterix `**`
                 rst = self.build(kw.value)
                 if not isinstance(rst, dict):
-                    raise TypeError('Invalid argument for call.'
-                                    'Must be a mapping object.')
+                    raise TypeError(
+                        'Invalid argument for call.Must be a mapping object.',
+                    )
                 # give preference to the keys set directly from arg=value
                 for k, v in rst.items():
                     if k not in kwargs:
@@ -267,32 +278,6 @@ def _build_call35(self, o):
                 kwargs[kw.arg] = self.build(kw.value)
         return callee(*args, **kwargs)
 
-    def build_Call(self, o):
-        if sys.version_info >= (3, 5):
-            return self._build_call35(o)
-
-        callee = self.build(o.func)
-
-        if o.args is None:
-            args = ()
-        else:
-            args = tuple([self.build(a) for a in o.args])
-
-        if o.starargs is None:
-            starargs = ()
-        else:
-            starargs = tuple(self.build(o.starargs))
-
-        if o.kwargs is None:
-            kwargs = {}
-        else:
-            kwargs = self.build(o.kwargs)
-        if o.keywords is not None:  # direct a=b keywords
-            for kw in o.keywords:
-                # preference because is a direct keyword against **kwargs
-                kwargs[kw.arg] = self.build(kw.value)
-        return callee(*(args + starargs), **kwargs)
-
     def build_List(self, o):
         return list(map(self.build, o.elts))
 
@@ -303,8 +288,9 @@ def build_Num(self, o):
         return o.n
 
     def build_Dict(self, o):
-        return dict([(self.build(k), self.build(v))
-                     for k, v in zip(o.keys, o.values)])
+        return dict(
+            [(self.build(k), self.build(v)) for k, v in zip(o.keys, o.values)],
+        )
 
     def build_Tuple(self, o):
         return tuple(self.build_List(o))
@@ -332,11 +318,9 @@ def build_Name(self, o):
 
         raise TypeError('unrepr could not resolve the name %s' % repr(name))
 
-    def build_NameConstant(self, o):
+    def build_Constant(self, o):
         return o.value
 
-    build_Constant = build_NameConstant  # Python 3.8 change
-
     def build_UnaryOp(self, o):
         op, operand = map(self.build, [o.op, o.operand])
         return op(operand)
@@ -379,10 +363,9 @@ def modules(modulePath):
 
 def attributes(full_attribute_name):
     """Load a module and retrieve an attribute of that module."""
-
     # Parse out the path, module, and attribute
     last_dot = full_attribute_name.rfind('.')
-    attr_name = full_attribute_name[last_dot + 1:]
+    attr_name = full_attribute_name[last_dot + 1 :]
     mod_path = full_attribute_name[:last_dot]
 
     mod = modules(mod_path)
@@ -390,8 +373,9 @@ def attributes(full_attribute_name):
     try:
         attr = getattr(mod, attr_name)
     except AttributeError:
-        raise AttributeError("'%s' object has no attribute '%s'"
-                             % (mod_path, attr_name))
+        raise AttributeError(
+            "'%s' object has no attribute '%s'" % (mod_path, attr_name),
+        )
 
     # Return a reference to the attribute.
     return attr
diff --git a/cherrypy/lib/sessions.py b/cherrypy/lib/sessions.py
index 5b3328f2d..0ab0fb4f1 100644
--- a/cherrypy/lib/sessions.py
+++ b/cherrypy/lib/sessions.py
@@ -100,6 +100,7 @@
 expiration date, although this was on a system with an inaccurate system time.
 Maybe FF doesn't trust system time.
 """
+
 import sys
 import datetime
 import os
@@ -108,7 +109,7 @@
 import binascii
 import pickle
 
-import zc.lockfile
+from filelock import FileLock, Timeout
 
 import cherrypy
 from cherrypy.lib import httputil
@@ -120,7 +121,6 @@
 
 
 class Session(object):
-
     """A CherryPy dict-like Session object (one per request)."""
 
     _id = None
@@ -148,9 +148,11 @@ def id(self, value):
     to session data."""
 
     loaded = False
+    """If True, data has been retrieved from storage.
+
+    This should happen automatically on the first attempt to access
+    session data.
     """
-    If True, data has been retrieved from storage. This should happen
-    automatically on the first attempt to access session data."""
 
     clean_thread = None
     'Class-level Monitor which calls self.clean_up.'
@@ -165,9 +167,10 @@ def id(self, value):
     'True if the session requested by the client did not exist.'
 
     regenerated = False
+    """True if the application called session.regenerate().
+
+    This is not set by internal calls to regenerate the session id.
     """
-    True if the application called session.regenerate(). This is not set by
-    internal calls to regenerate the session id."""
 
     debug = False
     'If True, log debug information.'
@@ -175,6 +178,7 @@ def id(self, value):
     # --------------------- Session management methods --------------------- #
 
     def __init__(self, id=None, **kwargs):
+        """Initialize the session tool."""
         self.id_observers = []
         self._data = {}
 
@@ -194,8 +198,11 @@ def __init__(self, id=None, **kwargs):
                     cherrypy.log('Set id to %s.' % id, 'TOOLS.SESSIONS')
             else:
                 if self.debug:
-                    cherrypy.log('Expired or malicious session %r; '
-                                 'making a new one' % id, 'TOOLS.SESSIONS')
+                    cherrypy.log(
+                        'Expired or malicious session %r; '
+                        'making a new one' % id,
+                        'TOOLS.SESSIONS',
+                    )
                 # Expired or malicious session. Make a new one.
                 # See https://github.com/cherrypy/cherrypy/issues/709.
                 self.id = None
@@ -221,7 +228,8 @@ def _regenerate(self):
                 cherrypy.log(
                     'Deleting the existing session %r before '
                     'regeneration.' % self.id,
-                    'TOOLS.SESSIONS')
+                    'TOOLS.SESSIONS',
+                )
             self.delete()
 
         old_session_was_locked = self.locked
@@ -237,8 +245,7 @@ def _regenerate(self):
             if self._exists():
                 self.id = None
         if self.debug:
-            cherrypy.log('Set id to generated %s.' % self.id,
-                         'TOOLS.SESSIONS')
+            cherrypy.log('Set id to generated %s.' % self.id, 'TOOLS.SESSIONS')
 
         if old_session_was_locked:
             self.acquire_lock()
@@ -262,15 +269,19 @@ def save(self):
                 t = datetime.timedelta(seconds=self.timeout * 60)
                 expiration_time = self.now() + t
                 if self.debug:
-                    cherrypy.log('Saving session %r with expiry %s' %
-                                 (self.id, expiration_time),
-                                 'TOOLS.SESSIONS')
+                    cherrypy.log(
+                        'Saving session %r with expiry %s'
+                        % (self.id, expiration_time),
+                        'TOOLS.SESSIONS',
+                    )
                 self._save(expiration_time)
             else:
                 if self.debug:
                     cherrypy.log(
-                        'Skipping save of session %r (no session loaded).' %
-                        self.id, 'TOOLS.SESSIONS')
+                        'Skipping save of session %r (no session loaded).'
+                        % self.id,
+                        'TOOLS.SESSIONS',
+                    )
         finally:
             if self.locked:
                 # Always release the lock if the user didn't release it
@@ -284,13 +295,17 @@ def load(self):
         # data is either None or a tuple (session_data, expiration_time)
         if data is None or data[1] < self.now():
             if self.debug:
-                cherrypy.log('Expired session %r, flushing data.' % self.id,
-                             'TOOLS.SESSIONS')
+                cherrypy.log(
+                    'Expired session %r, flushing data.' % self.id,
+                    'TOOLS.SESSIONS',
+                )
             self._data = {}
         else:
             if self.debug:
-                cherrypy.log('Data loaded for session %r.' % self.id,
-                             'TOOLS.SESSIONS')
+                cherrypy.log(
+                    'Data loaded for session %r.' % self.id,
+                    'TOOLS.SESSIONS',
+                )
             self._data = data[0]
         self.loaded = True
 
@@ -301,8 +316,11 @@ def load(self):
             # clean_up is an instancemethod and not a classmethod,
             # so that tool config can be accessed inside the method.
             t = cherrypy.process.plugins.Monitor(
-                cherrypy.engine, self.clean_up, self.clean_freq * 60,
-                name='Session cleanup')
+                cherrypy.engine,
+                self.clean_up,
+                self.clean_freq * 60,
+                name='Session cleanup',
+            )
             t.subscribe()
             cls.clean_thread = t
             t.start()
@@ -313,30 +331,33 @@ def delete(self):
         """Delete stored session data."""
         self._delete()
         if self.debug:
-            cherrypy.log('Deleted session %s.' % self.id,
-                         'TOOLS.SESSIONS')
+            cherrypy.log('Deleted session %s.' % self.id, 'TOOLS.SESSIONS')
 
     # -------------------- Application accessor methods -------------------- #
 
     def __getitem__(self, key):
+        """Retrieve a session-stored object."""
         if not self.loaded:
             self.load()
         return self._data[key]
 
     def __setitem__(self, key, value):
+        """Store an object in the session."""
         if not self.loaded:
             self.load()
         self._data[key] = value
 
     def __delitem__(self, key):
+        """Delete object stored in the session."""
         if not self.loaded:
             self.load()
         del self._data[key]
 
     def pop(self, key, default=missing):
         """Remove the specified key and return the corresponding value.
-        If key is not found, default is returned if given,
-        otherwise KeyError is raised.
+
+        If key is not found, default is returned if given, otherwise
+        KeyError is raised.
         """
         if not self.loaded:
             self.load()
@@ -346,54 +367,80 @@ def pop(self, key, default=missing):
             return self._data.pop(key, default)
 
     def __contains__(self, key):
+        """Check if the session has an object by key."""
         if not self.loaded:
             self.load()
         return key in self._data
 
     def get(self, key, default=None):
-        """D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None."""
+        """Retrieve a session-stored object.
+
+        D.get(k[,d]) -> D[k] if k in D, else d.
+        d defaults to None.
+        """
         if not self.loaded:
             self.load()
         return self._data.get(key, default)
 
     def update(self, d):
-        """D.update(E) -> None.  Update D from E: for k in E: D[k] = E[k]."""
+        """Update multiple session-stored objects in one go.
+
+        D.update(E) -> None.
+        Update D from E: for k in E: D[k] = E[k].
+        """
         if not self.loaded:
             self.load()
         self._data.update(d)
 
     def setdefault(self, key, default=None):
-        """D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D."""
+        """Set a default session key value.
+
+        D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D.
+        """
         if not self.loaded:
             self.load()
         return self._data.setdefault(key, default)
 
     def clear(self):
-        """D.clear() -> None.  Remove all items from D."""
+        """Clean up the session-stored data.
+
+        D.clear() -> None.
+        Remove all items from D.
+        """
         if not self.loaded:
             self.load()
         self._data.clear()
 
     def keys(self):
-        """D.keys() -> list of D's keys."""
+        """Return an iterable of session keys.
+
+        D.keys() -> list of D's keys.
+        """
         if not self.loaded:
             self.load()
         return self._data.keys()
 
     def items(self):
-        """D.items() -> list of D's (key, value) pairs, as 2-tuples."""
+        """Return an iterable of items as tuples.
+
+        D.items() -> list of D's (key, value) pairs, as 2-tuples.
+        """
         if not self.loaded:
             self.load()
         return self._data.items()
 
     def values(self):
-        """D.values() -> list of D's values."""
+        """Return an iterable of session objects.
+
+        D.values() -> list of D's values.
+        """
         if not self.loaded:
             self.load()
         return self._data.values()
 
 
 class RamSession(Session):
+    """A memory-baked session store implementation."""
 
     # Class-level objects. Don't rebind these!
     cache = {}
@@ -401,7 +448,6 @@ class RamSession(Session):
 
     def clean_up(self):
         """Clean up expired sessions."""
-
         now = self.now()
         for _id, (data, expiration_time) in self.cache.copy().items():
             if expiration_time <= now:
@@ -418,9 +464,8 @@ def clean_up(self):
 
         # added to remove obsolete lock objects
         for _id in list(self.locks):
-            locked = (
-                _id not in self.cache
-                and self.locks[_id].acquire(blocking=False)
+            locked = _id not in self.cache and self.locks[_id].acquire(
+                blocking=False,
             )
             if locked:
                 lock = self.locks.pop(_id)
@@ -454,8 +499,7 @@ def __len__(self):
 
 
 class FileSession(Session):
-
-    """Implementation of the File backend for sessions
+    """Implementation of the file backend for sessions.
 
     storage_path
         The folder where session data will be saved. Each session
@@ -473,6 +517,7 @@ class FileSession(Session):
     pickle_protocol = pickle.HIGHEST_PROTOCOL
 
     def __init__(self, id=None, **kwargs):
+        """Prepare the file session store."""
         # The 'storage_path' arg is required for file-based sessions.
         kwargs['storage_path'] = os.path.abspath(kwargs['storage_path'])
         kwargs.setdefault('lock_timeout', None)
@@ -484,7 +529,8 @@ def __init__(self, id=None, **kwargs):
             self.lock_timeout = datetime.timedelta(seconds=self.lock_timeout)
         if not isinstance(self.lock_timeout, (datetime.timedelta, type(None))):
             raise ValueError(
-                'Lock timeout must be numeric seconds or a timedelta instance.'
+                'Lock timeout must be numeric seconds '
+                'or a timedelta instance.',
             )
 
     @classmethod
@@ -492,7 +538,8 @@ def setup(cls, **kwargs):
         """Set up the storage system for file-based sessions.
 
         This should only be called once per process; this will be done
-        automatically when using sessions.init (as the built-in Tool does).
+        automatically when using sessions.init (as the built-in Tool
+        does).
         """
         # The 'storage_path' arg is required for file-based sessions.
         kwargs['storage_path'] = os.path.abspath(kwargs['storage_path'])
@@ -511,35 +558,37 @@ def _exists(self):
         return os.path.exists(path)
 
     def _load(self, path=None):
-        assert self.locked, ('The session load without being locked.  '
-                             "Check your tools' priority levels.")
+        assert self.locked, (
+            'The session load without being locked.  '
+            "Check your tools' priority levels."
+        )
         if path is None:
             path = self._get_file_path()
         try:
-            f = open(path, 'rb')
-            try:
+            with open(path, 'rb') as f:
                 return pickle.load(f)
-            finally:
-                f.close()
         except (IOError, EOFError):
             e = sys.exc_info()[1]
             if self.debug:
-                cherrypy.log('Error loading the session pickle: %s' %
-                             e, 'TOOLS.SESSIONS')
+                cherrypy.log(
+                    'Error loading the session pickle: %s' % e,
+                    'TOOLS.SESSIONS',
+                )
             return None
 
     def _save(self, expiration_time):
-        assert self.locked, ('The session was saved without being locked.  '
-                             "Check your tools' priority levels.")
-        f = open(self._get_file_path(), 'wb')
-        try:
+        assert self.locked, (
+            'The session was saved without being locked.  '
+            "Check your tools' priority levels."
+        )
+        with open(self._get_file_path(), 'wb') as f:
             pickle.dump((self._data, expiration_time), f, self.pickle_protocol)
-        finally:
-            f.close()
 
     def _delete(self):
-        assert self.locked, ('The session deletion without being locked.  '
-                             "Check your tools' priority levels.")
+        assert self.locked, (
+            'The session deletion without being locked.  '
+            "Check your tools' priority levels."
+        )
         try:
             os.unlink(self._get_file_path())
         except OSError:
@@ -552,19 +601,21 @@ def acquire_lock(self, path=None):
         path += self.LOCK_SUFFIX
         checker = locking.LockChecker(self.id, self.lock_timeout)
         while not checker.expired():
+            lock = FileLock(path)
+            timeout = 0.1
             try:
-                self.lock = zc.lockfile.LockFile(path)
-            except zc.lockfile.LockError:
-                time.sleep(0.1)
-            else:
+                lock.acquire(timeout=timeout)
+                self.lock = lock
                 break
+            except Timeout:
+                time.sleep(timeout)
         self.locked = True
         if self.debug:
             cherrypy.log('Lock acquired.', 'TOOLS.SESSIONS')
 
     def release_lock(self, path=None):
         """Release the lock on the currently-loaded session data."""
-        self.lock.close()
+        self.lock.release()
         self.locked = False
 
     def clean_up(self):
@@ -572,10 +623,9 @@ def clean_up(self):
         now = self.now()
         # Iterate over all session files in self.storage_path
         for fname in os.listdir(self.storage_path):
-            have_session = (
-                fname.startswith(self.SESSION_PREFIX)
-                and not fname.endswith(self.LOCK_SUFFIX)
-            )
+            have_session = fname.startswith(
+                self.SESSION_PREFIX,
+            ) and not fname.endswith(self.LOCK_SUFFIX)
             if have_session:
                 # We have a session file: lock and load it and check
                 #   if it's expired. If it fails, nevermind.
@@ -601,12 +651,20 @@ def clean_up(self):
 
     def __len__(self):
         """Return the number of active sessions."""
-        return len([fname for fname in os.listdir(self.storage_path)
-                    if (fname.startswith(self.SESSION_PREFIX) and
-                        not fname.endswith(self.LOCK_SUFFIX))])
+        return len(
+            [
+                fname
+                for fname in os.listdir(self.storage_path)
+                if (
+                    fname.startswith(self.SESSION_PREFIX)
+                    and not fname.endswith(self.LOCK_SUFFIX)
+                )
+            ],
+        )
 
 
 class MemcachedSession(Session):
+    """A Memcached-baked session store."""
 
     # The most popular memcached client for Python isn't thread-safe.
     # Wrap all .get and .set operations in a single lock.
@@ -622,12 +680,14 @@ def setup(cls, **kwargs):
         """Set up the storage system for memcached-based sessions.
 
         This should only be called once per process; this will be done
-        automatically when using sessions.init (as the built-in Tool does).
+        automatically when using sessions.init (as the built-in Tool
+        does).
         """
         for k, v in kwargs.items():
             setattr(cls, k, v)
 
         import memcache
+
         cls.cache = memcache.Client(cls.servers)
 
     def _exists(self):
@@ -651,7 +711,8 @@ def _save(self, expiration_time):
         try:
             if not self.cache.set(self.id, (self._data, expiration_time), td):
                 raise AssertionError(
-                    'Session data for id %r not set.' % self.id)
+                    'Session data for id %r not set.' % self.id,
+                )
         finally:
             self.mc_lock.release()
 
@@ -677,9 +738,9 @@ def __len__(self):
 
 # Hook functions (for CherryPy tools)
 
+
 def save():
     """Save any changed session data."""
-
     if not hasattr(cherrypy.serving, 'session'):
         return
     request = cherrypy.serving.request
@@ -719,12 +780,22 @@ def close():
 close.priority = 90
 
 
-def init(storage_type=None, path=None, path_header=None, name='session_id',
-         timeout=60, domain=None, secure=False, clean_freq=5,
-         persistent=True, httponly=False, debug=False,
-         # Py27 compat
-         # *, storage_class=RamSession,
-         **kwargs):
+def init(
+    storage_type=None,
+    path=None,
+    path_header=None,
+    name='session_id',
+    timeout=60,
+    domain=None,
+    secure=False,
+    clean_freq=5,
+    persistent=True,
+    httponly=False,
+    debug=False,
+    # Py27 compat
+    # *, storage_class=RamSession,
+    **kwargs,
+):
     """Initialize session object (using cookies).
 
     storage_class
@@ -775,7 +846,6 @@ def init(storage_type=None, path=None, path_header=None, name='session_id',
     and may be specific to the storage type. See the subclass of Session
     you're using for more information.
     """
-
     # Py27 compat
     storage_class = kwargs.pop('storage_class', RamSession)
 
@@ -791,8 +861,10 @@ def init(storage_type=None, path=None, path_header=None, name='session_id',
     if name in request.cookie:
         id = request.cookie[name].value
         if debug:
-            cherrypy.log('ID obtained from request.cookie: %r' % id,
-                         'TOOLS.SESSIONS')
+            cherrypy.log(
+                'ID obtained from request.cookie: %r' % id,
+                'TOOLS.SESSIONS',
+            )
 
     first_time = not hasattr(cherrypy, 'session')
 
@@ -819,6 +891,7 @@ def init(storage_type=None, path=None, path_header=None, name='session_id',
     def update_cookie(id):
         """Update the cookie every time the session id changes."""
         cherrypy.serving.response.cookie[name] = id
+
     sess.id_observers.append(update_cookie)
 
     # Create cherrypy.session which will proxy to cherrypy.serving.session
@@ -831,13 +904,26 @@ def update_cookie(id):
         # See http://support.microsoft.com/kb/223799/EN-US/
         # and http://support.mozilla.com/en-US/kb/Cookies
         cookie_timeout = None
-    set_response_cookie(path=path, path_header=path_header, name=name,
-                        timeout=cookie_timeout, domain=domain, secure=secure,
-                        httponly=httponly)
+    set_response_cookie(
+        path=path,
+        path_header=path_header,
+        name=name,
+        timeout=cookie_timeout,
+        domain=domain,
+        secure=secure,
+        httponly=httponly,
+    )
 
 
-def set_response_cookie(path=None, path_header=None, name='session_id',
-                        timeout=60, domain=None, secure=False, httponly=False):
+def set_response_cookie(
+    path=None,
+    path_header=None,
+    name='session_id',
+    timeout=60,
+    domain=None,
+    secure=False,
+    httponly=False,
+):
     """Set a response cookie for the client.
 
     path
@@ -871,9 +957,7 @@ def set_response_cookie(path=None, path_header=None, name='session_id',
     cookie = cherrypy.serving.response.cookie
     cookie[name] = cherrypy.serving.session.id
     cookie[name]['path'] = (
-        path or
-        cherrypy.serving.request.headers.get(path_header) or
-        '/'
+        path or cherrypy.serving.request.headers.get(path_header) or '/'
     )
 
     if timeout:
@@ -890,7 +974,8 @@ def set_response_cookie(path=None, path_header=None, name='session_id',
 
 
 def _add_MSIE_max_age_workaround(cookie, timeout):
-    """
+    """Inject a Microsoft Internet Explorer ``max-age`` workaround.
+
     We'd like to use the "max-age" param as indicated in
     http://www.faqs.org/rfcs/rfc2109.html but IE doesn't
     save it to disk and the session is lost if people close
@@ -903,7 +988,9 @@ def _add_MSIE_max_age_workaround(cookie, timeout):
 def expire():
     """Expire the current session cookie."""
     name = cherrypy.serving.request.config.get(
-        'tools.sessions.name', 'session_id')
+        'tools.sessions.name',
+        'session_id',
+    )
     one_year = 60 * 60 * 24 * 365
     e = time.time() - one_year
     cherrypy.serving.response.cookie[name]['expires'] = httputil.HTTPDate(e)
diff --git a/cherrypy/lib/static.py b/cherrypy/lib/static.py
index 66a5a9474..a4ff5054d 100644
--- a/cherrypy/lib/static.py
+++ b/cherrypy/lib/static.py
@@ -1,19 +1,18 @@
 """Module with helpers for serving static files."""
 
+import mimetypes
 import os
 import platform
 import re
 import stat
-import mimetypes
-import urllib.parse
 import unicodedata
-
+import urllib.parse
 from email.generator import _make_boundary as make_boundary
 from io import UnsupportedOperation
 
 import cherrypy
 from cherrypy._cpcompat import ntob
-from cherrypy.lib import cptools, httputil, file_generator_limited
+from cherrypy.lib import cptools, file_generator_limited, httputil
 
 
 def _setup_mimetypes():
@@ -43,29 +42,35 @@ def _make_content_disposition(disposition, file_name):
     # searching, and may be substituted for each other.
     # See: https://en.wikipedia.org/wiki/Unicode_equivalence.
     ascii_name = (
-        unicodedata.normalize('NFKC', file_name).
-        encode('ascii', errors='ignore').decode()
+        unicodedata.normalize('NFKC', file_name)
+        .encode('ascii', errors='ignore')
+        .decode()
     )
     header = '{}; filename="{}"'.format(disposition, ascii_name)
     if ascii_name != file_name:
         quoted_name = urllib.parse.quote(file_name)
-        header += '; filename*=UTF-8\'\'{}'.format(quoted_name)
+        header += "; filename*=UTF-8''{}".format(quoted_name)
     return header
 
 
-def serve_file(path, content_type=None, disposition=None, name=None,
-               debug=False):
+def serve_file(
+    path,
+    content_type=None,
+    disposition=None,
+    name=None,
+    debug=False,
+):
     """Set status, headers, and body in order to serve the given path.
 
-    The Content-Type header will be set to the content_type arg, if provided.
-    If not provided, the Content-Type will be guessed by the file extension
-    of the 'path' argument.
+    The Content-Type header will be set to the content_type arg, if
+    provided. If not provided, the Content-Type will be guessed by the
+    file extension of the 'path' argument.
 
-    If disposition is not None, the Content-Disposition header will be set
-    to "<disposition>; filename=<name>; filename*=utf-8''<name>"
-    as described in :rfc:`6266#appendix-D`.
-    If name is None, it will be set to the basename of path.
-    If disposition is None, no Content-Disposition header will be written.
+    If disposition is not None, the Content-Disposition header will be
+    set to "<disposition>; filename=<name>; filename*=utf-8''<name>" as
+    described in :rfc:`6266#appendix-D`. If name is None, it will be set
+    to the basename of path. If disposition is None, no Content-
+    Disposition header will be written.
     """
     response = cherrypy.serving.response
 
@@ -130,8 +135,13 @@ def serve_file(path, content_type=None, disposition=None, name=None,
     return _serve_fileobj(fileobj, content_type, content_length, debug=debug)
 
 
-def serve_fileobj(fileobj, content_type=None, disposition=None, name=None,
-                  debug=False):
+def serve_fileobj(
+    fileobj,
+    content_type=None,
+    disposition=None,
+    name=None,
+    debug=False,
+):
     """Set status, headers, and body in order to serve the given file object.
 
     The Content-Type header will be set to the content_type arg, if provided.
@@ -185,7 +195,10 @@ def serve_fileobj(fileobj, content_type=None, disposition=None, name=None,
 
 
 def _serve_fileobj(fileobj, content_type, content_length, debug=False):
-    """Internal. Set response.body to the given file object, perhaps ranged."""
+    """Set ``response.body`` to the given file object, perhaps ranged.
+
+    Internal helper.
+    """
     response = cherrypy.serving.response
 
     # HTTP/1.0 didn't have Range/Accept-Ranges headers, or the 206 code
@@ -195,8 +208,9 @@ def _serve_fileobj(fileobj, content_type, content_length, debug=False):
         r = httputil.get_ranges(request.headers.get('Range'), content_length)
         if r == []:
             response.headers['Content-Range'] = 'bytes */%s' % content_length
-            message = ('Invalid Range (first-byte-pos greater than '
-                       'Content-Length)')
+            message = (
+                'Invalid Range (first-byte-pos greater than Content-Length)'
+            )
             if debug:
                 cherrypy.log(message, 'TOOLS.STATIC')
             raise cherrypy.HTTPError(416, message)
@@ -211,10 +225,14 @@ def _serve_fileobj(fileobj, content_type, content_length, debug=False):
                 if debug:
                     cherrypy.log(
                         'Single part; start: %r, stop: %r' % (start, stop),
-                        'TOOLS.STATIC')
+                        'TOOLS.STATIC',
+                    )
                 response.status = '206 Partial Content'
-                response.headers['Content-Range'] = (
-                    'bytes %s-%s/%s' % (start, stop - 1, content_length))
+                response.headers['Content-Range'] = 'bytes %s-%s/%s' % (
+                    start,
+                    stop - 1,
+                    content_length,
+                )
                 response.headers['Content-Length'] = r_len
                 fileobj.seek(start)
                 response.body = file_generator_limited(fileobj, r_len)
@@ -235,16 +253,20 @@ def file_ranges():
                     for start, stop in r:
                         if debug:
                             cherrypy.log(
-                                'Multipart; start: %r, stop: %r' % (
-                                    start, stop),
-                                'TOOLS.STATIC')
+                                'Multipart; start: %r, stop: %r'
+                                % (start, stop),
+                                'TOOLS.STATIC',
+                            )
                         yield ntob('--' + boundary, 'ascii')
-                        yield ntob('\r\nContent-type: %s' % content_type,
-                                   'ascii')
                         yield ntob(
-                            '\r\nContent-range: bytes %s-%s/%s\r\n\r\n' % (
-                                start, stop - 1, content_length),
-                            'ascii')
+                            '\r\nContent-type: %s' % content_type,
+                            'ascii',
+                        )
+                        yield ntob(
+                            '\r\nContent-range: bytes %s-%s/%s\r\n\r\n'
+                            % (start, stop - 1, content_length),
+                            'ascii',
+                        )
                         fileobj.seek(start)
                         gen = file_generator_limited(fileobj, stop - start)
                         for chunk in gen:
@@ -255,6 +277,7 @@ def file_ranges():
 
                     # Apache compatibility:
                     yield b'\r\n'
+
                 response.body = file_ranges()
             return response.body
         else:
@@ -276,8 +299,10 @@ def serve_download(path, name=None):
 
 def _attempt(filename, content_types, debug=False):
     if debug:
-        cherrypy.log('Attempting %r (content_types %r)' %
-                     (filename, content_types), 'TOOLS.STATICDIR')
+        cherrypy.log(
+            'Attempting %r (content_types %r)' % (filename, content_types),
+            'TOOLS.STATICDIR',
+        )
     try:
         # you can set the content types for a
         # complete directory per extension
@@ -295,8 +320,15 @@ def _attempt(filename, content_types, debug=False):
         return False
 
 
-def staticdir(section, dir, root='', match='', content_types=None, index='',
-              debug=False):
+def staticdir(
+    section,
+    dir,
+    root='',
+    match='',
+    content_types=None,
+    index='',
+    debug=False,
+):
     """Serve a static resource from the given (root +) dir.
 
     match
@@ -323,8 +355,11 @@ def staticdir(section, dir, root='', match='', content_types=None, index='',
 
     if match and not re.search(match, request.path_info):
         if debug:
-            cherrypy.log('request.path_info %r does not match pattern %r' %
-                         (request.path_info, match), 'TOOLS.STATICDIR')
+            cherrypy.log(
+                'request.path_info %r does not match pattern %r'
+                % (request.path_info, match),
+                'TOOLS.STATICDIR',
+            )
         return False
 
     # Allow the use of '~' to refer to a user's home directory.
@@ -344,7 +379,7 @@ def staticdir(section, dir, root='', match='', content_types=None, index='',
     if section == 'global':
         section = '/'
     section = section.rstrip(r'\/')
-    branch = request.path_info[len(section) + 1:]
+    branch = request.path_info[len(section) + 1 :]
     branch = urllib.parse.unquote(branch.lstrip(r'\/'))
 
     # Requesting a file in sub-dir of the staticdir results
@@ -358,8 +393,10 @@ def staticdir(section, dir, root='', match='', content_types=None, index='',
     # If branch is "", filename will end in a slash
     filename = os.path.join(dir, branch)
     if debug:
-        cherrypy.log('Checking file %r to fulfill %r' %
-                     (filename, request.path_info), 'TOOLS.STATICDIR')
+        cherrypy.log(
+            'Checking file %r to fulfill %r' % (filename, request.path_info),
+            'TOOLS.STATICDIR',
+        )
 
     # There's a chance that the branch pulled from the URL might
     # have ".." or similar uplevel attacks in it. Check that the final
@@ -399,15 +436,19 @@ def staticfile(filename, root=None, match='', content_types=None, debug=False):
 
     if match and not re.search(match, request.path_info):
         if debug:
-            cherrypy.log('request.path_info %r does not match pattern %r' %
-                         (request.path_info, match), 'TOOLS.STATICFILE')
+            cherrypy.log(
+                'request.path_info %r does not match pattern %r'
+                % (request.path_info, match),
+                'TOOLS.STATICFILE',
+            )
         return False
 
     # If filename is relative, make absolute using "root".
     if not os.path.isabs(filename):
         if not root:
             msg = "Static tool requires an absolute filename (got '%s')." % (
-                filename,)
+                filename,
+            )
             if debug:
                 cherrypy.log(msg, 'TOOLS.STATICFILE')
             raise ValueError(msg)
diff --git a/cherrypy/lib/xmlrpcutil.py b/cherrypy/lib/xmlrpcutil.py
index 29d9c4a2b..315026706 100644
--- a/cherrypy/lib/xmlrpcutil.py
+++ b/cherrypy/lib/xmlrpcutil.py
@@ -1,8 +1,10 @@
 """XML-RPC tool helpers."""
+
 import sys
 from xmlrpc.client import (
-    loads as xmlrpc_loads, dumps as xmlrpc_dumps,
-    Fault as XMLRPCFault
+    loads as xmlrpc_loads,
+    dumps as xmlrpc_dumps,
+    Fault as XMLRPCFault,
 )
 
 import cherrypy
@@ -14,7 +16,7 @@ def process_body():
     try:
         return xmlrpc_loads(cherrypy.request.body.read())
     except Exception:
-        return ('ERROR PARAMS', ), 'ERRORMETHOD'
+        return ('ERROR PARAMS',), 'ERRORMETHOD'
 
 
 def patched_path(path):
@@ -47,10 +49,11 @@ def respond(body, encoding='utf-8', allow_none=0):
 
     _set_response(
         xmlrpc_dumps(
-            body, methodresponse=1,
+            body,
+            methodresponse=1,
             encoding=encoding,
-            allow_none=allow_none
-        )
+            allow_none=allow_none,
+        ),
     )
 
 
diff --git a/cherrypy/process/plugins.py b/cherrypy/process/plugins.py
index d2f87a4d4..1e65b7486 100644
--- a/cherrypy/process/plugins.py
+++ b/cherrypy/process/plugins.py
@@ -31,7 +31,6 @@
 
 
 class SimplePlugin(object):
-
     """Plugin base class which auto-subscribes methods for known channels."""
 
     bus = None
@@ -39,6 +38,7 @@ class SimplePlugin(object):
     """
 
     def __init__(self, bus):
+        """Initialize a simple plugin."""
         self.bus = bus
 
     def subscribe(self):
@@ -59,7 +59,6 @@ def unsubscribe(self):
 
 
 class SignalHandler(object):
-
     """Register bus channels (and listeners) for system signals.
 
     You can modify what signals your application listens for, and what it does
@@ -95,18 +94,22 @@ class SignalHandler(object):
     del k, v
 
     def __init__(self, bus):
+        """Initialize a signal handler plugin."""
         self.bus = bus
         # Set default handlers
-        self.handlers = {'SIGTERM': self.bus.exit,
-                         'SIGHUP': self.handle_SIGHUP,
-                         'SIGUSR1': self.bus.graceful,
-                         }
+        self.handlers = {
+            'SIGTERM': self.bus.exit,
+            'SIGHUP': self.handle_SIGHUP,
+            'SIGUSR1': self.bus.graceful,
+        }
 
         if sys.platform[:4] == 'java':
             del self.handlers['SIGUSR1']
             self.handlers['SIGUSR2'] = self.bus.graceful
-            self.bus.log('SIGUSR1 cannot be set on the JVM platform. '
-                         'Using SIGUSR2 instead.')
+            self.bus.log(
+                'SIGUSR1 cannot be set on the JVM platform. '
+                'Using SIGUSR2 instead.',
+            )
             self.handlers['SIGINT'] = self._jython_SIGINT_handler
 
         self._previous_handlers = {}
@@ -119,8 +122,7 @@ def _jython_SIGINT_handler(self, signum=None, frame=None):
         self.bus.exit()
 
     def _is_daemonized(self):
-        """Return boolean indicating if the current process is
-        running as a daemon.
+        """Check if current process is running as a daemon.
 
         The criteria to determine the `daemon` condition is to verify
         if the current pid is not the same as the one that got used on
@@ -131,9 +133,8 @@ def _is_daemonized(self):
         is executing inside other process like in a CI tool
         (Buildbot, Jenkins).
         """
-        return (
-            self._original_pid != os.getpid() and
-            not os.isatty(sys.stdin.fileno())
+        return self._original_pid != os.getpid() and not os.isatty(
+            sys.stdin.fileno(),
         )
 
     def subscribe(self):
@@ -158,12 +159,17 @@ def unsubscribe(self):
             try:
                 our_handler = _signal.signal(signum, handler)
                 if our_handler is None:
-                    self.bus.log('Restored old %s handler %r, but our '
-                                 'handler was not registered.' %
-                                 (signame, handler), level=30)
+                    self.bus.log(
+                        'Restored old %s handler %r, but our '
+                        'handler was not registered.' % (signame, handler),
+                        level=30,
+                    )
             except ValueError:
-                self.bus.log('Unable to restore %s handler %r.' %
-                             (signame, handler), level=40, traceback=True)
+                self.bus.log(
+                    'Unable to restore %s handler %r.' % (signame, handler),
+                    level=40,
+                    traceback=True,
+                )
 
     def set_handler(self, signal, listener=None):
         """Subscribe a handler for the given signal (number or name).
@@ -171,8 +177,8 @@ def set_handler(self, signal, listener=None):
         If the optional 'listener' argument is provided, it will be
         subscribed as a listener for the given signal's channel.
 
-        If the given signal name or number is not available on the current
-        platform, ValueError is raised.
+        If the given signal name or number is not available on the
+        current platform, ValueError is raised.
         """
         if isinstance(signal, text_or_bytes):
             signum = getattr(_signal, signal, None)
@@ -218,14 +224,14 @@ def handle_SIGHUP(self):
 
 
 class DropPrivileges(SimplePlugin):
-
     """Drop privileges. uid/gid arguments not available on Windows.
 
     Special thanks to `Gavin Baker
-    <http://antonym.org/2005/12/dropping-privileges-in-python.html>`_
+    <http://antonym.org/2005/12/dropping-privileges-in-python.html>`_.
     """
 
     def __init__(self, bus, umask=None, uid=None, gid=None):
+        """Initialize the privilege dropping plugin."""
         SimplePlugin.__init__(self, bus)
         self.finalized = False
         self.uid = uid
@@ -234,15 +240,20 @@ def __init__(self, bus, umask=None, uid=None, gid=None):
 
     @property
     def uid(self):
-        """The uid under which to run. Availability: Unix."""
+        """The uid under which to run.
+
+        Availability: Unix.
+        """
         return self._uid
 
     @uid.setter
     def uid(self, val):
         if val is not None:
             if pwd is None:
-                self.bus.log('pwd module not available; ignoring uid.',
-                             level=30)
+                self.bus.log(
+                    'pwd module not available; ignoring uid.',
+                    level=30,
+                )
                 val = None
             elif isinstance(val, text_or_bytes):
                 val = pwd.getpwnam(val)[2]
@@ -250,15 +261,20 @@ def uid(self, val):
 
     @property
     def gid(self):
-        """The gid under which to run. Availability: Unix."""
+        """The gid under which to run.
+
+        Availability: Unix.
+        """
         return self._gid
 
     @gid.setter
     def gid(self, val):
         if val is not None:
             if grp is None:
-                self.bus.log('grp module not available; ignoring gid.',
-                             level=30)
+                self.bus.log(
+                    'grp module not available; ignoring gid.',
+                    level=30,
+                )
                 val = None
             elif isinstance(val, text_or_bytes):
                 val = grp.getgrnam(val)[2]
@@ -279,12 +295,16 @@ def umask(self, val):
             try:
                 os.umask
             except AttributeError:
-                self.bus.log('umask function not available; ignoring umask.',
-                             level=30)
+                self.bus.log(
+                    'umask function not available; ignoring umask.',
+                    level=30,
+                )
                 val = None
         self._umask = val
 
     def start(self):
+        """Drop the process privileges."""
+
         # uid/gid
         def current_ids():
             """Return the current (uid, gid) if available."""
@@ -297,8 +317,9 @@ def current_ids():
 
         if self.finalized:
             if not (self.uid is None and self.gid is None):
-                self.bus.log('Already running as uid: %r gid: %r' %
-                             current_ids())
+                self.bus.log(
+                    'Already running as uid: %r gid: %r' % current_ids(),
+                )
         else:
             if self.uid is None and self.gid is None:
                 if pwd or grp:
@@ -321,10 +342,12 @@ def current_ids():
                 self.bus.log('umask not set', level=30)
             else:
                 old_umask = os.umask(self.umask)
-                self.bus.log('umask old: %03o, new: %03o' %
-                             (old_umask, self.umask))
+                self.bus.log(
+                    'umask old: %03o, new: %03o' % (old_umask, self.umask),
+                )
 
         self.finalized = True
+
     # This is slightly higher than the priority for server.start
     # in order to facilitate the most common use: starting on a low
     # port (which requires root) and then dropping to another user.
@@ -332,7 +355,6 @@ def current_ids():
 
 
 class Daemonizer(SimplePlugin):
-
     """Daemonize the running script.
 
     Use this with a Web Site Process Bus via::
@@ -349,8 +371,14 @@ class Daemonizer(SimplePlugin):
     indicates if the process successfully finished the first fork.
     """
 
-    def __init__(self, bus, stdin='/dev/null', stdout='/dev/null',
-                 stderr='/dev/null'):
+    def __init__(
+        self,
+        bus,
+        stdin='/dev/null',
+        stdout='/dev/null',
+        stderr='/dev/null',
+    ):
+        """Initialize the daemonizer plugin."""
         SimplePlugin.__init__(self, bus)
         self.stdin = stdin
         self.stdout = stdout
@@ -358,6 +386,7 @@ def __init__(self, bus, stdin='/dev/null', stdout='/dev/null',
         self.finalized = False
 
     def start(self):
+        """Attempt to daemonize the process."""
         if self.finalized:
             self.bus.log('Already deamonized.')
 
@@ -366,20 +395,28 @@ def start(self):
         # "The general problem with making fork() work in a multi-threaded
         #  world is what to do with all of the threads..."
         # So we check for active threads:
-        if threading.activeCount() != 1:
-            self.bus.log('There are %r active threads. '
-                         'Daemonizing now may cause strange failures.' %
-                         threading.enumerate(), level=30)
+        if threading.active_count() != 1:
+            self.bus.log(
+                'There are %r active threads. '
+                'Daemonizing now may cause strange failures.'
+                % threading.enumerate(),
+                level=30,
+            )
 
         self.daemonize(self.stdin, self.stdout, self.stderr, self.bus.log)
 
         self.finalized = True
+
     start.priority = 65
 
     @staticmethod
     def daemonize(
-            stdin='/dev/null', stdout='/dev/null', stderr='/dev/null',
-            logger=lambda msg: None):
+        stdin='/dev/null',
+        stdout='/dev/null',
+        stderr='/dev/null',
+        logger=lambda msg: None,
+    ):
+        """Daemonize the process."""
         # See http://www.erlenstar.demon.co.uk/unix/faq_2.html#SEC16
         # (or http://www.faqs.org/faqs/unix-faq/programmer/faq/ section 1.7)
         # and http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/66012
@@ -423,25 +460,29 @@ def daemonize(
 
 
 class PIDFile(SimplePlugin):
-
     """Maintain a PID file via a WSPBus."""
 
     def __init__(self, bus, pidfile):
+        """Initialize the PID file plugin."""
         SimplePlugin.__init__(self, bus)
         self.pidfile = pidfile
         self.finalized = False
 
     def start(self):
+        """Write a PID file to disk."""
         pid = os.getpid()
         if self.finalized:
             self.bus.log('PID %r already written to %r.' % (pid, self.pidfile))
         else:
-            open(self.pidfile, 'wb').write(ntob('%s\n' % pid, 'utf8'))
+            with open(self.pidfile, 'wb') as f:
+                f.write(ntob('%s\n' % pid, 'utf8'))
             self.bus.log('PID %r written to %r.' % (pid, self.pidfile))
             self.finalized = True
+
     start.priority = 70
 
     def exit(self):
+        """Delete the PID file from disk."""
         try:
             os.remove(self.pidfile)
             self.bus.log('PID file removed: %r.' % self.pidfile)
@@ -452,20 +493,20 @@ def exit(self):
 
 
 class PerpetualTimer(threading.Timer):
-
     """A responsive subclass of threading.Timer whose run() method repeats.
 
     Use this timer only when you really need a very interruptible timer;
-    this checks its 'finished' condition up to 20 times a second, which can
-    results in pretty high CPU usage
+    this checks its 'finished' condition up to 20 times a second, which
+    can results in pretty high CPU usage
     """
 
     def __init__(self, *args, **kwargs):
-        "Override parent constructor to allow 'bus' to be provided."
+        """Override parent constructor to allow 'bus' to be provided."""
         self.bus = kwargs.pop('bus', None)
         super(PerpetualTimer, self).__init__(*args, **kwargs)
 
     def run(self):
+        """Run an infinitely repeated callable."""
         while True:
             self.finished.wait(self.interval)
             if self.finished.isSet():
@@ -475,24 +516,28 @@ def run(self):
             except Exception:
                 if self.bus:
                     self.bus.log(
-                        'Error in perpetual timer thread function %r.' %
-                        self.function, level=40, traceback=True)
+                        'Error in perpetual timer thread function %r.'
+                        % self.function,
+                        level=40,
+                        traceback=True,
+                    )
                 # Quit on first error to avoid massive logs.
                 raise
 
 
 class BackgroundTask(threading.Thread):
-
     """A subclass of threading.Thread whose run() method repeats.
 
-    Use this class for most repeating tasks. It uses time.sleep() to wait
-    for each interval, which isn't very responsive; that is, even if you call
-    self.cancel(), you'll have to wait until the sleep() call finishes before
-    the thread stops. To compensate, it defaults to being daemonic, which means
-    it won't delay stopping the whole process.
+    Use this class for most repeating tasks. It uses time.sleep() to
+    wait for each interval, which isn't very responsive; that is, even
+    if you call self.cancel(), you'll have to wait until the sleep()
+    call finishes before the thread stops. To compensate, it defaults to
+    being daemonic, which means it won't delay stopping the whole
+    process.
     """
 
     def __init__(self, interval, function, args=[], kwargs={}, bus=None):
+        """Initialize a background task parameters."""
         super(BackgroundTask, self).__init__()
         self.interval = interval
         self.function = function
@@ -505,9 +550,11 @@ def __init__(self, interval, function, args=[], kwargs={}, bus=None):
         self.daemon = True
 
     def cancel(self):
+        """Set a task cancellation flag."""
         self.running = False
 
     def run(self):
+        """Start running the repeated background task in the loop."""
         self.running = True
         while self.running:
             time.sleep(self.interval)
@@ -517,14 +564,17 @@ def run(self):
                 self.function(*self.args, **self.kwargs)
             except Exception:
                 if self.bus:
-                    self.bus.log('Error in background task thread function %r.'
-                                 % self.function, level=40, traceback=True)
+                    self.bus.log(
+                        'Error in background task thread function %r.'
+                        % self.function,
+                        level=40,
+                        traceback=True,
+                    )
                 # Quit on first error to avoid massive logs.
                 raise
 
 
 class Monitor(SimplePlugin):
-
     """WSPBus listener to periodically run a callback in its own thread."""
 
     callback = None
@@ -539,6 +589,7 @@ class Monitor(SimplePlugin):
     """
 
     def __init__(self, bus, callback, frequency=60, name=None):
+        """Initialize the monitor plugin."""
         SimplePlugin.__init__(self, bus)
         self.callback = callback
         self.frequency = frequency
@@ -550,23 +601,29 @@ def start(self):
         if self.frequency > 0:
             threadname = self.name or self.__class__.__name__
             if self.thread is None:
-                self.thread = BackgroundTask(self.frequency, self.callback,
-                                             bus=self.bus)
-                self.thread.setName(threadname)
+                self.thread = BackgroundTask(
+                    self.frequency,
+                    self.callback,
+                    bus=self.bus,
+                )
+                self.thread.name = threadname
                 self.thread.start()
                 self.bus.log('Started monitor thread %r.' % threadname)
             else:
                 self.bus.log('Monitor thread %r already started.' % threadname)
+
     start.priority = 70
 
     def stop(self):
         """Stop our callback's background task thread."""
         if self.thread is None:
-            self.bus.log('No thread running for %s.' %
-                         self.name or self.__class__.__name__)
+            self.bus.log(
+                'No thread running for %s.' % self.name
+                or self.__class__.__name__,
+            )
         else:
-            if self.thread is not threading.currentThread():
-                name = self.thread.getName()
+            if self.thread is not threading.current_thread():
+                name = self.thread.name
                 self.thread.cancel()
                 if not self.thread.daemon:
                     self.bus.log('Joining %r' % name)
@@ -581,7 +638,6 @@ def graceful(self):
 
 
 class Autoreloader(Monitor):
-
     """Monitor which re-executes the process when files change.
 
     This :ref:`plugin<plugins>` restarts the process (via :func:`os.execv`)
@@ -612,6 +668,7 @@ class Autoreloader(Monitor):
     """A regular expression by which to match filenames."""
 
     def __init__(self, bus, frequency=1, match='.*'):
+        """Initialize the auto-reloader monitor plugin."""
         self.mtimes = {}
         self.files = set()
         self.match = match
@@ -622,6 +679,7 @@ def start(self):
         if self.thread is None:
             self.mtimes = {}
         Monitor.start(self)
+
     start.priority = 70
 
     def sysfiles(self):
@@ -636,10 +694,9 @@ def sysfiles(self):
     @classmethod
     def _file_for_module(cls, module):
         """Return the relevant file for the module."""
-        return (
-            cls._archive_for_zip_module(module)
-            or cls._file_for_file_module(module)
-        )
+        return cls._archive_for_zip_module(
+            module,
+        ) or cls._file_for_file_module(module)
 
     @staticmethod
     def _archive_for_zip_module(module):
@@ -660,8 +717,12 @@ def _file_for_file_module(cls, module):
     @staticmethod
     def _make_absolute(filename):
         """Ensure filename is absolute to avoid effect of os.chdir."""
-        return filename if os.path.isabs(filename) else (
-            os.path.normpath(os.path.join(_module__file__base, filename))
+        return (
+            filename
+            if os.path.isabs(filename)
+            else (
+                os.path.normpath(os.path.join(_module__file__base, filename))
+            )
         )
 
     def run(self):
@@ -688,36 +749,37 @@ def run(self):
                 else:
                     if mtime is None or mtime > oldtime:
                         # The file has been deleted or modified.
-                        self.bus.log('Restarting because %s changed.' %
-                                     filename)
+                        self.bus.log(
+                            'Restarting because %s changed.' % filename,
+                        )
                         self.thread.cancel()
-                        self.bus.log('Stopped thread %r.' %
-                                     self.thread.getName())
+                        self.bus.log('Stopped thread %r.' % self.thread.name)
                         self.bus.restart()
                         return
 
 
 class ThreadManager(SimplePlugin):
-
     """Manager for HTTP request threads.
 
     If you have control over thread creation and destruction, publish to
-    the 'acquire_thread' and 'release_thread' channels (for each thread).
-    This will register/unregister the current thread and publish to
-    'start_thread' and 'stop_thread' listeners in the bus as needed.
+    the 'acquire_thread' and 'release_thread' channels (for each
+    thread). This will register/unregister the current thread and
+    publish to 'start_thread' and 'stop_thread' listeners in the bus as
+    needed.
 
     If threads are created and destroyed by code you do not control
     (e.g., Apache), then, at the beginning of every HTTP request,
     publish to 'acquire_thread' only. You should not publish to
-    'release_thread' in this case, since you do not know whether
-    the thread will be re-used or not. The bus will call
-    'stop_thread' listeners for you when it stops.
+    'release_thread' in this case, since you do not know whether the
+    thread will be re-used or not. The bus will call 'stop_thread'
+    listeners for you when it stops.
     """
 
     threads = None
     """A map of {thread ident: index number} pairs."""
 
     def __init__(self, bus):
+        """Initialize the thread manager plugin."""
         self.threads = {}
         SimplePlugin.__init__(self, bus)
         self.bus.listeners.setdefault('acquire_thread', set())
@@ -751,4 +813,5 @@ def stop(self):
         for thread_ident, i in self.threads.items():
             self.bus.publish('stop_thread', i)
         self.threads.clear()
+
     graceful = stop
diff --git a/cherrypy/process/servers.py b/cherrypy/process/servers.py
index dcb34de61..304d87a5d 100644
--- a/cherrypy/process/servers.py
+++ b/cherrypy/process/servers.py
@@ -1,4 +1,6 @@
 r"""
+Server interfaces.
+
 Starting in CherryPy 3.1, cherrypy.server is implemented as an
 :ref:`Engine Plugin<plugins>`. It's an instance of
 :class:`cherrypy._cpserver.Server`, which is a subclass of
@@ -127,12 +129,13 @@ def index(self):
 
 
 class Timeouts:
+    """Timeout constants."""
+
     occupied = 5
     free = 1
 
 
 class ServerAdapter(object):
-
     """Adapter for an HTTP server.
 
     If you need to start more than one HTTP server (to serve on multiple
@@ -147,6 +150,7 @@ class ServerAdapter(object):
     """
 
     def __init__(self, bus, httpserver=None, bind_addr=None):
+        """Initialize the HTTP server plugin."""
         self.bus = bus
         self.httpserver = httpserver
         self.bind_addr = bind_addr
@@ -154,10 +158,12 @@ def __init__(self, bus, httpserver=None, bind_addr=None):
         self.running = False
 
     def subscribe(self):
+        """Subscribe control methods to the bus lifecycle events."""
         self.bus.subscribe('start', self.start)
         self.bus.subscribe('stop', self.stop)
 
     def unsubscribe(self):
+        """Unsubcribe control methods to the bus lifecycle events."""
         self.bus.unsubscribe('start', self.start)
         self.bus.unsubscribe('stop', self.stop)
 
@@ -177,20 +183,20 @@ def start(self):
                 portend.free(*self.bind_addr, timeout=Timeouts.free)
 
         import threading
+
         t = threading.Thread(target=self._start_http_thread)
-        t.setName('HTTPServer ' + t.getName())
+        t.name = 'HTTPServer ' + t.name
         t.start()
 
         self.wait()
         self.running = True
         self.bus.log('Serving on %s' % self.description)
+
     start.priority = 75
 
     @property
     def description(self):
-        """
-        A description about where this server is bound.
-        """
+        """A description about where this server is bound."""
         if self.bind_addr is None:
             on_what = 'unknown interface (dynamic?)'
         elif isinstance(self.bind_addr, tuple):
@@ -215,7 +221,9 @@ def _get_base(self):
         return '%s://%s' % (scheme, host)
 
     def _start_http_thread(self):
-        """HTTP servers MUST be running in new threads, so that the
+        """Start the HTTP server thread.
+
+        HTTP servers MUST be running in new threads, so that the
         main thread persists to receive KeyboardInterrupt's. If an
         exception is raised in the httpserver's thread then it's
         trapped here, and the bus (and therefore our httpserver)
@@ -234,8 +242,11 @@ def _start_http_thread(self):
             raise
         except Exception:
             self.interrupt = sys.exc_info()[1]
-            self.bus.log('Error in HTTP server: shutting down',
-                         traceback=True, level=40)
+            self.bus.log(
+                'Error in HTTP server: shutting down',
+                traceback=True,
+                level=40,
+            )
             self.bus.exit()
             raise
 
@@ -244,7 +255,7 @@ def wait(self):
         while not getattr(self.httpserver, 'ready', False):
             if self.interrupt:
                 raise self.interrupt
-            time.sleep(.1)
+            time.sleep(0.1)
 
         # bypass check when LISTEN_PID is set
         if os.environ.get('LISTEN_PID', None):
@@ -261,9 +272,10 @@ def wait(self):
 
     @property
     def bound_addr(self):
-        """
-        The bind address, or if it's an ephemeral port and the
-        socket has been bound, return the actual port bound.
+        """The bind address.
+
+        If it's an ephemeral port and the socket has been bound,
+        return the actual port bound.
         """
         host, port = self.bind_addr
         if port == 0 and self.httpserver.socket:
@@ -283,6 +295,7 @@ def stop(self):
             self.bus.log('HTTP Server %s shut down' % self.httpserver)
         else:
             self.bus.log('HTTP Server %s already shut down' % self.httpserver)
+
     stop.priority = 25
 
     def restart(self):
@@ -292,10 +305,10 @@ def restart(self):
 
 
 class FlupCGIServer(object):
-
     """Adapter for a flup.server.cgi.WSGIServer."""
 
     def __init__(self, *args, **kwargs):
+        """Initialize the flup CGI Server plugin."""
         self.args = args
         self.kwargs = kwargs
         self.ready = False
@@ -316,17 +329,19 @@ def stop(self):
 
 
 class FlupFCGIServer(object):
-
     """Adapter for a flup.server.fcgi.WSGIServer."""
 
     def __init__(self, *args, **kwargs):
+        """Initialize the FCGI server parameters."""
         if kwargs.get('bindAddress', None) is None:
             import socket
+
             if not hasattr(socket, 'fromfd'):
                 raise ValueError(
                     'Dynamic FCGI server not available on this platform. '
                     'You must use a static or external one by providing a '
-                    'legal bindAddress.')
+                    'legal bindAddress.',
+                )
         self.args = args
         self.kwargs = kwargs
         self.ready = False
@@ -336,6 +351,7 @@ def start(self):
         # We have to instantiate the server class here because its __init__
         # starts a threadpool. If we do it too early, daemonize won't work.
         from flup.server.fcgi import WSGIServer
+
         self.fcgiserver = WSGIServer(*self.args, **self.kwargs)
         # TODO: report this bug upstream to flup.
         # If we don't set _oldSIGs on Windows, we get:
@@ -357,15 +373,16 @@ def stop(self):
         self.fcgiserver._keepGoing = False
         # Force all worker threads to die off.
         self.fcgiserver._threadPool.maxSpare = (
-            self.fcgiserver._threadPool._idleCount)
+            self.fcgiserver._threadPool._idleCount
+        )
         self.ready = False
 
 
 class FlupSCGIServer(object):
-
     """Adapter for a flup.server.scgi.WSGIServer."""
 
     def __init__(self, *args, **kwargs):
+        """Initialize the SCGI server parameters."""
         self.args = args
         self.kwargs = kwargs
         self.ready = False
@@ -375,6 +392,7 @@ def start(self):
         # We have to instantiate the server class here because its __init__
         # starts a threadpool. If we do it too early, daemonize won't work.
         from flup.server.scgi import WSGIServer
+
         self.scgiserver = WSGIServer(*self.args, **self.kwargs)
         # TODO: report this bug upstream to flup.
         # If we don't set _oldSIGs on Windows, we get:
@@ -401,7 +419,8 @@ def stop(self):
 
 @contextlib.contextmanager
 def _safe_wait(host, port):
-    """
+    """Warn when bind interface is ambiguous.
+
     On systems where a loopback interface is not available and the
     server is bound to all interfaces, it's difficult to determine
     whether the server is in fact occupying the port. In this case,
diff --git a/cherrypy/process/win32.py b/cherrypy/process/win32.py
index b7a79b1b0..98a203a82 100644
--- a/cherrypy/process/win32.py
+++ b/cherrypy/process/win32.py
@@ -1,4 +1,7 @@
-"""Windows service. Requires pywin32."""
+"""Windows service.
+
+Requires pywin32.
+"""
 
 import os
 import win32api
@@ -11,27 +14,32 @@
 
 
 class ConsoleCtrlHandler(plugins.SimplePlugin):
-
     """A WSPBus plugin for handling Win32 console events (like Ctrl-C)."""
 
     def __init__(self, bus):
+        """Initialize the console control handler."""
         self.is_set = False
         plugins.SimplePlugin.__init__(self, bus)
 
     def start(self):
+        """Register handling of the console control events."""
         if self.is_set:
             self.bus.log('Handler for console events already set.', level=20)
             return
 
         result = win32api.SetConsoleCtrlHandler(self.handle, 1)
         if result == 0:
-            self.bus.log('Could not SetConsoleCtrlHandler (error %r)' %
-                         win32api.GetLastError(), level=40)
+            self.bus.log(
+                'Could not SetConsoleCtrlHandler (error %r)'
+                % win32api.GetLastError(),
+                level=40,
+            )
         else:
             self.bus.log('Set handler for console events.', level=20)
             self.is_set = True
 
     def stop(self):
+        """Unregister the console control handlers."""
         if not self.is_set:
             self.bus.log('Handler for console events already off.', level=20)
             return
@@ -43,17 +51,24 @@ def stop(self):
             result = 1
 
         if result == 0:
-            self.bus.log('Could not remove SetConsoleCtrlHandler (error %r)' %
-                         win32api.GetLastError(), level=40)
+            self.bus.log(
+                'Could not remove SetConsoleCtrlHandler (error %r)'
+                % win32api.GetLastError(),
+                level=40,
+            )
         else:
             self.bus.log('Removed handler for console events.', level=20)
             self.is_set = False
 
     def handle(self, event):
         """Handle console control events (like Ctrl-C)."""
-        if event in (win32con.CTRL_C_EVENT, win32con.CTRL_LOGOFF_EVENT,
-                     win32con.CTRL_BREAK_EVENT, win32con.CTRL_SHUTDOWN_EVENT,
-                     win32con.CTRL_CLOSE_EVENT):
+        if event in (
+            win32con.CTRL_C_EVENT,
+            win32con.CTRL_LOGOFF_EVENT,
+            win32con.CTRL_BREAK_EVENT,
+            win32con.CTRL_SHUTDOWN_EVENT,
+            win32con.CTRL_CLOSE_EVENT,
+        ):
             self.bus.log('Console event %s: shutting down bus' % event)
 
             # Remove self immediately so repeated Ctrl-C doesn't re-call it.
@@ -69,13 +84,14 @@ def handle(self, event):
 
 
 class Win32Bus(wspbus.Bus):
-
     """A Web Site Process Bus implementation for Win32.
 
-    Instead of time.sleep, this bus blocks using native win32event objects.
+    Instead of time.sleep, this bus blocks using native win32event
+    objects.
     """
 
     def __init__(self):
+        """Initialize a Win32 bus implementation."""
         self.events = {}
         wspbus.Bus.__init__(self)
 
@@ -84,18 +100,23 @@ def _get_state_event(self, state):
         try:
             return self.events[state]
         except KeyError:
-            event = win32event.CreateEvent(None, 0, 0,
-                                           'WSPBus %s Event (pid=%r)' %
-                                           (state.name, os.getpid()))
+            event = win32event.CreateEvent(
+                None,
+                0,
+                0,
+                'WSPBus %s Event (pid=%r)' % (state.name, os.getpid()),
+            )
             self.events[state] = event
             return event
 
     @property
     def state(self):
+        """The bus state."""
         return self._state
 
     @state.setter
     def state(self, value):
+        """Set the bus state."""
         self._state = value
         event = self._get_state_event(value)
         win32event.PulseEvent(event)
@@ -111,7 +132,10 @@ def wait(self, state, interval=0.1, channel=None):
             if self.state not in state:
                 events = tuple([self._get_state_event(s) for s in state])
                 win32event.WaitForMultipleObjects(
-                    events, 0, win32event.INFINITE)
+                    events,
+                    0,
+                    win32event.INFINITE,
+                )
         else:
             # Don't wait for an event that beat us to the punch ;)
             if self.state != state:
@@ -120,7 +144,6 @@ def wait(self, state, interval=0.1, channel=None):
 
 
 class _ControlCodes(dict):
-
     """Control codes used to "signal" a service via ControlService.
 
     User-defined control codes are in the range 128-255. We generally use
@@ -143,6 +166,7 @@ def key_for(self, obj):
 
 
 def signal_child(service, command):
+    """Send a control command to a service."""
     if command == 'stop':
         win32serviceutil.StopService(service)
     elif command == 'restart':
@@ -152,30 +176,35 @@ def signal_child(service, command):
 
 
 class PyWebService(win32serviceutil.ServiceFramework):
-
     """Python Web Service."""
 
     _svc_name_ = 'Python Web Service'
     _svc_display_name_ = 'Python Web Service'
-    _svc_deps_ = None        # sequence of service names on which this depends
+    _svc_deps_ = None  # sequence of service names on which this depends
     _exe_name_ = 'pywebsvc'
-    _exe_args_ = None        # Default to no arguments
+    _exe_args_ = None  # Default to no arguments
 
     # Only exists on Windows 2000 or later, ignored on windows NT
     _svc_description_ = 'Python Web Service'
 
     def SvcDoRun(self):
+        """Start the service."""
         from cherrypy import process
+
         process.bus.start()
         process.bus.block()
 
     def SvcStop(self):
+        """Stop the service."""
         from cherrypy import process
+
         self.ReportServiceStatus(win32service.SERVICE_STOP_PENDING)
         process.bus.exit()
 
     def SvcOther(self, control):
+        """Send a command to the service."""
         from cherrypy import process
+
         process.bus.publish(control_codes.key_for(control))
 
 
diff --git a/cherrypy/process/wspbus.py b/cherrypy/process/wspbus.py
index ead90a4e2..1ea2dccaa 100644
--- a/cherrypy/process/wspbus.py
+++ b/cherrypy/process/wspbus.py
@@ -57,7 +57,6 @@
           |        \    |
           |         V   V
         STARTED <-- STARTING
-
 """
 
 import atexit
@@ -65,7 +64,7 @@
 try:
     import ctypes
 except ImportError:
-    """Google AppEngine is shipped without ctypes
+    """Google AppEngine is shipped without ctypes.
 
     :seealso: http://stackoverflow.com/a/6523777/70170
     """
@@ -121,13 +120,14 @@ def __str__(self):
     def __bool__(self):
         """Determine whether any error happened in channel."""
         return bool(self._exceptions)
+
     __nonzero__ = __bool__
 
+
 # Use a flag to indicate the state of the bus.
 
 
 class _StateEnum(object):
-
     class State(object):
         name = None
 
@@ -165,8 +165,8 @@ class Bus(object):
     All listeners for a given channel are guaranteed to be called even
     if others at the same channel fail. Each failure is logged, but
     execution proceeds on to the next listener. The only way to stop all
-    processing from inside a listener is to raise SystemExit and stop the
-    whole server.
+    processing from inside a listener is to raise SystemExit and stop
+    the whole server.
     """
 
     states = states
@@ -179,10 +179,7 @@ def __init__(self):
         self.execv = False
         self.state = states.STOPPED
         channels = 'start', 'stop', 'exit', 'graceful', 'log', 'main'
-        self.listeners = dict(
-            (channel, set())
-            for channel in channels
-        )
+        self.listeners = dict((channel, set()) for channel in channels)
         self._priorities = {}
 
     def subscribe(self, channel, callback=None, priority=None):
@@ -242,8 +239,11 @@ def publish(self, channel, *args, **kwargs):
                     # Assume any further messages to 'log' will fail.
                     pass
                 else:
-                    self.log('Error in %r listener %r' % (channel, listener),
-                             level=40, traceback=True)
+                    self.log(
+                        'Error in %r listener %r' % (channel, listener),
+                        level=40,
+                        traceback=True,
+                    )
         if exc:
             raise exc
         return output
@@ -255,7 +255,9 @@ def _clean_exit(self):
                 'The main thread is exiting, but the Bus is in the %r state; '
                 'shutting it down automatically now. You must either call '
                 'bus.block() after start(), or call bus.exit() before the '
-                'main thread exits.' % self.state, RuntimeWarning)
+                'main thread exits.' % self.state,
+                RuntimeWarning,
+            )
             self.exit()
 
     def start(self):
@@ -271,8 +273,11 @@ def start(self):
         except (KeyboardInterrupt, SystemExit):
             raise
         except Exception:
-            self.log('Shutting down due to error in start listener:',
-                     level=40, traceback=True)
+            self.log(
+                'Shutting down due to error in start listener:',
+                level=40,
+                traceback=True,
+            )
             e_info = sys.exc_info()[1]
             try:
                 self.exit()
@@ -312,8 +317,9 @@ def exit(self):
     def restart(self):
         """Restart the process (may close connections).
 
-        This method does not restart the process from the calling thread;
-        instead, it stops the bus and asks the main thread to call execv.
+        This method does not restart the process from the calling
+        thread; instead, it stops the bus and asks the main thread to
+        call execv.
         """
         self.execv = True
         self.exit()
@@ -327,10 +333,11 @@ def block(self, interval=0.1):
         """Wait for the EXITING state, KeyboardInterrupt or SystemExit.
 
         This function is intended to be called only by the main thread.
-        After waiting for the EXITING state, it also waits for all threads
-        to terminate, and then calls os.execv if self.execv is True. This
-        design allows another thread to call bus.restart, yet have the main
-        thread perform the actual execv call (required on some platforms).
+        After waiting for the EXITING state, it also waits for all
+        threads to terminate, and then calls os.execv if self.execv is
+        True. This design allows another thread to call bus.restart, yet
+        have the main thread perform the actual execv call (required on
+        some platforms).
         """
         try:
             self.wait(states.EXITING, interval=interval, channel='main')
@@ -356,13 +363,14 @@ def block(self, interval=0.1):
             # implemented as a windows service and in any other case
             # that another thread executes cherrypy.engine.exit()
             if (
-                    t != threading.currentThread() and
-                    not isinstance(t, threading._MainThread) and
-                    # Note that any dummy (external) threads are
-                    # always daemonic.
-                    not t.daemon
+                t != threading.current_thread()
+                and not isinstance(t, threading._MainThread)
+                and
+                # Note that any dummy (external) threads are
+                # always daemonic.
+                not t.daemon
             ):
-                self.log('Waiting for thread %s.' % t.getName())
+                self.log('Waiting for thread %s.' % t.name)
                 t.join()
 
         if self.execv:
@@ -379,13 +387,14 @@ def wait(self, state, interval=0.1, channel=None):
     def _do_execv(self):
         """Re-execute the current process.
 
-        This must be called from the main thread, because certain platforms
-        (OS X) don't allow execv to be called in a child thread very well.
+        This must be called from the main thread, because certain
+        platforms (OS X) don't allow execv to be called in a child
+        thread very well.
         """
         try:
             args = self._get_true_argv()
         except NotImplementedError:
-            """It's probably win32 or GAE"""
+            """It's probably win32 or GAE."""
             args = [sys.executable] + self._get_interpreter_argv() + sys.argv
 
         self.log('Re-spawning %s' % ' '.join(args))
@@ -394,6 +403,7 @@ def _do_execv(self):
 
         if sys.platform[:4] == 'java':
             from _systemrestart import SystemRestart
+
             raise SystemRestart
         else:
             if sys.platform == 'win32':
@@ -418,9 +428,11 @@ def _get_interpreter_argv():
         :seealso: https://github.com/cherrypy/cherrypy/issues/1526
         Ref: https://pythonhosted.org/PyInstaller/runtime-information.html
         """
-        return ([]
-                if getattr(sys, 'frozen', False)
-                else subprocess._args_from_interpreter_flags())
+        return (
+            []
+            if getattr(sys, 'frozen', False)
+            else subprocess._args_from_interpreter_flags()
+        )
 
     @staticmethod
     def _get_true_argv():
@@ -443,7 +455,7 @@ def _get_true_argv():
                 ctypes.byref(argv),
             )
 
-            _argv = argv[:argc.value]
+            _argv = argv[: argc.value]
 
             # The code below is trying to correctly handle special cases.
             # `-c`'s argument interpreted by Python itself becomes `-c` as
@@ -472,29 +484,32 @@ def _get_true_argv():
                 c_ind = None
 
             if is_module:
-                """It's containing `-m -m` sequence of arguments"""
+                """It's containing `-m -m` sequence of arguments."""
                 if is_command and c_ind < m_ind:
                     """There's `-c -c` before `-m`"""
                     raise RuntimeError(
                         "Cannot reconstruct command from '-c'. Ref: "
-                        'https://github.com/cherrypy/cherrypy/issues/1545')
+                        'https://github.com/cherrypy/cherrypy/issues/1545',
+                    )
                 # Survive module argument here
                 original_module = sys.argv[0]
                 if not os.access(original_module, os.R_OK):
-                    """There's no such module exist"""
+                    """There's no such module exist."""
                     raise AttributeError(
                         "{} doesn't seem to be a module "
-                        'accessible by current user'.format(original_module))
-                del _argv[m_ind:m_ind + 2]  # remove `-m -m`
+                        'accessible by current user'.format(original_module),
+                    )
+                del _argv[m_ind : m_ind + 2]  # remove `-m -m`
                 # ... and substitute it with the original module path:
                 _argv.insert(m_ind, original_module)
             elif is_command:
-                """It's containing just `-c -c` sequence of arguments"""
+                """It's containing just `-c -c` sequence of arguments."""
                 raise RuntimeError(
                     "Cannot reconstruct command from '-c'. "
-                    'Ref: https://github.com/cherrypy/cherrypy/issues/1545')
+                    'Ref: https://github.com/cherrypy/cherrypy/issues/1545',
+                )
         except AttributeError:
-            """It looks Py_GetArgcArgv is completely absent in some environments
+            """It looks Py_GetArgcArgv's completely absent in some environments
 
             It is known, that there's no Py_GetArgcArgv in MS Windows and
             ``ctypes`` module is completely absent in Google AppEngine
@@ -512,21 +527,20 @@ def _extend_pythonpath(env):
         """Prepend current working dir to PATH environment variable if needed.
 
         If sys.path[0] is an empty string, the interpreter was likely
-        invoked with -m and the effective path is about to change on
-        re-exec.  Add the current directory to $PYTHONPATH to ensure
-        that the new process sees the same path.
+        invoked with -m and the effective path is about to change on re-
+        exec.  Add the current directory to $PYTHONPATH to ensure that
+        the new process sees the same path.
 
         This issue cannot be addressed in the general case because
-        Python cannot reliably reconstruct the
-        original command line (http://bugs.python.org/issue14208).
+        Python cannot reliably reconstruct the original command line (
+        http://bugs.python.org/issue14208).
 
         (This idea filched from tornado.autoreload)
         """
         path_prefix = '.' + os.pathsep
         existing_path = env.get('PYTHONPATH', '')
-        needs_patch = (
-            sys.path[0] == '' and
-            not existing_path.startswith(path_prefix)
+        needs_patch = sys.path[0] == '' and not existing_path.startswith(
+            path_prefix,
         )
 
         if needs_patch:
@@ -536,10 +550,10 @@ def _set_cloexec(self):
         """Set the CLOEXEC flag on all open files (except stdin/out/err).
 
         If self.max_cloexec_files is an integer (the default), then on
-        platforms which support it, it represents the max open files setting
-        for the operating system. This function will be called just before
-        the process is restarted via os.execv() to prevent open files
-        from persisting into the new process.
+        platforms which support it, it represents the max open files
+        setting for the operating system. This function will be called
+        just before the process is restarted via os.execv() to prevent
+        open files from persisting into the new process.
 
         Set self.max_cloexec_files to 0 to disable this behavior.
         """
@@ -569,8 +583,9 @@ def start_with_callback(self, func, args=None, kwargs=None):
         def _callback(func, *a, **kw):
             self.wait(states.STARTED)
             func(*a, **kw)
+
         t = threading.Thread(target=_callback, args=args, kwargs=kwargs)
-        t.setName('Bus Callback ' + t.getName())
+        t.name = 'Bus Callback ' + t.name
         t.start()
 
         self.start()
@@ -578,7 +593,10 @@ def _callback(func, *a, **kw):
         return t
 
     def log(self, msg='', level=20, traceback=False):
-        """Log the given message. Append the last traceback if requested."""
+        """Log the given message.
+
+        Append the last traceback if requested.
+        """
         if traceback:
             msg += '\n' + ''.join(_traceback.format_exception(*sys.exc_info()))
         self.publish('log', msg, level)
diff --git a/cherrypy/scaffold/__init__.py b/cherrypy/scaffold/__init__.py
index bcddba2db..19fa995d4 100644
--- a/cherrypy/scaffold/__init__.py
+++ b/cherrypy/scaffold/__init__.py
@@ -9,13 +9,13 @@
 Change to this directory and run:
 
     cherryd -c site.conf
-
 """
 
 import cherrypy
 from cherrypy import tools, url
 
 import os
+
 local_dir = os.path.join(os.getcwd(), os.path.dirname(__file__))
 
 
@@ -31,8 +31,11 @@ def index(self):
 or a <a href='%s?n=14'>default</a> path.<br />
 Or, just look at the pretty picture:<br />
 <img src='%s' />
-</body></html>""" % (url('other'), url('else'),
-                     url('files/made_with_cherrypy_small.png'))
+</body></html>""" % (
+            url('other'),
+            url('else'),
+            url('files/made_with_cherrypy_small.png'),
+        )
 
     @cherrypy.expose
     def default(self, *args, **kwargs):
@@ -52,7 +55,7 @@ def other(self, a=2, b='bananas', c=None):
         section='/files',
         dir=os.path.join(local_dir, 'static'),
         # Ignore .php files, etc.
-                match=r'\.(css|gif|html?|ico|jpe?g|js|png|swf|xml)$',
+        match=r'\.(css|gif|html?|ico|jpe?g|js|png|swf|xml)$',
     )
 
 
diff --git a/cherrypy/test/__init__.py b/cherrypy/test/__init__.py
index 068382be1..05bb17ad7 100644
--- a/cherrypy/test/__init__.py
+++ b/cherrypy/test/__init__.py
@@ -1,16 +1,16 @@
-"""
-Regression test suite for CherryPy.
-"""
+"""Regression test suite for CherryPy."""
 
 import os
 import sys
 
 
 def newexit():
+    """Exit the process with return code of 1."""
     os._exit(1)
 
 
 def setup():
+    """Monkey-patch ``sys.exit()``."""
     # We want to monkey patch sys.exit so that we can get some
     # information about where exit is being called.
     newexit._old = sys.exit
@@ -18,6 +18,7 @@ def setup():
 
 
 def teardown():
+    """Recover the original ``sys.exit()``."""
     try:
         sys.exit = sys.exit._old
     except AttributeError:
diff --git a/cherrypy/test/_test_decorators.py b/cherrypy/test/_test_decorators.py
index 74832e40a..9e261d383 100644
--- a/cherrypy/test/_test_decorators.py
+++ b/cherrypy/test/_test_decorators.py
@@ -1,33 +1,40 @@
-"""Test module for the @-decorator syntax, which is version-specific"""
+"""Test module for the @-decorator syntax, which is version-specific."""
 
 import cherrypy
 from cherrypy import expose, tools
 
 
 class ExposeExamples(object):
+    """Exposed routes test app."""
 
     @expose
     def no_call(self):
+        """Return a string on ``/no_call``."""
         return 'Mr E. R. Bradshaw'
 
     @expose()
     def call_empty(self):
+        """Return a string on ``/call_empty``."""
         return 'Mrs. B.J. Smegma'
 
     @expose('call_alias')
     def nesbitt(self):
+        """Return "Mr Nesbitt" on ``/call_alias``."""
         return 'Mr Nesbitt'
 
     @expose(['alias1', 'alias2'])
     def andrews(self):
+        """Return a string on ``/andrews``, ``/alias1``, ``/alias2``."""
         return 'Mr Ken Andrews'
 
     @expose(alias='alias3')
     def watson(self):
+        """Return "Mr. and Mrs. Watson" on ``/watson``, ``/alias3``."""
         return 'Mr. and Mrs. Watson'
 
 
 class ToolExamples(object):
+    """A web app with tools."""
 
     @expose
     # This is here to demonstrate that using the config decorator
@@ -36,4 +43,5 @@ class ToolExamples(object):
     @cherrypy.config(**{'response.stream': True})
     @tools.response_headers(headers=[('Content-Type', 'application/data')])
     def blah(self):
+        """Emit "Blah" on ``/blah``."""
         yield b'blah'
diff --git a/cherrypy/test/_test_states_demo.py b/cherrypy/test/_test_states_demo.py
index a49407baf..ea24461e3 100644
--- a/cherrypy/test/_test_states_demo.py
+++ b/cherrypy/test/_test_states_demo.py
@@ -8,25 +8,31 @@
 
 
 class Root:
+    """A test web app."""
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of test app index URI."""
         return 'Hello World'
 
     @cherrypy.expose
     def mtimes(self):
+        """Respond with timestamps."""
         return repr(cherrypy.engine.publish('Autoreloader', 'mtimes'))
 
     @cherrypy.expose
     def pid(self):
+        """Respond with the current process ID."""
         return str(os.getpid())
 
     @cherrypy.expose
     def start(self):
+        """Respond with the start time."""
         return repr(starttime)
 
     @cherrypy.expose
     def exit(self):
+        """Stop the server."""
         # This handler might be called before the engine is STARTED if an
         # HTTP worker thread handles it before the HTTP server returns
         # control to engine.start. We avoid that race condition here
@@ -37,6 +43,7 @@ def exit(self):
 
 @cherrypy.engine.subscribe('start', priority=100)
 def unsub_sig():
+    """Unsubscribe the default signal handler."""
     cherrypy.log('unsubsig: %s' % cherrypy.config.get('unsubsig', False))
     if cherrypy.config.get('unsubsig', False):
         cherrypy.log('Unsubscribing the default cherrypy signal handler')
@@ -46,24 +53,29 @@ def unsub_sig():
     except ImportError:
         pass
     else:
+
         def old_term_handler(signum=None, frame=None):
             cherrypy.log('I am an old SIGTERM handler.')
             sys.exit(0)
+
         cherrypy.log('Subscribing the new one.')
         signal(SIGTERM, old_term_handler)
 
 
 @cherrypy.engine.subscribe('start', priority=6)
 def starterror():
+    """Error out on start."""
     if cherrypy.config.get('starterror', False):
         1 / 0
 
 
 @cherrypy.engine.subscribe('start', priority=6)
 def log_test_case_name():
+    """Log test case name."""
     if cherrypy.config.get('test_case_name', False):
-        cherrypy.log('STARTED FROM: %s' %
-                     cherrypy.config.get('test_case_name'))
+        cherrypy.log(
+            'STARTED FROM: %s' % cherrypy.config.get('test_case_name'),
+        )
 
 
 cherrypy.tree.mount(Root(), '/', {'/': {}})
diff --git a/cherrypy/test/benchmark.py b/cherrypy/test/benchmark.py
index 44dfeff12..00e31356b 100644
--- a/cherrypy/test/benchmark.py
+++ b/cherrypy/test/benchmark.py
@@ -1,24 +1,24 @@
-"""CherryPy Benchmark Tool
-
-    Usage:
-        benchmark.py [options]
-
-    --null:        use a null Request object (to bench the HTTP server only)
-    --notests:     start the server but do not run the tests; this allows
-                   you to check the tested pages with a browser
-    --help:        show this help message
-    --cpmodpy:     run tests via apache on 54583 (with the builtin _cpmodpy)
-    --modpython:   run tests via apache on 54583 (with modpython_gateway)
-    --ab=path:     Use the ab script/executable at 'path' (see below)
-    --apache=path: Use the apache script/exe at 'path' (see below)
-
-    To run the benchmarks, the Apache Benchmark tool "ab" must either be on
-    your system path, or specified via the --ab=path option.
-
-    To run the modpython tests, the "apache" executable or script must be
-    on your system path, or provided via the --apache=path option. On some
-    platforms, "apache" may be called "apachectl" or "apache2ctl"--create
-    a symlink to them if needed.
+"""CherryPy Benchmark Tool.
+
+Usage:
+    benchmark.py [options]
+
+--null:        use a null Request object (to bench the HTTP server only)
+--notests:     start the server but do not run the tests; this allows
+               you to check the tested pages with a browser
+--help:        show this help message
+--cpmodpy:     run tests via apache on 54583 (with the builtin _cpmodpy)
+--modpython:   run tests via apache on 54583 (with modpython_gateway)
+--ab=path:     Use the ab script/executable at 'path' (see below)
+--apache=path: Use the apache script/exe at 'path' (see below)
+
+To run the benchmarks, the Apache Benchmark tool "ab" must either be on
+your system path, or specified via the --ab=path option.
+
+To run the modpython tests, the "apache" executable or script must be
+on your system path, or provided via the --apache=path option. On some
+platforms, "apache" may be called "apachectl" or "apache2ctl"--create
+a symlink to them if needed.
 """
 
 import getopt
@@ -38,18 +38,25 @@
 APACHE_PATH = 'apache'
 SCRIPT_NAME = '/cpbench/users/rdelon/apps/blog'
 
-__all__ = ['ABSession', 'Root', 'print_report',
-           'run_standard_benchmarks', 'safe_threads',
-           'size_report', 'thread_report',
-           ]
+__all__ = [
+    'ABSession',
+    'Root',
+    'print_report',
+    'run_standard_benchmarks',
+    'safe_threads',
+    'size_report',
+    'thread_report',
+]
 
 size_cache = {}
 
 
 class Root:
+    """Test web app."""
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of test app index URI."""
         return """<html>
 <head>
     <title>CherryPy Benchmark</title>
@@ -67,10 +74,12 @@ def index(self):
 
     @cherrypy.expose
     def hello(self):
+        """Render a "Hello world!" message on ``/hello`` URI."""
         return 'Hello, world\r\n'
 
     @cherrypy.expose
     def sizer(self, size):
+        """Send a cached sized response."""
         resp = size_cache.get(size, None)
         if resp is None:
             size_cache[size] = resp = 'X' * int(size)
@@ -78,15 +87,17 @@ def sizer(self, size):
 
 
 def init():
-
-    cherrypy.config.update({
-        'log.error.file': '',
-        'environment': 'production',
-        'server.socket_host': '127.0.0.1',
-        'server.socket_port': 54583,
-        'server.max_request_header_size': 0,
-        'server.max_request_body_size': 0,
-    })
+    """Configure the test server."""
+    cherrypy.config.update(
+        {
+            'log.error.file': '',
+            'environment': 'production',
+            'server.socket_host': '127.0.0.1',
+            'server.socket_port': 54583,
+            'server.max_request_header_size': 0,
+            'server.max_request_body_size': 0,
+        },
+    )
 
     # Cheat mode on ;)
     del cherrypy.config['tools.log_tracebacks.on']
@@ -106,121 +117,137 @@ def init():
 
 
 class NullRequest:
-
     """A null HTTP request class, returning 200 and an empty body."""
 
     def __init__(self, local, remote, scheme='http'):
-        pass
+        """Initialize a null request instance."""
 
     def close(self):
-        pass
+        """Close the null request."""
 
     def run(self, method, path, query_string, protocol, headers, rfile):
+        """Construct an HTTP response."""
         cherrypy.response.status = '200 OK'
-        cherrypy.response.header_list = [('Content-Type', 'text/html'),
-                                         ('Server', 'Null CherryPy'),
-                                         ('Date', httputil.HTTPDate()),
-                                         ('Content-Length', '0'),
-                                         ]
+        cherrypy.response.header_list = [
+            ('Content-Type', 'text/html'),
+            ('Server', 'Null CherryPy'),
+            ('Date', httputil.HTTPDate()),
+            ('Content-Length', '0'),
+        ]
         cherrypy.response.body = ['']
         return cherrypy.response
 
 
 class NullResponse:
-    pass
+    """A null HTTP response."""
 
 
 class ABSession:
-
     """A session of 'ab', the Apache HTTP server benchmarking tool.
 
-Example output from ab:
-
-This is ApacheBench, Version 2.0.40-dev <$Revision: 1.121.2.1 $> apache-2.0
-Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
-Copyright (c) 1998-2002 The Apache Software Foundation, http://www.apache.org/
-
-Benchmarking 127.0.0.1 (be patient)
-Completed 100 requests
-Completed 200 requests
-Completed 300 requests
-Completed 400 requests
-Completed 500 requests
-Completed 600 requests
-Completed 700 requests
-Completed 800 requests
-Completed 900 requests
-
-
-Server Software:        CherryPy/3.1beta
-Server Hostname:        127.0.0.1
-Server Port:            54583
-
-Document Path:          /static/index.html
-Document Length:        14 bytes
-
-Concurrency Level:      10
-Time taken for tests:   9.643867 seconds
-Complete requests:      1000
-Failed requests:        0
-Write errors:           0
-Total transferred:      189000 bytes
-HTML transferred:       14000 bytes
-Requests per second:    103.69 [#/sec] (mean)
-Time per request:       96.439 [ms] (mean)
-Time per request:       9.644 [ms] (mean, across all concurrent requests)
-Transfer rate:          19.08 [Kbytes/sec] received
-
-Connection Times (ms)
-              min  mean[+/-sd] median   max
-Connect:        0    0   2.9      0      10
-Processing:    20   94   7.3     90     130
-Waiting:        0   43  28.1     40     100
-Total:         20   95   7.3    100     130
-
-Percentage of the requests served within a certain time (ms)
-  50%    100
-  66%    100
-  75%    100
-  80%    100
-  90%    100
-  95%    100
-  98%    100
-  99%    110
- 100%    130 (longest request)
-Finished 1000 requests
-"""
+    Example output from ab:
+
+    This is ApacheBench, Version 2.0.40-dev <$Revision: 1.121.2.1 $> apache-2.0
+    Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd,
+    http://www.zeustech.net/
+    Copyright (c) 1998-2002 The Apache Software Foundation,
+    http://www.apache.org/
+
+    Benchmarking 127.0.0.1 (be patient)
+    Completed 100 requests
+    Completed 200 requests
+    Completed 300 requests
+    Completed 400 requests
+    Completed 500 requests
+    Completed 600 requests
+    Completed 700 requests
+    Completed 800 requests
+    Completed 900 requests
+
+
+    Server Software:        CherryPy/3.1beta
+    Server Hostname:        127.0.0.1
+    Server Port:            54583
+
+    Document Path:          /static/index.html
+    Document Length:        14 bytes
+
+    Concurrency Level:      10
+    Time taken for tests:   9.643867 seconds
+    Complete requests:      1000
+    Failed requests:        0
+    Write errors:           0
+    Total transferred:      189000 bytes
+    HTML transferred:       14000 bytes
+    Requests per second:    103.69 [#/sec] (mean)
+    Time per request:       96.439 [ms] (mean)
+    Time per request:       9.644 [ms] (mean, across all concurrent requests)
+    Transfer rate:          19.08 [Kbytes/sec] received
+
+    Connection Times (ms)
+                  min  mean[+/-sd] median   max
+    Connect:        0    0   2.9      0      10
+    Processing:    20   94   7.3     90     130
+    Waiting:        0   43  28.1     40     100
+    Total:         20   95   7.3    100     130
+
+    Percentage of the requests served within a certain time (ms)
+      50%    100
+      66%    100
+      75%    100
+      80%    100
+      90%    100
+      95%    100
+      98%    100
+      99%    110
+     100%    130 (longest request)
+    Finished 1000 requests
+    """
 
     parse_patterns = [
-        ('complete_requests', 'Completed',
-         br'^Complete requests:\s*(\d+)'),
-        ('failed_requests', 'Failed',
-         br'^Failed requests:\s*(\d+)'),
-        ('requests_per_second', 'req/sec',
-         br'^Requests per second:\s*([0-9.]+)'),
-        ('time_per_request_concurrent', 'msec/req',
-         br'^Time per request:\s*([0-9.]+).*concurrent requests\)$'),
-        ('transfer_rate', 'KB/sec',
-         br'^Transfer rate:\s*([0-9.]+)')
+        ('complete_requests', 'Completed', rb'^Complete requests:\s*(\d+)'),
+        ('failed_requests', 'Failed', rb'^Failed requests:\s*(\d+)'),
+        (
+            'requests_per_second',
+            'req/sec',
+            rb'^Requests per second:\s*([0-9.]+)',
+        ),
+        (
+            'time_per_request_concurrent',
+            'msec/req',
+            rb'^Time per request:\s*([0-9.]+).*concurrent requests\)$',
+        ),
+        ('transfer_rate', 'KB/sec', rb'^Transfer rate:\s*([0-9.]+)'),
     ]
 
-    def __init__(self, path=SCRIPT_NAME + '/hello', requests=1000,
-                 concurrency=10):
+    def __init__(
+        self,
+        path=SCRIPT_NAME + '/hello',
+        requests=1000,
+        concurrency=10,
+    ):
+        """Initialize an Apache Benchmark session."""
         self.path = path
         self.requests = requests
         self.concurrency = concurrency
 
     def args(self):
+        """Compute the Apache Benchmark CLI arguments."""
         port = cherrypy.server.socket_port
         assert self.concurrency > 0
         assert self.requests > 0
         # Don't use "localhost".
         # Cf
         # http://mail.python.org/pipermail/python-win32/2008-March/007050.html
-        return ('-k -n %s -c %s http://127.0.0.1:%s%s' %
-                (self.requests, self.concurrency, port, self.path))
+        return '-k -n %s -c %s http://127.0.0.1:%s%s' % (
+            self.requests,
+            self.concurrency,
+            port,
+            self.path,
+        )
 
     def run(self):
+        """Run an Apache Benchmark test."""
         # Parse output of ab, setting attributes on self
         try:
             self.output = _cpmodpy.read_process(AB_PATH or 'ab', self.args())
@@ -244,6 +271,7 @@ def run(self):
 
 
 def thread_report(path=SCRIPT_NAME + '/hello', concurrency=safe_threads):
+    """Report Apache Benchmark against a multi-threaded server."""
     sess = ABSession(path)
     attrs, names, patterns = list(zip(*sess.parse_patterns))
     avg = dict.fromkeys(attrs, 0.0)
@@ -269,8 +297,11 @@ def thread_report(path=SCRIPT_NAME + '/hello', concurrency=safe_threads):
     yield ['Average'] + [str(avg[attr] / len(concurrency)) for attr in attrs]
 
 
-def size_report(sizes=(10, 100, 1000, 10000, 100000, 100000000),
-                concurrency=50):
+def size_report(
+    sizes=(10, 100, 1000, 10000, 100000, 100000000),
+    concurrency=50,
+):
+    """Report Apache Benchmark against different payload sizes."""
     sess = ABSession(concurrency=concurrency)
     attrs, names, patterns = list(zip(*sess.parse_patterns))
     yield ('bytes',) + names
@@ -281,6 +312,7 @@ def size_report(sizes=(10, 100, 1000, 10000, 100000, 100000000),
 
 
 def print_report(rows):
+    """Print rows to standard out."""
     for row in rows:
         print('')
         for val in row:
@@ -289,27 +321,34 @@ def print_report(rows):
 
 
 def run_standard_benchmarks():
+    """Run Standard Benchmarks."""
     print('')
-    print('Client Thread Report (1000 requests, 14 byte response body, '
-          '%s server threads):' % cherrypy.server.thread_pool)
+    print(
+        'Client Thread Report (1000 requests, 14 byte response body, '
+        '%s server threads):' % cherrypy.server.thread_pool,
+    )
     print_report(thread_report())
 
     print('')
-    print('Client Thread Report (1000 requests, 14 bytes via staticdir, '
-          '%s server threads):' % cherrypy.server.thread_pool)
+    print(
+        'Client Thread Report (1000 requests, 14 bytes via staticdir, '
+        '%s server threads):' % cherrypy.server.thread_pool,
+    )
     print_report(thread_report('%s/static/index.html' % SCRIPT_NAME))
 
     print('')
-    print('Size Report (1000 requests, 50 client threads, '
-          '%s server threads):' % cherrypy.server.thread_pool)
+    print(
+        'Size Report (1000 requests, 50 client threads, '
+        '%s server threads):' % cherrypy.server.thread_pool,
+    )
     print_report(size_report())
 
 
 #                         modpython and other WSGI                         #
 
+
 def startup_modpython(req=None):
-    """Start the CherryPy app server in 'serverless' mode (for modpython/WSGI).
-    """
+    """Start CherryPy app server in 'serverless' mode (for modpython/WSGI)."""
     if cherrypy.engine.state == cherrypy._cpengine.STOPPED:
         if req:
             if 'nullreq' in req.get_options():
@@ -340,13 +379,19 @@ def run_modpython(use_wsgi=False):
     if use_wsgi:
         pyopts.append(('wsgi.application', 'cherrypy::tree'))
         pyopts.append(
-            ('wsgi.startup', 'cherrypy.test.benchmark::startup_modpython'))
+            ('wsgi.startup', 'cherrypy.test.benchmark::startup_modpython'),
+        )
         handler = 'modpython_gateway::handler'
-        s = s(port=54583, opts=pyopts,
-              apache_path=APACHE_PATH, handler=handler)
+        s = s(
+            port=54583,
+            opts=pyopts,
+            apache_path=APACHE_PATH,
+            handler=handler,
+        )
     else:
         pyopts.append(
-            ('cherrypy.setup', 'cherrypy.test.benchmark::startup_modpython'))
+            ('cherrypy.setup', 'cherrypy.test.benchmark::startup_modpython'),
+        )
         s = s(port=54583, opts=pyopts, apache_path=APACHE_PATH)
 
     try:
@@ -359,8 +404,15 @@ def run_modpython(use_wsgi=False):
 if __name__ == '__main__':
     init()
 
-    longopts = ['cpmodpy', 'modpython', 'null', 'notests',
-                'help', 'ab=', 'apache=']
+    longopts = [
+        'cpmodpy',
+        'modpython',
+        'null',
+        'notests',
+        'help',
+        'ab=',
+        'apache=',
+    ]
     try:
         switches, args = getopt.getopt(sys.argv[1:], '', longopts)
         opts = dict(switches)
@@ -380,12 +432,15 @@ def run_modpython(use_wsgi=False):
         # can be tested from a standard web browser.
         def run():
             port = cherrypy.server.socket_port
-            print('You may now open http://127.0.0.1:%s%s/' %
-                  (port, SCRIPT_NAME))
+            print(
+                'You may now open http://127.0.0.1:%s%s/'
+                % (port, SCRIPT_NAME),
+            )
 
             if '--null' in opts:
                 print('Using null Request object')
     else:
+
         def run():
             end = time.time() - start
             print('Started in %s seconds' % end)
@@ -403,11 +458,11 @@ def run():
     print('Starting CherryPy app server...')
 
     class NullWriter(object):
-
         """Suppresses the printing of socket errors."""
 
         def write(self, data):
             pass
+
     sys.stderr = NullWriter()
 
     start = time.time()
diff --git a/cherrypy/test/checkerdemo.py b/cherrypy/test/checkerdemo.py
index 3438bd0c5..92e92d902 100644
--- a/cherrypy/test/checkerdemo.py
+++ b/cherrypy/test/checkerdemo.py
@@ -1,49 +1,57 @@
 """Demonstration app for cherrypy.checker.
 
-This application is intentionally broken and badly designed.
-To demonstrate the output of the CherryPy Checker, simply execute
-this module.
+This application is intentionally broken and badly designed. To
+demonstrate the output of the CherryPy Checker, simply execute this
+module.
 """
 
 import os
 import cherrypy
+
 thisdir = os.path.dirname(os.path.abspath(__file__))
 
 
 class Root:
-    pass
+    """Demo web app."""
 
 
 if __name__ == '__main__':
-    conf = {'/base': {'tools.staticdir.root': thisdir,
-                      # Obsolete key.
-                      'throw_errors': True,
-                      },
-            # This entry should be OK.
-            '/base/static': {'tools.staticdir.on': True,
-                             'tools.staticdir.dir': 'static'},
-            # Warn on missing folder.
-            '/base/js': {'tools.staticdir.on': True,
-                         'tools.staticdir.dir': 'js'},
-            # Warn on dir with an abs path even though we provide root.
-            '/base/static2': {'tools.staticdir.on': True,
-                              'tools.staticdir.dir': '/static'},
-            # Warn on dir with a relative path with no root.
-            '/static3': {'tools.staticdir.on': True,
-                         'tools.staticdir.dir': 'static'},
-            # Warn on unknown namespace
-            '/unknown': {'toobles.gzip.on': True},
-            # Warn special on cherrypy.<known ns>.*
-            '/cpknown': {'cherrypy.tools.encode.on': True},
-            # Warn on mismatched types
-            '/conftype': {'request.show_tracebacks': 14},
-            # Warn on unknown tool.
-            '/web': {'tools.unknown.on': True},
-            # Warn on server.* in app config.
-            '/app1': {'server.socket_host': '0.0.0.0'},
-            # Warn on 'localhost'
-            'global': {'server.socket_host': 'localhost'},
-            # Warn on '[name]'
-            '[/extra_brackets]': {},
-            }
+    conf = {
+        '/base': {
+            'tools.staticdir.root': thisdir,
+            # Obsolete key.
+            'throw_errors': True,
+        },
+        # This entry should be OK.
+        '/base/static': {
+            'tools.staticdir.on': True,
+            'tools.staticdir.dir': 'static',
+        },
+        # Warn on missing folder.
+        '/base/js': {'tools.staticdir.on': True, 'tools.staticdir.dir': 'js'},
+        # Warn on dir with an abs path even though we provide root.
+        '/base/static2': {
+            'tools.staticdir.on': True,
+            'tools.staticdir.dir': '/static',
+        },
+        # Warn on dir with a relative path with no root.
+        '/static3': {
+            'tools.staticdir.on': True,
+            'tools.staticdir.dir': 'static',
+        },
+        # Warn on unknown namespace
+        '/unknown': {'toobles.gzip.on': True},
+        # Warn special on cherrypy.<known ns>.*
+        '/cpknown': {'cherrypy.tools.encode.on': True},
+        # Warn on mismatched types
+        '/conftype': {'request.show_tracebacks': 14},
+        # Warn on unknown tool.
+        '/web': {'tools.unknown.on': True},
+        # Warn on server.* in app config.
+        '/app1': {'server.socket_host': '0.0.0.0'},
+        # Warn on 'localhost'
+        'global': {'server.socket_host': 'localhost'},
+        # Warn on '[name]'
+        '[/extra_brackets]': {},
+    }
     cherrypy.quickstart(Root(), config=conf)
diff --git a/cherrypy/test/helper.py b/cherrypy/test/helper.py
index c1ca45353..7c6de4c81 100644
--- a/cherrypy/test/helper.py
+++ b/cherrypy/test/helper.py
@@ -18,7 +18,7 @@
 from cheroot.test import webtest
 
 import cherrypy
-from cherrypy._cpcompat import text_or_bytes, HTTPSConnection, ntob
+from cherrypy._cpcompat import text_or_bytes, HTTPSConnection, ntob, IS_PYPY
 from cherrypy.lib import httputil
 from cherrypy.lib import gctools
 
@@ -28,10 +28,10 @@
 
 
 class Supervisor(object):
-
     """Base class for modeling and controlling servers during testing."""
 
     def __init__(self, **kwargs):
+        """Initialize a supervisor."""
         for k, v in kwargs.items():
             if k == 'port':
                 setattr(self, k, int(v))
@@ -39,24 +39,24 @@ def __init__(self, **kwargs):
 
 
 def log_to_stderr(msg, level):
+    """Log to Standard Error."""
     return sys.stderr.write(msg + os.linesep)
 
 
 class LocalSupervisor(Supervisor):
+    """Base for modeling/controlling servers which run in the same process.
 
-    """Base class for modeling/controlling servers which run in the same
-    process.
-
-    When the server side runs in a different process, start/stop can dump all
-    state between each test module easily. When the server side runs in the
-    same process as the client, however, we have to do a bit more work to
-    ensure config and mounted apps are reset between tests.
+    When the server side runs in a different process, start/stop can
+    dump all state between each test module easily. When the server side
+    runs in the same process as the client, however, we have to do a bit
+    more work to ensure config and mounted apps are reset between tests.
     """
 
     using_apache = False
     using_wsgi = False
 
     def __init__(self, **kwargs):
+        """Initialize the local supervisor."""
         for k, v in kwargs.items():
             setattr(self, k, v)
 
@@ -87,6 +87,7 @@ def sync_apps(self):
         pass
 
     def stop(self):
+        """Stop the HTTP server."""
         td = getattr(self, 'teardown', None)
         if td:
             td()
@@ -99,7 +100,6 @@ def stop(self):
 
 
 class NativeServerSupervisor(LocalSupervisor):
-
     """Server supervisor for the builtin HTTP server."""
 
     httpserver_class = 'cherrypy._cpnative_server.CPHTTPServer'
@@ -107,11 +107,11 @@ class NativeServerSupervisor(LocalSupervisor):
     using_wsgi = False
 
     def __str__(self):
+        """Render a :class:`NativeServerSupervisor` instance as a string."""
         return 'Builtin HTTP Server on %s:%s' % (self.host, self.port)
 
 
 class LocalWSGISupervisor(LocalSupervisor):
-
     """Server supervisor for the builtin WSGI server."""
 
     httpserver_class = 'cherrypy._cpwsgi_server.CPWSGIServer'
@@ -119,10 +119,11 @@ class LocalWSGISupervisor(LocalSupervisor):
     using_wsgi = True
 
     def __str__(self):
+        """Render a :class:`LocalWSGISupervisor` instance as a string."""
         return 'Builtin WSGI Server on %s:%s' % (self.host, self.port)
 
     def sync_apps(self):
-        """Hook a new WSGI app into the origin server."""
+        """Connect a new WSGI app into the origin server."""
         cherrypy.server.httpserver.wsgi_app = self.get_app()
 
     def get_app(self, app=None):
@@ -135,7 +136,8 @@ def get_app(self, app=None):
                 from wsgiref import validate
             except ImportError:
                 warnings.warn(
-                    'Error importing wsgiref. The validator will not run.')
+                    'Error importing wsgiref. The validator will not run.',
+                )
             else:
                 # wraps the app in the validator
                 app = validate.validator(app)
@@ -144,14 +146,18 @@ def get_app(self, app=None):
 
 
 def get_cpmodpy_supervisor(**options):
+    """Load a CherryPy ``mod_python`` supervisor."""
     from cherrypy.test import modpy
+
     sup = modpy.ModPythonSupervisor(**options)
     sup.template = modpy.conf_cpmodpy
     return sup
 
 
 def get_modpygw_supervisor(**options):
+    """Load a CherryPy ``mod_python`` gateway supervisor."""
     from cherrypy.test import modpy
+
     sup = modpy.ModPythonSupervisor(**options)
     sup.template = modpy.conf_modpython_gateway
     sup.using_wsgi = True
@@ -159,39 +165,48 @@ def get_modpygw_supervisor(**options):
 
 
 def get_modwsgi_supervisor(**options):
+    """Load a CherryPy ``mod_wsgi`` supervisor."""
     from cherrypy.test import modwsgi
+
     return modwsgi.ModWSGISupervisor(**options)
 
 
 def get_modfcgid_supervisor(**options):
+    """Load a CherryPy ``mod_fcgi`` supervisor."""
     from cherrypy.test import modfcgid
+
     return modfcgid.ModFCGISupervisor(**options)
 
 
 def get_modfastcgi_supervisor(**options):
+    """Load a CherryPy ``mod_fastcgi`` supervisor."""
     from cherrypy.test import modfastcgi
+
     return modfastcgi.ModFCGISupervisor(**options)
 
 
 def get_wsgi_u_supervisor(**options):
+    """Load a CherryPy WSGI supervisor."""
     cherrypy.server.wsgi_version = ('u', 0)
     return LocalWSGISupervisor(**options)
 
 
 class CPWebCase(webtest.WebCase):
+    """CherryPy web test case base."""
 
     script_name = ''
     scheme = 'http'
 
-    available_servers = {'wsgi': LocalWSGISupervisor,
-                         'wsgi_u': get_wsgi_u_supervisor,
-                         'native': NativeServerSupervisor,
-                         'cpmodpy': get_cpmodpy_supervisor,
-                         'modpygw': get_modpygw_supervisor,
-                         'modwsgi': get_modwsgi_supervisor,
-                         'modfcgid': get_modfcgid_supervisor,
-                         'modfastcgi': get_modfastcgi_supervisor,
-                         }
+    available_servers = {
+        'wsgi': LocalWSGISupervisor,
+        'wsgi_u': get_wsgi_u_supervisor,
+        'native': NativeServerSupervisor,
+        'cpmodpy': get_cpmodpy_supervisor,
+        'modpygw': get_modpygw_supervisor,
+        'modwsgi': get_modwsgi_supervisor,
+        'modfcgid': get_modfcgid_supervisor,
+        'modfastcgi': get_modfastcgi_supervisor,
+    }
     default_server = 'wsgi'
 
     @classmethod
@@ -218,11 +233,14 @@ def _setup_server(cls, supervisor, conf):
         else:
             conf = conf or {}
         baseconf = conf.copy()
-        baseconf.update({'server.socket_host': supervisor.host,
-                         'server.socket_port': supervisor.port,
-                         'server.protocol_version': supervisor.protocol,
-                         'environment': 'test_suite',
-                         })
+        baseconf.update(
+            {
+                'server.socket_host': supervisor.host,
+                'server.socket_port': supervisor.port,
+                'server.protocol_version': supervisor.protocol,
+                'environment': 'test_suite',
+            },
+        )
         if supervisor.scheme == 'https':
             # baseconf['server.ssl_module'] = 'builtin'
             baseconf['server.ssl_certificate'] = serverpem
@@ -240,8 +258,7 @@ def _setup_server(cls, supervisor, conf):
 
     @classmethod
     def setup_class(cls):
-        ''
-        # Creates a server
+        """Invoke a test server."""
         conf = {
             'scheme': 'http',
             'protocol': 'HTTP/1.1',
@@ -251,7 +268,8 @@ def setup_class(cls):
             'server': 'wsgi',
         }
         supervisor_factory = cls.available_servers.get(
-            conf.get('server', 'wsgi'))
+            conf.get('server', 'wsgi'),
+        )
         if supervisor_factory is None:
             raise RuntimeError('Unknown server in config: %s' % conf['server'])
         supervisor = supervisor_factory(**conf)
@@ -271,20 +289,21 @@ def setup_class(cls):
             # Add a resource for verifying there are no refleaks
             # to *every* test class.
             cherrypy.tree.mount(gctools.GCRoot(), '/gc')
-            cls.do_gc_test = True
+            cls.do_gc_test = not IS_PYPY
             supervisor.start(cls.__module__)
 
         cls.supervisor = supervisor
 
     @classmethod
     def teardown_class(cls):
-        ''
+        """Tear down the test server."""
         if hasattr(cls, 'setup_server'):
             cls.supervisor.stop()
 
     do_gc_test = False
 
     def test_gc(self):
+        """Perform the garbage collection testing."""
         if not self.do_gc_test:
             return
 
@@ -295,37 +314,45 @@ def test_gc(self):
             'Failures occur intermittently. See #1420'
 
     def prefix(self):
+        """Get an HTTP handler prefix."""
         return self.script_name.rstrip('/')
 
     def base(self):
-        if ((self.scheme == 'http' and self.PORT == 80) or
-                (self.scheme == 'https' and self.PORT == 443)):
+        """Construct the base server URL."""
+        if (self.scheme == 'http' and self.PORT == 80) or (
+            self.scheme == 'https' and self.PORT == 443
+        ):
             port = ''
         else:
             port = ':%s' % self.PORT
 
-        return '%s://%s%s%s' % (self.scheme, self.HOST, port,
-                                self.script_name.rstrip('/'))
+        return '%s://%s%s%s' % (
+            self.scheme,
+            self.HOST,
+            port,
+            self.script_name.rstrip('/'),
+        )
 
     def exit(self):
+        """Terminate the program."""
         sys.exit()
 
     def getPage(self, url, *args, **kwargs):
-        """Open the url.
-        """
+        """Open the url."""
         if self.script_name:
             url = httputil.urljoin(self.script_name, url)
         return webtest.WebCase.getPage(self, url, *args, **kwargs)
 
     def skip(self, msg='skipped '):
+        """Skip the currently running test."""
         pytest.skip(msg)
 
     def assertErrorPage(self, status, message=None, pattern=''):
         """Compare the response body with a built in error page.
 
-        The function will optionally look for the regexp pattern,
-        within the exception embedded in the error page."""
-
+        The function will optionally look for the regexp pattern, within
+        the exception embedded in the error page.
+        """
         # This will never contain a traceback
         page = cherrypy._cperror.get_error_page(status, message=message)
 
@@ -333,14 +360,17 @@ def assertErrorPage(self, status, message=None, pattern=''):
         # Stick a match-all group (.*) in to grab the traceback.
         def esc(text):
             return re.escape(ntob(text))
+
         epage = re.escape(page)
         epage = epage.replace(
             esc('<pre id="traceback"></pre>'),
-            esc('<pre id="traceback">') + b'(.*)' + esc('</pre>'))
+            esc('<pre id="traceback">') + b'(.*)' + esc('</pre>'),
+        )
         m = re.match(epage, self.body, re.DOTALL)
         if not m:
             self._handlewebError(
-                'Error page does not match; expected:\n' + page)
+                'Error page does not match; expected:\n' + page,
+            )
             return
 
         # Now test the pattern against the traceback
@@ -350,8 +380,11 @@ def esc(text):
                 self._handlewebError('Error page contains traceback')
         else:
             if (m is None) or (
-                not re.search(ntob(re.escape(pattern), self.encoding),
-                              m.group(1))):
+                not re.search(
+                    ntob(re.escape(pattern), self.encoding),
+                    m.group(1),
+                )
+            ):
                 msg = 'Error page does not contain %s in traceback'
                 self._handlewebError(msg % repr(pattern))
 
@@ -367,8 +400,9 @@ def assertEqualDates(self, dt1, dt2, seconds=None):
         else:
             diff = dt2 - dt1
         if not diff < datetime.timedelta(seconds=seconds):
-            raise AssertionError('%r and %r are not within %r seconds.' %
-                                 (dt1, dt2, seconds))
+            raise AssertionError(
+                '%r and %r are not within %r seconds.' % (dt1, dt2, seconds),
+            )
 
 
 def _test_method_sorter(_, x, y):
@@ -394,10 +428,12 @@ def setup_client():
     if cherrypy.server.ssl_certificate:
         CPWebCase.scheme = 'https'
 
+
 # --------------------------- Spawning helpers --------------------------- #
 
 
 class CPProcess(object):
+    """CherryPy Process Spawning Helper."""
 
     pid_file = os.path.join(thisdir, 'test.pid')
     config_file = os.path.join(thisdir, 'test.conf')
@@ -414,8 +450,15 @@ class CPProcess(object):
     error_log = os.path.join(thisdir, 'test.error.log')
     access_log = os.path.join(thisdir, 'test.access.log')
 
-    def __init__(self, wait=False, daemonize=False, ssl=False,
-                 socket_host=None, socket_port=None):
+    def __init__(
+        self,
+        wait=False,
+        daemonize=False,
+        ssl=False,
+        socket_host=None,
+        socket_port=None,
+    ):
+        """Initialize a server process runner."""
         self.wait = wait
         self.daemonize = daemonize
         self.ssl = ssl
@@ -423,6 +466,7 @@ def __init__(self, wait=False, daemonize=False, ssl=False,
         self.port = socket_port or cherrypy.server.socket_port
 
     def write_conf(self, extra=''):
+        """Write the server config to disk."""
         if self.ssl:
             serverpem = os.path.join(thisdir, 'test.pem')
             ssl = """
@@ -450,22 +494,22 @@ def start(self, imports=None):
         args = [
             '-m',
             'cherrypy',
-            '-c', self.config_file,
-            '-p', self.pid_file,
+            '-c',
+            self.config_file,
+            '-p',
+            self.pid_file,
         ]
-        r"""
-        Command for running cherryd server with autoreload enabled
+        r"""Command for running cherryd server with autoreload enabled.
 
         Using
 
         ```
         ['-c',
          "__requires__ = 'CherryPy'; \
-         import pkg_resources, re, sys; \
+         import importlib.metadata, re, sys; \
          sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]); \
          sys.exit(\
-            pkg_resources.load_entry_point(\
-                'CherryPy', 'console_scripts', 'cherryd')())"]
+            importlib.metadata.distribution('cherrypy').entry_points[0])"]
         ```
 
         doesn't work as it's impossible to reconstruct the `-c`'s contents.
@@ -488,7 +532,8 @@ def start(self, imports=None):
         grandparentdir = os.path.abspath(os.path.join(thisdir, '..', '..'))
         if env.get('PYTHONPATH', ''):
             env['PYTHONPATH'] = os.pathsep.join(
-                (grandparentdir, env['PYTHONPATH']))
+                (grandparentdir, env['PYTHONPATH']),
+            )
         else:
             env['PYTHONPATH'] = grandparentdir
         self._proc = subprocess.Popen([sys.executable] + args, env=env)
@@ -504,8 +549,10 @@ def start(self, imports=None):
             time.sleep(1)
 
     def get_pid(self):
+        """Get the server process ID."""
         if self.daemonize:
-            return int(open(self.pid_file, 'rb').read())
+            with open(self.pid_file, 'rb') as f:
+                return int(f.read())
         return self._proc.pid
 
     def join(self):
diff --git a/cherrypy/test/logtest.py b/cherrypy/test/logtest.py
index 344be9877..0c839dcba 100644
--- a/cherrypy/test/logtest.py
+++ b/cherrypy/test/logtest.py
@@ -1,4 +1,4 @@
-"""logtest, a unittest.TestCase helper for testing log output."""
+"""Logtest, a unittest.TestCase helper for testing log output."""
 
 import sys
 import time
@@ -14,6 +14,7 @@
     import msvcrt
 
     def getchar():
+        """Get a key press from the Windows terminal."""
         return msvcrt.getch()
 except ImportError:
     # Unix getchr
@@ -21,6 +22,7 @@ def getchar():
     import termios
 
     def getchar():
+        """Get a key press from the UNIX terminal."""
         fd = sys.stdin.fileno()
         old_settings = termios.tcgetattr(fd)
         try:
@@ -32,7 +34,6 @@ def getchar():
 
 
 class LogCase(object):
-
     """unittest.TestCase mixin for testing log messages.
 
     logfile: a filename for the desired log. Yes, I know modes are evil,
@@ -57,9 +58,11 @@ def _handleLogError(self, msg, data, marker, pattern):
         if not self.interactive:
             raise pytest.fail(msg)
 
-        p = ('    Show: '
-             '[L]og [M]arker [P]attern; '
-             '[I]gnore, [R]aise, or sys.e[X]it >> ')
+        p = (
+            '    Show: '
+            '[L]og [M]arker [P]attern; '
+            '[I]gnore, [R]aise, or sys.e[X]it >> '
+        )
         sys.stdout.write(p + ' ')
         # ARGH
         sys.stdout.flush()
@@ -93,11 +96,13 @@ def _handleLogError(self, msg, data, marker, pattern):
             sys.stdout.write(p + ' ')
 
     def exit(self):
+        """Terminate the program."""
         sys.exit()
 
     def emptyLog(self):
         """Overwrite self.logfile with 0 bytes."""
-        open(self.logfile, 'wb').write('')
+        with open(self.logfile, 'wb') as f:
+            f.write('')
 
     def markLog(self, key=None):
         """Insert a marker line into the log and set self.lastmarker."""
@@ -105,45 +110,50 @@ def markLog(self, key=None):
             key = str(time.time())
         self.lastmarker = key
 
-        open(self.logfile, 'ab+').write(
-            b'%s%s\n'
-            % (self.markerPrefix, key.encode('utf-8'))
-        )
+        with open(self.logfile, 'ab+') as f:
+            f.write(b'%s%s\n' % (self.markerPrefix, key.encode('utf-8')))
 
     def _read_marked_region(self, marker=None):
         """Return lines from self.logfile in the marked region.
 
         If marker is None, self.lastmarker is used. If the log hasn't
-        been marked (using self.markLog), the entire log will be returned.
+        been marked (using self.markLog), the entire log will be
+        returned.
         """
-# Give the logger time to finish writing?
-# time.sleep(0.5)
+        # Give the logger time to finish writing?
+        # time.sleep(0.5)
 
         logfile = self.logfile
         marker = marker or self.lastmarker
         if marker is None:
-            return open(logfile, 'rb').readlines()
+            with open(logfile, 'rb') as f:
+                return f.readlines()
 
         if isinstance(marker, str):
             marker = marker.encode('utf-8')
         data = []
         in_region = False
-        for line in open(logfile, 'rb'):
-            if in_region:
-                if line.startswith(self.markerPrefix) and marker not in line:
-                    break
-                else:
-                    data.append(line)
-            elif marker in line:
-                in_region = True
+        with open(logfile, 'rb') as f:
+            for line in f:
+                if in_region:
+                    if (
+                        line.startswith(self.markerPrefix)
+                        and marker not in line
+                    ):
+                        break
+                    else:
+                        data.append(line)
+                elif marker in line:
+                    in_region = True
         return data
 
     def assertInLog(self, line, marker=None):
         """Fail if the given (partial) line is not in the log.
 
-        The log will be searched from the given marker to the next marker.
-        If marker is None, self.lastmarker is used. If the log hasn't
-        been marked (using self.markLog), the entire log will be searched.
+        The log will be searched from the given marker to the next
+        marker. If marker is None, self.lastmarker is used. If the log
+        hasn't been marked (using self.markLog), the entire log will be
+        searched.
         """
         data = self._read_marked_region(marker)
         for logline in data:
@@ -155,9 +165,10 @@ def assertInLog(self, line, marker=None):
     def assertNotInLog(self, line, marker=None):
         """Fail if the given (partial) line is in the log.
 
-        The log will be searched from the given marker to the next marker.
-        If marker is None, self.lastmarker is used. If the log hasn't
-        been marked (using self.markLog), the entire log will be searched.
+        The log will be searched from the given marker to the next
+        marker. If marker is None, self.lastmarker is used. If the log
+        hasn't been marked (using self.markLog), the entire log will be
+        searched.
         """
         data = self._read_marked_region(marker)
         for logline in data:
@@ -168,14 +179,14 @@ def assertNotInLog(self, line, marker=None):
     def assertValidUUIDv4(self, marker=None):
         """Fail if the given UUIDv4 is not valid.
 
-        The log will be searched from the given marker to the next marker.
-        If marker is None, self.lastmarker is used. If the log hasn't
-        been marked (using self.markLog), the entire log will be searched.
+        The log will be searched from the given marker to the next
+        marker. If marker is None, self.lastmarker is used. If the log
+        hasn't been marked (using self.markLog), the entire log will be
+        searched.
         """
         data = self._read_marked_region(marker)
         data = [
-            chunk.decode('utf-8').rstrip('\n').rstrip('\r')
-            for chunk in data
+            chunk.decode('utf-8').rstrip('\n').rstrip('\r') for chunk in data
         ]
         for log_chunk in data:
             try:
@@ -195,9 +206,10 @@ def assertValidUUIDv4(self, marker=None):
     def assertLog(self, sliceargs, lines, marker=None):
         """Fail if log.readlines()[sliceargs] is not contained in 'lines'.
 
-        The log will be searched from the given marker to the next marker.
-        If marker is None, self.lastmarker is used. If the log hasn't
-        been marked (using self.markLog), the entire log will be searched.
+        The log will be searched from the given marker to the next
+        marker. If marker is None, self.lastmarker is used. If the log
+        hasn't been marked (using self.markLog), the entire log will be
+        searched.
         """
         data = self._read_marked_region(marker)
         if isinstance(sliceargs, int):
@@ -210,17 +222,20 @@ def assertLog(self, sliceargs, lines, marker=None):
                 msg = '%r not found on log line %r' % (lines, sliceargs)
                 self._handleLogError(
                     msg,
-                    [data[sliceargs], '--EXTRA CONTEXT--'] + data[
-                        sliceargs + 1:sliceargs + 6],
+                    [data[sliceargs], '--EXTRA CONTEXT--']
+                    + data[sliceargs + 1 : sliceargs + 6],
                     marker,
-                    lines)
+                    lines,
+                )
         else:
             # Multiple args. Use __getslice__ and require lines to be list.
             if isinstance(lines, tuple):
                 lines = list(lines)
             elif isinstance(lines, text_or_bytes):
-                raise TypeError("The 'lines' arg must be a list when "
-                                "'sliceargs' is a tuple.")
+                raise TypeError(
+                    "The 'lines' arg must be a list when "
+                    "'sliceargs' is a tuple.",
+                )
 
             start, stop = sliceargs
             for line, logline in zip(lines, data[start:stop]):
diff --git a/cherrypy/test/modfastcgi.py b/cherrypy/test/modfastcgi.py
index 79ec3d182..52b6cd56c 100644
--- a/cherrypy/test/modfastcgi.py
+++ b/cherrypy/test/modfastcgi.py
@@ -14,7 +14,7 @@
 
 1. Apache processes Range headers automatically; CherryPy's truncated
     output is then truncated again by Apache. See test_core.testRanges.
-    This was worked around in http://www.cherrypy.org/changeset/1319.
+    This was worked around in http://www.cherrypy.dev/changeset/1319.
 2. Apache does not allow custom HTTP methods like CONNECT as per the spec.
     See test_core.testHTTPMethods.
 3. Max request header and body settings do not work with Apache.
@@ -44,11 +44,15 @@
 
 
 def read_process(cmd, args=''):
+    """Return subprocess' console output."""
     pipein, pipeout = os.popen4('%s %s' % (cmd, args))
     try:
         firstline = pipeout.readline()
-        if (re.search(r'(not recognized|No such file|not found)', firstline,
-                      re.IGNORECASE)):
+        if re.search(
+            r'(not recognized|No such file|not found)',
+            firstline,
+            re.IGNORECASE,
+        ):
             raise IOError('%s must be on your system path.' % cmd)
         output = firstline + pipeout.read()
     finally:
@@ -81,11 +85,13 @@ def read_process(cmd, args=''):
 
 
 def erase_script_name(environ, start_response):
+    """Erase script name from the WSGI environment."""
     environ['SCRIPT_NAME'] = ''
     return cherrypy.tree(environ, start_response)
 
 
 class ModFCGISupervisor(helper.LocalWSGISupervisor):
+    """Server Controller for ModFastCGI and CherryPy."""
 
     httpserver_class = 'cherrypy.process.servers.FlupFCGIServer'
     using_apache = True
@@ -93,11 +99,15 @@ class ModFCGISupervisor(helper.LocalWSGISupervisor):
     template = conf_fastcgi
 
     def __str__(self):
+        """Render a :class:`ModFastCGISupervisor` instance as a string."""
         return 'FCGI Server on %s:%s' % (self.host, self.port)
 
     def start(self, modulename):
+        """Spawn an Apache ``mod_fastcgi`` supervisor process."""
         cherrypy.server.httpserver = servers.FlupFCGIServer(
-            application=erase_script_name, bindAddress=('127.0.0.1', 4000))
+            application=erase_script_name,
+            bindAddress=('127.0.0.1', 4000),
+        )
         cherrypy.server.httpserver.bind_addr = ('127.0.0.1', 4000)
         cherrypy.server.socket_port = 4000
         # For FCGI, we both start apache...
@@ -107,20 +117,21 @@ def start(self, modulename):
         self.sync_apps()
 
     def start_apache(self):
+        """Start Apache instance."""
         fcgiconf = CONF_PATH
         if not os.path.isabs(fcgiconf):
             fcgiconf = os.path.join(curdir, fcgiconf)
 
         # Write the Apache conf file.
-        f = open(fcgiconf, 'wb')
-        try:
+        with open(fcgiconf, 'wb') as f:
             server = repr(os.path.join(curdir, 'fastcgi.pyc'))[1:-1]
-            output = self.template % {'port': self.port, 'root': curdir,
-                                      'server': server}
+            output = self.template % {
+                'port': self.port,
+                'root': curdir,
+                'server': server,
+            }
             output = output.replace('\r\n', '\n')
             f.write(output)
-        finally:
-            f.close()
 
         result = read_process(APACHE_PATH, '-k start -f %s' % fcgiconf)
         if result:
@@ -132,5 +143,7 @@ def stop(self):
         helper.LocalWSGISupervisor.stop(self)
 
     def sync_apps(self):
+        """Set up the FastCGI request handler."""
         cherrypy.server.httpserver.fcgiserver.application = self.get_app(
-            erase_script_name)
+            erase_script_name,
+        )
diff --git a/cherrypy/test/modfcgid.py b/cherrypy/test/modfcgid.py
index d101bd67f..a8cf5c373 100644
--- a/cherrypy/test/modfcgid.py
+++ b/cherrypy/test/modfcgid.py
@@ -14,7 +14,7 @@
 
 1. Apache processes Range headers automatically; CherryPy's truncated
     output is then truncated again by Apache. See test_core.testRanges.
-    This was worked around in http://www.cherrypy.org/changeset/1319.
+    This was worked around in http://www.cherrypy.dev/changeset/1319.
 2. Apache does not allow custom HTTP methods like CONNECT as per the spec.
     See test_core.testHTTPMethods.
 3. Max request header and body settings do not work with Apache.
@@ -45,11 +45,15 @@
 
 
 def read_process(cmd, args=''):
+    """Return subprocess' console output."""
     pipein, pipeout = os.popen4('%s %s' % (cmd, args))
     try:
         firstline = pipeout.readline()
-        if (re.search(r'(not recognized|No such file|not found)', firstline,
-                      re.IGNORECASE)):
+        if re.search(
+            r'(not recognized|No such file|not found)',
+            firstline,
+            re.IGNORECASE,
+        ):
             raise IOError('%s must be on your system path.' % cmd)
         output = firstline + pipeout.read()
     finally:
@@ -78,17 +82,22 @@ def read_process(cmd, args=''):
 
 
 class ModFCGISupervisor(helper.LocalSupervisor):
+    """Server Controller for ModFCGI and CherryPy."""
 
     using_apache = True
     using_wsgi = True
     template = conf_fcgid
 
     def __str__(self):
+        """Render a :class:`ModFCGISupervisor` instance as a string."""
         return 'FCGI Server on %s:%s' % (self.host, self.port)
 
     def start(self, modulename):
+        """Spawn an Apache ``mod_fcgid`` supervisor process."""
         cherrypy.server.httpserver = servers.FlupFCGIServer(
-            application=cherrypy.tree, bindAddress=('127.0.0.1', 4000))
+            application=cherrypy.tree,
+            bindAddress=('127.0.0.1', 4000),
+        )
         cherrypy.server.httpserver.bind_addr = ('127.0.0.1', 4000)
         # For FCGI, we both start apache...
         self.start_apache()
@@ -96,20 +105,21 @@ def start(self, modulename):
         helper.LocalServer.start(self, modulename)
 
     def start_apache(self):
+        """Start Apache instance."""
         fcgiconf = CONF_PATH
         if not os.path.isabs(fcgiconf):
             fcgiconf = os.path.join(curdir, fcgiconf)
 
         # Write the Apache conf file.
-        f = open(fcgiconf, 'wb')
-        try:
+        with open(fcgiconf, 'wb') as f:
             server = repr(os.path.join(curdir, 'fastcgi.pyc'))[1:-1]
-            output = self.template % {'port': self.port, 'root': curdir,
-                                      'server': server}
+            output = self.template % {
+                'port': self.port,
+                'root': curdir,
+                'server': server,
+            }
             output = ntob(output.replace('\r\n', '\n'))
             f.write(output)
-        finally:
-            f.close()
 
         result = read_process(APACHE_PATH, '-k start -f %s' % fcgiconf)
         if result:
@@ -121,4 +131,5 @@ def stop(self):
         helper.LocalServer.stop(self)
 
     def sync_apps(self):
+        """Set up the FCGID request handler."""
         cherrypy.server.httpserver.fcgiserver.application = self.get_app()
diff --git a/cherrypy/test/modpy.py b/cherrypy/test/modpy.py
index 7c288d2c0..b1bf919ac 100644
--- a/cherrypy/test/modpy.py
+++ b/cherrypy/test/modpy.py
@@ -15,7 +15,7 @@
 
 1. Apache processes Range headers automatically; CherryPy's truncated
     output is then truncated again by Apache. See test_core.testRanges.
-    This was worked around in http://www.cherrypy.org/changeset/1319.
+    This was worked around in http://www.cherrypy.dev/changeset/1319.
 2. Apache does not allow custom HTTP methods like CONNECT as per the spec.
     See test_core.testHTTPMethods.
 3. Max request header and body settings do not work with Apache.
@@ -44,11 +44,15 @@
 
 
 def read_process(cmd, args=''):
+    """Return subprocess' console output."""
     pipein, pipeout = os.popen4('%s %s' % (cmd, args))
     try:
         firstline = pipeout.readline()
-        if (re.search(r'(not recognized|No such file|not found)', firstline,
-                      re.IGNORECASE)):
+        if re.search(
+            r'(not recognized|No such file|not found)',
+            firstline,
+            re.IGNORECASE,
+        ):
             raise IOError('%s must be on your system path.' % cmd)
         output = firstline + pipeout.read()
     finally:
@@ -94,26 +98,31 @@ def read_process(cmd, args=''):
 
 
 class ModPythonSupervisor(helper.Supervisor):
+    """Server Controller for ModPython and CherryPy."""
 
     using_apache = True
     using_wsgi = False
     template = None
 
     def __str__(self):
+        """Render a :class:`ModPythonSupervisor` instance as a string."""
         return 'ModPython Server on %s:%s' % (self.host, self.port)
 
     def start(self, modulename):
+        """Spawn an Apache ``mod_python`` supervisor process."""
         mpconf = CONF_PATH
         if not os.path.isabs(mpconf):
             mpconf = os.path.join(curdir, mpconf)
 
-        f = open(mpconf, 'wb')
-        try:
-            f.write(self.template %
-                    {'port': self.port, 'modulename': modulename,
-                     'host': self.host})
-        finally:
-            f.close()
+        with open(mpconf, 'wb') as f:
+            f.write(
+                self.template
+                % {
+                    'port': self.port,
+                    'modulename': modulename,
+                    'host': self.host,
+                },
+            )
 
         result = read_process(APACHE_PATH, '-k start -f %s' % mpconf)
         if result:
@@ -128,16 +137,19 @@ def stop(self):
 
 
 def wsgisetup(req):
+    """Start a WGSI server."""
     global loaded
     if not loaded:
         loaded = True
         options = req.get_options()
 
-        cherrypy.config.update({
-            'log.error_file': os.path.join(curdir, 'test.log'),
-            'environment': 'test_suite',
-            'server.socket_host': options['socket_host'],
-        })
+        cherrypy.config.update(
+            {
+                'log.error_file': os.path.join(curdir, 'test.log'),
+                'environment': 'test_suite',
+                'server.socket_host': options['socket_host'],
+            },
+        )
 
         modname = options['testmod']
         mod = __import__(modname, globals(), locals(), [''])
@@ -146,19 +158,24 @@ def wsgisetup(req):
         cherrypy.server.unsubscribe()
         cherrypy.engine.start()
     from mod_python import apache
+
     return apache.OK
 
 
 def cpmodpysetup(req):
+    """Start a CherryPy server with ``mod_python``."""
     global loaded
     if not loaded:
         loaded = True
         options = req.get_options()
 
-        cherrypy.config.update({
-            'log.error_file': os.path.join(curdir, 'test.log'),
-            'environment': 'test_suite',
-            'server.socket_host': options['socket_host'],
-        })
+        cherrypy.config.update(
+            {
+                'log.error_file': os.path.join(curdir, 'test.log'),
+                'environment': 'test_suite',
+                'server.socket_host': options['socket_host'],
+            },
+        )
     from mod_python import apache
+
     return apache.OK
diff --git a/cherrypy/test/modwsgi.py b/cherrypy/test/modwsgi.py
index da7d240b5..c935bd73c 100644
--- a/cherrypy/test/modwsgi.py
+++ b/cherrypy/test/modwsgi.py
@@ -11,7 +11,7 @@
 
 1. Apache processes Range headers automatically; CherryPy's truncated
     output is then truncated again by Apache. See test_core.testRanges.
-    This was worked around in http://www.cherrypy.org/changeset/1319.
+    This was worked around in http://www.cherrypy.dev/changeset/1319.
 2. Apache does not allow custom HTTP methods like CONNECT as per the spec.
     See test_core.testHTTPMethods.
 3. Max request header and body settings do not work with Apache.
@@ -48,11 +48,15 @@
 
 
 def read_process(cmd, args=''):
+    """Return subprocess' console output."""
     pipein, pipeout = os.popen4('%s %s' % (cmd, args))
     try:
         firstline = pipeout.readline()
-        if (re.search(r'(not recognized|No such file|not found)', firstline,
-                      re.IGNORECASE)):
+        if re.search(
+            r'(not recognized|No such file|not found)',
+            firstline,
+            re.IGNORECASE,
+        ):
             raise IOError('%s must be on your system path.' % cmd)
         output = firstline + pipeout.read()
     finally:
@@ -90,11 +94,10 @@ def read_process(cmd, args=''):
 
 WSGIScriptAlias / "%(curdir)s/modwsgi.py"
 SetEnv testmod %(testmod)s
-""" # noqa E501
+"""  # noqa E501
 
 
 class ModWSGISupervisor(helper.Supervisor):
-
     """Server Controller for ModWSGI and CherryPy."""
 
     using_apache = True
@@ -102,21 +105,22 @@ class ModWSGISupervisor(helper.Supervisor):
     template = conf_modwsgi
 
     def __str__(self):
+        """Render a :class:`ModWSGISupervisor` instance as a string."""
         return 'ModWSGI Server on %s:%s' % (self.host, self.port)
 
     def start(self, modulename):
+        """Spawn an Apache ``mod_wsgi`` supervisor process."""
         mpconf = CONF_PATH
         if not os.path.isabs(mpconf):
             mpconf = os.path.join(curdir, mpconf)
 
-        f = open(mpconf, 'wb')
-        try:
-            output = (self.template %
-                      {'port': self.port, 'testmod': modulename,
-                       'curdir': curdir})
+        with open(mpconf, 'wb') as f:
+            output = self.template % {
+                'port': self.port,
+                'testmod': modulename,
+                'curdir': curdir,
+            }
             f.write(output)
-        finally:
-            f.close()
 
         result = read_process(APACHE_PATH, '-k start -f %s' % mpconf)
         if result:
@@ -137,6 +141,7 @@ def stop(self):
 
 
 def application(environ, start_response):
+    """Respond to a WSGI-interfaced HTTP request via test module."""
     global loaded
     if not loaded:
         loaded = True
@@ -144,11 +149,13 @@ def application(environ, start_response):
         mod = __import__(modname, globals(), locals(), [''])
         mod.setup_server()
 
-        cherrypy.config.update({
-            'log.error_file': os.path.join(curdir, 'test.error.log'),
-            'log.access_file': os.path.join(curdir, 'test.access.log'),
-            'environment': 'test_suite',
-            'engine.SIGHUP': None,
-            'engine.SIGTERM': None,
-        })
+        cherrypy.config.update(
+            {
+                'log.error_file': os.path.join(curdir, 'test.error.log'),
+                'log.access_file': os.path.join(curdir, 'test.access.log'),
+                'environment': 'test_suite',
+                'engine.SIGHUP': None,
+                'engine.SIGTERM': None,
+            },
+        )
     return cherrypy.tree(environ, start_response)
diff --git a/cherrypy/test/sessiondemo.py b/cherrypy/test/sessiondemo.py
index 3849a2593..a5c6fc909 100755
--- a/cherrypy/test/sessiondemo.py
+++ b/cherrypy/test/sessiondemo.py
@@ -3,6 +3,7 @@
 
 import calendar
 from datetime import datetime
+from datetime import timezone as _timezone
 import sys
 
 import cherrypy
@@ -97,17 +98,21 @@
 
 
 class Root(object):
+    """Session demo app."""
 
     def page(self):
+        """Render HTTP request-related details."""
         changemsg = []
         if cherrypy.session.id != cherrypy.session.originalid:
             if cherrypy.session.originalid is None:
                 changemsg.append(
-                    'Created new session because no session id was given.')
+                    'Created new session because no session id was given.',
+                )
             if cherrypy.session.missing:
                 changemsg.append(
                     'Created new session due to missing '
-                    '(expired or malicious) session.')
+                    '(expired or malicious) session.',
+                )
             if cherrypy.session.regenerated:
                 changemsg.append('Application generated a new session.')
 
@@ -123,9 +128,11 @@ def page(self):
             'reqcookie': cherrypy.request.cookie.output(),
             'sessiondata': list(cherrypy.session.items()),
             'servertime': (
-                datetime.utcnow().strftime('%Y/%m/%d %H:%M') + ' UTC'
+                datetime.now(_timezone.utc).strftime('%Y/%m/%d %H:%M UTC')
+            ),
+            'serverunixtime': calendar.timegm(
+                datetime.utcnow(_timezone.utc).timetuple(),
             ),
-            'serverunixtime': calendar.timegm(datetime.utcnow().timetuple()),
             'cpversion': cherrypy.__version__,
             'pyversion': sys.version,
             'expires': expires,
@@ -133,17 +140,20 @@ def page(self):
 
     @cherrypy.expose
     def index(self):
+        """Save green color in session at app index URI."""
         # Must modify data or the session will not be saved.
         cherrypy.session['color'] = 'green'
         return self.page()
 
     @cherrypy.expose
     def expire(self):
+        """Expire the existing session."""
         sessions.expire()
         return self.page()
 
     @cherrypy.expose
     def regen(self):
+        """Regenerate the session, storing yellow color in it."""
         cherrypy.session.regenerate()
         # Must modify data or the session will not be saved.
         cherrypy.session['color'] = 'yellow'
@@ -151,9 +161,11 @@ def regen(self):
 
 
 if __name__ == '__main__':
-    cherrypy.config.update({
-        # 'environment': 'production',
-        'log.screen': True,
-        'tools.sessions.on': True,
-    })
+    cherrypy.config.update(
+        {
+            # 'environment': 'production',
+            'log.screen': True,
+            'tools.sessions.on': True,
+        },
+    )
     cherrypy.quickstart(Root())
diff --git a/cherrypy/test/test_auth_basic.py b/cherrypy/test/test_auth_basic.py
index d7e69a9b4..9dc8d3e5c 100644
--- a/cherrypy/test/test_auth_basic.py
+++ b/cherrypy/test/test_auth_basic.py
@@ -1,4 +1,4 @@
-# This file is part of CherryPy <http://www.cherrypy.org/>
+# This file is part of CherryPy <http://www.cherrypy.dev/>
 # -*- coding: utf-8 -*-
 # vim:ts=4:sw=4:expandtab:fileencoding=utf-8
 
@@ -11,35 +11,33 @@
 
 
 class BasicAuthTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'This is public.'
 
         class BasicProtected:
-
             @cherrypy.expose
             def index(self):
                 return "Hello %s, you've been authorized." % (
-                    cherrypy.request.login)
+                    cherrypy.request.login
+                )
 
         class BasicProtected2:
-
             @cherrypy.expose
             def index(self):
                 return "Hello %s, you've been authorized." % (
-                    cherrypy.request.login)
+                    cherrypy.request.login
+                )
 
         class BasicProtected2_u:
-
             @cherrypy.expose
             def index(self):
                 return "Hello %s, you've been authorized." % (
-                    cherrypy.request.login)
+                    cherrypy.request.login
+                )
 
         userpassdict = {'xuser': 'xpassword'}
         userhashdict = {'xuser': md5(b'xpassword').hexdigest()}
@@ -58,7 +56,7 @@ def checkpasshash_u(realm, user, password):
             '/basic': {
                 'tools.auth_basic.on': True,
                 'tools.auth_basic.realm': 'wonderland',
-                'tools.auth_basic.checkpassword': basic_checkpassword_dict
+                'tools.auth_basic.checkpassword': basic_checkpassword_dict,
             },
             '/basic2': {
                 'tools.auth_basic.on': True,
@@ -91,15 +89,19 @@ def testBasic(self):
         self.assertStatus(401)
         self.assertHeader(
             'WWW-Authenticate',
-            'Basic realm="wonderland", charset="UTF-8"'
+            'Basic realm="wonderland", charset="UTF-8"',
         )
 
-        self.getPage('/basic/',
-                     [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')])
+        self.getPage(
+            '/basic/',
+            [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')],
+        )
         self.assertStatus(401)
 
-        self.getPage('/basic/',
-                     [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')])
+        self.getPage(
+            '/basic/',
+            [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')],
+        )
         self.assertStatus('200 OK')
         self.assertBody("Hello xuser, you've been authorized.")
 
@@ -108,12 +110,16 @@ def testBasic2(self):
         self.assertStatus(401)
         self.assertHeader('WWW-Authenticate', 'Basic realm="wonderland"')
 
-        self.getPage('/basic2/',
-                     [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')])
+        self.getPage(
+            '/basic2/',
+            [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3JX')],
+        )
         self.assertStatus(401)
 
-        self.getPage('/basic2/',
-                     [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')])
+        self.getPage(
+            '/basic2/',
+            [('Authorization', 'Basic eHVzZXI6eHBhc3N3b3Jk')],
+        )
         self.assertStatus('200 OK')
         self.assertBody("Hello xuser, you've been authorized.")
 
@@ -122,14 +128,18 @@ def testBasic2_u(self):
         self.assertStatus(401)
         self.assertHeader(
             'WWW-Authenticate',
-            'Basic realm="wonderland", charset="UTF-8"'
+            'Basic realm="wonderland", charset="UTF-8"',
         )
 
-        self.getPage('/basic2_u/',
-                     [('Authorization', 'Basic eNGO0LfQtdGAOtGX0LbRgw==')])
+        self.getPage(
+            '/basic2_u/',
+            [('Authorization', 'Basic eNGO0LfQtdGAOtGX0LbRgw==')],
+        )
         self.assertStatus(401)
 
-        self.getPage('/basic2_u/',
-                     [('Authorization', 'Basic eNGO0LfQtdGAOtGX0LbQsA==')])
+        self.getPage(
+            '/basic2_u/',
+            [('Authorization', 'Basic eNGO0LfQtdGAOtGX0LbQsA==')],
+        )
         self.assertStatus('200 OK')
         self.assertBody("Hello xюзер, you've been authorized.")
diff --git a/cherrypy/test/test_auth_digest.py b/cherrypy/test/test_auth_digest.py
index 745f89e6c..6e054ba78 100644
--- a/cherrypy/test/test_auth_digest.py
+++ b/cherrypy/test/test_auth_digest.py
@@ -1,4 +1,4 @@
-# This file is part of CherryPy <http://www.cherrypy.org/>
+# This file is part of CherryPy <http://www.cherrypy.dev/>
 # -*- coding: utf-8 -*-
 # vim:ts=4:sw=4:expandtab:fileencoding=utf-8
 
@@ -18,28 +18,30 @@ def _fetch_users():
 
 
 class DigestAuthTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'This is public.'
 
         class DigestProtected:
-
             @cherrypy.expose
             def index(self, *args, **kwargs):
                 return "Hello %s, you've been authorized." % (
-                    cherrypy.request.login)
-
-        conf = {'/digest': {'tools.auth_digest.on': True,
-                            'tools.auth_digest.realm': 'localhost',
-                            'tools.auth_digest.get_ha1': get_ha1,
-                            'tools.auth_digest.key': 'a565c27146791cfb',
-                            'tools.auth_digest.debug': True,
-                            'tools.auth_digest.accept_charset': 'UTF-8'}}
+                    cherrypy.request.login
+                )
+
+        conf = {
+            '/digest': {
+                'tools.auth_digest.on': True,
+                'tools.auth_digest.realm': 'localhost',
+                'tools.auth_digest.get_ha1': get_ha1,
+                'tools.auth_digest.key': 'a565c27146791cfb',
+                'tools.auth_digest.debug': True,
+                'tools.auth_digest.accept_charset': 'UTF-8',
+            },
+        }
 
         root = Root()
         root.digest = DigestProtected()
@@ -58,11 +60,13 @@ def _test_parametric_digest(self, username, realm):
         assert self.status_code == 401
 
         msg = 'Digest authentification scheme was not found'
-        www_auth_digest = tuple(filter(
-            lambda kv: kv[0].lower() == 'www-authenticate'
-            and kv[1].startswith('Digest '),
-            self.headers,
-        ))
+        www_auth_digest = tuple(
+            filter(
+                lambda kv: kv[0].lower() == 'www-authenticate'
+                and kv[1].startswith('Digest '),
+                self.headers,
+            ),
+        )
         assert len(www_auth_digest) == 1, msg
 
         items = www_auth_digest[0][-1][7:].split(', ')
@@ -79,30 +83,40 @@ def _test_parametric_digest(self, username, realm):
         nonce = tokens['nonce'].strip('"')
 
         # Test user agent response with a wrong value for 'realm'
-        base_auth = ('Digest username="%s", '
-                     'realm="%s", '
-                     'nonce="%s", '
-                     'uri="%s", '
-                     'algorithm=MD5, '
-                     'response="%s", '
-                     'qop=auth, '
-                     'nc=%s, '
-                     'cnonce="1522e61005789929"')
+        base_auth = (
+            'Digest username="%s", '
+            'realm="%s", '
+            'nonce="%s", '
+            'uri="%s", '
+            'algorithm=MD5, '
+            'response="%s", '
+            'qop=auth, '
+            'nc=%s, '
+            'cnonce="1522e61005789929"'
+        )
 
         encoded_user = username
         encoded_user = encoded_user.encode('utf-8')
         encoded_user = encoded_user.decode('latin1')
         auth_header = base_auth % (
-            encoded_user, realm, nonce, test_uri,
-            '11111111111111111111111111111111', '00000001',
+            encoded_user,
+            realm,
+            nonce,
+            test_uri,
+            '11111111111111111111111111111111',
+            '00000001',
         )
         auth = auth_digest.HttpDigestAuthorization(auth_header, 'GET')
         # calculate the response digest
         ha1 = get_ha1(auth.realm, auth.username)
         response = auth.request_digest(ha1)
         auth_header = base_auth % (
-            encoded_user, realm, nonce, test_uri,
-            response, '00000001',
+            encoded_user,
+            realm,
+            nonce,
+            test_uri,
+            response,
+            '00000001',
         )
         self.getPage(test_uri, [('Authorization', auth_header)])
 
@@ -120,7 +134,8 @@ def test_unicode_user(self):
         self._test_parametric_digest(username='☃йюзер', realm='localhost')
         assert self.status == '200 OK'
         assert self.body == ntob(
-            "Hello ☃йюзер, you've been authorized.", 'utf-8',
+            "Hello ☃йюзер, you've been authorized.",
+            'utf-8',
         )
 
     def test_wrong_scheme(self):
diff --git a/cherrypy/test/test_bus.py b/cherrypy/test/test_bus.py
index 594023a23..1c6d5d27b 100644
--- a/cherrypy/test/test_bus.py
+++ b/cherrypy/test/test_bus.py
@@ -9,6 +9,7 @@
 
 import pytest
 
+from cherrypy._cpcompat import IS_PYPY, IS_WINDOWS
 from cherrypy.process import wspbus
 
 
@@ -25,6 +26,7 @@ def bus():
 @pytest.fixture
 def log_tracker(bus):
     """Return an instance of bus log tracker."""
+
     class LogTracker:  # pylint: disable=too-few-public-methods
         """Bus log tracker."""
 
@@ -33,6 +35,7 @@ class LogTracker:  # pylint: disable=too-few-public-methods
         def __init__(self, bus):
             def logit(msg, level):  # pylint: disable=unused-argument
                 self.log_entries.append(msg)
+
             bus.subscribe('log', logit)
 
     return LogTracker(bus)
@@ -41,6 +44,7 @@ def logit(msg, level):  # pylint: disable=unused-argument
 @pytest.fixture
 def listener():
     """Return an instance of bus response tracker."""
+
     class Listner:  # pylint: disable=too-few-public-methods
         """Bus handler return value tracker."""
 
@@ -48,8 +52,10 @@ class Listner:  # pylint: disable=too-few-public-methods
 
         def get_listener(self, channel, index):
             """Return an argument tracking listener."""
+
             def listener(arg=None):
                 self.responses.append(msg % (index, channel, arg))
+
             return listener
 
     return Listner()
@@ -125,9 +131,9 @@ def test_start(bus, listener, log_tracker):
     bus.start()
     try:
         # The start method MUST call all 'start' listeners.
-        assert (
-            set(listener.responses) ==
-            set(msg % (i, 'start', None) for i in range(num)))
+        assert set(listener.responses) == set(
+            msg % (i, 'start', None) for i in range(num)
+        )
         # The start method MUST move the state to STARTED
         # (or EXITING, if errors occur)
         assert bus.state == bus.states.STARTED
@@ -148,8 +154,9 @@ def test_stop(bus, listener, log_tracker):
     bus.stop()
 
     # The stop method MUST call all 'stop' listeners.
-    assert (set(listener.responses) ==
-            set(msg % (i, 'stop', None) for i in range(num)))
+    assert set(listener.responses) == set(
+        msg % (i, 'stop', None) for i in range(num)
+    )
 
     # The stop method MUST move the state to STOPPED
     assert bus.state == bus.states.STOPPED
@@ -168,9 +175,9 @@ def test_graceful(bus, listener, log_tracker):
     bus.graceful()
 
     # The graceful method MUST call all 'graceful' listeners.
-    assert (
-        set(listener.responses) ==
-        set(msg % (i, 'graceful', None) for i in range(num)))
+    assert set(listener.responses) == set(
+        msg % (i, 'graceful', None) for i in range(num)
+    )
 
     # The graceful method MUST log its states.
     assert log_tracker.log_entries == ['Bus graceful']
@@ -188,20 +195,26 @@ def test_exit(bus, listener, log_tracker):
 
     # The exit method MUST call all 'stop' listeners,
     # and then all 'exit' listeners.
-    assert (set(listener.responses) ==
-            set([msg % (i, 'stop', None) for i in range(num)] +
-                [msg % (i, 'exit', None) for i in range(num)]))
+    assert set(listener.responses) == set(
+        [msg % (i, 'stop', None) for i in range(num)]
+        + [msg % (i, 'exit', None) for i in range(num)],
+    )
 
     # The exit method MUST move the state to EXITING
     assert bus.state == bus.states.EXITING
 
     # The exit method MUST log its states.
-    assert (log_tracker.log_entries ==
-            ['Bus STOPPING', 'Bus STOPPED', 'Bus EXITING', 'Bus EXITED'])
+    assert log_tracker.log_entries == [
+        'Bus STOPPING',
+        'Bus STOPPED',
+        'Bus EXITING',
+        'Bus EXITED',
+    ]
 
 
 def test_wait(bus):
     """Test that bus wait awaits for states."""
+
     def f(method):  # pylint: disable=invalid-name
         time.sleep(0.2)
         getattr(bus, method)()
@@ -221,6 +234,8 @@ def f(method):  # pylint: disable=invalid-name
         assert bus.state in states, 'State %r not in %r' % (bus.state, states)
 
 
+# FIXME: This test is unstable on slow envs like Windows and such.
+@pytest.mark.flaky(reruns=3, reruns_delay=2, condition=IS_WINDOWS)
 @pytest.mark.xfail(CI_ON_MACOS, reason='continuous integration on macOS fails')
 def test_wait_publishes_periodically(bus):
     """Test that wait publishes each tick."""
@@ -230,13 +245,17 @@ def test_wait_publishes_periodically(bus):
     def set_start():
         time.sleep(0.05)
         bus.start()
+
     threading.Thread(target=set_start).start()
     bus.wait(bus.states.STARTED, interval=0.01, channel='main')
     assert callback.call_count > 3
 
 
+# FIXME: This test is unstable on platforms with custom GC, like PyPy.
+@pytest.mark.flaky(reruns=3, reruns_delay=2, condition=IS_PYPY)
 def test_block(bus, log_tracker):
     """Test that bus block waits for exiting."""
+
     def f():  # pylint: disable=invalid-name
         time.sleep(0.2)
         bus.exit()
@@ -277,6 +296,8 @@ def g():  # pylint: disable=invalid-name
     )
 
 
+# FIXME: This test is unstable on slow envs like macOS and such.
+@pytest.mark.flaky(reruns=3, reruns_delay=2, condition=CI_ON_MACOS)
 def test_start_with_callback(bus):
     """Test that callback fires on bus start."""
     try:
@@ -287,6 +308,7 @@ def f(*args, **kwargs):  # pylint: disable=invalid-name
 
         def g():  # pylint: disable=invalid-name
             events.append('g')
+
         bus.subscribe('start', g)
         bus.start_with_callback(f, (1, 3, 5), {'foo': 'bar'})
 
diff --git a/cherrypy/test/test_caching.py b/cherrypy/test/test_caching.py
index c0b897976..ecae3b76d 100644
--- a/cherrypy/test/test_caching.py
+++ b/cherrypy/test/test_caching.py
@@ -23,13 +23,10 @@
 
 
 class CacheTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         @cherrypy.config(**{'tools.caching.on': True})
         class Root:
-
             def __init__(self):
                 self.counter = 0
                 self.control_counter = 0
@@ -48,8 +45,9 @@ def control(self):
 
             @cherrypy.expose
             def a_gif(self):
-                cherrypy.response.headers[
-                    'Last-Modified'] = httputil.HTTPDate()
+                cherrypy.response.headers['Last-Modified'] = (
+                    httputil.HTTPDate()
+                )
                 return gif_bytes
 
             @cherrypy.expose
@@ -65,15 +63,16 @@ def long_process(self, seconds='1'):
             def clear_cache(self, path):
                 cherrypy._cache.store[cherrypy.request.base + path].clear()
 
-        @cherrypy.config(**{
-            'tools.caching.on': True,
-            'tools.response_headers.on': True,
-            'tools.response_headers.headers': [
-                ('Vary', 'Our-Varying-Header')
-            ],
-        })
+        @cherrypy.config(
+            **{
+                'tools.caching.on': True,
+                'tools.response_headers.on': True,
+                'tools.response_headers.headers': [
+                    ('Vary', 'Our-Varying-Header'),
+                ],
+            },
+        )
         class VaryHeaderCachingServer(object):
-
             def __init__(self):
                 self.counter = count(1)
 
@@ -81,15 +80,16 @@ def __init__(self):
             def index(self):
                 return 'visit #%s' % next(self.counter)
 
-        @cherrypy.config(**{
-            'tools.expires.on': True,
-            'tools.expires.secs': 60,
-            'tools.staticdir.on': True,
-            'tools.staticdir.dir': 'static',
-            'tools.staticdir.root': curdir,
-        })
+        @cherrypy.config(
+            **{
+                'tools.expires.on': True,
+                'tools.expires.secs': 60,
+                'tools.staticdir.on': True,
+                'tools.staticdir.dir': 'static',
+                'tools.staticdir.root': curdir,
+            },
+        )
         class UnCached(object):
-
             @cherrypy.expose
             @cherrypy.config(**{'tools.expires.secs': 0})
             def force(self):
@@ -112,8 +112,9 @@ def cacheable(self):
             @cherrypy.expose
             @cherrypy.config(**{'tools.expires.secs': 86400})
             def specific(self):
-                cherrypy.response.headers[
-                    'Etag'] = 'need_this_to_make_me_cacheable'
+                cherrypy.response.headers['Etag'] = (
+                    'need_this_to_make_me_cacheable'
+                )
                 return 'I am being specific'
 
             class Foo(object):
@@ -122,17 +123,20 @@ class Foo(object):
             @cherrypy.expose
             @cherrypy.config(**{'tools.expires.secs': Foo()})
             def wrongtype(self):
-                cherrypy.response.headers[
-                    'Etag'] = 'need_this_to_make_me_cacheable'
+                cherrypy.response.headers['Etag'] = (
+                    'need_this_to_make_me_cacheable'
+                )
                 return 'Woops'
 
-        @cherrypy.config(**{
-            'tools.gzip.mime_types': ['text/*', 'image/*'],
-            'tools.caching.on': True,
-            'tools.staticdir.on': True,
-            'tools.staticdir.dir': 'static',
-            'tools.staticdir.root': curdir
-        })
+        @cherrypy.config(
+            **{
+                'tools.gzip.mime_types': ['text/*', 'image/*'],
+                'tools.caching.on': True,
+                'tools.staticdir.on': True,
+                'tools.staticdir.dir': 'static',
+                'tools.staticdir.root': curdir,
+            },
+        )
         class GzipStaticCache(object):
             pass
 
@@ -176,7 +180,9 @@ def testCaching(self):
         self.assertHeader('Content-Encoding', 'gzip')
         self.assertHeader('Vary')
         self.assertEqual(
-            cherrypy.lib.encoding.decompress(self.body), b'visit #5')
+            cherrypy.lib.encoding.decompress(self.body),
+            b'visit #5',
+        )
 
         # Now check that a second request gets the gzip header and gzipped body
         # This also tests a bug in 3.0 to 3.0.2 whereby the cached, gzipped
@@ -184,7 +190,9 @@ def testCaching(self):
         self.getPage('/', method='GET', headers=[('Accept-Encoding', 'gzip')])
         self.assertHeader('Content-Encoding', 'gzip')
         self.assertEqual(
-            cherrypy.lib.encoding.decompress(self.body), b'visit #5')
+            cherrypy.lib.encoding.decompress(self.body),
+            b'visit #5',
+        )
 
         # Now check that a third request that doesn't accept gzip
         # skips the cache (because the 'Vary' header denies it).
@@ -201,13 +209,17 @@ def testVaryHeader(self):
         # Now check that different 'Vary'-fields don't evict each other.
         # This test creates 2 requests with different 'Our-Varying-Header'
         # and then tests if the first one still exists.
-        self.getPage('/varying_headers/',
-                     headers=[('Our-Varying-Header', 'request 2')])
+        self.getPage(
+            '/varying_headers/',
+            headers=[('Our-Varying-Header', 'request 2')],
+        )
         self.assertStatus('200 OK')
         self.assertBody('visit #2')
 
-        self.getPage('/varying_headers/',
-                     headers=[('Our-Varying-Header', 'request 2')])
+        self.getPage(
+            '/varying_headers/',
+            headers=[('Our-Varying-Header', 'request 2')],
+        )
         self.assertStatus('200 OK')
         self.assertBody('visit #2')
 
@@ -357,6 +369,7 @@ def run():
             self.getPage(slow_url)
             # The response should be the same every time
             self.assertBody('success!')
+
         ts = [threading.Thread(target=run) for i in range(100)]
         for t in ts:
             t.start()
diff --git a/cherrypy/test/test_config.py b/cherrypy/test/test_config.py
index 5e880d873..eb28946b3 100644
--- a/cherrypy/test/test_config.py
+++ b/cherrypy/test/test_config.py
@@ -18,10 +18,8 @@ def StringIOFromNative(x):
 
 
 def setup_server():
-
     @cherrypy.config(foo='this', bar='that')
     class Root:
-
         def __init__(self):
             cherrypy.config.namespaces['db'] = self.db_namespace
 
@@ -47,14 +45,15 @@ def plain(self, x):
             return x
 
         favicon_ico = cherrypy.tools.staticfile.handler(
-            filename=os.path.join(localDir, '../favicon.ico'))
+            filename=os.path.join(localDir, '../favicon.ico'),
+        )
 
     @cherrypy.config(foo='this2', baz='that2')
     class Foo:
-
         @cherrypy.expose
         def index(self, key):
             return cherrypy.request.config.get(key, 'None')
+
         nex = index
 
         @cherrypy.expose
@@ -69,7 +68,6 @@ def bar(self, key):
             return repr(cherrypy.request.config.get(key, None))
 
     class Another:
-
         @cherrypy.expose
         def index(self, key):
             return str(cherrypy.request.config.get(key, 'None'))
@@ -86,6 +84,7 @@ def wrapper():
                     except KeyError:
                         pass
                 return handler()
+
             cherrypy.request.handler = wrapper
         elif key == 'output':
             handler = cherrypy.request.handler
@@ -93,17 +92,18 @@ def wrapper():
             def wrapper():
                 # 'value' is a type (like int or str).
                 return value(handler())
+
             cherrypy.request.handler = wrapper
 
     @cherrypy.config(**{'raw.output': repr})
     class Raw:
-
         @cherrypy.expose
         @cherrypy.config(**{'raw.input.map': {'num': int}})
         def incr(self, num):
             return num + 1
 
-    ioconf = StringIOFromNative("""
+    ioconf = StringIOFromNative(
+        """
 [/]
 neg: -1234
 filename: os.path.join(sys.prefix, "hello.py")
@@ -117,7 +117,9 @@ def incr(self, num):
 
 [/favicon.ico]
 tools.staticfile.filename = %r
-""" % os.path.join(localDir, 'static/dirback.jpg'))
+"""
+        % os.path.join(localDir, 'static/dirback.jpg'),
+    )
 
     root = Root()
     root.foo = Foo()
@@ -126,9 +128,12 @@ def incr(self, num):
     app.request_class.namespaces['raw'] = raw_namespace
 
     cherrypy.tree.mount(Another(), '/another')
-    cherrypy.config.update({'luxuryyacht': 'throatwobblermangrove',
-                            'db.scheme': r'sqlite///memory',
-                            })
+    cherrypy.config.update(
+        {
+            'luxuryyacht': 'throatwobblermangrove',
+            'db.scheme': r'sqlite///memory',
+        },
+    )
 
 
 #                             Client-side code                             #
@@ -193,6 +198,7 @@ def testUnrepr(self):
             # server and client are running in different processes.
             self.getPage('/repr?key=thing2')
             from cherrypy.tutorial import thing2
+
             self.assertBody(repr(thing2))
 
         self.getPage('/repr?key=complex')
@@ -221,14 +227,19 @@ def testHandlerToolConfigOverride(self):
         # the favicon in the page handler to be '../favicon.ico',
         # but then overrode it in config to be './static/dirback.jpg'.
         self.getPage('/favicon.ico')
-        self.assertBody(open(os.path.join(localDir, 'static/dirback.jpg'),
-                             'rb').read())
+        with open(os.path.join(localDir, 'static/dirback.jpg'), 'rb') as tf:
+            self.assertBody(tf.read())
 
     def test_request_body_namespace(self):
-        self.getPage('/plain', method='POST', headers=[
-            ('Content-Type', 'application/x-www-form-urlencoded'),
-            ('Content-Length', '13')],
-            body=b'\xff\xfex\x00=\xff\xfea\x00b\x00c\x00')
+        self.getPage(
+            '/plain',
+            method='POST',
+            headers=[
+                ('Content-Type', 'application/x-www-form-urlencoded'),
+                ('Content-Length', '13'),
+            ],
+            body=b'\xff\xfex\x00=\xff\xfea\x00b\x00c\x00',
+        )
         self.assertBody('abc')
 
 
@@ -254,8 +265,10 @@ def test_config(self):
 
         cherrypy.config.update(fp)
         self.assertEqual(cherrypy.config['my']['my.dir'], '/some/dir/my/dir')
-        self.assertEqual(cherrypy.config['my']
-                         ['my.dir2'], '/some/dir/my/dir/dir2')
+        self.assertEqual(
+            cherrypy.config['my']['my.dir2'],
+            '/some/dir/my/dir/dir2',
+        )
 
 
 class CallablesInConfigTest(unittest.TestCase):
@@ -263,6 +276,7 @@ class CallablesInConfigTest(unittest.TestCase):
 
     def test_call_with_literal_dict(self):
         from textwrap import dedent
+
         conf = dedent("""
         [my]
         value = dict(**{'foo': 'bar'})
@@ -273,15 +287,12 @@ def test_call_with_literal_dict(self):
 
     def test_call_with_kwargs(self):
         from textwrap import dedent
+
         conf = dedent("""
         [my]
         value = dict(foo="buzz", **cherrypy._test_dict)
         """)
-        test_dict = {
-            'foo': 'bar',
-            'bar': 'foo',
-            'fizz': 'buzz'
-        }
+        test_dict = {'foo': 'bar', 'bar': 'foo', 'fizz': 'buzz'}
         cherrypy._test_dict = test_dict
         fp = StringIOFromNative(conf)
         cherrypy.config.update(fp)
diff --git a/cherrypy/test/test_config_server.py b/cherrypy/test/test_config_server.py
index 7b1835304..00c228b68 100644
--- a/cherrypy/test/test_config_server.py
+++ b/cherrypy/test/test_config_server.py
@@ -13,12 +13,9 @@
 
 
 class ServerConfigTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return cherrypy.request.wsgi_environ['SERVER_PORT']
@@ -34,21 +31,21 @@ def tinyupload(self):
 
         cherrypy.tree.mount(Root())
 
-        cherrypy.config.update({
-            'server.socket_host': '0.0.0.0',
-            'server.socket_port': 9876,
-            'server.max_request_body_size': 200,
-            'server.max_request_header_size': 500,
-            'server.socket_timeout': 0.5,
-
-            # Test explicit server.instance
-            'server.2.instance': 'cherrypy._cpwsgi_server.CPWSGIServer',
-            'server.2.socket_port': 9877,
-
-            # Test non-numeric <servername>
-            # Also test default server.instance = builtin server
-            'server.yetanother.socket_port': 9878,
-        })
+        cherrypy.config.update(
+            {
+                'server.socket_host': '0.0.0.0',
+                'server.socket_port': 9876,
+                'server.max_request_body_size': 200,
+                'server.max_request_header_size': 500,
+                'server.socket_timeout': 0.5,
+                # Test explicit server.instance
+                'server.2.instance': 'cherrypy._cpwsgi_server.CPWSGIServer',
+                'server.2.socket_port': 9877,
+                # Test non-numeric <servername>
+                # Also test default server.instance = builtin server
+                'server.yetanother.socket_port': 9878,
+            },
+        )
 
     PORT = 9876
 
@@ -70,17 +67,27 @@ def testMaxRequestSizePerHandler(self):
         if getattr(cherrypy.server, 'using_apache', False):
             return self.skip('skipped due to known Apache differences... ')
 
-        self.getPage('/tinyupload', method='POST',
-                     headers=[('Content-Type', 'text/plain'),
-                              ('Content-Length', '100')],
-                     body='x' * 100)
+        self.getPage(
+            '/tinyupload',
+            method='POST',
+            headers=[
+                ('Content-Type', 'text/plain'),
+                ('Content-Length', '100'),
+            ],
+            body='x' * 100,
+        )
         self.assertStatus(200)
         self.assertBody('x' * 100)
 
-        self.getPage('/tinyupload', method='POST',
-                     headers=[('Content-Type', 'text/plain'),
-                              ('Content-Length', '101')],
-                     body='x' * 101)
+        self.getPage(
+            '/tinyupload',
+            method='POST',
+            headers=[
+                ('Content-Type', 'text/plain'),
+                ('Content-Length', '101'),
+            ],
+            body='x' * 101,
+        )
         self.assertStatus(413)
 
     def testMaxRequestSize(self):
@@ -95,32 +102,34 @@ def testMaxRequestSize(self):
         # (Incorrect border condition in readline of SizeCheckWrapper).
         # This hangs in rev 891 and earlier.
         lines256 = 'x' * 248
-        self.getPage('/',
-                     headers=[('Host', '%s:%s' % (self.HOST, self.PORT)),
-                              ('From', lines256)])
+        self.getPage(
+            '/',
+            headers=[
+                ('Host', '%s:%s' % (self.HOST, self.PORT)),
+                ('From', lines256),
+            ],
+        )
 
         # Test upload
         cd = (
-            'Content-Disposition: form-data; '
-            'name="file"; '
-            'filename="hello.txt"'
+            'Content-Disposition: form-data; name="file"; filename="hello.txt"'
+        )
+        body = '\r\n'.join(
+            ['--x', cd, 'Content-Type: text/plain', '', '%s', '--x--'],
         )
-        body = '\r\n'.join([
-            '--x',
-            cd,
-            'Content-Type: text/plain',
-            '',
-            '%s',
-            '--x--'])
         partlen = 200 - len(body)
         b = body % ('x' * partlen)
-        h = [('Content-type', 'multipart/form-data; boundary=x'),
-             ('Content-Length', '%s' % len(b))]
+        h = [
+            ('Content-type', 'multipart/form-data; boundary=x'),
+            ('Content-Length', '%s' % len(b)),
+        ]
         self.getPage('/upload', h, 'POST', b)
         self.assertBody('Size: %d' % partlen)
 
         b = body % ('x' * 200)
-        h = [('Content-type', 'multipart/form-data; boundary=x'),
-             ('Content-Length', '%s' % len(b))]
+        h = [
+            ('Content-type', 'multipart/form-data; boundary=x'),
+            ('Content-Length', '%s' % len(b)),
+        ]
         self.getPage('/upload', h, 'POST', b)
         self.assertStatus(413)
diff --git a/cherrypy/test/test_conn.py b/cherrypy/test/test_conn.py
index e4426c422..5f602e281 100644
--- a/cherrypy/test/test_conn.py
+++ b/cherrypy/test/test_conn.py
@@ -13,21 +13,22 @@
 from cherrypy._cpcompat import HTTPSConnection, ntob, tonative
 from cherrypy.test import helper
 
+import pytest
+
 
 timeout = 1
 pov = 'pPeErRsSiIsStTeEnNcCeE oOfF vViIsSiIoOnN'
 
 
 def setup_server():
-
     def raise500():
         raise cherrypy.HTTPError(500)
 
     class Root:
-
         @cherrypy.expose
         def index(self):
             return pov
+
         page1 = index
         page2 = index
         page3 = index
@@ -59,9 +60,11 @@ def error(self, code=500):
         @cherrypy.expose
         def upload(self):
             if not cherrypy.request.method == 'POST':
-                raise AssertionError("'POST' != request.method %r" %
-                                     cherrypy.request.method)
-            return "thanks for '%s'" % cherrypy.request.body.read()
+                raise AssertionError(
+                    "'POST' != request.method %r" % cherrypy.request.method,
+                )
+            request_body_txt = tonative(cherrypy.request.body.read())
+            return f"thanks for '{request_body_txt!s}'"
 
         @cherrypy.expose
         def custom(self, response_code):
@@ -93,10 +96,12 @@ def custom_cl(self, body, cl):
             return newbody
 
     cherrypy.tree.mount(Root())
-    cherrypy.config.update({
-        'server.max_request_body_size': 1001,
-        'server.socket_timeout': timeout,
-    })
+    cherrypy.config.update(
+        {
+            'server.max_request_body_size': 1001,
+            'server.socket_timeout': timeout,
+        },
+    )
 
 
 class ConnectionCloseTests(helper.CPWebCase):
@@ -217,8 +222,10 @@ def _streaming(self, set_cl):
             if set_cl:
                 # When a Content-Length is provided, the content should
                 # stream without closing the connection.
-                self.getPage('/stream?set_cl=Yes',
-                             headers=[('Connection', 'Keep-Alive')])
+                self.getPage(
+                    '/stream?set_cl=Yes',
+                    headers=[('Connection', 'Keep-Alive')],
+                )
                 self.assertHeader('Content-Length')
                 self.assertHeader('Connection', 'Keep-Alive')
                 self.assertNoHeader('Transfer-Encoding')
@@ -350,13 +357,14 @@ def test_HTTP11_Timeout_after_request(self):
         conn._output(ntob('Host: %s' % self.HOST, 'ascii'))
         conn._send_output()
         response = conn.response_class(conn.sock, method='GET')
-        msg = (
-            "Writing to timed out socket didn't fail as it should have: %s")
+        msg = "Writing to timed out socket didn't fail as it should have: %s"
         try:
             response.begin()
         except Exception:
-            if not isinstance(sys.exc_info()[1],
-                              (socket.error, BadStatusLine)):
+            if not isinstance(
+                sys.exc_info()[1],
+                (socket.error, BadStatusLine),
+            ):
                 self.fail(msg % sys.exc_info()[1])
         else:
             if response.status != 408:
@@ -385,8 +393,10 @@ def test_HTTP11_Timeout_after_request(self):
         try:
             response.begin()
         except Exception:
-            if not isinstance(sys.exc_info()[1],
-                              (socket.error, BadStatusLine)):
+            if not isinstance(
+                sys.exc_info()[1],
+                (socket.error, BadStatusLine),
+            ):
                 self.fail(msg % sys.exc_info()[1])
         else:
             if response.status != 408:
@@ -492,8 +502,9 @@ def test_100_Continue(self):
                 line = response.fp.readline().strip()
                 if line:
                     self.fail(
-                        '100 Continue should not output any headers. Got %r' %
-                        line)
+                        '100 Continue should not output any headers. Got %r'
+                        % line,
+                    )
                 else:
                     break
 
@@ -505,7 +516,7 @@ def test_100_Continue(self):
             response.begin()
             self.status, self.headers, self.body = webtest.shb(response)
             self.assertStatus(200)
-            self.assertBody("thanks for '%s'" % body)
+            self.assertBody("thanks for '%s'" % tonative(body))
         finally:
             conn.close()
 
@@ -582,7 +593,7 @@ def test_readall_or_close(self):
             response.begin()
             self.status, self.headers, self.body = webtest.shb(response)
             self.assertStatus(200)
-            self.assertBody("thanks for '%s'" % body)
+            self.assertBody("thanks for '%s'" % tonative(body))
             conn.close()
 
     def test_No_Message_Body(self):
@@ -618,8 +629,10 @@ def test_Chunked_Encoding(self):
         if cherrypy.server.protocol_version != 'HTTP/1.1':
             return self.skip()
 
-        if (hasattr(self, 'harness') and
-                'modpython' in self.harness.__class__.__name__.lower()):
+        if (
+            hasattr(self, 'harness')
+            and 'modpython' in self.harness.__class__.__name__.lower()
+        ):
             # mod_python forbids chunked encoding
             return self.skip()
 
@@ -630,9 +643,11 @@ def test_Chunked_Encoding(self):
         conn = self.HTTP_CONN
 
         # Try a normal chunked request (with extensions)
-        body = ntob('8;key=value\r\nxx\r\nxxxx\r\n5\r\nyyyyy\r\n0\r\n'
-                    'Content-Type: application/json\r\n'
-                    '\r\n')
+        body = ntob(
+            '8;key=value\r\nxx\r\nxxxx\r\n5\r\nyyyyy\r\n0\r\n'
+            'Content-Type: application/json\r\n'
+            '\r\n',
+        )
         conn.putrequest('POST', '/upload', skip_host=True)
         conn.putheader('Host', self.HOST)
         conn.putheader('Transfer-Encoding', 'chunked')
@@ -646,7 +661,7 @@ def test_Chunked_Encoding(self):
         response = conn.getresponse()
         self.status, self.headers, self.body = webtest.shb(response)
         self.assertStatus('200 OK')
-        self.assertBody("thanks for '%s'" % b'xx\r\nxxxxyyyyy')
+        self.assertBody("thanks for '%s'" % 'xx\r\nxxxxyyyyy')
 
         # Try a chunked request that exceeds server.max_request_body_size.
         # Note that the delimiters and trailer are included.
@@ -677,8 +692,10 @@ def test_Content_Length_in(self):
         response = conn.getresponse()
         self.status, self.headers, self.body = webtest.shb(response)
         self.assertStatus(413)
-        self.assertBody('The entity sent with the request exceeds '
-                        'the maximum allowed bytes.')
+        self.assertBody(
+            'The entity sent with the request exceeds '
+            'the maximum allowed bytes.',
+        )
         conn.close()
 
     def test_Content_Length_out_preheaders(self):
@@ -686,8 +703,11 @@ def test_Content_Length_out_preheaders(self):
         # the actual bytes in the response body.
         self.persistent = True
         conn = self.HTTP_CONN
-        conn.putrequest('GET', '/custom_cl?body=I+have+too+many+bytes&cl=5',
-                        skip_host=True)
+        conn.putrequest(
+            'GET',
+            '/custom_cl?body=I+have+too+many+bytes&cl=5',
+            skip_host=True,
+        )
         conn.putheader('Host', self.HOST)
         conn.endheaders()
         response = conn.getresponse()
@@ -695,7 +715,8 @@ def test_Content_Length_out_preheaders(self):
         self.assertStatus(500)
         self.assertBody(
             'The requested resource returned more bytes than the '
-            'declared Content-Length.')
+            'declared Content-Length.',
+        )
         conn.close()
 
     def test_Content_Length_out_postheaders(self):
@@ -704,8 +725,10 @@ def test_Content_Length_out_postheaders(self):
         self.persistent = True
         conn = self.HTTP_CONN
         conn.putrequest(
-            'GET', '/custom_cl?body=I+too&body=+have+too+many&cl=5',
-            skip_host=True)
+            'GET',
+            '/custom_cl?body=I+too&body=+have+too+many&cl=5',
+            skip_host=True,
+        )
         conn.putheader('Host', self.HOST)
         conn.endheaders()
         response = conn.getresponse()
@@ -740,29 +763,29 @@ def test_598(self):
 
 
 def setup_upload_server():
-
     class Root:
         @cherrypy.expose
         def upload(self):
             if not cherrypy.request.method == 'POST':
-                raise AssertionError("'POST' != request.method %r" %
-                                     cherrypy.request.method)
+                raise AssertionError(
+                    "'POST' != request.method %r" % cherrypy.request.method,
+                )
             return "thanks for '%s'" % tonative(cherrypy.request.body.read())
 
     cherrypy.tree.mount(Root())
-    cherrypy.config.update({
-        'server.max_request_body_size': 1001,
-        'server.socket_timeout': 10,
-        'server.accepted_queue_size': 5,
-        'server.accepted_queue_timeout': 0.1,
-    })
+    cherrypy.config.update(
+        {
+            'server.max_request_body_size': 1001,
+            'server.socket_timeout': 10,
+            'server.accepted_queue_size': 5,
+            'server.accepted_queue_timeout': 0.1,
+        },
+    )
 
 
 reset_names = 'ECONNRESET', 'WSAECONNRESET'
 socket_reset_errors = [
-    getattr(errno, name)
-    for name in reset_names
-    if hasattr(errno, name)
+    getattr(errno, name) for name in reset_names if hasattr(errno, name)
 ]
 'reset error numbers available on this platform'
 
@@ -776,6 +799,10 @@ def upload(self):
 class LimitedRequestQueueTests(helper.CPWebCase):
     setup_server = staticmethod(setup_upload_server)
 
+    @pytest.mark.xfail(
+        reason='Cheroot 11 returns HTTP 503 Service Unavailable on overflows: '
+        'https://github.com/cherrypy/cherrypy/issues/2073',
+    )
     def test_queue_full(self):
         conns = []
         overflow_conn = None
@@ -796,8 +823,12 @@ def test_queue_full(self):
             # server immediately.
             overflow_conn = self.HTTP_CONN(self.HOST, self.PORT)
             # Manually connect since httplib won't let us set a timeout
-            for res in socket.getaddrinfo(self.HOST, self.PORT, 0,
-                                          socket.SOCK_STREAM):
+            for res in socket.getaddrinfo(
+                self.HOST,
+                self.PORT,
+                0,
+                socket.SOCK_STREAM,
+            ):
                 af, socktype, proto, canonname, sa = res
                 overflow_conn.sock = socket.socket(af, socktype, proto)
                 overflow_conn.sock.settimeout(5)
diff --git a/cherrypy/test/test_core.py b/cherrypy/test/test_core.py
index 6fde3a973..b7418b95f 100644
--- a/cherrypy/test/test_core.py
+++ b/cherrypy/test/test_core.py
@@ -1,5 +1,4 @@
 # coding: utf-8
-
 """Basic tests for the CherryPy core: request handling."""
 
 import os
@@ -22,11 +21,9 @@
 
 
 class CoreRequestHandlingTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'hello'
@@ -36,9 +33,14 @@ def index(self):
             @cherrypy.expose
             def defct(self, newct):
                 newct = 'text/%s' % newct
-                cherrypy.config.update({'tools.response_headers.on': True,
-                                        'tools.response_headers.headers':
-                                        [('Content-Type', newct)]})
+                cherrypy.config.update(
+                    {
+                        'tools.response_headers.on': True,
+                        'tools.response_headers.headers': [
+                            ('Content-Type', newct),
+                        ],
+                    },
+                )
 
             @cherrypy.expose
             def baseurl(self, path_info, relative=None):
@@ -48,22 +50,22 @@ def baseurl(self, path_info, relative=None):
         root.expose_dec = ExposeExamples()
 
         class TestType(type):
-
             """Metaclass which automatically exposes all functions in each
             subclass, and adds an instance of the subclass as an attribute
             of root.
             """
+
             def __init__(cls, name, bases, dct):
                 type.__init__(cls, name, bases, dct)
                 for value in dct.values():
                     if isinstance(value, types.FunctionType):
                         value.exposed = True
                 setattr(root, name.lower(), cls())
-        Test = TestType('Test', (object, ), {})
+
+        Test = TestType('Test', (object,), {})
 
         @cherrypy.config(**{'tools.trailing_slash.on': False})
         class URL(Test):
-
             def index(self, path_info, relative=None):
                 if relative != 'server':
                     relative = bool(relative)
@@ -79,11 +81,13 @@ def qs(self, qs):
 
         def log_status():
             Status.statuses.append(cherrypy.response.status)
+
         cherrypy.tools.log_status = cherrypy.Tool(
-            'on_end_resource', log_status)
+            'on_end_resource',
+            log_status,
+        )
 
         class Status(Test):
-
             def index(self):
                 return 'normal'
 
@@ -115,12 +119,13 @@ def on_end_resource_stage(self):
                 return repr(self.statuses)
 
         class Redirect(Test):
-
-            @cherrypy.config(**{
-                'tools.err_redirect.on': True,
-                'tools.err_redirect.url': '/errpage',
-                'tools.err_redirect.internal': False,
-            })
+            @cherrypy.config(
+                **{
+                    'tools.err_redirect.on': True,
+                    'tools.err_redirect.url': '/errpage',
+                    'tools.err_redirect.internal': False,
+                },
+            )
             class Error:
                 @cherrypy.expose
                 def index(self):
@@ -151,11 +156,12 @@ def fragment(self, frag):
                 raise cherrypy.HTTPRedirect('/some/url#%s' % frag)
 
             def url_with_quote(self):
-                raise cherrypy.HTTPRedirect("/some\"url/that'we/want")
+                raise cherrypy.HTTPRedirect('/some"url/that\'we/want')
 
             def url_with_xss(self):
                 raise cherrypy.HTTPRedirect(
-                    "/some<script>alert(1);</script>url/that'we/want")
+                    "/some<script>alert(1);</script>url/that'we/want",
+                )
 
             def url_with_unicode(self):
                 raise cherrypy.HTTPRedirect(ntou('тест', 'utf-8'))
@@ -163,13 +169,13 @@ def url_with_unicode(self):
         def login_redir():
             if not getattr(cherrypy.request, 'login', None):
                 raise cherrypy.InternalRedirect('/internalredirect/login')
+
         tools.login_redir = _cptools.Tool('before_handler', login_redir)
 
         def redir_custom():
             raise cherrypy.InternalRedirect('/internalredirect/custom_err')
 
         class InternalRedirect(Test):
-
             def index(self):
                 raise cherrypy.InternalRedirect('/')
 
@@ -189,21 +195,25 @@ def petshop(self, user_id):
                 if user_id == 'parrot':
                     # Trade it for a slug when redirecting
                     raise cherrypy.InternalRedirect(
-                        '/image/getImagesByUser?user_id=slug')
+                        '/image/getImagesByUser?user_id=slug',
+                    )
                 elif user_id == 'terrier':
                     # Trade it for a fish when redirecting
                     raise cherrypy.InternalRedirect(
-                        '/image/getImagesByUser?user_id=fish')
+                        '/image/getImagesByUser?user_id=fish',
+                    )
                 else:
                     # This should pass the user_id through to getImagesByUser
                     raise cherrypy.InternalRedirect(
-                        '/image/getImagesByUser?user_id=%s' % str(user_id))
+                        '/image/getImagesByUser?user_id=%s' % str(user_id),
+                    )
 
             # We support Python 2.3, but the @-deco syntax would look like
             # this:
             # @tools.login_redir()
             def secure(self):
                 return 'Welcome!'
+
             secure = tools.login_redir()(secure)
             # Since calling the tool returns the same function you pass in,
             # you could skip binding the return value, and just write:
@@ -220,12 +230,10 @@ def early_ir(self, arg):
                 return 'whatever'
 
         class Image(Test):
-
             def getImagesByUser(self, user_id):
                 return '0 images for %s' % user_id
 
         class Flatten(Test):
-
             def as_string(self):
                 return 'content'
 
@@ -244,17 +252,16 @@ def as_refyield(self):
                     yield chunk
 
         class Ranges(Test):
-
             def get_ranges(self, bytes):
                 return repr(httputil.get_ranges('bytes=%s' % bytes, 8))
 
             def slice_file(self):
                 path = os.path.join(os.getcwd(), os.path.dirname(__file__))
                 return static.serve_file(
-                    os.path.join(path, 'static/index.html'))
+                    os.path.join(path, 'static/index.html'),
+                )
 
         class Cookies(Test):
-
             def single(self, name):
                 cookie = cherrypy.request.cookie[name]
                 # Python2's SimpleCookie.__setitem__ won't take unicode keys.
@@ -267,23 +274,30 @@ def append_headers(header_list, debug=False):
             if debug:
                 cherrypy.log(
                     'Extending response headers with %s' % repr(header_list),
-                    'TOOLS.APPEND_HEADERS')
+                    'TOOLS.APPEND_HEADERS',
+                )
             cherrypy.serving.response.header_list.extend(header_list)
+
         cherrypy.tools.append_headers = cherrypy.Tool(
-            'on_end_resource', append_headers)
+            'on_end_resource',
+            append_headers,
+        )
 
         class MultiHeader(Test):
-
             def header_list(self):
                 pass
-            header_list = cherrypy.tools.append_headers(header_list=[
-                (b'WWW-Authenticate', b'Negotiate'),
-                (b'WWW-Authenticate', b'Basic realm="foo"'),
-            ])(header_list)
+
+            header_list = cherrypy.tools.append_headers(
+                header_list=[
+                    (b'WWW-Authenticate', b'Negotiate'),
+                    (b'WWW-Authenticate', b'Basic realm="foo"'),
+                ],
+            )(header_list)
 
             def commas(self):
-                cherrypy.response.headers[
-                    'WWW-Authenticate'] = 'Negotiate,Basic realm="foo"'
+                cherrypy.response.headers['WWW-Authenticate'] = (
+                    'Negotiate,Basic realm="foo"'
+                )
 
         cherrypy.tree.mount(root)
 
@@ -325,7 +339,7 @@ def testSlashes(self):
         self.assertStatus(301)
         self.assertMatchesBody(
             '<a href=([\'"])%s/redirect/[?]id=3\\1>'
-            '%s/redirect/[?]id=3</a>' % (self.base(), self.base())
+            '%s/redirect/[?]id=3</a>' % (self.base(), self.base()),
         )
 
         if self.prefix():
@@ -333,8 +347,9 @@ def testSlashes(self):
             # we're using a virtual root and the URI is "/vroot" (no slash).
             self.getPage('')
             self.assertStatus(301)
-            self.assertMatchesBody("<a href=(['\"])%s/\\1>%s/</a>" %
-                                   (self.base(), self.base()))
+            self.assertMatchesBody(
+                '<a href=([\'"])%s/\\1>%s/</a>' % (self.base(), self.base()),
+            )
 
         # Test that requests for NON-index methods WITH a trailing slash
         # get redirected to the same URI path WITHOUT a trailing slash.
@@ -342,9 +357,8 @@ def testSlashes(self):
         self.getPage('/redirect/by_code/?code=307')
         self.assertStatus(301)
         self.assertMatchesBody(
-            "<a href=(['\"])%s/redirect/by_code[?]code=307\\1>"
-            '%s/redirect/by_code[?]code=307</a>'
-            % (self.base(), self.base())
+            '<a href=([\'"])%s/redirect/by_code[?]code=307\\1>'
+            '%s/redirect/by_code[?]code=307</a>' % (self.base(), self.base()),
         )
 
         # If the trailing_slash tool is off, CP should just continue
@@ -362,32 +376,38 @@ def testRedirect(self):
 
         self.getPage('/redirect/by_code?code=300')
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
+            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>",
+        )
         self.assertStatus(300)
 
         self.getPage('/redirect/by_code?code=301')
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
+            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>",
+        )
         self.assertStatus(301)
 
         self.getPage('/redirect/by_code?code=302')
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
+            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>",
+        )
         self.assertStatus(302)
 
         self.getPage('/redirect/by_code?code=303')
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
+            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>",
+        )
         self.assertStatus(303)
 
         self.getPage('/redirect/by_code?code=307')
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
+            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>",
+        )
         self.assertStatus(307)
 
         self.getPage('/redirect/by_code?code=308')
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>")
+            r"<a href=(['\"])(.*)somewhere%20else\1>\2somewhere%20else</a>",
+        )
         self.assertStatus(308)
 
         self.getPage('/redirect/nomodify')
@@ -417,8 +437,9 @@ def testRedirect(self):
         frag = 'foo'
         self.getPage('/redirect/fragment/%s' % frag)
         self.assertMatchesBody(
-            r"<a href=(['\"])(.*)\/some\/url\#%s\1>\2\/some\/url\#%s</a>" % (
-                frag, frag))
+            r"<a href=(['\"])(.*)\/some\/url\#%s\1>\2\/some\/url\#%s</a>"
+            % (frag, frag),
+        )
         loc = self.assertHeader('Location')
         assert loc.endswith('#%s' % frag)
         self.assertStatus(('302 Found', '303 See Other'))
@@ -427,7 +448,8 @@ def testRedirect(self):
         # See https://github.com/cherrypy/cherrypy/issues/1003
         self.getPage(
             '/redirect/custom?'
-            'code=303&url=/foobar/%0d%0aSet-Cookie:%20somecookie=someval')
+            'code=303&url=/foobar/%0d%0aSet-Cookie:%20somecookie=someval',
+        )
         self.assertStatus(303)
         loc = self.assertHeader('Location')
         assert 'Set-Cookie' in loc
@@ -435,9 +457,10 @@ def testRedirect(self):
 
         def assertValidXHTML():
             from xml.etree import ElementTree
+
             try:
                 ElementTree.fromstring(
-                    '<html><body>%s</body></html>' % self.body,
+                    '<html><body>%s</body></html>' % self.body.decode('utf-8'),
                 )
             except ElementTree.ParseError:
                 self._handlewebError(
@@ -484,7 +507,8 @@ def test_InternalRedirect(self):
 
         # Test passthrough
         self.getPage(
-            '/internalredirect/petshop?user_id=Sir-not-appearing-in-this-film')
+            '/internalredirect/petshop?user_id=Sir-not-appearing-in-this-film',
+        )
         self.assertBody('0 images for Sir-not-appearing-in-this-film')
         self.assertStatus(200)
 
@@ -494,14 +518,20 @@ def test_InternalRedirect(self):
         self.assertStatus(200)
 
         # Test POST
-        self.getPage('/internalredirect/petshop', method='POST',
-                     body='user_id=terrier')
+        self.getPage(
+            '/internalredirect/petshop',
+            method='POST',
+            body='user_id=terrier',
+        )
         self.assertBody('0 images for fish')
         self.assertStatus(200)
 
         # Test ir before body read
-        self.getPage('/internalredirect/early_ir', method='POST',
-                     body='arg=aha!')
+        self.getPage(
+            '/internalredirect/early_ir',
+            method='POST',
+            body='arg=aha!',
+        )
         self.assertBody('Something went horribly wrong.')
         self.assertStatus(200)
 
@@ -521,9 +551,13 @@ def test_InternalRedirect(self):
         self.assertBody('Something went horribly wrong.')
 
     def testFlatten(self):
-        for url in ['/flatten/as_string', '/flatten/as_list',
-                    '/flatten/as_yield', '/flatten/as_dblyield',
-                    '/flatten/as_refyield']:
+        for url in [
+            '/flatten/as_string',
+            '/flatten/as_list',
+            '/flatten/as_yield',
+            '/flatten/as_dblyield',
+            '/flatten/as_refyield',
+        ]:
             self.getPage(url)
             self.assertBody('content')
 
@@ -555,18 +589,20 @@ def testRanges(self):
             ct = self.assertHeader('Content-Type')
             expected_type = 'multipart/byteranges; boundary='
             assert ct.startswith(expected_type)
-            boundary = ct[len(expected_type):]
-            expected_body = ('\r\n--%s\r\n'
-                             'Content-type: text/html\r\n'
-                             'Content-range: bytes 4-6/14\r\n'
-                             '\r\n'
-                             'o, \r\n'
-                             '--%s\r\n'
-                             'Content-type: text/html\r\n'
-                             'Content-range: bytes 2-5/14\r\n'
-                             '\r\n'
-                             'llo,\r\n'
-                             '--%s--\r\n' % (boundary, boundary, boundary))
+            boundary = ct[len(expected_type) :]
+            expected_body = (
+                '\r\n--%s\r\n'
+                'Content-type: text/html\r\n'
+                'Content-range: bytes 4-6/14\r\n'
+                '\r\n'
+                'o, \r\n'
+                '--%s\r\n'
+                'Content-type: text/html\r\n'
+                'Content-range: bytes 2-5/14\r\n'
+                '\r\n'
+                'llo,\r\n'
+                '--%s--\r\n' % (boundary, boundary, boundary)
+            )
             self.assertBody(expected_body)
             self.assertHeader('Content-Length')
 
@@ -586,9 +622,8 @@ def testRanges(self):
     def testFavicon(self):
         # favicon.ico is served by staticfile.
         icofilename = os.path.join(localDir, '../favicon.ico')
-        icofile = open(icofilename, 'rb')
-        data = icofile.read()
-        icofile.close()
+        with open(icofilename, 'rb') as icofile:
+            data = icofile.read()
 
         self.getPage('/favicon.ico')
         self.assertBody(data)
@@ -609,18 +644,25 @@ def skip_if_bad_cookies(self):
     def testCookies(self):
         self.skip_if_bad_cookies()
 
-        self.getPage('/cookies/single?name=First',
-                     [('Cookie', 'First=Dinsdale;')])
+        self.getPage(
+            '/cookies/single?name=First',
+            [('Cookie', 'First=Dinsdale;')],
+        )
         self.assertHeader('Set-Cookie', 'First=Dinsdale')
 
-        self.getPage('/cookies/multiple?names=First&names=Last',
-                     [('Cookie', 'First=Dinsdale; Last=Piranha;'),
-                      ])
+        self.getPage(
+            '/cookies/multiple?names=First&names=Last',
+            [
+                ('Cookie', 'First=Dinsdale; Last=Piranha;'),
+            ],
+        )
         self.assertHeader('Set-Cookie', 'First=Dinsdale')
         self.assertHeader('Set-Cookie', 'Last=Piranha')
 
-        self.getPage('/cookies/single?name=Something-With%2CComma',
-                     [('Cookie', 'Something-With,Comma=some-value')])
+        self.getPage(
+            '/cookies/single?name=Something-With%2CComma',
+            [('Cookie', 'Something-With,Comma=some-value')],
+        )
         self.assertStatus(400)
 
     def testDefaultContentType(self):
@@ -635,9 +677,11 @@ def test_multiple_headers(self):
         self.getPage('/multiheader/header_list')
         self.assertEqual(
             [(k, v) for k, v in self.headers if k == 'WWW-Authenticate'],
-            [('WWW-Authenticate', 'Negotiate'),
-             ('WWW-Authenticate', 'Basic realm="foo"'),
-             ])
+            [
+                ('WWW-Authenticate', 'Negotiate'),
+                ('WWW-Authenticate', 'Basic realm="foo"'),
+            ],
+        )
         self.getPage('/multiheader/commas')
         self.assertHeader('WWW-Authenticate', 'Negotiate,Basic realm="foo"')
 
@@ -649,8 +693,7 @@ def test_cherrypy_url(self):
         self.assertBody('%s/url/page1' % self.base())
         # Other host header
         host = 'www.mydomain.example'
-        self.getPage('/url/leaf?path_info=page1',
-                     headers=[('Host', host)])
+        self.getPage('/url/leaf?path_info=page1', headers=[('Host', host)])
         self.assertBody('%s://%s/url/page1' % (self.scheme, host))
 
         # Input is 'absolute'; that is, relative to script_name
@@ -763,17 +806,18 @@ def test_expose_decorator(self):
 
 
 class ErrorTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         def break_header():
             # Add a header after finalize that is invalid
             cherrypy.serving.response.header_list.append((2, 3))
+
         cherrypy.tools.break_header = cherrypy.Tool(
-            'on_end_resource', break_header)
+            'on_end_resource',
+            break_header,
+        )
 
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'hello'
@@ -795,15 +839,16 @@ def test_start_response_error(self):
         self.getPage('/start_response_error')
         self.assertStatus(500)
         self.assertInBody(
-            'TypeError: response.header_list key 2 is not a byte string.')
+            'TypeError: response.header_list key 2 is not a byte string.',
+        )
 
     def test_contextmanager(self):
         self.getPage('/stat/missing')
         self.assertStatus(404)
         body_text = self.body.decode('utf-8')
         assert (
-            'No such file or directory' in body_text or
-            'cannot find the file specified' in body_text
+            'No such file or directory' in body_text
+            or 'cannot find the file specified' in body_text
         )
 
 
diff --git a/cherrypy/test/test_dynamicobjectmapping.py b/cherrypy/test/test_dynamicobjectmapping.py
index aaa89ca7f..6364dfb69 100644
--- a/cherrypy/test/test_dynamicobjectmapping.py
+++ b/cherrypy/test/test_dynamicobjectmapping.py
@@ -6,7 +6,6 @@
 
 def setup_server():
     class SubSubRoot:
-
         @cherrypy.expose
         def index(self):
             return 'SubSubRoot index'
@@ -29,7 +28,6 @@ def dispatch(self):
     }
 
     class SubRoot:
-
         @cherrypy.expose
         def index(self):
             return 'SubRoot index'
@@ -51,7 +49,6 @@ def _cp_dispatch(self, vpath):
     }
 
     class Root:
-
         @cherrypy.expose
         def index(self):
             return 'index'
@@ -71,7 +68,6 @@ def _cp_dispatch(self, vpath):
     # DynamicNodeAndMethodDispatcher example.
     # This example exposes a fairly naive HTTP api
     class User(object):
-
         def __init__(self, id, name):
             self.id = id
             self.name = name
@@ -95,11 +91,8 @@ def make_user(name, id=None):
 
     @cherrypy.expose
     class UserContainerNode(object):
-
         def POST(self, name):
-            """
-            Allow the creation of a new Object
-            """
+            """Allow the creation of a new Object."""
             return 'POST %d' % make_user(name)
 
         def GET(self):
@@ -114,7 +107,6 @@ def dynamic_dispatch(self, vpath):
 
     @cherrypy.expose
     class UserInstanceNode(object):
-
         def __init__(self, id):
             self.id = id
             self.user = user_lookup.get(id, None)
@@ -125,15 +117,11 @@ def __init__(self, id):
                 raise cherrypy.HTTPError(404)
 
         def GET(self, *args, **kwargs):
-            """
-            Return the appropriate representation of the instance.
-            """
+            """Return the appropriate representation of the instance."""
             return str(self.user)
 
         def POST(self, name):
-            """
-            Update the fields of the user instance.
-            """
+            """Update the fields of the user instance."""
             self.user.name = name
             return 'POST %d' % self.user.id
 
@@ -151,18 +139,14 @@ def PUT(self, name):
                 return 'PUT %d' % make_user(name, self.id)
 
         def DELETE(self):
-            """
-            Delete the user specified at the id.
-            """
+            """Delete the user specified at the id."""
             id = self.user.id
             del user_lookup[self.user.id]
             del self.user
             return 'DELETE %d' % id
 
     class ABHandler:
-
         class CustomDispatch:
-
             @cherrypy.expose
             def index(self, a, b):
                 return 'custom'
@@ -185,7 +169,6 @@ def delete(self, a, b):
             return 'deleting ' + str(a) + ' and ' + str(b)
 
     class IndexOnly:
-
         def _cp_dispatch(self, vpath):
             """Make sure that popping ALL of vpath still shows the index
             handler.
@@ -199,7 +182,6 @@ def index(self):
             return 'IndexOnly index'
 
     class DecoratedPopArgs:
-
         """Test _cp_dispatch with @cherrypy.popargs."""
 
         @cherrypy.expose
@@ -209,11 +191,12 @@ def index(self):
         @cherrypy.expose
         def hi(self):
             return "hi was not interpreted as 'a' param"
-    DecoratedPopArgs = cherrypy.popargs(
-        'a', 'b', handler=ABHandler())(DecoratedPopArgs)
 
-    class NonDecoratedPopArgs:
+    DecoratedPopArgs = cherrypy.popargs('a', 'b', handler=ABHandler())(
+        DecoratedPopArgs,
+    )
 
+    class NonDecoratedPopArgs:
         """Test _cp_dispatch = cherrypy.popargs()"""
 
         _cp_dispatch = cherrypy.popargs('a')
@@ -223,8 +206,7 @@ def index(self, a):
             return 'index: ' + str(a)
 
     class ParameterizedHandler:
-
-        """Special handler created for each request"""
+        """Special handler created for each request."""
 
         def __init__(self, a):
             self.a = a
@@ -233,15 +215,17 @@ def __init__(self, a):
         def index(self):
             if 'a' in cherrypy.request.params:
                 raise Exception(
-                    'Parameterized handler argument ended up in '
-                    'request.params')
+                    'Parameterized handler argument ended up '
+                    'in request.params',
+                )
             return self.a
 
     class ParameterizedPopArgs:
+        """Test cherrypy.popargs() with a function call handler."""
 
-        """Test cherrypy.popargs() with a function call handler"""
-    ParameterizedPopArgs = cherrypy.popargs(
-        'a', handler=ParameterizedHandler)(ParameterizedPopArgs)
+    ParameterizedPopArgs = cherrypy.popargs('a', handler=ParameterizedHandler)(
+        ParameterizedPopArgs,
+    )
 
     Root.decorated = DecoratedPopArgs()
     Root.undecorated = NonDecoratedPopArgs()
@@ -256,9 +240,7 @@ class ParameterizedPopArgs:
             '/': {
                 'user': (url or '/').split('/')[-2],
             },
-            '/users': {
-                'request.dispatch': md
-            },
+            '/users': {'request.dispatch': md},
         }
         cherrypy.tree.mount(Root(), url, conf)
 
@@ -372,14 +354,20 @@ def testMethodDispatch(self):
             self.assertHeader('Allow', headers)
 
             # Make sure POSTs update already existings resources
-            self.getPage('/users/%d' %
-                         id, method='POST', body='name=%s' % updatedname)
+            self.getPage(
+                '/users/%d' % id,
+                method='POST',
+                body='name=%s' % updatedname,
+            )
             self.assertBody('POST %d' % id)
             self.assertHeader('Allow', headers)
 
             # Make sure PUTs Update already existing resources.
-            self.getPage('/users/%d' %
-                         id, method='PUT', body='name=%s' % updatedname)
+            self.getPage(
+                '/users/%d' % id,
+                method='PUT',
+                body='name=%s' % updatedname,
+            )
             self.assertBody('PUT %d' % id)
             self.assertHeader('Allow', headers)
 
diff --git a/cherrypy/test/test_encoding.py b/cherrypy/test/test_encoding.py
index 882d7a5b8..c020f5357 100644
--- a/cherrypy/test/test_encoding.py
+++ b/cherrypy/test/test_encoding.py
@@ -20,15 +20,15 @@
 
 
 class EncodingTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self, param):
                 assert param == europoundUnicode, '%r != %r' % (
-                    param, europoundUnicode)
+                    param,
+                    europoundUnicode,
+                )
                 yield europoundUnicode
 
             @cherrypy.expose
@@ -46,32 +46,38 @@ def cookies_and_headers(self):
                 #  any part which is unicode (even ascii), the response
                 #  should not fail.
                 cherrypy.response.cookie['candy'] = 'bar'
-                cherrypy.response.cookie['candy']['domain'] = 'cherrypy.org'
-                cherrypy.response.headers[
-                    'Some-Header'] = 'My d\xc3\xb6g has fleas'
-                cherrypy.response.headers[
-                    'Bytes-Header'] = b'Bytes given header'
+                cherrypy.response.cookie['candy']['domain'] = 'cherrypy.dev'
+                cherrypy.response.headers['Some-Header'] = (
+                    'My d\xc3\xb6g has fleas'
+                )
+                cherrypy.response.headers['Bytes-Header'] = (
+                    b'Bytes given header'
+                )
                 return 'Any content'
 
             @cherrypy.expose
             def reqparams(self, *args, **kwargs):
                 return b', '.join(
-                    [': '.join((k, v)).encode('utf8')
-                     for k, v in sorted(cherrypy.request.params.items())]
+                    [
+                        ': '.join((k, v)).encode('utf8')
+                        for k, v in sorted(cherrypy.request.params.items())
+                    ],
                 )
 
             @cherrypy.expose
-            @cherrypy.config(**{
-                'tools.encode.text_only': False,
-                'tools.encode.add_charset': True,
-            })
+            @cherrypy.config(
+                **{
+                    'tools.encode.text_only': False,
+                    'tools.encode.add_charset': True,
+                },
+            )
             def nontext(self, *args, **kwargs):
-                cherrypy.response.headers[
-                    'Content-Type'] = 'application/binary'
+                cherrypy.response.headers['Content-Type'] = (
+                    'application/binary'
+                )
                 return '\x00\x01\x02\x03'
 
         class GZIP:
-
             @cherrypy.expose
             def index(self):
                 yield 'Hello, world'
@@ -96,24 +102,35 @@ def noshow_stream(self):
                 yield 'Here be dragons'
 
         class Decode:
-
             @cherrypy.expose
-            @cherrypy.config(**{
-                'tools.decode.on': True,
-                'tools.decode.default_encoding': ['utf-16'],
-            })
+            @cherrypy.config(
+                **{
+                    'tools.decode.on': True,
+                    'tools.decode.default_encoding': ['utf-16'],
+                },
+            )
             def extra_charset(self, *args, **kwargs):
-                return ', '.join([': '.join((k, v))
-                                  for k, v in cherrypy.request.params.items()])
+                return ', '.join(
+                    [
+                        ': '.join((k, v))
+                        for k, v in cherrypy.request.params.items()
+                    ],
+                )
 
             @cherrypy.expose
-            @cherrypy.config(**{
-                'tools.decode.on': True,
-                'tools.decode.encoding': 'utf-16',
-            })
+            @cherrypy.config(
+                **{
+                    'tools.decode.on': True,
+                    'tools.decode.encoding': 'utf-16',
+                },
+            )
             def force_charset(self, *args, **kwargs):
-                return ', '.join([': '.join((k, v))
-                                  for k, v in cherrypy.request.params.items()])
+                return ', '.join(
+                    [
+                        ': '.join((k, v))
+                        for k, v in cherrypy.request.params.items()
+                    ],
+                )
 
         root = Root()
         root.gzip = GZIP()
@@ -141,122 +158,170 @@ def test_query_string_decoding(self):
         self.assertErrorPage(
             404,
             'The given query string could not be processed. Query '
-            "strings for this resource must be encoded with 'utf8'.")
+            "strings for this resource must be encoded with 'utf8'.",
+        )
 
     def test_urlencoded_decoding(self):
         # Test the decoding of an application/x-www-form-urlencoded entity.
         europoundUtf8 = europoundUnicode.encode('utf-8')
         body = b'param=' + europoundUtf8
-        self.getPage('/',
-                     method='POST',
-                     headers=[
-                         ('Content-Type', 'application/x-www-form-urlencoded'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'application/x-www-form-urlencoded'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(europoundUtf8)
 
         # Encoded utf8 entities MUST be parsed and decoded correctly.
         # Here, q is the POUND SIGN U+00A3 encoded in utf8
         body = b'q=\xc2\xa3'
-        self.getPage('/reqparams', method='POST',
-                     headers=[(
-                         'Content-Type', 'application/x-www-form-urlencoded'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/reqparams',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'application/x-www-form-urlencoded'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(b'q: \xc2\xa3')
 
         # ...and in utf16, which is not in the default attempt_charsets list:
         body = b'\xff\xfeq\x00=\xff\xfe\xa3\x00'
-        self.getPage('/reqparams',
-                     method='POST',
-                     headers=[
-                         ('Content-Type',
-                          'application/x-www-form-urlencoded;charset=utf-16'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/reqparams',
+                method='POST',
+                headers=[
+                    (
+                        'Content-Type',
+                        'application/x-www-form-urlencoded;charset=utf-16',
+                    ),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(b'q: \xc2\xa3')
 
         # Entities that are incorrectly encoded MUST raise 400.
         # Here, q is the POUND SIGN U+00A3 encoded in utf16, but
         # the Content-Type incorrectly labels it utf-8.
         body = b'\xff\xfeq\x00=\xff\xfe\xa3\x00'
-        self.getPage('/reqparams',
-                     method='POST',
-                     headers=[
-                         ('Content-Type',
-                          'application/x-www-form-urlencoded;charset=utf-8'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/reqparams',
+                method='POST',
+                headers=[
+                    (
+                        'Content-Type',
+                        'application/x-www-form-urlencoded;charset=utf-8',
+                    ),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertStatus(400)
         self.assertErrorPage(
             400,
             'The request entity could not be decoded. The following charsets '
-            "were attempted: ['utf-8']")
+            "were attempted: ['utf-8']",
+        )
 
     def test_decode_tool(self):
         # An extra charset should be tried first, and succeed if it matches.
         # Here, we add utf-16 as a charset and pass a utf-16 body.
         body = b'\xff\xfeq\x00=\xff\xfe\xa3\x00'
-        self.getPage('/decode/extra_charset', method='POST',
-                     headers=[(
-                         'Content-Type', 'application/x-www-form-urlencoded'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/decode/extra_charset',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'application/x-www-form-urlencoded'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(b'q: \xc2\xa3')
 
         # An extra charset should be tried first, and continue to other default
         # charsets if it doesn't match.
         # Here, we add utf-16 as a charset but still pass a utf-8 body.
         body = b'q=\xc2\xa3'
-        self.getPage('/decode/extra_charset', method='POST',
-                     headers=[(
-                         'Content-Type', 'application/x-www-form-urlencoded'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/decode/extra_charset',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'application/x-www-form-urlencoded'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(b'q: \xc2\xa3')
 
         # An extra charset should error if force is True and it doesn't match.
         # Here, we force utf-16 as a charset but still pass a utf-8 body.
         body = b'q=\xc2\xa3'
-        self.getPage('/decode/force_charset', method='POST',
-                     headers=[(
-                         'Content-Type', 'application/x-www-form-urlencoded'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        (
+            self.getPage(
+                '/decode/force_charset',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'application/x-www-form-urlencoded'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertErrorPage(
             400,
             'The request entity could not be decoded. The following charsets '
-            "were attempted: ['utf-16']")
+            "were attempted: ['utf-16']",
+        )
 
     def test_multipart_decoding(self):
         # Test the decoding of a multipart entity when the charset (utf16) is
         # explicitly given.
-        body = ntob('\r\n'.join([
-            '--X',
-            'Content-Type: text/plain;charset=utf-16',
-            'Content-Disposition: form-data; name="text"',
-            '',
-            '\xff\xfea\x00b\x00\x1c c\x00',
-            '--X',
-            'Content-Type: text/plain;charset=utf-16',
-            'Content-Disposition: form-data; name="submit"',
-            '',
-            '\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
-            '--X--'
-        ]))
-        self.getPage('/reqparams', method='POST',
-                     headers=[(
-                         'Content-Type', 'multipart/form-data;boundary=X'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        body = ntob(
+            '\r\n'.join(
+                [
+                    '--X',
+                    'Content-Type: text/plain;charset=utf-16',
+                    'Content-Disposition: form-data; name="text"',
+                    '',
+                    '\xff\xfea\x00b\x00\x1c c\x00',
+                    '--X',
+                    'Content-Type: text/plain;charset=utf-16',
+                    'Content-Disposition: form-data; name="submit"',
+                    '',
+                    '\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
+                    '--X--',
+                ],
+            ),
+        )
+        (
+            self.getPage(
+                '/reqparams',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'multipart/form-data;boundary=X'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(b'submit: Create, text: ab\xe2\x80\x9cc')
 
     @mock.patch('cherrypy._cpreqbody.Part.maxrambytes', 1)
@@ -270,50 +335,69 @@ def test_multipart_decoding_bigger_maxrambytes(self):
     def test_multipart_decoding_no_charset(self):
         # Test the decoding of a multipart entity when the charset (utf8) is
         # NOT explicitly given, but is in the list of charsets to attempt.
-        body = ntob('\r\n'.join([
-            '--X',
-            'Content-Disposition: form-data; name="text"',
-            '',
-            '\xe2\x80\x9c',
-            '--X',
-            'Content-Disposition: form-data; name="submit"',
-            '',
-            'Create',
-            '--X--'
-        ]))
-        self.getPage('/reqparams', method='POST',
-                     headers=[(
-                         'Content-Type', 'multipart/form-data;boundary=X'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        body = ntob(
+            '\r\n'.join(
+                [
+                    '--X',
+                    'Content-Disposition: form-data; name="text"',
+                    '',
+                    '\xe2\x80\x9c',
+                    '--X',
+                    'Content-Disposition: form-data; name="submit"',
+                    '',
+                    'Create',
+                    '--X--',
+                ],
+            ),
+        )
+        (
+            self.getPage(
+                '/reqparams',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'multipart/form-data;boundary=X'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(b'submit: Create, text: \xe2\x80\x9c')
 
     def test_multipart_decoding_no_successful_charset(self):
         # Test the decoding of a multipart entity when the charset (utf16) is
         # NOT explicitly given, and is NOT in the list of charsets to attempt.
-        body = ntob('\r\n'.join([
-            '--X',
-            'Content-Disposition: form-data; name="text"',
-            '',
-            '\xff\xfea\x00b\x00\x1c c\x00',
-            '--X',
-            'Content-Disposition: form-data; name="submit"',
-            '',
-            '\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
-            '--X--'
-        ]))
-        self.getPage('/reqparams', method='POST',
-                     headers=[(
-                         'Content-Type', 'multipart/form-data;boundary=X'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        body = ntob(
+            '\r\n'.join(
+                [
+                    '--X',
+                    'Content-Disposition: form-data; name="text"',
+                    '',
+                    '\xff\xfea\x00b\x00\x1c c\x00',
+                    '--X',
+                    'Content-Disposition: form-data; name="submit"',
+                    '',
+                    '\xff\xfeC\x00r\x00e\x00a\x00t\x00e\x00',
+                    '--X--',
+                ],
+            ),
+        )
+        (
+            self.getPage(
+                '/reqparams',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'multipart/form-data;boundary=X'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertStatus(400)
         self.assertErrorPage(
             400,
             'The request entity could not be decoded. The following charsets '
-            "were attempted: ['us-ascii', 'utf-8']")
+            "were attempted: ['us-ascii', 'utf-8']",
+        )
 
     def test_nontext(self):
         self.getPage('/nontext')
@@ -332,8 +416,10 @@ def testEncoding(self):
 
         # Ask for multiple encodings. ISO-8859-1 should fail, and utf-16
         # should be produced.
-        self.getPage('/mao_zedong', [('Accept-Charset',
-                                      'iso-8859-1;q=1, utf-16;q=0.5')])
+        self.getPage(
+            '/mao_zedong',
+            [('Accept-Charset', 'iso-8859-1;q=1, utf-16;q=0.5')],
+        )
         self.assertBody(sing16)
 
         # The "*" value should default to our default_encoding, utf-8
@@ -343,17 +429,23 @@ def testEncoding(self):
         # Only allow iso-8859-1, which should fail and raise 406.
         self.getPage('/mao_zedong', [('Accept-Charset', 'iso-8859-1, *;q=0')])
         self.assertStatus('406 Not Acceptable')
-        self.assertInBody('Your client sent this Accept-Charset header: '
-                          'iso-8859-1, *;q=0. We tried these charsets: '
-                          'iso-8859-1.')
+        self.assertInBody(
+            'Your client sent this Accept-Charset header: '
+            'iso-8859-1, *;q=0. We tried these charsets: '
+            'iso-8859-1.',
+        )
 
         # Ask for x-mac-ce, which should be unknown. See ticket #569.
-        self.getPage('/mao_zedong', [('Accept-Charset',
-                                      'us-ascii, ISO-8859-1, x-mac-ce')])
+        self.getPage(
+            '/mao_zedong',
+            [('Accept-Charset', 'us-ascii, ISO-8859-1, x-mac-ce')],
+        )
         self.assertStatus('406 Not Acceptable')
-        self.assertInBody('Your client sent this Accept-Charset header: '
-                          'us-ascii, ISO-8859-1, x-mac-ce. We tried these '
-                          'charsets: ISO-8859-1, us-ascii, x-mac-ce.')
+        self.assertInBody(
+            'Your client sent this Accept-Charset header: '
+            'us-ascii, ISO-8859-1, x-mac-ce. We tried these '
+            'charsets: ISO-8859-1, us-ascii, x-mac-ce.',
+        )
 
         # Test the 'encoding' arg to encode.
         self.getPage('/utf8')
@@ -362,8 +454,10 @@ def testEncoding(self):
         self.assertStatus('406 Not Acceptable')
 
         # Test malformed quality value, which should raise 400.
-        self.getPage('/mao_zedong', [('Accept-Charset',
-                                      'ISO-8859-1,utf-8;q=0.7,*;q=0.7)')])
+        self.getPage(
+            '/mao_zedong',
+            [('Accept-Charset', 'ISO-8859-1,utf-8;q=0.7,*;q=0.7)')],
+        )
         self.assertStatus('400 Bad Request')
 
     def testGzip(self):
@@ -409,18 +503,26 @@ def testGzip(self):
         # readable page, since 1) the gzip header is already set,
         # and 2) we may have already written some of the body.
         # The fix is to never stream yields when using gzip.
-        if (cherrypy.server.protocol_version == 'HTTP/1.0' or
-                getattr(cherrypy.server, 'using_apache', False)):
-            self.getPage('/gzip/noshow_stream',
-                         headers=[('Accept-Encoding', 'gzip')])
+        if cherrypy.server.protocol_version == 'HTTP/1.0' or getattr(
+            cherrypy.server,
+            'using_apache',
+            False,
+        ):
+            self.getPage(
+                '/gzip/noshow_stream',
+                headers=[('Accept-Encoding', 'gzip')],
+            )
             self.assertHeader('Content-Encoding', 'gzip')
             self.assertInBody('\x1f\x8b\x08\x00')
         else:
             # The wsgiserver will simply stop sending data, and the HTTP client
             # will error due to an incomplete chunk-encoded stream.
-            self.assertRaises((ValueError, IncompleteRead), self.getPage,
-                              '/gzip/noshow_stream',
-                              headers=[('Accept-Encoding', 'gzip')])
+            self.assertRaises(
+                (ValueError, IncompleteRead),
+                self.getPage,
+                '/gzip/noshow_stream',
+                headers=[('Accept-Encoding', 'gzip')],
+            )
 
     def test_UnicodeHeaders(self):
         self.getPage('/cookies_and_headers')
diff --git a/cherrypy/test/test_etags.py b/cherrypy/test/test_etags.py
index 293eb8662..b8898443f 100644
--- a/cherrypy/test/test_etags.py
+++ b/cherrypy/test/test_etags.py
@@ -4,11 +4,9 @@
 
 
 class ETagTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def resource(self):
                 return 'Oh wah ta goo Siam.'
@@ -27,9 +25,12 @@ def fail(self, code):
             def unicoded(self):
                 return ntou('I am a \u1ee4nicode string.', 'escape')
 
-        conf = {'/': {'tools.etags.on': True,
-                      'tools.etags.autotags': True,
-                      }}
+        conf = {
+            '/': {
+                'tools.etags.on': True,
+                'tools.etags.autotags': True,
+            },
+        }
         cherrypy.tree.mount(Root(), config=conf)
 
     def test_etags(self):
@@ -52,8 +53,11 @@ def test_etags(self):
         # Test If-None-Match (both valid and invalid)
         self.getPage('/resource', headers=[('If-None-Match', etag)])
         self.assertStatus(304)
-        self.getPage('/resource', method='POST',
-                     headers=[('If-None-Match', etag)])
+        self.getPage(
+            '/resource',
+            method='POST',
+            headers=[('If-None-Match', etag)],
+        )
         self.assertStatus('412 Precondition Failed')
         self.getPage('/resource', headers=[('If-None-Match', '*')])
         self.assertStatus(304)
diff --git a/cherrypy/test/test_http.py b/cherrypy/test/test_http.py
index a955be43d..3ac4de2ba 100644
--- a/cherrypy/test/test_http.py
+++ b/cherrypy/test/test_http.py
@@ -16,9 +16,7 @@
 
 
 def is_ascii(text):
-    """
-    Return True if the text encodes as ascii.
-    """
+    """Return True if the text encodes as ascii."""
     try:
         text.encode('ascii')
         return True
@@ -28,18 +26,20 @@ def is_ascii(text):
 
 
 def encode_filename(filename):
-    """
-    Given a filename to be used in a multipart/form-data,
-    encode the name. Return the key and encoded filename.
+    """Given a filename to be used in a multipart/form-data, encode the name.
+
+    Return the key and encoded filename.
     """
     if is_ascii(filename):
         return 'filename', '"{filename}"'.format(**locals())
     encoded = urllib.parse.quote(filename, encoding='utf-8')
-    return 'filename*', "'".join((
-        'UTF-8',
-        '',  # lang
-        encoded,
-    ))
+    return 'filename*', "'".join(
+        (
+            'UTF-8',
+            '',  # lang
+            encoded,
+        ),
+    )
 
 
 def encode_multipart_formdata(files):
@@ -54,8 +54,9 @@ def encode_multipart_formdata(files):
         L.append('--' + BOUNDARY)
 
         fn_key, encoded = encode_filename(filename)
-        tmpl = \
+        tmpl = (
             'Content-Disposition: form-data; name="{key}"; {fn_key}={encoded}'
+        )
         L.append(tmpl.format(**locals()))
         ct = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
         L.append('Content-Type: %s' % ct)
@@ -69,7 +70,6 @@ def encode_multipart_formdata(files):
 
 
 class HTTPTests(helper.CPWebCase):
-
     def make_connection(self):
         if self.scheme == 'https':
             return HTTPSConnection('%s:%s' % (self.interface(), self.PORT))
@@ -79,7 +79,6 @@ def make_connection(self):
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self, *args, **kwargs):
                 return 'Hello world!'
@@ -114,7 +113,7 @@ def post_multipart(self, file):
 
             @cherrypy.expose
             def post_filename(self, myfile):
-                '''Return the name of the file which was uploaded.'''
+                """Return the name of the file which was uploaded."""
                 return myfile.filename
 
         cherrypy.tree.mount(Root())
@@ -136,6 +135,9 @@ def test_no_content_length(self):
         self.assertStatus(200)
         self.assertBody(b'Hello world!')
 
+        response.close()
+        c.close()
+
         # Now send a message that has no Content-Length, but does send a body.
         # Verify that CP times out the socket and responds
         # with 411 Length Required.
@@ -144,21 +146,22 @@ def test_no_content_length(self):
         else:
             c = HTTPConnection('%s:%s' % (self.interface(), self.PORT))
 
-        # `_get_content_length` is needed for Python 3.6+
         with mock.patch.object(
-                c,
-                '_get_content_length',
-                lambda body, method: None,
-                create=True):
-            # `_set_content_length` is needed for Python 2.7-3.5
-            with mock.patch.object(c, '_set_content_length', create=True):
-                c.request('POST', '/')
+            c,
+            '_get_content_length',
+            lambda body, method: None,
+            create=True,
+        ):
+            c.request('POST', '/')
 
         response = c.getresponse()
         self.body = response.fp.read()
         self.status = str(response.status)
         self.assertStatus(411)
 
+        response.close()
+        c.close()
+
     def test_post_multipart(self):
         alphabet = 'abcdefghijklmnopqrstuvwxyz'
         # generate file contents for a large post
@@ -184,6 +187,9 @@ def test_post_multipart(self):
         parts = ['%s * 65536' % ch for ch in alphabet]
         self.assertBody(', '.join(parts))
 
+        response.close()
+        c.close()
+
     def test_post_filename_with_special_characters(self):
         """Testing that we can handle filenames with special characters.
 
@@ -195,8 +201,13 @@ def test_post_filename_with_special_characters(self):
         """
         # We'll upload a bunch of files with differing names.
         fnames = [
-            'boop.csv', 'foo, bar.csv', 'bar, xxxx.csv', 'file"name.csv',
-            'file;name.csv', 'file; name.csv', u'test_łóąä.txt',
+            'boop.csv',
+            'foo, bar.csv',
+            'bar, xxxx.csv',
+            'file"name.csv',
+            'file;name.csv',
+            'file; name.csv',
+            'test_łóąä.txt',
         ]
         for fname in fnames:
             files = [('myfile', fname, 'yunyeenyunyue')]
@@ -217,6 +228,9 @@ def test_post_filename_with_special_characters(self):
             self.assertStatus(200)
             self.assertBody(fname)
 
+            response.close()
+            c.close()
+
     def test_malformed_request_line(self):
         if getattr(cherrypy.server, 'using_apache', False):
             return self.skip('skipped due to known Apache differences...')
@@ -225,12 +239,7 @@ def test_malformed_request_line(self):
         c = self.make_connection()
         c._output(b'geT /')
         c._send_output()
-        if hasattr(c, 'strict'):
-            response = c.response_class(c.sock, strict=c.strict, method='GET')
-        else:
-            # Python 3.2 removed the 'strict' feature, saying:
-            # "http.client now always assumes HTTP/1.x compliant servers."
-            response = c.response_class(c.sock, method='GET')
+        response = c.response_class(c.sock, method='GET')
         response.begin()
         self.assertEqual(response.status, 400)
         self.assertEqual(response.fp.read(22), b'Malformed Request-Line')
@@ -238,8 +247,8 @@ def test_malformed_request_line(self):
 
     def test_request_line_split_issue_1220(self):
         params = {
-            'intervenant-entreprise-evenement_classaction':
-                'evenement-mailremerciements',
+            'intervenant-entreprise-evenement_classaction': 'evenement-'
+            'mailremerciements',
             '_path': 'intervenant-entreprise-evenement',
             'intervenant-entreprise-evenement_action-id': 19404,
             'intervenant-entreprise-evenement_id': 19404,
@@ -264,6 +273,9 @@ def test_malformed_header(self):
         self.body = response.fp.read(20)
         self.assertBody('Illegal header line.')
 
+        response.close()
+        c.close()
+
     def test_http_over_https(self):
         if self.scheme != 'https':
             return self.skip('skipped (not running HTTPS)... ')
@@ -278,8 +290,10 @@ def test_http_over_https(self):
             response.begin()
             self.assertEqual(response.status, 400)
             self.body = response.read()
-            self.assertBody('The client sent a plain HTTP request, but this '
-                            'server only speaks HTTPS on this port.')
+            self.assertBody(
+                'The client sent a plain HTTP request, but this '
+                'server only speaks HTTPS on this port.',
+            )
         except socket.error:
             e = sys.exc_info()[1]
             # "Connection reset by peer" is also acceptable.
@@ -295,8 +309,7 @@ def test_garbage_in(self):
         try:
             response.begin()
             self.assertEqual(response.status, 400)
-            self.assertEqual(response.fp.read(22),
-                             b'Malformed Request-Line')
+            self.assertEqual(response.fp.read(22), b'Malformed Request-Line')
             c.close()
         except socket.error:
             e = sys.exc_info()[1]
diff --git a/cherrypy/test/test_httputil.py b/cherrypy/test/test_httputil.py
index 846614247..9adae2b56 100644
--- a/cherrypy/test/test_httputil.py
+++ b/cherrypy/test/test_httputil.py
@@ -1,4 +1,5 @@
 """Test helpers from ``cherrypy.lib.httputil`` module."""
+
 import pytest
 import http.client
 
@@ -24,7 +25,7 @@
         ('', '/pi', '/pi'),
         ('', '/', '/'),
         ('', '', '/'),
-    ]
+    ],
 )
 def test_urljoin(script_name, path_info, expected_url):
     """Test all slash+atom combinations for SCRIPT_NAME and PATH_INFO."""
@@ -51,7 +52,7 @@ def test_urljoin(script_name, path_info, expected_url):
         ('500', EXPECTED_500),
         (http.client.NOT_FOUND, EXPECTED_404),
         ('444 Non-existent reason', EXPECTED_444),
-    ]
+    ],
 )
 def test_valid_status(status, expected_status):
     """Check valid int, string and http.client-constants
@@ -64,7 +65,7 @@ def test_valid_status(status, expected_status):
     [
         (
             'hey',
-            r"Illegal response status from server \('hey' is non-numeric\)."
+            r"Illegal response status from server \('hey' is non-numeric\).",
         ),
         (
             {'hey': 'hi'},
@@ -73,7 +74,7 @@ def test_valid_status(status, expected_status):
         ),
         (1, r'Illegal response status from server \(1 is out of range\).'),
         (600, r'Illegal response status from server \(600 is out of range\).'),
-    ]
+    ],
 )
 def test_invalid_status(status_code, error_msg):
     """Check that invalid status cause certain errors."""
diff --git a/cherrypy/test/test_iterator.py b/cherrypy/test/test_iterator.py
index 6600a78db..ffcca536d 100644
--- a/cherrypy/test/test_iterator.py
+++ b/cherrypy/test/test_iterator.py
@@ -3,7 +3,6 @@
 
 
 class IteratorBase(object):
-
     created = 0
     datachunk = 'butternut squash' * 256
 
@@ -17,7 +16,6 @@ def decr(cls):
 
 
 class OurGenerator(IteratorBase):
-
     def __iter__(self):
         self.incr()
         try:
@@ -28,7 +26,6 @@ def __iter__(self):
 
 
 class OurIterator(IteratorBase):
-
     started = False
     closed_off = False
     count = 0
@@ -60,13 +57,11 @@ def __del__(self):
 
 
 class OurClosableIterator(OurIterator):
-
     def close(self):
         self.decrement()
 
 
 class OurNotClosableIterator(OurIterator):
-
     # We can't close something which requires an additional argument.
     def close(self, somearg):
         self.decrement()
@@ -77,12 +72,9 @@ class OurUnclosableIterator(OurIterator):
 
 
 class IteratorTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         class Root(object):
-
             @cherrypy.expose
             def count(self, clsname):
                 cherrypy.response.headers['Content-Type'] = 'text/plain'
@@ -118,6 +110,7 @@ def _test_iterator(self):
         all_classes = closables + unclosables
 
         import random
+
         random.shuffle(all_classes)
 
         for clsname in all_classes:
@@ -150,6 +143,8 @@ def _test_iterator(self):
             self.assertStatus(200)
             self.assertBody('0')
 
+            itr_conn.close()
+
         # Now we do the same check with streaming - some classes will
         # be automatically closed, while others cannot.
         stream_counts = {}
@@ -174,12 +169,12 @@ def _test_iterator(self):
             # we will test to see if the value has gone back down to
             # zero.
             if clsname in closables:
-
                 # Sometimes we try to get the answer too quickly - we
                 # will wait for 100 ms before asking again if we didn't
                 # get the answer we wanted.
                 if self.body != '0':
                     import time
+
                     time.sleep(0.1)
                     self.getPage('/count/' + clsname)
 
diff --git a/cherrypy/test/test_json.py b/cherrypy/test/test_json.py
index 4b8be548f..0878b740f 100644
--- a/cherrypy/test/test_json.py
+++ b/cherrypy/test/test_json.py
@@ -8,11 +8,9 @@
 
 
 class JsonTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root(object):
-
             @cherrypy.expose
             def plain(self):
                 return 'hello'
@@ -72,20 +70,26 @@ def test_json_input(self):
             return
 
         body = '[13, "c"]'
-        headers = [('Content-Type', 'application/json'),
-                   ('Content-Length', str(len(body)))]
+        headers = [
+            ('Content-Type', 'application/json'),
+            ('Content-Length', str(len(body))),
+        ]
         self.getPage('/json_post', method='POST', headers=headers, body=body)
         self.assertBody('ok')
 
         body = '[13, "c"]'
-        headers = [('Content-Type', 'text/plain'),
-                   ('Content-Length', str(len(body)))]
+        headers = [
+            ('Content-Type', 'text/plain'),
+            ('Content-Length', str(len(body))),
+        ]
         self.getPage('/json_post', method='POST', headers=headers, body=body)
         self.assertStatus(415, 'Expected an application/json content type')
 
         body = '[13, -]'
-        headers = [('Content-Type', 'application/json'),
-                   ('Content-Length', str(len(body)))]
+        headers = [
+            ('Content-Type', 'application/json'),
+            ('Content-Length', str(len(body))),
+        ]
         self.getPage('/json_post', method='POST', headers=headers, body=body)
         self.assertStatus(400, 'Invalid JSON document')
 
diff --git a/cherrypy/test/test_logging.py b/cherrypy/test/test_logging.py
index 5308fb72f..7b4729209 100644
--- a/cherrypy/test/test_logging.py
+++ b/cherrypy/test/test_logging.py
@@ -1,5 +1,6 @@
 """Basic tests for the CherryPy core: request handling."""
 
+import datetime
 import logging
 
 from cheroot.test import webtest
@@ -11,8 +12,8 @@
 
 
 # Some unicode strings.
-tartaros = u'\u03a4\u1f71\u03c1\u03c4\u03b1\u03c1\u03bf\u03c2'
-erebos = u'\u0388\u03c1\u03b5\u03b2\u03bf\u03c2.com'
+tartaros = '\u03a4\u1f71\u03c1\u03c4\u03b1\u03c1\u03bf\u03c2'
+erebos = '\u0388\u03c1\u03b5\u03b2\u03bf\u03c2.com'
 
 
 @pytest.fixture
@@ -47,7 +48,6 @@ def shutdown_server():
 @pytest.fixture
 def configure_server(access_log_file, error_log_file):
     class Root:
-
         @cherrypy.expose
         def index(self):
             return 'hello'
@@ -86,16 +86,20 @@ def error(self):
     root = Root()
 
     cherrypy.config.reset()
-    cherrypy.config.update({
-        'server.socket_host': webtest.WebCase.HOST,
-        'server.socket_port': webtest.WebCase.PORT,
-        'server.protocol_version': webtest.WebCase.PROTOCOL,
-        'environment': 'test_suite',
-    })
-    cherrypy.config.update({
-        'log.error_file': str(error_log_file),
-        'log.access_file': str(access_log_file),
-    })
+    cherrypy.config.update(
+        {
+            'server.socket_host': webtest.WebCase.HOST,
+            'server.socket_port': webtest.WebCase.PORT,
+            'server.protocol_version': webtest.WebCase.PROTOCOL,
+            'environment': 'test_suite',
+        },
+    )
+    cherrypy.config.update(
+        {
+            'log.error_file': str(error_log_file),
+            'log.access_file': str(access_log_file),
+        },
+    )
     cherrypy.tree.mount(root)
 
 
@@ -103,6 +107,7 @@ def error(self):
 def log_tracker(access_log_file):
     class LogTracker(LogCase):
         logfile = str(access_log_file)
+
     return LogTracker()
 
 
@@ -113,7 +118,7 @@ def test_normal_return(log_tracker, server):
     resp = requests.get(
         'http://%s:%s/as_string' % (host, port),
         headers={
-            'Referer': 'http://www.cherrypy.org/',
+            'Referer': 'http://www.cherrypy.dev/',
             'User-Agent': 'Mozilla/5.0',
         },
     )
@@ -127,16 +132,14 @@ def test_normal_return(log_tracker, server):
 
     content_length = len(expected_body)
     if not any(
-            k for k, v in resp.headers.items()
-            if k.lower() == 'content-length'
+        k for k, v in resp.headers.items() if k.lower() == 'content-length'
     ):
         content_length = '-'
 
     log_tracker.assertLog(
         -1,
         '] "GET /as_string HTTP/1.1" 200 %s '
-        '"http://www.cherrypy.org/" "Mozilla/5.0"'
-        % content_length,
+        '"http://www.cherrypy.dev/" "Mozilla/5.0"' % content_length,
     )
 
 
@@ -159,15 +162,13 @@ def test_normal_yield(log_tracker, server):
     log_tracker.assertLog(-1, intro)
     content_length = len(expected_body)
     if not any(
-            k for k, v in resp.headers.items()
-            if k.lower() == 'content-length'
+        k for k, v in resp.headers.items() if k.lower() == 'content-length'
     ):
         content_length = '-'
 
     log_tracker.assertLog(
         -1,
-        '] "GET /as_yield HTTP/1.1" 200 %s "" ""'
-        % content_length,
+        '] "GET /as_yield HTTP/1.1" 200 %s "" ""' % content_length,
     )
 
 
@@ -192,11 +193,37 @@ def test_custom_log_format(log_tracker, monkeypatch, server):
     log_tracker.assertLog(-1, '%s - - [' % host)
     log_tracker.assertLog(
         -1,
-        '] "GET /as_string HTTP/1.1" '
-        '200 7 "REFERER" "USERAGENT" HOST',
+        '] "GET /as_string HTTP/1.1" 200 7 "REFERER" "USERAGENT" HOST',
     )
 
 
+def test_utc_in_timez(monkeypatch):
+    """Test ``LazyRfc3339UtcTime`` renders as ``str`` UTC timestamp."""
+    utcoffset8_local_time_in_naive_utc = (
+        datetime.datetime(
+            year=2020,
+            month=1,
+            day=1,
+            hour=1,
+            minute=23,
+            second=45,
+            tzinfo=datetime.timezone(datetime.timedelta(hours=8)),
+        )
+        .astimezone(datetime.timezone.utc)
+        .replace(tzinfo=None)
+    )
+
+    class mock_datetime:
+        @classmethod
+        def now(cls, tz):
+            return utcoffset8_local_time_in_naive_utc
+
+    monkeypatch.setattr('datetime.datetime', mock_datetime)
+    rfc3339_utc_time = str(cherrypy._cplogging.LazyRfc3339UtcTime())
+    expected_time = '2019-12-31T17:23:45Z'
+    assert rfc3339_utc_time == expected_time
+
+
 def test_timez_log_format(log_tracker, monkeypatch, server):
     """Test a customized access_log_format string, which is a
     feature of _cplogging.LogManager.access()."""
@@ -226,8 +253,7 @@ def test_timez_log_format(log_tracker, monkeypatch, server):
     log_tracker.assertLog(-1, expected_time)
     log_tracker.assertLog(
         -1,
-        ' "GET /as_string HTTP/1.1" '
-        '200 7 "REFERER" "USERAGENT" HOST',
+        ' "GET /as_string HTTP/1.1" 200 7 "REFERER" "USERAGENT" HOST',
     )
 
 
diff --git a/cherrypy/test/test_mime.py b/cherrypy/test/test_mime.py
index ef35d10e7..0828006a3 100644
--- a/cherrypy/test/test_mime.py
+++ b/cherrypy/test/test_mime.py
@@ -6,9 +6,7 @@
 
 
 def setup_server():
-
     class Root:
-
         @cherrypy.expose
         def multipart(self, parts):
             return repr(parts)
@@ -19,8 +17,11 @@ def multipart_form_data(self, **kwargs):
 
         @cherrypy.expose
         def flashupload(self, Filedata, Upload, Filename):
-            return ('Upload: %s, Filename: %s, Filedata: %r' %
-                    (Upload, Filename, Filedata.file.read()))
+            return 'Upload: %s, Filename: %s, Filedata: %r' % (
+                Upload,
+                Filename,
+                Filedata.file.read(),
+            )
 
     cherrypy.config.update({'server.max_request_body_size': 0})
     cherrypy.tree.mount(Root())
@@ -45,18 +46,22 @@ def test_multipart(self):
 This is the <strong>HTML</strong> version
 </body>
 </html>
-""")
-        body = '\r\n'.join([
-            '--123456789',
-            "Content-Type: text/plain; charset='ISO-8859-1'",
-            'Content-Transfer-Encoding: 7bit',
-            '',
-            text_part,
-            '--123456789',
-            "Content-Type: text/html; charset='ISO-8859-1'",
-            '',
-            html_part,
-            '--123456789--'])
+""",
+        )
+        body = '\r\n'.join(
+            [
+                '--123456789',
+                "Content-Type: text/plain; charset='ISO-8859-1'",
+                'Content-Transfer-Encoding: 7bit',
+                '',
+                text_part,
+                '--123456789',
+                "Content-Type: text/html; charset='ISO-8859-1'",
+                '',
+                html_part,
+                '--123456789--',
+            ],
+        )
         headers = [
             ('Content-Type', 'multipart/mixed; boundary=123456789'),
             ('Content-Length', str(len(body))),
@@ -65,32 +70,40 @@ def test_multipart(self):
         self.assertBody(repr([text_part, html_part]))
 
     def test_multipart_form_data(self):
-        body = '\r\n'.join([
-            '--X',
-            'Content-Disposition: form-data; name="foo"',
-            '',
-            'bar',
-            '--X',
-            # Test a param with more than one value.
-            # See
-            # https://github.com/cherrypy/cherrypy/issues/1028
-            'Content-Disposition: form-data; name="baz"',
-            '',
-            '111',
-            '--X',
-            'Content-Disposition: form-data; name="baz"',
-            '',
-            '333',
-            '--X--'
-        ])
-        self.getPage('/multipart_form_data', method='POST',
-                     headers=[(
-                         'Content-Type', 'multipart/form-data;boundary=X'),
-                         ('Content-Length', str(len(body))),
-                     ],
-                     body=body),
+        body = '\r\n'.join(
+            [
+                '--X',
+                'Content-Disposition: form-data; name="foo"',
+                '',
+                'bar',
+                '--X',
+                # Test a param with more than one value.
+                # See
+                # https://github.com/cherrypy/cherrypy/issues/1028
+                'Content-Disposition: form-data; name="baz"',
+                '',
+                '111',
+                '--X',
+                'Content-Disposition: form-data; name="baz"',
+                '',
+                '333',
+                '--X--',
+            ],
+        )
+        (
+            self.getPage(
+                '/multipart_form_data',
+                method='POST',
+                headers=[
+                    ('Content-Type', 'multipart/form-data;boundary=X'),
+                    ('Content-Length', str(len(body))),
+                ],
+                body=body,
+            ),
+        )
         self.assertBody(
-            repr([('baz', [ntou('111'), ntou('333')]), ('foo', ntou('bar'))]))
+            repr([('baz', [ntou('111'), ntou('333')]), ('foo', ntou('bar'))]),
+        )
 
 
 class SafeMultipartHandlingTest(helper.CPWebCase):
@@ -99,17 +112,22 @@ class SafeMultipartHandlingTest(helper.CPWebCase):
     def test_Flash_Upload(self):
         headers = [
             ('Accept', 'text/*'),
-            ('Content-Type', 'multipart/form-data; '
-             'boundary=----------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6'),
+            (
+                'Content-Type',
+                'multipart/form-data; '
+                'boundary=----------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6',
+            ),
             ('User-Agent', 'Shockwave Flash'),
             ('Host', 'www.example.com:54583'),
             ('Content-Length', '499'),
             ('Connection', 'Keep-Alive'),
             ('Cache-Control', 'no-cache'),
         ]
-        filedata = (b'<?xml version="1.0" encoding="UTF-8"?>\r\n'
-                    b'<projectDescription>\r\n'
-                    b'</projectDescription>\r\n')
+        filedata = (
+            b'<?xml version="1.0" encoding="UTF-8"?>\r\n'
+            b'<projectDescription>\r\n'
+            b'</projectDescription>\r\n'
+        )
         body = (
             b'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6\r\n'
             b'Content-Disposition: form-data; name="Filename"\r\n'
@@ -119,9 +137,7 @@ def test_Flash_Upload(self):
             b'Content-Disposition: form-data; '
             b'name="Filedata"; filename=".project"\r\n'
             b'Content-Type: application/octet-stream\r\n'
-            b'\r\n' +
-            filedata +
-            b'\r\n'
+            b'\r\n' + filedata + b'\r\n'
             b'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6\r\n'
             b'Content-Disposition: form-data; name="Upload"\r\n'
             b'\r\n'
@@ -130,5 +146,7 @@ def test_Flash_Upload(self):
             b'------------KM7Ij5cH2KM7Ef1gL6ae0ae0cH2gL6--'
         )
         self.getPage('/flashupload', headers, 'POST', body)
-        self.assertBody('Upload: Submit Query, Filename: .project, '
-                        'Filedata: %r' % filedata)
+        self.assertBody(
+            'Upload: Submit Query, Filename: .project, Filedata: %r'
+            % filedata,
+        )
diff --git a/cherrypy/test/test_misc_tools.py b/cherrypy/test/test_misc_tools.py
index fb85b8f89..df132ba6f 100644
--- a/cherrypy/test/test_misc_tools.py
+++ b/cherrypy/test/test_misc_tools.py
@@ -11,28 +11,29 @@
 
 def setup_server():
     class Root:
-
         @cherrypy.expose
         def index(self):
             yield 'Hello, world'
+
         h = [('Content-Language', 'en-GB'), ('Content-Type', 'text/plain')]
         tools.response_headers(headers=h)(index)
 
         @cherrypy.expose
-        @cherrypy.config(**{
-            'tools.response_headers.on': True,
-            'tools.response_headers.headers': [
-                ('Content-Language', 'fr'),
-                ('Content-Type', 'text/plain'),
-            ],
-            'tools.log_hooks.on': True,
-        })
+        @cherrypy.config(
+            **{
+                'tools.response_headers.on': True,
+                'tools.response_headers.headers': [
+                    ('Content-Language', 'fr'),
+                    ('Content-Type', 'text/plain'),
+                ],
+                'tools.log_hooks.on': True,
+            },
+        )
         def other(self):
             return 'salut'
 
     @cherrypy.config(**{'tools.accept.on': True})
     class Accept:
-
         @cherrypy.expose
         def index(self):
             return '<a href="feed">Atom feed</a>'
@@ -55,14 +56,13 @@ def select(self):
                 return 'PAGE TITLE'
 
     class Referer:
-
         @cherrypy.expose
         def accept(self):
             return 'Accepted!'
+
         reject = accept
 
     class AutoVary:
-
         @cherrypy.expose
         def index(self):
             # Read a header directly with 'get'
@@ -77,14 +77,17 @@ def index(self):
             tools.accept.callable(['text/html', 'text/plain'])
             return 'Hello, world!'
 
-    conf = {'/referer': {'tools.referer.on': True,
-                         'tools.referer.pattern': r'http://[^/]*example\.com',
-                         },
-            '/referer/reject': {'tools.referer.accept': False,
-                                'tools.referer.accept_missing': True,
-                                },
-            '/autovary': {'tools.autovary.on': True},
-            }
+    conf = {
+        '/referer': {
+            'tools.referer.on': True,
+            'tools.referer.pattern': r'http://[^/]*example\.com',
+        },
+        '/referer/reject': {
+            'tools.referer.accept': False,
+            'tools.referer.accept_missing': True,
+        },
+        '/autovary': {'tools.autovary.on': True},
+    }
 
     root = Root()
     root.referer = Referer()
@@ -115,8 +118,10 @@ def testReferer(self):
         self.getPage('/referer/accept')
         self.assertErrorPage(403, 'Forbidden Referer header.')
 
-        self.getPage('/referer/accept',
-                     headers=[('Referer', 'http://www.example.com/')])
+        self.getPage(
+            '/referer/accept',
+            headers=[('Referer', 'http://www.example.com/')],
+        )
         self.assertStatus(200)
         self.assertBody('Accepted!')
 
@@ -125,8 +130,10 @@ def testReferer(self):
         self.assertStatus(200)
         self.assertBody('Accepted!')
 
-        self.getPage('/referer/reject',
-                     headers=[('Referer', 'http://www.example.com/')])
+        self.getPage(
+            '/referer/reject',
+            headers=[('Referer', 'http://www.example.com/')],
+        )
         self.assertErrorPage(403, 'Forbidden Referer header.')
 
 
@@ -140,8 +147,10 @@ def test_Accept_Tool(self):
         self.assertInBody('<title>Unknown Blog</title>')
 
         # Specify exact media type
-        self.getPage('/accept/feed',
-                     headers=[('Accept', 'application/atom+xml')])
+        self.getPage(
+            '/accept/feed',
+            headers=[('Accept', 'application/atom+xml')],
+        )
         self.assertStatus(200)
         self.assertInBody('<title>Unknown Blog</title>')
 
@@ -157,10 +166,12 @@ def test_Accept_Tool(self):
 
         # Specify unacceptable media types
         self.getPage('/accept/feed', headers=[('Accept', 'text/html')])
-        self.assertErrorPage(406,
-                             'Your client sent this Accept header: text/html. '
-                             'But this resource only emits these media types: '
-                             'application/atom+xml.')
+        self.assertErrorPage(
+            406,
+            'Your client sent this Accept header: text/html. '
+            'But this resource only emits these media types: '
+            'application/atom+xml.',
+        )
 
         # Test resource where tool is 'on' but media is None (not set).
         self.getPage('/accept/')
@@ -175,8 +186,10 @@ def test_accept_selection(self):
         self.getPage('/accept/select', [('Accept', 'text/plain')])
         self.assertStatus(200)
         self.assertBody('PAGE TITLE')
-        self.getPage('/accept/select',
-                     [('Accept', 'text/plain, text/*;q=0.5')])
+        self.getPage(
+            '/accept/select',
+            [('Accept', 'text/plain, text/*;q=0.5')],
+        )
         self.assertStatus(200)
         self.assertBody('PAGE TITLE')
 
@@ -195,7 +208,8 @@ def test_accept_selection(self):
             406,
             'Your client sent this Accept header: application/xml. '
             'But this resource only emits these media types: '
-            'text/html, text/plain.')
+            'text/html, text/plain.',
+        )
 
 
 class AutoVaryTest(helper.CPWebCase):
@@ -206,5 +220,5 @@ def testAutoVary(self):
         self.assertHeader(
             'Vary',
             'Accept, Accept-Charset, Accept-Encoding, '
-            'Host, If-Modified-Since, Range'
+            'Host, If-Modified-Since, Range',
         )
diff --git a/cherrypy/test/test_native.py b/cherrypy/test/test_native.py
index 08bf99977..71b6010e4 100644
--- a/cherrypy/test/test_native.py
+++ b/cherrypy/test/test_native.py
@@ -15,6 +15,7 @@
 @pytest.fixture
 def cp_native_server(request):
     """A native server."""
+
     class Root(object):
         @cherrypy.expose
         def index(self):
diff --git a/cherrypy/test/test_objectmapping.py b/cherrypy/test/test_objectmapping.py
index 98402b8b9..9afa0fddc 100644
--- a/cherrypy/test/test_objectmapping.py
+++ b/cherrypy/test/test_objectmapping.py
@@ -8,11 +8,9 @@
 
 
 class ObjectMappingTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self, name='world'):
                 return name
@@ -55,26 +53,26 @@ def translate_html(self):
         @cherrypy.expose
         def mapped_func(self, ID=None):
             return 'ID is %s' % ID
+
         setattr(Root, 'Von B\xfclow', mapped_func)
 
         class Exposing:
-
             @cherrypy.expose
             def base(self):
                 return 'expose works!'
+
             cherrypy.expose(base, '1')
             cherrypy.expose(base, '2')
 
         class ExposingNewStyle(object):
-
             @cherrypy.expose
             def base(self):
                 return 'expose works!'
+
             cherrypy.expose(base, '1')
             cherrypy.expose(base, '2')
 
         class Dir1:
-
             @cherrypy.expose
             def index(self):
                 return 'index for dir1'
@@ -83,14 +81,14 @@ def index(self):
             @cherrypy.config(**{'tools.trailing_slash.extra': True})
             def myMethod(self):
                 return 'myMethod from dir1, path_info is:' + repr(
-                    cherrypy.request.path_info)
+                    cherrypy.request.path_info,
+                )
 
             @cherrypy.expose
             def default(self, *params):
                 return 'default for dir1, param is:' + repr(params)
 
         class Dir2:
-
             @cherrypy.expose
             def index(self):
                 return 'index for dir2, path is:' + cherrypy.request.path_info
@@ -108,17 +106,14 @@ def posparam(self, *vpath):
                 return '/'.join(vpath)
 
         class Dir3:
-
             def default(self):
                 return 'default for dir3, not exposed'
 
         class Dir4:
-
             def index(self):
                 return 'index for dir4, not exposed'
 
         class DefNoIndex:
-
             @cherrypy.expose
             def default(self, *args):
                 raise cherrypy.HTTPRedirect('contact')
@@ -126,7 +121,6 @@ def default(self, *args):
         # MethodDispatcher code
         @cherrypy.expose
         class ByMethod:
-
             def __init__(self, *things):
                 self.things = list(things)
 
@@ -151,14 +145,14 @@ class Collection:
 
         d = cherrypy.dispatch.MethodDispatcher()
         for url in script_names:
-            conf = {'/': {'user': (url or '/').split('/')[-2]},
-                    '/bymethod': {'request.dispatch': d},
-                    '/collection': {'request.dispatch': d},
-                    }
+            conf = {
+                '/': {'user': (url or '/').split('/')[-2]},
+                '/bymethod': {'request.dispatch': d},
+                '/collection': {'request.dispatch': d},
+            }
             cherrypy.tree.mount(Root(), url, conf)
 
         class Isolated:
-
             @cherrypy.expose
             def index(self):
                 return 'made it!'
@@ -167,12 +161,14 @@ def index(self):
 
         @cherrypy.expose
         class AnotherApp:
-
             def GET(self):
                 return 'milk'
 
-        cherrypy.tree.mount(AnotherApp(), '/app',
-                            {'/': {'request.dispatch': d}})
+        cherrypy.tree.mount(
+            AnotherApp(),
+            '/app',
+            {'/': {'request.dispatch': d}},
+        )
 
     def testObjectMapping(self):
         for url in script_names:
@@ -183,11 +179,13 @@ def testObjectMapping(self):
 
             self.getPage('/dir1/myMethod')
             self.assertBody(
-                "myMethod from dir1, path_info is:'/dir1/myMethod'")
+                "myMethod from dir1, path_info is:'/dir1/myMethod'",
+            )
 
             self.getPage('/this/method/does/not/exist')
             self.assertBody(
-                "default:('this', 'method', 'does', 'not', 'exist')")
+                "default:('this', 'method', 'does', 'not', 'exist')",
+            )
 
             self.getPage('/extra/too/much')
             self.assertBody("('too', 'much')")
@@ -214,7 +212,8 @@ def testObjectMapping(self):
             # Test that default method must be exposed in order to match.
             self.getPage('/dir1/dir2/dir3/dir4/index')
             self.assertBody(
-                "default for dir1, param is:('dir2', 'dir3', 'dir4', 'index')")
+                "default for dir1, param is:('dir2', 'dir3', 'dir4', 'index')",
+            )
 
             # Test *vpath when default() is defined but not index()
             # This also tests HTTPRedirect with default.
@@ -223,12 +222,16 @@ def testObjectMapping(self):
             self.assertHeader('Location', '%s/contact' % self.base())
             self.getPage('/defnoindex/')
             self.assertStatus((302, 303))
-            self.assertHeader('Location', '%s/defnoindex/contact' %
-                              self.base())
+            self.assertHeader(
+                'Location',
+                '%s/defnoindex/contact' % self.base(),
+            )
             self.getPage('/defnoindex/page')
             self.assertStatus((302, 303))
-            self.assertHeader('Location', '%s/defnoindex/contact' %
-                              self.base())
+            self.assertHeader(
+                'Location',
+                '%s/defnoindex/contact' % self.base(),
+            )
 
             self.getPage('/redirect')
             self.assertStatus('302 Found')
@@ -262,8 +265,10 @@ def testObjectMapping(self):
         self.getPage('http://%s:%s/' % (self.interface(), self.PORT))
         self.assertBody('world')
 
-        self.getPage('http://%s:%s/abs/?service=http://192.168.0.1/x/y/z' %
-                     (self.interface(), self.PORT))
+        self.getPage(
+            'http://%s:%s/abs/?service=http://192.168.0.1/x/y/z'
+            % (self.interface(), self.PORT),
+        )
         self.assertBody("default:('abs',)")
 
         self.getPage('/rel/?service=http://192.168.120.121:8000/x/y/z')
@@ -387,7 +392,6 @@ def testMethodDispatch(self):
 
     def testTreeMounting(self):
         class Root(object):
-
             @cherrypy.expose
             def hello(self):
                 return 'Hello world!'
diff --git a/cherrypy/test/test_params.py b/cherrypy/test/test_params.py
index 73b4cb4cf..62c406c27 100644
--- a/cherrypy/test/test_params.py
+++ b/cherrypy/test/test_params.py
@@ -14,8 +14,10 @@ class Root:
             @cherrypy.tools.params()
             def resource(self, limit=None, sort=None):
                 return type(limit).__name__
+
             # for testing on Py 2
             resource.__annotations__ = {'limit': int}
+
         conf = {'/': {'tools.params.on': True}}
         cherrypy.tree.mount(Root(), config=conf)
 
diff --git a/cherrypy/test/test_plugins.py b/cherrypy/test/test_plugins.py
index 4d3aa6b1a..189e9a0fa 100644
--- a/cherrypy/test/test_plugins.py
+++ b/cherrypy/test/test_plugins.py
@@ -6,8 +6,8 @@
 
 class TestAutoreloader:
     def test_file_for_file_module_when_None(self):
-        """No error when module.__file__ is None.
-        """
+        """No error when ``module.__file__`` is :py:data:`None`."""
+
         class test_module:
             __file__ = None
 
diff --git a/cherrypy/test/test_proxy.py b/cherrypy/test/test_proxy.py
index 4d34440ab..03a2b0600 100644
--- a/cherrypy/test/test_proxy.py
+++ b/cherrypy/test/test_proxy.py
@@ -5,24 +5,25 @@
 
 
 class ProxyTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         # Set up site
-        cherrypy.config.update({
-            'tools.proxy.on': True,
-            'tools.proxy.base': 'www.mydomain.test',
-        })
+        cherrypy.config.update(
+            {
+                'tools.proxy.on': True,
+                'tools.proxy.base': 'www.mydomain.test',
+            },
+        )
 
         # Set up application
 
         class Root:
-
             def __init__(self, sn):
                 # Calculate a URL outside of any requests.
                 self.thisnewpage = cherrypy.url(
-                    '/this/new/page', script_name=sn)
+                    '/this/new/page',
+                    script_name=sn,
+                )
 
             @cherrypy.expose
             def pageurl(self):
@@ -37,10 +38,12 @@ def remoteip(self):
                 return cherrypy.request.remote.ip
 
             @cherrypy.expose
-            @cherrypy.config(**{
-                'tools.proxy.local': 'X-Host',
-                'tools.trailing_slash.extra': True,
-            })
+            @cherrypy.config(
+                **{
+                    'tools.proxy.local': 'X-Host',
+                    'tools.trailing_slash.extra': True,
+                },
+            )
             def xhost(self):
                 raise cherrypy.HTTPRedirect('blah')
 
@@ -55,13 +58,16 @@ def ssl(self):
 
             @cherrypy.expose
             def newurl(self):
-                return ("Browse to <a href='%s'>this page</a>."
-                        % cherrypy.url('/this/new/page'))
+                return "Browse to <a href='%s'>this page</a>." % cherrypy.url(
+                    '/this/new/page',
+                )
 
             @cherrypy.expose
-            @cherrypy.config(**{
-                'tools.proxy.base': None,
-            })
+            @cherrypy.config(
+                **{
+                    'tools.proxy.base': None,
+                },
+            )
             def base_no_base(self):
                 return cherrypy.request.base
 
@@ -70,38 +76,53 @@ def base_no_base(self):
 
     def testProxy(self):
         self.getPage('/')
-        self.assertHeader('Location',
-                          '%s://www.mydomain.test%s/dummy' %
-                          (self.scheme, self.prefix()))
+        self.assertHeader(
+            'Location',
+            '%s://www.mydomain.test%s/dummy' % (self.scheme, self.prefix()),
+        )
 
         # Test X-Forwarded-Host (Apache 1.3.33+ and Apache 2)
         self.getPage(
-            '/', headers=[('X-Forwarded-Host', 'http://www.example.test')])
+            '/',
+            headers=[('X-Forwarded-Host', 'http://www.example.test')],
+        )
         self.assertHeader('Location', 'http://www.example.test/dummy')
         self.getPage('/', headers=[('X-Forwarded-Host', 'www.example.test')])
-        self.assertHeader('Location', '%s://www.example.test/dummy' %
-                          self.scheme)
+        self.assertHeader(
+            'Location',
+            '%s://www.example.test/dummy' % self.scheme,
+        )
         # Test multiple X-Forwarded-Host headers
-        self.getPage('/', headers=[
-            ('X-Forwarded-Host', 'http://www.example.test, www.cherrypy.test'),
-        ])
+        self.getPage(
+            '/',
+            headers=[
+                (
+                    'X-Forwarded-Host',
+                    'http://www.example.test, www.cherrypy.test',
+                ),
+            ],
+        )
         self.assertHeader('Location', 'http://www.example.test/dummy')
 
         # Test X-Forwarded-For (Apache2)
-        self.getPage('/remoteip',
-                     headers=[('X-Forwarded-For', '192.168.0.20')])
+        self.getPage(
+            '/remoteip',
+            headers=[('X-Forwarded-For', '192.168.0.20')],
+        )
         self.assertBody('192.168.0.20')
         # Fix bug #1268
-        self.getPage('/remoteip',
-                     headers=[
-                         ('X-Forwarded-For', '67.15.36.43, 192.168.0.20')
-                     ])
+        self.getPage(
+            '/remoteip',
+            headers=[('X-Forwarded-For', '67.15.36.43, 192.168.0.20')],
+        )
         self.assertBody('67.15.36.43')
 
         # Test X-Host (lighttpd; see https://trac.lighttpd.net/trac/ticket/418)
         self.getPage('/xhost', headers=[('X-Host', 'www.example.test')])
-        self.assertHeader('Location', '%s://www.example.test/blah' %
-                          self.scheme)
+        self.assertHeader(
+            'Location',
+            '%s://www.example.test/blah' % self.scheme,
+        )
 
         # Test X-Forwarded-Proto (lighttpd)
         self.getPage('/base', headers=[('X-Forwarded-Proto', 'https')])
@@ -116,12 +137,19 @@ def testProxy(self):
             # Test the value inside requests
             self.getPage(sn + '/newurl')
             self.assertBody(
-                "Browse to <a href='%s://www.mydomain.test" % self.scheme +
-                sn + "/this/new/page'>this page</a>.")
-            self.getPage(sn + '/newurl', headers=[('X-Forwarded-Host',
-                                                   'http://www.example.test')])
-            self.assertBody("Browse to <a href='http://www.example.test" +
-                            sn + "/this/new/page'>this page</a>.")
+                "Browse to <a href='%s://www.mydomain.test" % self.scheme
+                + sn
+                + "/this/new/page'>this page</a>.",
+            )
+            self.getPage(
+                sn + '/newurl',
+                headers=[('X-Forwarded-Host', 'http://www.example.test')],
+            )
+            self.assertBody(
+                "Browse to <a href='http://www.example.test"
+                + sn
+                + "/this/new/page'>this page</a>.",
+            )
 
             # Test the value outside requests
             port = ''
@@ -132,17 +160,24 @@ def testProxy(self):
             host = self.HOST
             if host in ('0.0.0.0', '::'):
                 import socket
+
                 host = socket.gethostname()
-            expected = ('%s://%s%s%s/this/new/page'
-                        % (self.scheme, host, port, sn))
+            expected = '%s://%s%s%s/this/new/page' % (
+                self.scheme,
+                host,
+                port,
+                sn,
+            )
             self.getPage(sn + '/pageurl')
             self.assertBody(expected)
 
         # Test trailing slash (see
         # https://github.com/cherrypy/cherrypy/issues/562).
         self.getPage('/xhost/', headers=[('X-Host', 'www.example.test')])
-        self.assertHeader('Location', '%s://www.example.test/xhost'
-                          % self.scheme)
+        self.assertHeader(
+            'Location',
+            '%s://www.example.test/xhost' % self.scheme,
+        )
 
     def test_no_base_port_in_host(self):
         """
diff --git a/cherrypy/test/test_refleaks.py b/cherrypy/test/test_refleaks.py
index 958136790..1aad30096 100644
--- a/cherrypy/test/test_refleaks.py
+++ b/cherrypy/test/test_refleaks.py
@@ -5,8 +5,10 @@
 import threading
 from http.client import HTTPConnection
 
+import pytest
+
 import cherrypy
-from cherrypy._cpcompat import HTTPSConnection
+from cherrypy._cpcompat import HTTPSConnection, IS_PYPY
 from cherrypy.test import helper
 
 
@@ -14,12 +16,9 @@
 
 
 class ReferenceTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         class Root:
-
             @cherrypy.expose
             def index(self, *args, **kwargs):
                 cherrypy.request.thing = data
@@ -27,6 +26,8 @@ def index(self, *args, **kwargs):
 
         cherrypy.tree.mount(Root())
 
+    # FIXME: This test is unstable on platforms with custom GC, like PyPy.
+    @pytest.mark.flaky(reruns=3, reruns_delay=2, condition=IS_PYPY)
     def test_threadlocal_garbage(self):
         if platform.system() == 'Darwin':
             self.skip('queue issues; see #1474')
@@ -51,10 +52,7 @@ def getpage():
 
         ITERATIONS = 25
 
-        ts = [
-            threading.Thread(target=getpage)
-            for _ in range(ITERATIONS)
-        ]
+        ts = [threading.Thread(target=getpage) for _ in range(ITERATIONS)]
 
         for t in ts:
             t.start()
diff --git a/cherrypy/test/test_request_obj.py b/cherrypy/test/test_request_obj.py
index 31023e8fc..8c279a6d0 100644
--- a/cherrypy/test/test_request_obj.py
+++ b/cherrypy/test/test_request_obj.py
@@ -14,19 +14,26 @@
 
 localDir = os.path.dirname(__file__)
 
-defined_http_methods = ('OPTIONS', 'GET', 'HEAD', 'POST', 'PUT', 'DELETE',
-                        'TRACE', 'PROPFIND', 'PATCH')
+defined_http_methods = (
+    'OPTIONS',
+    'GET',
+    'HEAD',
+    'POST',
+    'PUT',
+    'DELETE',
+    'TRACE',
+    'PROPFIND',
+    'PATCH',
+)
 
 
 #                             Client-side code                             #
 
 
 class RequestObjectTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'hello'
@@ -64,21 +71,21 @@ class TestType(type):
             subclass, and adds an instance of the subclass as an attribute
             of root.
             """
+
             def __init__(cls, name, bases, dct):
                 type.__init__(cls, name, bases, dct)
                 for value in dct.values():
                     if isinstance(value, types.FunctionType):
                         value.exposed = True
                 setattr(root, name.lower(), cls())
+
         Test = TestType('Test', (object,), {})
 
         class PathInfo(Test):
-
             def default(self, *args):
                 return cherrypy.request.path_info
 
         class Params(Test):
-
             def index(self, thing):
                 return repr(thing)
 
@@ -91,7 +98,6 @@ def default(self, *args, **kwargs):
 
         @cherrypy.expose
         class ParamErrorsCallable(object):
-
             def __call__(self):
                 return 'data'
 
@@ -99,10 +105,10 @@ def handler_dec(f):
             @wraps(f)
             def wrapper(handler, *args, **kwargs):
                 return f(handler, *args, **kwargs)
+
             return wrapper
 
         class ParamErrors(Test):
-
             @cherrypy.expose
             def one_positional(self, param1):
                 return 'data'
@@ -152,25 +158,34 @@ def raise_type_error_decorated(self, *args, **kwargs):
 
         def callable_error_page(status, **kwargs):
             return "Error %s - Well, I'm very sorry but you haven't paid!" % (
-                status)
+                status
+            )
 
         @cherrypy.config(**{'tools.log_tracebacks.on': True})
         class Error(Test):
-
             def reason_phrase(self):
                 raise cherrypy.HTTPError("410 Gone fishin'")
 
-            @cherrypy.config(**{
-                'error_page.404': os.path.join(localDir, 'static/index.html'),
-                'error_page.401': callable_error_page,
-            })
+            @cherrypy.config(
+                **{
+                    'error_page.404': os.path.join(
+                        localDir,
+                        'static/index.html',
+                    ),
+                    'error_page.401': callable_error_page,
+                },
+            )
             def custom(self, err='404'):
                 raise cherrypy.HTTPError(
-                    int(err), 'No, <b>really</b>, not found!')
+                    int(err),
+                    'No, <b>really</b>, not found!',
+                )
 
-            @cherrypy.config(**{
-                'error_page.default': callable_error_page,
-            })
+            @cherrypy.config(
+                **{
+                    'error_page.default': callable_error_page,
+                },
+            )
             def custom_default(self):
                 return 1 + 'a'  # raise an unexpected error
 
@@ -204,7 +219,6 @@ def rethrow(self):
                 raise ValueError()
 
         class Expect(Test):
-
             def expectation_failed(self):
                 expect = cherrypy.request.headers.elements('Expect')
                 if expect and expect[0].value != '100-continue':
@@ -212,7 +226,6 @@ def expectation_failed(self):
                 raise cherrypy.HTTPError(417, 'Expectation Failed')
 
         class Headers(Test):
-
             def default(self, headername):
                 """Spit back out the value for the requested header."""
                 return cherrypy.request.headers[headername]
@@ -229,10 +242,11 @@ def doubledheaders(self):
                 hMap['content-type'] = 'text/html'
                 hMap['content-length'] = 18
                 hMap['server'] = 'CherryPy headertest'
-                hMap['location'] = ('%s://%s:%s/headers/'
-                                    % (cherrypy.request.local.ip,
-                                       cherrypy.request.local.port,
-                                       cherrypy.request.scheme))
+                hMap['location'] = '%s://%s:%s/headers/' % (
+                    cherrypy.request.local.ip,
+                    cherrypy.request.local.port,
+                    cherrypy.request.scheme,
+                )
 
                 # Set a rare header for fun
                 hMap['Expires'] = 'Thu, 01 Dec 2194 16:00:00 GMT'
@@ -246,13 +260,11 @@ def ifmatch(self):
                 return val
 
         class HeaderElements(Test):
-
             def get_elements(self, headername):
                 e = cherrypy.request.headers.elements(headername)
                 return '\n'.join([str(x) for x in e])
 
         class Method(Test):
-
             def index(self):
                 m = cherrypy.request.method
                 if m in defined_http_methods or m == 'CONNECT':
@@ -275,7 +287,6 @@ def reachable(self):
                 return 'success'
 
         class Divorce(Test):
-
             """HTTP Method handlers shouldn't collide with normal method names.
             For example, a GET-handler shouldn't collide with a method named
             'get'.
@@ -295,16 +306,18 @@ def index(self):
                 for id, contents in self.documents.items():
                     yield (
                         "    <li><a href='/divorce/get?ID=%s'>%s</a>:"
-                        ' %s</li>\n' % (id, id, contents))
+                        ' %s</li>\n' % (id, id, contents)
+                    )
                 yield '</ul>'
 
             @cherrypy.expose
             def get(self, ID):
-                return ('Divorce document %s: %s' %
-                        (ID, self.documents.get(ID, 'empty')))
+                return 'Divorce document %s: %s' % (
+                    ID,
+                    self.documents.get(ID, 'empty'),
+                )
 
         class ThreadLocal(Test):
-
             def index(self):
                 existing = repr(getattr(cherrypy.request, 'asdf', None))
                 cherrypy.request.asdf = 'rassfrassin'
@@ -312,8 +325,12 @@ def index(self):
 
         appconf = {
             '/method': {
-                'request.methods_with_bodies': ('POST', 'PUT', 'PROPFIND',
-                                                'PATCH')
+                'request.methods_with_bodies': (
+                    'POST',
+                    'PUT',
+                    'PROPFIND',
+                    'PATCH',
+                ),
             },
         }
         cherrypy.tree.mount(root, config=appconf)
@@ -325,16 +342,16 @@ def test_scheme(self):
     def test_per_request_uuid4(self):
         self.getPage('/request_uuid4')
         first_uuid4, _, second_uuid4 = self.body.decode().partition(' ')
-        assert (
-            uuid.UUID(first_uuid4, version=4)
-            == uuid.UUID(second_uuid4, version=4)
+        assert uuid.UUID(first_uuid4, version=4) == uuid.UUID(
+            second_uuid4,
+            version=4,
         )
 
         self.getPage('/request_uuid4')
         third_uuid4, _, _ = self.body.decode().partition(' ')
-        assert (
-            uuid.UUID(first_uuid4, version=4)
-            != uuid.UUID(third_uuid4, version=4)
+        assert uuid.UUID(first_uuid4, version=4) != uuid.UUID(
+            third_uuid4,
+            version=4,
         )
 
     def testRelativeURIPathInfo(self):
@@ -342,7 +359,7 @@ def testRelativeURIPathInfo(self):
         self.assertBody('/pathinfo/foo/bar')
 
     def testAbsoluteURIPathInfo(self):
-        # http://cherrypy.org/ticket/1061
+        # http://cherrypy.dev/ticket/1061
         self.getPage('http://localhost/pathinfo/foo/bar')
         self.assertBody('/pathinfo/foo/bar')
 
@@ -369,16 +386,25 @@ def testParams(self):
 
         # Test "% HEX HEX"-encoded URL, param keys, and values
         self.getPage('/params/%d4%20%e3/cheese?Gruy%E8re=Bulgn%e9ville')
-        self.assertBody('args: %s kwargs: %s' %
-                        (('\xd4 \xe3', 'cheese'),
-                         [('Gruy\xe8re', ntou('Bulgn\xe9ville'))]))
+        self.assertBody(
+            'args: %s kwargs: %s'
+            % (
+                ('\xd4 \xe3', 'cheese'),
+                [('Gruy\xe8re', ntou('Bulgn\xe9ville'))],
+            ),
+        )
 
         # Make sure that encoded = and & get parsed correctly
         self.getPage(
-            '/params/code?url=http%3A//cherrypy.org/index%3Fa%3D1%26b%3D2')
-        self.assertBody('args: %s kwargs: %s' %
-                        (('code',),
-                         [('url', ntou('http://cherrypy.org/index?a=1&b=2'))]))
+            '/params/code?url=http%3A//cherrypy.dev/index%3Fa%3D1%26b%3D2',
+        )
+        self.assertBody(
+            'args: %s kwargs: %s'
+            % (
+                ('code',),
+                [('url', ntou('http://cherrypy.dev/index?a=1&b=2'))],
+            ),
+        )
 
         # Test coordinates sent by <img ismap>
         self.getPage('/params/ismap?223,114')
@@ -386,40 +412,46 @@ def testParams(self):
 
         # Test "name[key]" dict-like params
         self.getPage('/params/dictlike?a[1]=1&a[2]=2&b=foo&b[bar]=baz')
-        self.assertBody('args: %s kwargs: %s' %
-                        (('dictlike',),
-                         [('a[1]', ntou('1')), ('a[2]', ntou('2')),
-                          ('b', ntou('foo')), ('b[bar]', ntou('baz'))]))
+        self.assertBody(
+            'args: %s kwargs: %s'
+            % (
+                ('dictlike',),
+                [
+                    ('a[1]', ntou('1')),
+                    ('a[2]', ntou('2')),
+                    ('b', ntou('foo')),
+                    ('b[bar]', ntou('baz')),
+                ],
+            ),
+        )
 
     def testParamErrors(self):
-
         # test that all of the handlers work when given
         # the correct parameters in order to ensure that the
         # errors below aren't coming from some other source.
         for uri in (
-                '/paramerrors/one_positional?param1=foo',
-                '/paramerrors/one_positional_args?param1=foo',
-                '/paramerrors/one_positional_args/foo',
-                '/paramerrors/one_positional_args/foo/bar/baz',
-                '/paramerrors/one_positional_args_kwargs?'
-                'param1=foo&param2=bar',
-                '/paramerrors/one_positional_args_kwargs/foo?'
-                'param2=bar&param3=baz',
-                '/paramerrors/one_positional_args_kwargs/foo/bar/baz?'
-                'param2=bar&param3=baz',
-                '/paramerrors/one_positional_kwargs?'
-                'param1=foo&param2=bar&param3=baz',
-                '/paramerrors/one_positional_kwargs/foo?'
-                'param4=foo&param2=bar&param3=baz',
-                '/paramerrors/no_positional',
-                '/paramerrors/no_positional_args/foo',
-                '/paramerrors/no_positional_args/foo/bar/baz',
-                '/paramerrors/no_positional_args_kwargs?param1=foo&param2=bar',
-                '/paramerrors/no_positional_args_kwargs/foo?param2=bar',
-                '/paramerrors/no_positional_args_kwargs/foo/bar/baz?'
-                'param2=bar&param3=baz',
-                '/paramerrors/no_positional_kwargs?param1=foo&param2=bar',
-                '/paramerrors/callable_object',
+            '/paramerrors/one_positional?param1=foo',
+            '/paramerrors/one_positional_args?param1=foo',
+            '/paramerrors/one_positional_args/foo',
+            '/paramerrors/one_positional_args/foo/bar/baz',
+            '/paramerrors/one_positional_args_kwargs?param1=foo&param2=bar',
+            '/paramerrors/one_positional_args_kwargs/foo?'
+            'param2=bar&param3=baz',
+            '/paramerrors/one_positional_args_kwargs/foo/bar/baz?'
+            'param2=bar&param3=baz',
+            '/paramerrors/one_positional_kwargs?'
+            'param1=foo&param2=bar&param3=baz',
+            '/paramerrors/one_positional_kwargs/foo?'
+            'param4=foo&param2=bar&param3=baz',
+            '/paramerrors/no_positional',
+            '/paramerrors/no_positional_args/foo',
+            '/paramerrors/no_positional_args/foo/bar/baz',
+            '/paramerrors/no_positional_args_kwargs?param1=foo&param2=bar',
+            '/paramerrors/no_positional_args_kwargs/foo?param2=bar',
+            '/paramerrors/no_positional_args_kwargs/foo/bar/baz?'
+            'param2=bar&param3=baz',
+            '/paramerrors/no_positional_kwargs?param1=foo&param2=bar',
+            '/paramerrors/callable_object',
         ):
             self.getPage(uri)
             self.assertStatus(200)
@@ -450,29 +482,42 @@ def testParamErrors(self):
             ('/paramerrors/one_positional?foo=foo', error_msgs[0]),
             ('/paramerrors/one_positional/foo/bar/baz', error_msgs[1]),
             ('/paramerrors/one_positional/foo?param1=foo', error_msgs[2]),
-            ('/paramerrors/one_positional/foo?param1=foo&param2=foo',
-             error_msgs[2]),
-            ('/paramerrors/one_positional_args/foo?param1=foo&param2=foo',
-             error_msgs[2]),
-            ('/paramerrors/one_positional_args/foo/bar/baz?param2=foo',
-             error_msgs[3]),
-            ('/paramerrors/one_positional_args_kwargs/foo/bar/baz?'
-             'param1=bar&param3=baz',
-             error_msgs[2]),
-            ('/paramerrors/one_positional_kwargs/foo?'
-             'param1=foo&param2=bar&param3=baz',
-             error_msgs[2]),
+            (
+                '/paramerrors/one_positional/foo?param1=foo&param2=foo',
+                error_msgs[2],
+            ),
+            (
+                '/paramerrors/one_positional_args/foo?param1=foo&param2=foo',
+                error_msgs[2],
+            ),
+            (
+                '/paramerrors/one_positional_args/foo/bar/baz?param2=foo',
+                error_msgs[3],
+            ),
+            (
+                '/paramerrors/one_positional_args_kwargs/foo/bar/baz?'
+                'param1=bar&param3=baz',
+                error_msgs[2],
+            ),
+            (
+                '/paramerrors/one_positional_kwargs/foo?'
+                'param1=foo&param2=bar&param3=baz',
+                error_msgs[2],
+            ),
             ('/paramerrors/no_positional/boo', error_msgs[1]),
             ('/paramerrors/no_positional?param1=foo', error_msgs[3]),
             ('/paramerrors/no_positional_args/boo?param1=foo', error_msgs[3]),
-            ('/paramerrors/no_positional_kwargs/boo?param1=foo',
-             error_msgs[1]),
+            (
+                '/paramerrors/no_positional_kwargs/boo?param1=foo',
+                error_msgs[1],
+            ),
             ('/paramerrors/callable_object?param1=foo', error_msgs[3]),
             ('/paramerrors/callable_object/boo', error_msgs[1]),
         ):
             for show_mismatched_params in (True, False):
                 cherrypy.config.update(
-                    {'request.show_mismatched_params': show_mismatched_params})
+                    {'request.show_mismatched_params': show_mismatched_params},
+                )
                 self.getPage(uri)
                 self.assertStatus(404)
                 if show_mismatched_params:
@@ -482,26 +527,44 @@ def testParamErrors(self):
 
         # if body parameters are wrong, a 400 must be returned.
         for uri, body, msg in (
-                ('/paramerrors/one_positional/foo',
-                 'param1=foo', error_msgs[2]),
-                ('/paramerrors/one_positional/foo',
-                 'param1=foo&param2=foo', error_msgs[2]),
-                ('/paramerrors/one_positional_args/foo',
-                 'param1=foo&param2=foo', error_msgs[2]),
-                ('/paramerrors/one_positional_args/foo/bar/baz',
-                 'param2=foo', error_msgs[4]),
-                ('/paramerrors/one_positional_args_kwargs/foo/bar/baz',
-                 'param1=bar&param3=baz', error_msgs[2]),
-                ('/paramerrors/one_positional_kwargs/foo',
-                 'param1=foo&param2=bar&param3=baz', error_msgs[2]),
-                ('/paramerrors/no_positional', 'param1=foo', error_msgs[4]),
-                ('/paramerrors/no_positional_args/boo',
-                 'param1=foo', error_msgs[4]),
-                ('/paramerrors/callable_object', 'param1=foo', error_msgs[4]),
+            ('/paramerrors/one_positional/foo', 'param1=foo', error_msgs[2]),
+            (
+                '/paramerrors/one_positional/foo',
+                'param1=foo&param2=foo',
+                error_msgs[2],
+            ),
+            (
+                '/paramerrors/one_positional_args/foo',
+                'param1=foo&param2=foo',
+                error_msgs[2],
+            ),
+            (
+                '/paramerrors/one_positional_args/foo/bar/baz',
+                'param2=foo',
+                error_msgs[4],
+            ),
+            (
+                '/paramerrors/one_positional_args_kwargs/foo/bar/baz',
+                'param1=bar&param3=baz',
+                error_msgs[2],
+            ),
+            (
+                '/paramerrors/one_positional_kwargs/foo',
+                'param1=foo&param2=bar&param3=baz',
+                error_msgs[2],
+            ),
+            ('/paramerrors/no_positional', 'param1=foo', error_msgs[4]),
+            (
+                '/paramerrors/no_positional_args/boo',
+                'param1=foo',
+                error_msgs[4],
+            ),
+            ('/paramerrors/callable_object', 'param1=foo', error_msgs[4]),
         ):
             for show_mismatched_params in (True, False):
                 cherrypy.config.update(
-                    {'request.show_mismatched_params': show_mismatched_params})
+                    {'request.show_mismatched_params': show_mismatched_params},
+                )
                 self.getPage(uri, method='POST', body=body)
                 self.assertStatus(400)
                 if show_mismatched_params:
@@ -512,24 +575,46 @@ def testParamErrors(self):
         # even if body parameters are wrong, if we get the uri wrong, then
         # it's a 404
         for uri, body, msg in (
-                ('/paramerrors/one_positional?param2=foo',
-                 'param1=foo', error_msgs[3]),
-                ('/paramerrors/one_positional/foo/bar',
-                 'param2=foo', error_msgs[1]),
-                ('/paramerrors/one_positional_args/foo/bar?param2=foo',
-                 'param3=foo', error_msgs[3]),
-                ('/paramerrors/one_positional_kwargs/foo/bar',
-                 'param2=bar&param3=baz', error_msgs[1]),
-                ('/paramerrors/no_positional?param1=foo',
-                 'param2=foo', error_msgs[3]),
-                ('/paramerrors/no_positional_args/boo?param2=foo',
-                 'param1=foo', error_msgs[3]),
-                ('/paramerrors/callable_object?param2=bar',
-                 'param1=foo', error_msgs[3]),
+            (
+                '/paramerrors/one_positional?param2=foo',
+                'param1=foo',
+                error_msgs[3],
+            ),
+            (
+                '/paramerrors/one_positional/foo/bar',
+                'param2=foo',
+                error_msgs[1],
+            ),
+            (
+                '/paramerrors/one_positional_args/foo/bar?param2=foo',
+                'param3=foo',
+                error_msgs[3],
+            ),
+            (
+                '/paramerrors/one_positional_kwargs/foo/bar',
+                'param2=bar&param3=baz',
+                error_msgs[1],
+            ),
+            (
+                '/paramerrors/no_positional?param1=foo',
+                'param2=foo',
+                error_msgs[3],
+            ),
+            (
+                '/paramerrors/no_positional_args/boo?param2=foo',
+                'param1=foo',
+                error_msgs[3],
+            ),
+            (
+                '/paramerrors/callable_object?param2=bar',
+                'param1=foo',
+                error_msgs[3],
+            ),
         ):
             for show_mismatched_params in (True, False):
                 cherrypy.config.update(
-                    {'request.show_mismatched_params': show_mismatched_params})
+                    {'request.show_mismatched_params': show_mismatched_params},
+                )
                 self.getPage(uri, method='POST', body=body)
                 self.assertStatus(404)
                 if show_mismatched_params:
@@ -540,10 +625,10 @@ def testParamErrors(self):
         # In the case that a handler raises a TypeError we should
         # let that type error through.
         for uri in (
-                '/paramerrors/raise_type_error',
-                '/paramerrors/raise_type_error_with_default_param?x=0',
-                '/paramerrors/raise_type_error_with_default_param?x=0&y=0',
-                '/paramerrors/raise_type_error_decorated',
+            '/paramerrors/raise_type_error',
+            '/paramerrors/raise_type_error_with_default_param?x=0',
+            '/paramerrors/raise_type_error_with_default_param?x=0&y=0',
+            '/paramerrors/raise_type_error_decorated',
         ):
             self.getPage(uri, method='GET')
             self.assertStatus(500)
@@ -564,8 +649,11 @@ def testErrorHandling(self):
             self.getPage('/error/page_yield')
             self.assertErrorPage(500, pattern=valerr)
 
-            if (cherrypy.server.protocol_version == 'HTTP/1.0' or
-                    getattr(cherrypy.server, 'using_apache', False)):
+            if cherrypy.server.protocol_version == 'HTTP/1.0' or getattr(
+                cherrypy.server,
+                'using_apache',
+                False,
+            ):
                 self.getPage('/error/page_streamed')
                 # Because this error is raised after the response body has
                 # started, the status should not change to an error status.
@@ -574,8 +662,11 @@ def testErrorHandling(self):
             else:
                 # Under HTTP/1.1, the chunked transfer-coding is used.
                 # The HTTP client will choke when the output is incomplete.
-                self.assertRaises((ValueError, IncompleteRead), self.getPage,
-                                  '/error/page_streamed')
+                self.assertRaises(
+                    (ValueError, IncompleteRead),
+                    self.getPage,
+                    '/error/page_streamed',
+                )
 
             # No traceback should be present
             self.getPage('/error/cause_err_in_finalize')
@@ -598,14 +689,16 @@ def testErrorHandling(self):
         self.assertStatus(401)
         self.assertBody(
             'Error 401 Unauthorized - '
-            "Well, I'm very sorry but you haven't paid!")
+            "Well, I'm very sorry but you haven't paid!",
+        )
 
         # Test default custom error page.
         self.getPage('/error/custom_default')
         self.assertStatus(500)
         self.assertBody(
             'Error 500 Internal Server Error - '
-            "Well, I'm very sorry but you haven't paid!".ljust(513))
+            "Well, I'm very sorry but you haven't paid!".ljust(513),
+        )
 
         # Test error in custom error page (ticket #305).
         # Note that the message is escaped for HTML (ticket #310).
@@ -615,10 +708,12 @@ def testErrorHandling(self):
             exc_name = 'FileNotFoundError'
         else:
             exc_name = 'IOError'
-        msg = ('No, &lt;b&gt;really&lt;/b&gt;, not found!<br />'
-               'In addition, the custom error page failed:\n<br />'
-               '%s: [Errno 2] '
-               "No such file or directory: 'nonexistent.html'") % (exc_name,)
+        msg = (
+            'No, &lt;b&gt;really&lt;/b&gt;, not found!<br />'
+            'In addition, the custom error page failed:\n<br />'
+            '%s: [Errno 2] '
+            "No such file or directory: 'nonexistent.html'"
+        ) % (exc_name,)
         self.assertInBody(msg)
 
         if getattr(cherrypy.server, 'using_apache', False):
@@ -641,98 +736,114 @@ def testHeaderElements(self):
         h = [('Accept', 'audio/*; q=0.2, audio/basic')]
         self.getPage('/headerelements/get_elements?headername=Accept', h)
         self.assertStatus(200)
-        self.assertBody('audio/basic\n'
-                        'audio/*;q=0.2')
+        self.assertBody('audio/basic\naudio/*;q=0.2')
 
         h = [
-            ('Accept',
-             'text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c')
+            (
+                'Accept',
+                'text/plain; q=0.5, text/html, text/x-dvi; q=0.8, text/x-c',
+            ),
         ]
         self.getPage('/headerelements/get_elements?headername=Accept', h)
         self.assertStatus(200)
-        self.assertBody('text/x-c\n'
-                        'text/html\n'
-                        'text/x-dvi;q=0.8\n'
-                        'text/plain;q=0.5')
+        self.assertBody(
+            'text/x-c\ntext/html\ntext/x-dvi;q=0.8\ntext/plain;q=0.5',
+        )
 
         # Test that more specific media ranges get priority.
         h = [('Accept', 'text/*, text/html, text/html;level=1, */*')]
         self.getPage('/headerelements/get_elements?headername=Accept', h)
         self.assertStatus(200)
-        self.assertBody('text/html;level=1\n'
-                        'text/html\n'
-                        'text/*\n'
-                        '*/*')
+        self.assertBody('text/html;level=1\ntext/html\ntext/*\n*/*')
 
         # Test Accept-Charset
         h = [('Accept-Charset', 'iso-8859-5, unicode-1-1;q=0.8')]
         self.getPage(
-            '/headerelements/get_elements?headername=Accept-Charset', h)
+            '/headerelements/get_elements?headername=Accept-Charset',
+            h,
+        )
         self.assertStatus('200 OK')
-        self.assertBody('iso-8859-5\n'
-                        'unicode-1-1;q=0.8')
+        self.assertBody('iso-8859-5\nunicode-1-1;q=0.8')
 
         # Test Accept-Encoding
         h = [('Accept-Encoding', 'gzip;q=1.0, identity; q=0.5, *;q=0')]
         self.getPage(
-            '/headerelements/get_elements?headername=Accept-Encoding', h)
+            '/headerelements/get_elements?headername=Accept-Encoding',
+            h,
+        )
         self.assertStatus('200 OK')
-        self.assertBody('gzip;q=1.0\n'
-                        'identity;q=0.5\n'
-                        '*;q=0')
+        self.assertBody('gzip;q=1.0\nidentity;q=0.5\n*;q=0')
 
         # Test Accept-Language
         h = [('Accept-Language', 'da, en-gb;q=0.8, en;q=0.7')]
         self.getPage(
-            '/headerelements/get_elements?headername=Accept-Language', h)
+            '/headerelements/get_elements?headername=Accept-Language',
+            h,
+        )
         self.assertStatus('200 OK')
-        self.assertBody('da\n'
-                        'en-gb;q=0.8\n'
-                        'en;q=0.7')
+        self.assertBody('da\nen-gb;q=0.8\nen;q=0.7')
 
         # Test malformed header parsing. See
         # https://github.com/cherrypy/cherrypy/issues/763.
-        self.getPage('/headerelements/get_elements?headername=Content-Type',
-                     # Note the illegal trailing ";"
-                     headers=[('Content-Type', 'text/html; charset=utf-8;')])
+        self.getPage(
+            '/headerelements/get_elements?headername=Content-Type',
+            # Note the illegal trailing ";"
+            headers=[('Content-Type', 'text/html; charset=utf-8;')],
+        )
         self.assertStatus(200)
         self.assertBody('text/html;charset=utf-8')
 
     def test_repeated_headers(self):
         # Test that two request headers are collapsed into one.
         # See https://github.com/cherrypy/cherrypy/issues/542.
-        self.getPage('/headers/Accept-Charset',
-                     headers=[('Accept-Charset', 'iso-8859-5'),
-                              ('Accept-Charset', 'unicode-1-1;q=0.8')])
+        self.getPage(
+            '/headers/Accept-Charset',
+            headers=[
+                ('Accept-Charset', 'iso-8859-5'),
+                ('Accept-Charset', 'unicode-1-1;q=0.8'),
+            ],
+        )
         self.assertBody('iso-8859-5, unicode-1-1;q=0.8')
 
         # Tests that each header only appears once, regardless of case.
         self.getPage('/headers/doubledheaders')
         self.assertBody('double header test')
         hnames = [name.title() for name, val in self.headers]
-        for key in ['Content-Length', 'Content-Type', 'Date',
-                    'Expires', 'Location', 'Server']:
+        for key in [
+            'Content-Length',
+            'Content-Type',
+            'Date',
+            'Expires',
+            'Location',
+            'Server',
+        ]:
             self.assertEqual(hnames.count(key), 1, self.headers)
 
     def test_encoded_headers(self):
         # First, make sure the innards work like expected.
         self.assertEqual(
-            httputil.decode_TEXT(ntou('=?utf-8?q?f=C3=BCr?=')), ntou('f\xfcr'))
+            httputil.decode_TEXT(ntou('=?utf-8?q?f=C3=BCr?=')),
+            ntou('f\xfcr'),
+        )
 
         if cherrypy.server.protocol_version == 'HTTP/1.1':
             # Test RFC-2047-encoded request and response header values
             u = ntou('\u212bngstr\xf6m', 'escape')
             c = ntou('=E2=84=ABngstr=C3=B6m')
-            self.getPage('/headers/ifmatch',
-                         [('If-Match', ntou('=?utf-8?q?%s?=') % c)])
+            self.getPage(
+                '/headers/ifmatch',
+                [('If-Match', ntou('=?utf-8?q?%s?=') % c)],
+            )
             # The body should be utf-8 encoded.
             self.assertBody(b'\xe2\x84\xabngstr\xc3\xb6m')
             # But the Etag header should be RFC-2047 encoded (binary)
             self.assertHeader('ETag', ntou('=?utf-8?b?4oSrbmdzdHLDtm0=?='))
 
             # Test a *LONG* RFC-2047-encoded request and response header value
-            self.getPage('/headers/ifmatch',
-                         [('If-Match', ntou('=?utf-8?q?%s?=') % (c * 10))])
+            self.getPage(
+                '/headers/ifmatch',
+                [('If-Match', ntou('=?utf-8?q?%s?=') % (c * 10))],
+            )
             self.assertBody(b'\xe2\x84\xabngstr\xc3\xb6m' * 10)
             # Note: this is different output for Python3, but it decodes fine.
             etag = self.assertHeader(
@@ -740,25 +851,41 @@ def test_encoded_headers(self):
                 '=?utf-8?b?4oSrbmdzdHLDtm3ihKtuZ3N0csO2beKEq25nc3Ryw7Zt'
                 '4oSrbmdzdHLDtm3ihKtuZ3N0csO2beKEq25nc3Ryw7Zt'
                 '4oSrbmdzdHLDtm3ihKtuZ3N0csO2beKEq25nc3Ryw7Zt'
-                '4oSrbmdzdHLDtm0=?=')
+                '4oSrbmdzdHLDtm0=?=',
+            )
             self.assertEqual(httputil.decode_TEXT(etag), u * 10)
 
     def test_header_presence(self):
         # If we don't pass a Content-Type header, it should not be present
         # in cherrypy.request.headers
-        self.getPage('/headers/Content-Type',
-                     headers=[])
+        self.getPage('/headers/Content-Type', headers=[])
         self.assertStatus(500)
 
         # If Content-Type is present in the request, it should be present in
         # cherrypy.request.headers
-        self.getPage('/headers/Content-Type',
-                     headers=[('Content-type', 'application/json')])
+        self.getPage(
+            '/headers/Content-Type',
+            headers=[('Content-type', 'application/json')],
+        )
         self.assertBody('application/json')
 
+    def test_dangerous_host(self):
+        """Dangerous characters like newlines should be elided.
+
+        Ref #1974.
+        """
+        # foo\nbar
+        encoded = '=?iso-8859-1?q?foo=0Abar?='
+        self.getPage('/headers/Host', headers=[('Host', encoded)])
+        self.assertBody('foobar')
+
     def test_basic_HTTPMethods(self):
-        helper.webtest.methods_with_bodies = ('POST', 'PUT', 'PROPFIND',
-                                              'PATCH')
+        helper.webtest.methods_with_bodies = (
+            'POST',
+            'PUT',
+            'PROPFIND',
+            'PATCH',
+        )
 
         # Test that all defined HTTP methods work.
         for m in defined_http_methods:
@@ -775,14 +902,16 @@ def test_basic_HTTPMethods(self):
 
         # test of PATCH requests
         # Request a PATCH method with a form-urlencoded body
-        self.getPage('/method/parameterized', method='PATCH',
-                     body='data=on+top+of+other+things')
+        self.getPage(
+            '/method/parameterized',
+            method='PATCH',
+            body='data=on+top+of+other+things',
+        )
         self.assertBody('on top of other things')
 
         # Request a PATCH method with a file body
         b = 'one thing on top of another'
-        h = [('Content-Type', 'text/plain'),
-             ('Content-Length', str(len(b)))]
+        h = [('Content-Type', 'text/plain'), ('Content-Length', str(len(b)))]
         self.getPage('/method/request_body', headers=h, method='PATCH', body=b)
         self.assertStatus(200)
         self.assertBody(b)
@@ -815,14 +944,16 @@ def test_basic_HTTPMethods(self):
 
         # HTTP PUT tests
         # Request a PUT method with a form-urlencoded body
-        self.getPage('/method/parameterized', method='PUT',
-                     body='data=on+top+of+other+things')
+        self.getPage(
+            '/method/parameterized',
+            method='PUT',
+            body='data=on+top+of+other+things',
+        )
         self.assertBody('on top of other things')
 
         # Request a PUT method with a file body
         b = 'one thing on top of another'
-        h = [('Content-Type', 'text/plain'),
-             ('Content-Length', str(len(b)))]
+        h = [('Content-Type', 'text/plain'), ('Content-Length', str(len(b)))]
         self.getPage('/method/request_body', headers=h, method='PUT', body=b)
         self.assertStatus(200)
         self.assertBody(b)
@@ -854,13 +985,18 @@ def test_basic_HTTPMethods(self):
         self.assertStatus(411)
 
         # Request a custom method with a request body
-        b = ('<?xml version="1.0" encoding="utf-8" ?>\n\n'
-             '<propfind xmlns="DAV:"><prop><getlastmodified/>'
-             '</prop></propfind>')
-        h = [('Content-Type', 'text/xml'),
-             ('Content-Length', str(len(b)))]
-        self.getPage('/method/request_body', headers=h,
-                     method='PROPFIND', body=b)
+        b = (
+            '<?xml version="1.0" encoding="utf-8" ?>\n\n'
+            '<propfind xmlns="DAV:"><prop><getlastmodified/>'
+            '</prop></propfind>'
+        )
+        h = [('Content-Type', 'text/xml'), ('Content-Length', str(len(b)))]
+        self.getPage(
+            '/method/request_body',
+            headers=h,
+            method='PROPFIND',
+            body=b,
+        )
         self.assertStatus(200)
         self.assertBody(b)
 
@@ -907,8 +1043,14 @@ def test_CONNECT_method(self):
             self.persistent = False
 
     def test_CONNECT_method_invalid_authority(self):
-        for request_target in ['example.com', 'http://example.com:33',
-                               '/path/', 'path/', '/?q=f', '#f']:
+        for request_target in [
+            'example.com',
+            'http://example.com:33',
+            '/path/',
+            'path/',
+            '/?q=f',
+            '#f',
+        ]:
             self.persistent = True
             try:
                 conn = self.HTTP_CONN
@@ -917,8 +1059,10 @@ def test_CONNECT_method_invalid_authority(self):
                 response.begin()
                 self.assertEqual(response.status, 400)
                 self.body = response.read()
-                self.assertBody(b'Invalid path in Request-URI: request-target '
-                                b'must match authority-form.')
+                self.assertBody(
+                    b'Invalid path in Request-URI: request-target '
+                    b'must match authority-form.',
+                )
             finally:
                 self.persistent = False
 
diff --git a/cherrypy/test/test_routes.py b/cherrypy/test/test_routes.py
index cc7147654..72dc49a5c 100644
--- a/cherrypy/test/test_routes.py
+++ b/cherrypy/test/test_routes.py
@@ -1,4 +1,5 @@
 """Test Routes dispatcher."""
+
 import os
 import importlib
 
@@ -22,22 +23,22 @@ def setup_server():
             pytest.skip('Install routes to test RoutesDispatcher code')
 
         class Dummy:
-
             def index(self):
                 return 'I said good day!'
 
         class City:
-
             def __init__(self, name):
                 self.name = name
                 self.population = 10000
 
-            @cherrypy.config(**{
-                'tools.response_headers.on': True,
-                'tools.response_headers.headers': [
-                    ('Content-Language', 'en-GB'),
-                ],
-            })
+            @cherrypy.config(
+                **{
+                    'tools.response_headers.on': True,
+                    'tools.response_headers.headers': [
+                        ('Content-Language', 'en-GB'),
+                    ],
+                },
+            )
             def index(self, **kwargs):
                 return 'Welcome to %s, pop. %s' % (self.name, self.population)
 
@@ -46,13 +47,25 @@ def update(self, **kwargs):
                 return 'OK'
 
         d = cherrypy.dispatch.RoutesDispatcher()
-        d.connect(action='index', name='hounslow', route='/hounslow',
-                  controller=City('Hounslow'))
         d.connect(
-            name='surbiton', route='/surbiton', controller=City('Surbiton'),
-            action='index', conditions=dict(method=['GET']))
-        d.mapper.connect('/surbiton', controller='surbiton',
-                         action='update', conditions=dict(method=['POST']))
+            action='index',
+            name='hounslow',
+            route='/hounslow',
+            controller=City('Hounslow'),
+        )
+        d.connect(
+            name='surbiton',
+            route='/surbiton',
+            controller=City('Surbiton'),
+            action='index',
+            conditions=dict(method=['GET']),
+        )
+        d.mapper.connect(
+            '/surbiton',
+            controller='surbiton',
+            action='update',
+            conditions=dict(method=['POST']),
+        )
         d.connect('main', ':action', controller=Dummy())
 
         conf = {'/': {'request.dispatch': d}}
diff --git a/cherrypy/test/test_session.py b/cherrypy/test/test_session.py
index 2d869e4bd..0cce9b4ea 100755
--- a/cherrypy/test/test_session.py
+++ b/cherrypy/test/test_session.py
@@ -4,7 +4,7 @@
 import time
 from http.client import HTTPConnection
 
-from distutils.spawn import find_executable
+from shutil import which
 import pytest
 from path import Path
 from more_itertools import consume
@@ -32,16 +32,16 @@ def http_methods_allowed(methods=['GET', 'HEAD']):
 
 
 def setup_server():
-
-    @cherrypy.config(**{
-        'tools.sessions.on': True,
-        'tools.sessions.storage_class': sessions.RamSession,
-        'tools.sessions.storage_path': localDir,
-        'tools.sessions.timeout': (1.0 / 60),
-        'tools.sessions.clean_freq': (1.0 / 60),
-    })
+    @cherrypy.config(
+        **{
+            'tools.sessions.on': True,
+            'tools.sessions.storage_class': sessions.RamSession,
+            'tools.sessions.storage_path': localDir,
+            'tools.sessions.timeout': (1.0 / 60),
+            'tools.sessions.clean_freq': (1.0 / 60),
+        },
+    )
     class Root:
-
         @cherrypy.expose
         def clear(self):
             cherrypy.session.cache.clear()
@@ -109,10 +109,12 @@ def iredir(self):
             raise cherrypy.InternalRedirect('/redir_target')
 
         @cherrypy.expose
-        @cherrypy.config(**{
-            'tools.allow.on': True,
-            'tools.allow.methods': ['GET'],
-        })
+        @cherrypy.config(
+            **{
+                'tools.allow.on': True,
+                'tools.allow.methods': ['GET'],
+            },
+        )
         def restricted(self):
             return cherrypy.request.method
 
@@ -126,11 +128,13 @@ def length(self):
             return str(len(cherrypy.session))
 
         @cherrypy.expose
-        @cherrypy.config(**{
-            'tools.sessions.path': '/session_cookie',
-            'tools.sessions.name': 'temp',
-            'tools.sessions.persistent': False,
-        })
+        @cherrypy.config(
+            **{
+                'tools.sessions.path': '/session_cookie',
+                'tools.sessions.name': 'temp',
+                'tools.sessions.persistent': False,
+            },
+        )
         def session_cookie(self):
             # Must load() to start the clean thread.
             cherrypy.session.load()
@@ -146,14 +150,16 @@ class SessionTest(helper.CPWebCase):
     def teardown_class(cls):
         """Clean up sessions."""
         super(cls, cls).teardown_class()
+        files_to_clean = localDir.iterdir()
+
         consume(
             file.remove_p()
-            for file in localDir.listdir()
-            if file.basename().startswith(
-                sessions.FileSession.SESSION_PREFIX
-            )
+            for file in files_to_clean
+            if file.basename().startswith(sessions.FileSession.SESSION_PREFIX)
         )
 
+    # FIXME: This test is unstable on slow envs like macOS
+    @pytest.mark.flaky(reruns=3, reruns_delay=2)
     def test_0_Session(self):
         self.getPage('/set_session_cls/cherrypy.lib.sessions.RamSession')
         self.getPage('/clear')
@@ -168,8 +174,9 @@ def test_0_Session(self):
 
         self.getPage('/testStr')
         assert self.body == b'1'
-        cookie_parts = dict([p.strip().split('=')
-                             for p in self.cookies[0][1].split(';')])
+        cookie_parts = dict(
+            [p.strip().split('=') for p in self.cookies[0][1].split(';')],
+        )
         # Assert there is an 'expires' param
         expected_cookie_keys = {'session_id', 'expires', 'Path', 'Max-Age'}
         assert set(cookie_parts.keys()) == expected_cookie_keys
@@ -224,6 +231,7 @@ def f():
                 for x in os.listdir(localDir)
                 if x.startswith('session-') and not x.endswith('.lock')
             ]
+
         assert f() == []
 
         # Wait for the cleanup thread to delete remaining session files
@@ -236,6 +244,9 @@ def test_1_Ram_Concurrency(self):
         self.getPage('/set_session_cls/cherrypy.lib.sessions.RamSession')
         self._test_Concurrency()
 
+    # FIXME: This test is unstable on slow envs like Windows.
+    # FIXME: It's possibly failing because of the slow fs scan.
+    @pytest.mark.flaky(reruns=3, reruns_delay=2)
     def test_2_File_Concurrency(self):
         self.getPage('/set_session_cls/cherrypy.lib.sessions.FileSession')
         self._test_Concurrency()
@@ -330,11 +341,16 @@ def test_6_regenerate(self):
         self.getPage('/testStr')
         # grab the cookie ID
         id1 = self.cookies[0][1].split(';', 1)[0].split('=', 1)[1]
-        self.getPage('/testStr',
-                     headers=[
-                         ('Cookie',
-                          'session_id=maliciousid; '
-                          'expires=Sat, 27 Oct 2017 04:18:28 GMT; Path=/;')])
+        self.getPage(
+            '/testStr',
+            headers=[
+                (
+                    'Cookie',
+                    'session_id=maliciousid; '
+                    'expires=Sat, 27 Oct 2017 04:18:28 GMT; Path=/;',
+                ),
+            ],
+        )
         id2 = self.cookies[0][1].split(';', 1)[0].split('=', 1)[1]
         assert id1 != id2
         assert id2 != 'maliciousid'
@@ -344,8 +360,9 @@ def test_7_session_cookies(self):
         self.getPage('/clear')
         self.getPage('/session_cookie')
         # grab the cookie ID
-        cookie_parts = dict([p.strip().split('=')
-                            for p in self.cookies[0][1].split(';')])
+        cookie_parts = dict(
+            [p.strip().split('=') for p in self.cookies[0][1].split(';')],
+        )
         # Assert there is no 'expires' param
         assert set(cookie_parts.keys()) == {'temp', 'Path'}
         id1 = cookie_parts['temp']
@@ -353,8 +370,9 @@ def test_7_session_cookies(self):
 
         # Send another request in the same "browser session".
         self.getPage('/session_cookie', self.cookies)
-        cookie_parts = dict([p.strip().split('=')
-                            for p in self.cookies[0][1].split(';')])
+        cookie_parts = dict(
+            [p.strip().split('=') for p in self.cookies[0][1].split(';')],
+        )
         # Assert there is no 'expires' param
         assert set(cookie_parts.keys()) == {'temp', 'Path'}
         assert self.body.decode('utf-8') == id1
@@ -363,8 +381,9 @@ def test_7_session_cookies(self):
         # Simulate a browser close by just not sending the cookies
         self.getPage('/session_cookie')
         # grab the cookie ID
-        cookie_parts = dict([p.strip().split('=')
-                            for p in self.cookies[0][1].split(';')])
+        cookie_parts = dict(
+            [p.strip().split('=') for p in self.cookies[0][1].split(';')],
+        )
         # Assert there is no 'expires' param
         assert set(cookie_parts.keys()) == {'temp', 'Path'}
         # Assert a new id has been generated...
@@ -402,7 +421,7 @@ def lock():
 
 
 def is_memcached_present():
-    executable = find_executable('memcached')
+    executable = which('memcached')
     return bool(executable)
 
 
@@ -418,9 +437,7 @@ def memcached_client_present():
 
 @pytest.fixture(scope='session')
 def memcached_instance(request, watcher_getter, memcached_server_present):
-    """
-    Start up an instance of memcached.
-    """
+    """Start up an instance of memcached."""
 
     port = portend.find_available_local_port()
 
@@ -442,7 +459,8 @@ def is_occupied():
 
 @pytest.fixture
 def memcached_configured(
-    memcached_instance, monkeypatch,
+    memcached_instance,
+    monkeypatch,
     memcached_client_present,
 ):
     server = 'localhost:{port}'.format_map(memcached_instance)
@@ -462,9 +480,7 @@ class MemcachedSessionTest(helper.CPWebCase):
     setup_server = staticmethod(setup_server)
 
     def test_0_Session(self):
-        self.getPage(
-            '/set_session_cls/cherrypy.lib.sessions.MemcachedSession'
-        )
+        self.getPage('/set_session_cls/cherrypy.lib.sessions.MemcachedSession')
 
         self.getPage('/testStr')
         assert self.body == b'1'
@@ -535,8 +551,7 @@ def test_3_Redirect(self):
 
     def test_5_Error_paths(self):
         self.getPage('/unknown/page')
-        self.assertErrorPage(
-            404, "The path '/unknown/page' was not found.")
+        self.assertErrorPage(404, "The path '/unknown/page' was not found.")
 
         # Note: this path is *not* the same as above. The above
         # takes a normal route through the session code; this one
diff --git a/cherrypy/test/test_sessionauthenticate.py b/cherrypy/test/test_sessionauthenticate.py
index 63053fcb7..480ed39ad 100644
--- a/cherrypy/test/test_sessionauthenticate.py
+++ b/cherrypy/test/test_sessionauthenticate.py
@@ -3,10 +3,8 @@
 
 
 class SessionAuthenticateTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         def check(username, password):
             # Dummy check_username_and_password function
             if username != 'test' or password != 'password':
@@ -19,10 +17,13 @@ def augment_params():
             cherrypy.request.params['test'] = 'test'
 
         cherrypy.tools.augment_params = cherrypy.Tool(
-            'before_handler', augment_params, None, priority=30)
+            'before_handler',
+            augment_params,
+            None,
+            priority=30,
+        )
 
         class Test:
-
             _cp_config = {
                 'tools.sessions.on': True,
                 'tools.session_auth.on': True,
diff --git a/cherrypy/test/test_states.py b/cherrypy/test/test_states.py
index 28dd65100..06fa74507 100644
--- a/cherrypy/test/test_states.py
+++ b/cherrypy/test/test_states.py
@@ -16,7 +16,6 @@
 
 
 class Dependency:
-
     def __init__(self, bus):
         self.bus = bus
         self.running = False
@@ -53,7 +52,6 @@ def stopthread(self, thread_id):
 
 def setup_server():
     class Root:
-
         @cherrypy.expose
         def index(self):
             return 'Hello World'
@@ -68,12 +66,15 @@ def graceful(self):
             return 'app was (gracefully) restarted succesfully'
 
     cherrypy.tree.mount(Root())
-    cherrypy.config.update({
-        'environment': 'test_suite',
-    })
+    cherrypy.config.update(
+        {
+            'environment': 'test_suite',
+        },
+    )
 
     db_connection.subscribe()
 
+
 # ------------ Enough helpers. Time for real live test cases. ------------ #
 
 
@@ -121,6 +122,7 @@ def exittest():
             self.getPage('/')
             self.assertBody('Hello World')
             engine.exit()
+
         cherrypy.server.start()
         engine.start_with_callback(exittest)
         engine.block()
@@ -220,12 +222,6 @@ def test_2_KeyboardInterrupt(self):
         self.assertEqual(db_connection.running, False)
         self.assertEqual(len(db_connection.threads), 0)
 
-    @pytest.mark.xfail(
-        'sys.platform == "Darwin" '
-        'and sys.version_info > (3, 7) '
-        'and os.environ["TRAVIS"]',
-        reason='https://github.com/cherrypy/cherrypy/issues/1693',
-    )
     def test_4_Autoreload(self):
         # If test_3 has not been executed, the server won't be stopped,
         # so we'll have to do it.
@@ -254,8 +250,10 @@ def test_4_Autoreload(self):
 
             self.getPage('/start')
             if not (float(self.body) > start):
-                raise AssertionError('start time %s not greater than %s' %
-                                     (float(self.body), start))
+                raise AssertionError(
+                    'start time %s not greater than %s'
+                    % (float(self.body), start),
+                )
         finally:
             # Shut down the spawned process
             self.getPage('/exit')
@@ -269,12 +267,11 @@ def test_5_Start_Error(self):
 
         # If a process errors during start, it should stop the engine
         # and exit with a non-zero exit code.
-        p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
-                             wait=True)
+        p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'), wait=True)
         p.write_conf(
             extra="""starterror: True
 test_case_name: "test_5_Start_Error"
-"""
+""",
         )
         p.start(imports='cherrypy.test._test_states_demo')
         if p.exit_code == 0:
@@ -282,7 +279,6 @@ def test_5_Start_Error(self):
 
 
 class PluginTests(helper.CPWebCase):
-
     def test_daemonize(self):
         if os.name not in ['posix']:
             return self.skip('skipped (not on posix) ')
@@ -291,12 +287,14 @@ def test_daemonize(self):
         # Spawn the process and wait, when this returns, the original process
         # is finished.  If it daemonized properly, we should still be able
         # to access pages.
-        p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
-                             wait=True, daemonize=True,
-                             socket_host='127.0.0.1',
-                             socket_port=8081)
-        p.write_conf(
-            extra='test_case_name: "test_daemonize"')
+        p = helper.CPProcess(
+            ssl=(self.scheme.lower() == 'https'),
+            wait=True,
+            daemonize=True,
+            socket_host='127.0.0.1',
+            socket_port=8081,
+        )
+        p.write_conf(extra='test_case_name: "test_daemonize"')
         p.start(imports='cherrypy.test._test_states_demo')
         try:
             # Just get the pid of the daemonization process.
@@ -316,7 +314,6 @@ def test_daemonize(self):
 
 
 class SignalHandlingTests(helper.CPWebCase):
-
     def test_SIGHUP_tty(self):
         # When not daemonized, SIGHUP should shut down the server.
         try:
@@ -326,8 +323,7 @@ def test_SIGHUP_tty(self):
 
         # Spawn the process.
         p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'))
-        p.write_conf(
-            extra='test_case_name: "test_SIGHUP_tty"')
+        p.write_conf(extra='test_case_name: "test_SIGHUP_tty"')
         p.start(imports='cherrypy.test._test_states_demo')
         # Send a SIGHUP
         os.kill(p.get_pid(), SIGHUP)
@@ -347,10 +343,12 @@ def test_SIGHUP_daemonized(self):
         # Spawn the process and wait, when this returns, the original process
         # is finished.  If it daemonized properly, we should still be able
         # to access pages.
-        p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
-                             wait=True, daemonize=True)
-        p.write_conf(
-            extra='test_case_name: "test_SIGHUP_daemonized"')
+        p = helper.CPProcess(
+            ssl=(self.scheme.lower() == 'https'),
+            wait=True,
+            daemonize=True,
+        )
+        p.write_conf(extra='test_case_name: "test_SIGHUP_daemonized"')
         p.start(imports='cherrypy.test._test_states_demo')
 
         pid = p.get_pid()
@@ -376,13 +374,12 @@ def _require_signal_and_kill(self, signal_name):
             self.skip('skipped (no os.kill)')
 
     def test_SIGTERM(self):
-        'SIGTERM should shut down the server whether daemonized or not.'
+        "SIGTERM should shut down the server whether daemonized or not."
         self._require_signal_and_kill('SIGTERM')
 
         # Spawn a normal, undaemonized process.
         p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'))
-        p.write_conf(
-            extra='test_case_name: "test_SIGTERM"')
+        p.write_conf(extra='test_case_name: "test_SIGTERM"')
         p.start(imports='cherrypy.test._test_states_demo')
         # Send a SIGTERM
         os.kill(p.get_pid(), signal.SIGTERM)
@@ -391,10 +388,12 @@ def test_SIGTERM(self):
 
         if os.name in ['posix']:
             # Spawn a daemonized process and test again.
-            p = helper.CPProcess(ssl=(self.scheme.lower() == 'https'),
-                                 wait=True, daemonize=True)
-            p.write_conf(
-                extra='test_case_name: "test_SIGTERM_2"')
+            p = helper.CPProcess(
+                ssl=(self.scheme.lower() == 'https'),
+                wait=True,
+                daemonize=True,
+            )
+            p.write_conf(extra='test_case_name: "test_SIGTERM_2"')
             p.start(imports='cherrypy.test._test_states_demo')
             # Send a SIGTERM
             os.kill(p.get_pid(), signal.SIGTERM)
@@ -416,7 +415,8 @@ def test_signal_handler_unsubscribe(self):
         p.write_conf(
             extra="""unsubsig: True
 test_case_name: "test_signal_handler_unsubscribe"
-""")
+""",
+        )
         p.start(imports='cherrypy.test._test_states_demo')
         # Ask the process to quit
         os.kill(p.get_pid(), signal.SIGTERM)
@@ -424,22 +424,22 @@ def test_signal_handler_unsubscribe(self):
         p.join()
 
         # Assert the old handler ran.
-        log_lines = list(open(p.error_log, 'rb'))
-        assert any(
-            line.endswith(b'I am an old SIGTERM handler.\n')
-            for line in log_lines
-        )
+        with open(p.error_log, 'rb') as f:
+            log_lines = list(f)
+            assert any(
+                line.endswith(b'I am an old SIGTERM handler.\n')
+                for line in log_lines
+            )
 
 
 def test_safe_wait_INADDR_ANY():  # pylint: disable=invalid-name
-    """
-    Wait on INADDR_ANY should not raise IOError
+    """Wait on INADDR_ANY should not raise IOError.
 
-    In cases where the loopback interface does not exist, CherryPy cannot
-    effectively determine if a port binding to INADDR_ANY was effected.
-    In this situation, CherryPy should assume that it failed to detect
-    the binding (not that the binding failed) and only warn that it could
-    not verify it.
+    In cases where the loopback interface does not exist, CherryPy
+    cannot effectively determine if a port binding to INADDR_ANY was
+    effected. In this situation, CherryPy should assume that it failed
+    to detect the binding (not that the binding failed) and only warn
+    that it could not verify it.
     """
     # At such a time that CherryPy can reliably determine one or more
     #  viable IP addresses of the host, this test may be removed.
@@ -455,8 +455,8 @@ def test_safe_wait_INADDR_ANY():  # pylint: disable=invalid-name
 
     # Wait on the free port that's unbound
     with pytest.warns(
-            UserWarning,
-            match='Unable to verify that the server is bound on ',
+        UserWarning,
+        match='Unable to verify that the server is bound on ',
     ) as warnings:
         # pylint: disable=protected-access
         with servers._safe_wait(inaddr_any, free_port):
diff --git a/cherrypy/test/test_static.py b/cherrypy/test/test_static.py
index bfe2f40fe..a6008adfa 100644
--- a/cherrypy/test/test_static.py
+++ b/cherrypy/test/test_static.py
@@ -53,7 +53,7 @@ def ensure_unicode_filesystem():
 # The file size needs to be big enough such that half the size of it
 # won't be socket-buffered (or server-buffered) all in one go. See
 # test_file_stream.
-MB = 2 ** 20
+MB = 2**20
 BIGFILE_SIZE = 32 * MB
 
 
@@ -66,15 +66,14 @@ def setup_server():
             with open(has_space_filepath, 'wb') as f:
                 f.write(b'Hello, world\r\n')
         needs_bigfile = (
-            not os.path.exists(bigfile_filepath) or
-            os.path.getsize(bigfile_filepath) != BIGFILE_SIZE
+            not os.path.exists(bigfile_filepath)
+            or os.path.getsize(bigfile_filepath) != BIGFILE_SIZE
         )
         if needs_bigfile:
             with open(bigfile_filepath, 'wb') as f:
                 f.write(b'x' * BIGFILE_SIZE)
 
         class Root:
-
             @cherrypy.expose
             @cherrypy.config(**{'response.stream': True})
             def bigfile(self):
@@ -102,17 +101,18 @@ def serve_file_utf8_filename(self):
                 return static.serve_file(
                     __file__,
                     disposition='attachment',
-                    name='has_utf-8_character_☃.html')
+                    name='has_utf-8_character_☃.html',
+                )
 
             @cherrypy.expose
             def serve_fileobj_utf8_filename(self):
                 return static.serve_fileobj(
                     io.BytesIO('☃\nfie\nfo\nfum'.encode('utf-8')),
                     disposition='attachment',
-                    name='has_utf-8_character_☃.html')
+                    name='has_utf-8_character_☃.html',
+                )
 
         class Static:
-
             @cherrypy.expose
             def index(self):
                 return 'You want the Baron? You can have the Baron!'
@@ -153,7 +153,7 @@ def dynamic(self):
                 'tools.staticdir.root': curdir,
                 'tools.staticdir.dir': 'static',
                 'error_page.404': error_page_404,
-            }
+            },
         }
         rootApp = cherrypy.Application(root)
         rootApp.merge(rootconf)
@@ -211,8 +211,10 @@ def test_static(self):
         ascii_fn = 'has_utf-8_character_.html'
         url_quote_fn = 'has_utf-8_character_%E2%98%83.html'  # %E2%98%83 == ☃
         expected_content_disposition = (
-            'attachment; filename="{!s}"; filename*=UTF-8\'\'{!s}'.
-            format(ascii_fn, url_quote_fn)
+            'attachment; filename="{!s}"; filename*=UTF-8\'\'{!s}'.format(
+                ascii_fn,
+                url_quote_fn,
+            )
         )
 
         self.getPage('/serve_file_utf8_filename')
@@ -254,9 +256,8 @@ def test_index(self):
         self.assertStatus(301)
         self.assertHeader('Location', '%s/docroot/' % self.base())
         self.assertMatchesBody(
-            "This resource .* <a href=(['\"])%s/docroot/\\1>"
-            '%s/docroot/</a>.'
-            % (self.base(), self.base())
+            'This resource .* <a href=([\'"])%s/docroot/\\1>'
+            '%s/docroot/</a>.' % (self.base(), self.base()),
         )
 
     def test_config_errors(self):
@@ -347,8 +348,12 @@ def test_file_stream(self):
             else:
                 newconn = HTTPConnection
             s, h, b = helper.webtest.openURL(
-                b'/tell', headers=[], host=self.HOST, port=self.PORT,
-                http_conn=newconn)
+                b'/tell',
+                headers=[],
+                host=self.HOST,
+                port=self.PORT,
+                http_conn=newconn,
+            )
             if not b:
                 # The file was closed on the server.
                 tell_position = BIGFILE_SIZE
@@ -382,17 +387,21 @@ def test_file_stream(self):
                         'The file should have advanced to position %r, but '
                         'has already advanced to the end of the file. It '
                         'may not be streamed as intended, or at the wrong '
-                        'chunk size (64k)' % read_so_far)
+                        'chunk size (64k)' % read_so_far,
+                    )
             elif tell_position < read_so_far:
                 self.fail(
                     'The file should have advanced to position %r, but has '
                     'only advanced to position %r. It may not be streamed '
-                    'as intended, or at the wrong chunk size (64k)' %
-                    (read_so_far, tell_position))
+                    'as intended, or at the wrong chunk size (64k)'
+                    % (read_so_far, tell_position),
+                )
 
         if body != b'x' * BIGFILE_SIZE:
-            self.fail("Body != 'x' * %d. Got %r instead (%d bytes)." %
-                      (BIGFILE_SIZE, body[:50], len(body)))
+            self.fail(
+                "Body != 'x' * %d. Got %r instead (%d bytes)."
+                % (BIGFILE_SIZE, body[:50], len(body)),
+            )
         conn.close()
 
     def test_file_stream_deadlock(self):
@@ -412,8 +421,10 @@ def test_file_stream_deadlock(self):
         self.assertEqual(response.status, 200)
         body = response.fp.read(65536)
         if body != b'x' * len(body):
-            self.fail("Body != 'x' * %d. Got %r instead (%d bytes)." %
-                      (65536, body[:50], len(body)))
+            self.fail(
+                "Body != 'x' * %d. Got %r instead (%d bytes)."
+                % (65536, body[:50], len(body)),
+            )
         response.close()
         conn.close()
 
@@ -421,8 +432,10 @@ def test_file_stream_deadlock(self):
         self.persistent = False
         self.getPage('/bigfile')
         if self.body != b'x' * BIGFILE_SIZE:
-            self.fail("Body != 'x' * %d. Got %r instead (%d bytes)." %
-                      (BIGFILE_SIZE, self.body[:50], len(body)))
+            self.fail(
+                "Body != 'x' * %d. Got %r instead (%d bytes)."
+                % (BIGFILE_SIZE, self.body[:50], len(body)),
+            )
 
     def test_error_page_with_serve_file(self):
         self.getPage('/404test/yunyeen')
@@ -442,7 +455,7 @@ def test_null_bytes(self):
     def unicode_file(cls):
         filename = ntou('Слава Україні.html', 'utf-8')
         filepath = curdir / 'static' / filename
-        with filepath.open('w', encoding='utf-8')as strm:
+        with filepath.open('w', encoding='utf-8') as strm:
             strm.write(ntou('Героям Слава!', 'utf-8'))
         cls.files_to_remove.append(filepath)
 
diff --git a/cherrypy/test/test_tools.py b/cherrypy/test/test_tools.py
index 40de2e521..9d864feeb 100644
--- a/cherrypy/test/test_tools.py
+++ b/cherrypy/test/test_tools.py
@@ -2,7 +2,6 @@
 
 import gzip
 import io
-import sys
 import time
 import types
 import unittest
@@ -15,16 +14,6 @@
 from cherrypy.test import helper, _test_decorators
 
 
-*PY_VER_MINOR, _ = PY_VER_PATCH = sys.version_info[:3]
-# Refs:
-# bugs.python.org/issue39389
-# docs.python.org/3.7/whatsnew/changelog.html#python-3-7-7-release-candidate-1
-# docs.python.org/3.8/whatsnew/changelog.html#python-3-8-2-release-candidate-1
-HAS_GZIP_COMPRESSION_HEADER_FIXED = PY_VER_PATCH >= (3, 8, 2) or (
-    PY_VER_MINOR == (3, 7) and PY_VER_PATCH >= (3, 7, 7)
-)
-
-
 timeout = 0.2
 europoundUnicode = ntou('\x80\xa3')
 
@@ -33,18 +22,19 @@
 
 
 class ToolTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         # Put check_access in a custom toolbox with its own namespace
         myauthtools = cherrypy._cptools.Toolbox('myauth')
 
         def check_access(default=False):
             if not getattr(cherrypy.request, 'userid', default):
                 raise cherrypy.HTTPError(401)
+
         myauthtools.check_access = cherrypy.Tool(
-            'before_request_body', check_access)
+            'before_request_body',
+            check_access,
+        )
 
         def numerify():
             def number_it(body):
@@ -52,19 +42,22 @@ def number_it(body):
                     for k, v in cherrypy.request.numerify_map:
                         chunk = chunk.replace(k, v)
                     yield chunk
+
             cherrypy.response.body = number_it(cherrypy.response.body)
 
         class NumTool(cherrypy.Tool):
-
             def _setup(self):
                 def makemap():
                     m = self._merged_args().get('map', {})
                     cherrypy.request.numerify_map = list(m.items())
+
                 cherrypy.request.hooks.attach('on_start_resource', makemap)
 
                 def critical():
                     cherrypy.request.error_response = cherrypy.HTTPError(
-                        502).set_response
+                        502,
+                    ).set_response
+
                 critical.failsafe = True
 
                 cherrypy.request.hooks.attach('on_start_resource', critical)
@@ -74,7 +67,6 @@ def critical():
 
         # It's not mandatory to inherit from cherrypy.Tool.
         class NadsatTool:
-
             def __init__(self):
                 self.ended = {}
                 self._name = 'nadsat'
@@ -85,7 +77,9 @@ def nadsat_it_up(body):
                         chunk = chunk.replace(b'good', b'horrorshow')
                         chunk = chunk.replace(b'piece', b'lomtick')
                         yield chunk
+
                 cherrypy.response.body = nadsat_it_up(cherrypy.response.body)
+
             nadsat.priority = 0
 
             def cleanup(self):
@@ -94,11 +88,13 @@ def cleanup(self):
                 id = cherrypy.request.params.get('id')
                 if id:
                     self.ended[id] = True
+
             cleanup.failsafe = True
 
             def _setup(self):
                 cherrypy.request.hooks.attach('before_finalize', self.nadsat)
                 cherrypy.request.hooks.attach('on_end_request', self.cleanup)
+
         tools.nadsat = NadsatTool()
 
         def pipe_body():
@@ -108,11 +104,11 @@ def pipe_body():
 
         # Assert that we can use a callable object instead of a function.
         class Rotator(object):
-
             def __call__(self, scale):
                 r = cherrypy.response
                 r.collapse_body()
                 r.body = [bytes([(x + scale) % 256 for x in r.body[0]])]
+
         cherrypy.tools.rotator = cherrypy.Tool('before_finalize', Rotator())
 
         def stream_handler(next_handler, *args, **kwargs):
@@ -126,20 +122,23 @@ def stream_handler(next_handler, *args, **kwargs):
                 return o.getvalue()
             finally:
                 o.close()
+
         cherrypy.tools.streamer = cherrypy._cptools.HandlerWrapperTool(
-            stream_handler)
+            stream_handler,
+        )
 
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'Howdy earth!'
 
             @cherrypy.expose
-            @cherrypy.config(**{
-                'tools.streamer.on': True,
-                'tools.streamer.arg': 'arg value',
-            })
+            @cherrypy.config(
+                **{
+                    'tools.streamer.on': True,
+                    'tools.streamer.arg': 'arg value',
+                },
+            )
             def tarfile(self):
                 actual = cherrypy.request.config.get('tools.streamer.arg')
                 assert actual == 'arg value'
@@ -171,6 +170,7 @@ def decorated_euro(self, *vpath):
                 yield ntou('Hello,')
                 yield ntou('world')
                 yield europoundUnicode
+
             decorated_euro = tools.gzip(compress_level=6)(decorated_euro)
             decorated_euro = tools.rotator(scale=3)(decorated_euro)
 
@@ -181,19 +181,20 @@ class TestType(type):
             subclass, and adds an instance of the subclass as an attribute
             of root.
             """
+
             def __init__(cls, name, bases, dct):
                 type.__init__(cls, name, bases, dct)
                 for value in dct.values():
                     if isinstance(value, types.FunctionType):
                         cherrypy.expose(value)
                 setattr(root, name.lower(), cls())
+
         Test = TestType('Test', (object,), {})
 
         # METHOD ONE:
         # Declare Tools in _cp_config
         @cherrypy.config(**{'tools.nadsat.on': True})
         class Demo(Test):
-
             def index(self, id=None):
                 return 'A good piece of cherry pie'
 
@@ -214,6 +215,7 @@ def errinstream(self, id=None):
             # @tools.check_access()
             def restricted(self):
                 return 'Welcome!'
+
             restricted = myauthtools.check_access()(restricted)
             userid = restricted
 
@@ -244,7 +246,7 @@ def stream(self, id=None):
             },
             '/demo/err_in_onstart': {
                 # Because this isn't a dict, on_start_resource will error.
-                'tools.numerify.map': 'pie->3.14159'
+                'tools.numerify.map': 'pie->3.14159',
             },
             # Combined tools
             '/euro': {
@@ -256,7 +258,7 @@ def stream(self, id=None):
                 'tools.gzip.priority': 10,
             },
             # Handler wrappers
-            '/tarfile': {'tools.streamer.on': True}
+            '/tarfile': {'tools.streamer.on': True},
         }
         app = cherrypy.tree.mount(root, config=conf)
         app.request_class.namespaces['myauth'] = myauthtools
@@ -282,8 +284,11 @@ def testHookErrors(self):
         self.assertBody('True')
 
         # If body is "razdrez", then on_end_request is being called too early.
-        if (cherrypy.server.protocol_version == 'HTTP/1.0' or
-                getattr(cherrypy.server, 'using_apache', False)):
+        if cherrypy.server.protocol_version == 'HTTP/1.0' or getattr(
+            cherrypy.server,
+            'using_apache',
+            False,
+        ):
             self.getPage('/demo/errinstream?id=5')
             # Because this error is raised after the response body has
             # started, the status should not change to an error status.
@@ -293,8 +298,11 @@ def testHookErrors(self):
             # Because this error is raised after the response body has
             # started, and because it's chunked output, an error is raised by
             # the HTTP client when it encounters incomplete output.
-            self.assertRaises((ValueError, IncompleteRead), self.getPage,
-                              '/demo/errinstream?id=5')
+            self.assertRaises(
+                (ValueError, IncompleteRead),
+                self.getPage,
+                '/demo/errinstream?id=5',
+            )
         # If this fails, then on_end_request isn't being called at all.
         time.sleep(0.1)
         self.getPage('/demo/ended/5')
@@ -354,26 +362,23 @@ def testGuaranteedHooks(self):
         self.assertInBody(expected_msg)
 
     def testCombinedTools(self):
-        expectedResult = (ntou('Hello,world') +
-                          europoundUnicode).encode('utf-8')
+        expectedResult = (ntou('Hello,world') + europoundUnicode).encode(
+            'utf-8',
+        )
         zbuf = io.BytesIO()
         zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=9)
         zfile.write(expectedResult)
         zfile.close()
 
-        self.getPage('/euro',
-                     headers=[
-                         ('Accept-Encoding', 'gzip'),
-                         ('Accept-Charset', 'ISO-8859-1,utf-8;q=0.7,*;q=0.7')])
+        self.getPage(
+            '/euro',
+            headers=[
+                ('Accept-Encoding', 'gzip'),
+                ('Accept-Charset', 'ISO-8859-1,utf-8;q=0.7,*;q=0.7'),
+            ],
+        )
         self.assertInBody(zbuf.getvalue()[:3])
 
-        if not HAS_GZIP_COMPRESSION_HEADER_FIXED:
-            # NOTE: CherryPy adopts a fix from the CPython bug 39389
-            # NOTE: introducing a variable compression XFL flag that
-            # NOTE: was hardcoded to "best compression" before. And so
-            # NOTE: we can only test it on CPython versions that also
-            # NOTE: implement this fix.
-            return
         zbuf = io.BytesIO()
         zfile = gzip.GzipFile(mode='wb', fileobj=zbuf, compresslevel=6)
         zfile.write(expectedResult)
@@ -386,16 +391,23 @@ def testCombinedTools(self):
         # lowered in conf, allowing the rotator to run after gzip.
         # Of course, we don't want breakage in production apps,
         # but it proves the priority was changed.
-        self.getPage('/decorated_euro/subpath',
-                     headers=[('Accept-Encoding', 'gzip')])
+        self.getPage(
+            '/decorated_euro/subpath',
+            headers=[('Accept-Encoding', 'gzip')],
+        )
         self.assertInBody(bytes([(x + 3) % 256 for x in zbuf.getvalue()]))
 
     def testBareHooks(self):
         content = 'bit of a pain in me gulliver'
-        self.getPage('/pipe',
-                     headers=[('Content-Length', str(len(content))),
-                              ('Content-Type', 'text/plain')],
-                     method='POST', body=content)
+        self.getPage(
+            '/pipe',
+            headers=[
+                ('Content-Length', str(len(content))),
+                ('Content-Type', 'text/plain'),
+            ],
+            method='POST',
+            body=content,
+        )
         self.assertBody(content)
 
     def testHandlerWrapperTool(self):
@@ -403,9 +415,6 @@ def testHandlerWrapperTool(self):
         self.assertBody('I am a tarfile')
 
     def testToolWithConfig(self):
-        if not sys.version_info >= (2, 5):
-            return self.skip('skipped (Python 2.5+ only)')
-
         self.getPage('/tooldecs/blah')
         self.assertHeader('Content-Type', 'application/data')
 
@@ -430,14 +439,18 @@ def testDecorator(self):
         @cherrypy.tools.register('on_start_resource')
         def example():
             pass
+
         self.assertTrue(isinstance(cherrypy.tools.example, cherrypy.Tool))
         self.assertEqual(cherrypy.tools.example._point, 'on_start_resource')
 
         @cherrypy.tools.register(  # noqa: F811
-            'before_finalize', name='renamed', priority=60,
+            'before_finalize',
+            name='renamed',
+            priority=60,
         )
         def example():  # noqa: F811
             pass
+
         self.assertTrue(isinstance(cherrypy.tools.renamed, cherrypy.Tool))
         self.assertEqual(cherrypy.tools.renamed._point, 'before_finalize')
         self.assertEqual(cherrypy.tools.renamed._name, 'renamed')
@@ -445,7 +458,6 @@ def example():  # noqa: F811
 
 
 class SessionAuthTest(unittest.TestCase):
-
     def test_login_screen_returns_bytes(self):
         """
         login_screen must return bytes even if unicode parameters are passed.
@@ -453,16 +465,17 @@ def test_login_screen_returns_bytes(self):
         username and password were unicode.
         """
         sa = cherrypy.lib.cptools.SessionAuth()
-        res = sa.login_screen(None, username=str('nobody'),
-                              password=str('anypass'))
+        res = sa.login_screen(
+            None,
+            username=str('nobody'),
+            password=str('anypass'),
+        )
         self.assertTrue(isinstance(res, bytes))
 
 
 class TestHooks:
     def test_priorities(self):
-        """
-        Hooks should sort by priority order.
-        """
+        """Hooks should sort by priority order."""
         Hook = cherrypy._cprequest.Hook
         hooks = [
             Hook(None, priority=48),
diff --git a/cherrypy/test/test_tutorials.py b/cherrypy/test/test_tutorials.py
index 39ca4d6f2..71a69ced7 100644
--- a/cherrypy/test/test_tutorials.py
+++ b/cherrypy/test/test_tutorials.py
@@ -6,21 +6,18 @@
 
 
 class TutorialTest(helper.CPWebCase):
-
     @classmethod
     def setup_server(cls):
-        """
-        Mount something so the engine starts.
-        """
+        """Mount something so the engine starts."""
+
         class Dummy:
             pass
+
         cherrypy.tree.mount(Dummy())
 
     @staticmethod
     def load_module(name):
-        """
-        Import or reload tutorial module as needed.
-        """
+        """Import or reload tutorial module as needed."""
         target = 'cherrypy.tutorial.' + name
         if target in sys.modules:
             module = importlib.reload(sys.modules[target])
@@ -34,7 +31,7 @@ def setup_tutorial(cls, name, root_name, config={}):
         module = cls.load_module(name)
         root = getattr(module, root_name)
         conf = getattr(module, 'tutconf')
-        class_types = type,
+        class_types = (type,)
         if isinstance(root, class_types):
             root = root()
         cherrypy.tree.mount(root, config=conf)
@@ -73,21 +70,21 @@ def test03GetAndPost(self):
     def test04ComplexSite(self):
         self.setup_tutorial('tut04_complex_site', 'root')
 
-        msg = '''
+        msg = """
             <p>Here are some extra useful links:</p>
 
             <ul>
                 <li><a href="http://del.icio.us">del.icio.us</a></li>
-                <li><a href="http://www.cherrypy.org">CherryPy</a></li>
+                <li><a href="http://www.cherrypy.dev">CherryPy</a></li>
             </ul>
 
-            <p>[<a href="../">Return to links page</a>]</p>'''
+            <p>[<a href="../">Return to links page</a>]</p>"""
         self.getPage('/links/extra/')
         self.assertBody(msg)
 
     def test05DerivedObjects(self):
         self.setup_tutorial('tut05_derived_objects', 'HomePage')
-        msg = '''
+        msg = """
             <html>
             <head>
                 <title>Another Page</title>
@@ -101,7 +98,7 @@ def test05DerivedObjects(self):
 
             </body>
             </html>
-        '''
+        """
         # the tutorial has some annoying spaces in otherwise blank lines
         msg = msg.replace('</h2>\n\n', '</h2>\n        \n')
         msg = msg.replace('</p>\n\n', '</p>\n        \n')
@@ -111,8 +108,10 @@ def test05DerivedObjects(self):
     def test06DefaultMethod(self):
         self.setup_tutorial('tut06_default_method', 'UsersPage')
         self.getPage('/hendrik')
-        self.assertBody('Hendrik Mans, CherryPy co-developer & crazy German '
-                        '(<a href="./">back</a>)')
+        self.assertBody(
+            'Hendrik Mans, CherryPy co-developer & crazy German '
+            '(<a href="./">back</a>)',
+        )
 
     def test07Sessions(self):
         self.setup_tutorial('tut07_sessions', 'HitCounter')
@@ -121,52 +120,65 @@ def test07Sessions(self):
         self.assertBody(
             "\n            During your current session, you've viewed this"
             '\n            page 1 times! Your life is a patio of fun!'
-            '\n        ')
+            '\n        ',
+        )
 
         self.getPage('/', self.cookies)
         self.assertBody(
             "\n            During your current session, you've viewed this"
             '\n            page 2 times! Your life is a patio of fun!'
-            '\n        ')
+            '\n        ',
+        )
 
     def test08GeneratorsAndYield(self):
         self.setup_tutorial('tut08_generators_and_yield', 'GeneratorDemo')
         self.getPage('/')
-        self.assertBody('<html><body><h2>Generators rule!</h2>'
-                        '<h3>List of users:</h3>'
-                        'Remi<br/>Carlos<br/>Hendrik<br/>Lorenzo Lamas<br/>'
-                        '</body></html>')
+        self.assertBody(
+            '<html><body><h2>Generators rule!</h2>'
+            '<h3>List of users:</h3>'
+            'Remi<br/>Carlos<br/>Hendrik<br/>Lorenzo Lamas<br/>'
+            '</body></html>',
+        )
 
     def test09Files(self):
         self.setup_tutorial('tut09_files', 'FileDemo')
 
         # Test upload
         filesize = 5
-        h = [('Content-type', 'multipart/form-data; boundary=x'),
-             ('Content-Length', str(105 + filesize))]
-        b = ('--x\n'
-             'Content-Disposition: form-data; name="myFile"; '
-             'filename="hello.txt"\r\n'
-             'Content-Type: text/plain\r\n'
-             '\r\n')
+        h = [
+            ('Content-type', 'multipart/form-data; boundary=x'),
+            ('Content-Length', str(105 + filesize)),
+        ]
+        b = (
+            '--x\n'
+            'Content-Disposition: form-data; name="myFile"; '
+            'filename="hello.txt"\r\n'
+            'Content-Type: text/plain\r\n'
+            '\r\n'
+        )
         b += 'a' * filesize + '\n' + '--x--\n'
         self.getPage('/upload', h, 'POST', b)
-        self.assertBody('''<html>
+        self.assertBody(
+            """<html>
         <body>
             myFile length: %d<br />
             myFile filename: hello.txt<br />
             myFile mime-type: text/plain
         </body>
-        </html>''' % filesize)
+        </html>"""
+            % filesize,
+        )
 
         # Test download
         self.getPage('/download')
         self.assertStatus('200 OK')
         self.assertHeader('Content-Type', 'application/x-download')
-        self.assertHeader('Content-Disposition',
-                          # Make sure the filename is quoted.
-                          'attachment; filename="pdf_file.pdf"')
-        self.assertEqual(len(self.body), 85698)
+        self.assertHeader(
+            'Content-Disposition',
+            # Make sure the filename is quoted.
+            'attachment; filename="pdf_file.pdf"',
+        )
+        self.assertEqual(len(self.body), 11961)
 
     def test10HTTPErrors(self):
         self.setup_tutorial('tut10_http_errors', 'HTTPErrorDemo')
@@ -174,6 +186,7 @@ def test10HTTPErrors(self):
         @cherrypy.expose
         def traceback_setting():
             return repr(cherrypy.request.show_tracebacks)
+
         cherrypy.tree.mount(traceback_setting, '/traceback_setting')
 
         self.getPage('/')
@@ -192,8 +205,10 @@ def traceback_setting():
 
         self.getPage('/error?code=500')
         self.assertStatus(500)
-        self.assertInBody('The server encountered an unexpected condition '
-                          'which prevented it from fulfilling the request.')
+        self.assertInBody(
+            'The server encountered an unexpected condition '
+            'which prevented it from fulfilling the request.',
+        )
 
         self.getPage('/error?code=403')
         self.assertStatus(403)
diff --git a/cherrypy/test/test_virtualhost.py b/cherrypy/test/test_virtualhost.py
index de88f9272..4e974979b 100644
--- a/cherrypy/test/test_virtualhost.py
+++ b/cherrypy/test/test_virtualhost.py
@@ -7,11 +7,9 @@
 
 
 class VirtualHostTest(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return 'Hello, world'
@@ -25,7 +23,6 @@ def method(self, value):
                 return 'You sent %s' % value
 
         class VHost:
-
             def __init__(self, sitename):
                 self.sitename = sitename
 
@@ -43,27 +40,35 @@ def url(self):
 
             # Test static as a handler (section must NOT include vhost prefix)
             static = cherrypy.tools.staticdir.handler(
-                section='/static', dir=curdir)
+                section='/static',
+                dir=curdir,
+            )
 
         root = Root()
         root.mydom2 = VHost('Domain 2')
         root.mydom3 = VHost('Domain 3')
-        hostmap = {'www.mydom2.com': '/mydom2',
-                   'www.mydom3.com': '/mydom3',
-                   'www.mydom4.com': '/dom4',
-                   }
-        cherrypy.tree.mount(root, config={
-            '/': {
-                'request.dispatch': cherrypy.dispatch.VirtualHost(**hostmap)
-            },
-            # Test static in config (section must include vhost prefix)
-            '/mydom2/static2': {
-                'tools.staticdir.on': True,
-                'tools.staticdir.root': curdir,
-                'tools.staticdir.dir': 'static',
-                'tools.staticdir.index': 'index.html',
+        hostmap = {
+            'www.mydom2.com': '/mydom2',
+            'www.mydom3.com': '/mydom3',
+            'www.mydom4.com': '/dom4',
+        }
+        cherrypy.tree.mount(
+            root,
+            config={
+                '/': {
+                    'request.dispatch': cherrypy.dispatch.VirtualHost(
+                        **hostmap,
+                    ),
+                },
+                # Test static in config (section must include vhost prefix)
+                '/mydom2/static2': {
+                    'tools.staticdir.on': True,
+                    'tools.staticdir.root': curdir,
+                    'tools.staticdir.dir': 'static',
+                    'tools.staticdir.index': 'index.html',
+                },
             },
-        })
+        )
 
     def testVirtualHost(self):
         self.getPage('/', [('Host', 'www.mydom1.com')])
@@ -83,8 +88,12 @@ def testVirtualHost(self):
         self.assertBody('You sent root')
         self.getPage('/vmethod?value=dom2+GET', [('Host', 'www.mydom2.com')])
         self.assertBody('You sent dom2 GET')
-        self.getPage('/vmethod', [('Host', 'www.mydom3.com')], method='POST',
-                     body='value=dom3+POST')
+        self.getPage(
+            '/vmethod',
+            [('Host', 'www.mydom3.com')],
+            method='POST',
+            body='value=dom3+POST',
+        )
         self.assertBody('You sent dom3 POST')
         self.getPage('/vmethod/pos', [('Host', 'www.mydom3.com')])
         self.assertBody('You sent pos')
diff --git a/cherrypy/test/test_wsgi_ns.py b/cherrypy/test/test_wsgi_ns.py
index 3545724c5..0ca8a4e93 100644
--- a/cherrypy/test/test_wsgi_ns.py
+++ b/cherrypy/test/test_wsgi_ns.py
@@ -3,12 +3,9 @@
 
 
 class WSGI_Namespace_Test(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         class WSGIResponse(object):
-
             def __init__(self, appresults):
                 self.appresults = appresults
                 self.iter = iter(appresults)
@@ -27,7 +24,6 @@ def close(self):
                     self.appresults.close()
 
         class ChangeCase(object):
-
             def __init__(self, app, to=None):
                 self.app = app
                 self.to = to
@@ -36,16 +32,15 @@ def __call__(self, environ, start_response):
                 res = self.app(environ, start_response)
 
                 class CaseResults(WSGIResponse):
-
                     def next(this):
                         return getattr(this.iter.next(), self.to)()
 
                     def __next__(this):
                         return getattr(next(this.iter), self.to)()
+
                 return CaseResults(res)
 
         class Replacer(object):
-
             def __init__(self, app, map={}):
                 self.app = app
                 self.map = map
@@ -54,7 +49,6 @@ def __call__(self, environ, start_response):
                 res = self.app(environ, start_response)
 
                 class ReplaceResults(WSGIResponse):
-
                     def next(this):
                         line = this.iter.next()
                         for k, v in self.map.iteritems():
@@ -66,18 +60,18 @@ def __next__(this):
                         for k, v in self.map.items():
                             line = line.replace(k, v)
                         return line
+
                 return ReplaceResults(res)
 
         class Root(object):
-
             @cherrypy.expose
             def index(self):
                 return 'HellO WoRlD!'
 
-        root_conf = {'wsgi.pipeline': [('replace', Replacer)],
-                     'wsgi.replace.map': {b'L': b'X',
-                                          b'l': b'r'},
-                     }
+        root_conf = {
+            'wsgi.pipeline': [('replace', Replacer)],
+            'wsgi.replace.map': {b'L': b'X', b'l': b'r'},
+        }
 
         app = cherrypy.Application(Root())
         app.wsgiapp.pipeline.append(('changecase', ChangeCase))
diff --git a/cherrypy/test/test_wsgi_unix_socket.py b/cherrypy/test/test_wsgi_unix_socket.py
index df0ab5f8d..c7d519d43 100644
--- a/cherrypy/test/test_wsgi_unix_socket.py
+++ b/cherrypy/test/test_wsgi_unix_socket.py
@@ -21,9 +21,7 @@ def usocket_path():
 
 
 class USocketHTTPConnection(HTTPConnection):
-    """
-    HTTPConnection over a unix socket.
-    """
+    """HTTPConnection over a unix socket."""
 
     def __init__(self, path):
         HTTPConnection.__init__(self, 'localhost')
@@ -54,12 +52,12 @@ class WSGI_UnixSocket_Test(helper.CPWebCase):
 
     It exercises the config option `server.socket_file`.
     """
+
     HTTP_CONN = USocketHTTPConnection(USOCKET_PATH)
 
     @staticmethod
     def setup_server():
         class Root(object):
-
             @cherrypy.expose
             def index(self):
                 return 'Test OK'
@@ -68,9 +66,7 @@ def index(self):
             def error(self):
                 raise Exception('Invalid page')
 
-        config = {
-            'server.socket_file': USOCKET_PATH
-        }
+        config = {'server.socket_file': USOCKET_PATH}
         cherrypy.config.update(config)
         cherrypy.tree.mount(Root())
 
diff --git a/cherrypy/test/test_wsgi_vhost.py b/cherrypy/test/test_wsgi_vhost.py
index 2b6e5ba90..f78edc83d 100644
--- a/cherrypy/test/test_wsgi_vhost.py
+++ b/cherrypy/test/test_wsgi_vhost.py
@@ -3,12 +3,9 @@
 
 
 class WSGI_VirtualHost_Test(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         class ClassOfRoot(object):
-
             def __init__(self, name):
                 self.name = name
 
@@ -31,5 +28,7 @@ def test_welcome(self):
 
         for year in range(1997, 2008):
             self.getPage(
-                '/', headers=[('Host', 'www.classof%s.example' % year)])
+                '/',
+                headers=[('Host', 'www.classof%s.example' % year)],
+            )
             self.assertBody('Welcome to the Class of %s website!' % year)
diff --git a/cherrypy/test/test_wsgiapps.py b/cherrypy/test/test_wsgiapps.py
index 1b3bf28fa..0cc7f07d2 100644
--- a/cherrypy/test/test_wsgiapps.py
+++ b/cherrypy/test/test_wsgiapps.py
@@ -6,16 +6,16 @@
 
 
 class WSGIGraftTests(helper.CPWebCase):
-
     @staticmethod
     def setup_server():
-
         def test_app(environ, start_response):
             status = '200 OK'
             response_headers = [('Content-type', 'text/plain')]
             start_response(status, response_headers)
-            output = ['Hello, world!\n',
-                      'This is a wsgi app running within CherryPy!\n\n']
+            output = [
+                'Hello, world!\n',
+                'This is a wsgi app running within CherryPy!\n\n',
+            ]
             keys = list(environ.keys())
             keys.sort()
             for k in keys:
@@ -27,11 +27,14 @@ def test_empty_string_app(environ, start_response):
             response_headers = [('Content-type', 'text/plain')]
             start_response(status, response_headers)
             return [
-                b'Hello', b'', b' ', b'', b'world',
+                b'Hello',
+                b'',
+                b' ',
+                b'',
+                b'world',
             ]
 
         class WSGIResponse(object):
-
             def __init__(self, appresults):
                 self.appresults = appresults
                 self.iter = iter(appresults)
@@ -40,9 +43,11 @@ def __iter__(self):
                 return self
 
             if sys.version_info >= (3, 0):
+
                 def __next__(self):
                     return next(self.iter)
             else:
+
                 def next(self):
                     return self.iter.next()
 
@@ -51,7 +56,6 @@ def close(self):
                     self.appresults.close()
 
         class ReversingMiddleware(object):
-
             def __init__(self, app):
                 self.app = app
 
@@ -59,13 +63,14 @@ def __call__(self, environ, start_response):
                 results = app(environ, start_response)
 
                 class Reverser(WSGIResponse):
-
                     if sys.version_info >= (3, 0):
+
                         def __next__(this):
                             line = list(next(this.iter))
                             line.reverse()
                             return bytes(line)
                     else:
+
                         def next(this):
                             line = list(this.iter.next())
                             line.reverse()
@@ -74,7 +79,6 @@ def next(this):
                 return Reverser(results)
 
         class Root:
-
             @cherrypy.expose
             def index(self):
                 return ntob("I'm a regular CherryPy page handler!")
@@ -89,8 +93,8 @@ def index(self):
         app = cherrypy.Application(Root(), script_name=None)
         cherrypy.tree.graft(ReversingMiddleware(app), '/hosted/app2')
 
-    wsgi_output = '''Hello, world!
-This is a wsgi app running within CherryPy!'''
+    wsgi_output = """Hello, world!
+This is a wsgi app running within CherryPy!"""
 
     def test_01_standard_app(self):
         self.getPage('/')
diff --git a/cherrypy/test/test_xmlrpc.py b/cherrypy/test/test_xmlrpc.py
index 61fde8bb2..6aac68d04 100644
--- a/cherrypy/test/test_xmlrpc.py
+++ b/cherrypy/test/test_xmlrpc.py
@@ -1,10 +1,7 @@
 import sys
 import socket
 
-from xmlrpc.client import (
-    DateTime, Fault,
-    ServerProxy, SafeTransport
-)
+from xmlrpc.client import DateTime, Fault, ServerProxy, SafeTransport
 
 import cherrypy
 from cherrypy import _cptools
@@ -18,15 +15,12 @@
 
 
 def setup_server():
-
     class Root:
-
         @cherrypy.expose
         def index(self):
             return "I'm a standard index!"
 
     class XmlRpc(_cptools.XMLRPCController):
-
         @cherrypy.expose
         def foo(self):
             return 'Hello world!'
@@ -77,17 +71,21 @@ def test_returning_Fault(self):
 
     root = Root()
     root.xmlrpc = XmlRpc()
-    cherrypy.tree.mount(root, config={'/': {
-        'request.dispatch': cherrypy.dispatch.XMLRPCDispatcher(),
-        'tools.xmlrpc.allow_none': 0,
-    }})
+    cherrypy.tree.mount(
+        root,
+        config={
+            '/': {
+                'request.dispatch': cherrypy.dispatch.XMLRPCDispatcher(),
+                'tools.xmlrpc.allow_none': 0,
+            },
+        },
+    )
 
 
 class XmlRpcTest(helper.CPWebCase):
     setup_server = staticmethod(setup_server)
 
     def testXmlRpc(self):
-
         scheme = self.scheme
         if scheme == 'https':
             url = 'https://%s:%s/xmlrpc/' % (self.interface(), self.PORT)
@@ -103,15 +101,21 @@ def testXmlRpc(self):
         self.assertEqual(proxy.return_single_item_list(), [42])
         self.assertNotEqual(proxy.return_single_item_list(), 'one bazillion')
         self.assertEqual(proxy.return_string(), 'here is a string')
-        self.assertEqual(proxy.return_tuple(),
-                         list(('here', 'is', 1, 'tuple')))
+        self.assertEqual(
+            proxy.return_tuple(),
+            list(('here', 'is', 1, 'tuple')),
+        )
         self.assertEqual(proxy.return_dict(), {'a': 1, 'c': 3, 'b': 2})
-        self.assertEqual(proxy.return_composite(),
-                         [{'a': 1, 'z': 26}, 'hi', ['welcome', 'friend']])
+        self.assertEqual(
+            proxy.return_composite(),
+            [{'a': 1, 'z': 26}, 'hi', ['welcome', 'friend']],
+        )
         self.assertEqual(proxy.return_int(), 42)
         self.assertEqual(proxy.return_float(), 3.14)
-        self.assertEqual(proxy.return_datetime(),
-                         DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1)))
+        self.assertEqual(
+            proxy.return_datetime(),
+            DateTime((2003, 10, 7, 8, 1, 0, 1, 280, -1)),
+        )
         self.assertEqual(proxy.return_boolean(), True)
         self.assertEqual(proxy.test_argument_passing(22), 22 * 2)
 
@@ -121,8 +125,10 @@ def testXmlRpc(self):
         except Exception:
             x = sys.exc_info()[1]
             self.assertEqual(x.__class__, Fault)
-            self.assertEqual(x.faultString, ('unsupported operand type(s) '
-                                             "for *: 'dict' and 'int'"))
+            self.assertEqual(
+                x.faultString,
+                ("unsupported operand type(s) for *: 'dict' and 'int'"),
+            )
         else:
             self.fail('Expected xmlrpclib.Fault')
 
@@ -133,8 +139,10 @@ def testXmlRpc(self):
         except Exception:
             x = sys.exc_info()[1]
             self.assertEqual(x.__class__, Fault)
-            self.assertEqual(x.faultString,
-                             'method "non_method" is not supported')
+            self.assertEqual(
+                x.faultString,
+                'method "non_method" is not supported',
+            )
         else:
             self.fail('Expected xmlrpclib.Fault')
 
diff --git a/cherrypy/test/webtest.py b/cherrypy/test/webtest.py
index 9fb6ce62b..715f85a6e 100644
--- a/cherrypy/test/webtest.py
+++ b/cherrypy/test/webtest.py
@@ -1,10 +1,16 @@
+"""A deprecated web app testing helper interface."""
+
 # for compatibility, expose cheroot webtest here
 import warnings
 
 from cheroot.test.webtest import (  # noqa
     interface,
-    WebCase, cleanHeaders, shb, openURL,
-    ServerError, server_error,
+    WebCase,
+    cleanHeaders,
+    shb,
+    openURL,
+    ServerError,
+    server_error,
 )
 
 
diff --git a/cherrypy/tutorial/__init__.py b/cherrypy/tutorial/__init__.py
index 08c142c5f..bcefff75d 100644
--- a/cherrypy/tutorial/__init__.py
+++ b/cherrypy/tutorial/__init__.py
@@ -1,3 +1,4 @@
+"""A package with standalone tutorial modules."""
 
 # This is used in test_config to test unrepr of "from A import B"
 thing2 = object()
diff --git a/cherrypy/tutorial/pdf_file.pdf b/cherrypy/tutorial/pdf_file.pdf
index 38b4f15ea..226dfe18f 100644
Binary files a/cherrypy/tutorial/pdf_file.pdf and b/cherrypy/tutorial/pdf_file.pdf differ
diff --git a/cherrypy/tutorial/tut01_helloworld.py b/cherrypy/tutorial/tut01_helloworld.py
index e86793c8d..5cdde927c 100644
--- a/cherrypy/tutorial/tut01_helloworld.py
+++ b/cherrypy/tutorial/tut01_helloworld.py
@@ -1,5 +1,5 @@
 """
-Tutorial - Hello World
+Tutorial - Hello World.
 
 The most basic (working) CherryPy application possible.
 """
@@ -11,13 +11,13 @@
 
 
 class HelloWorld:
-
-    """ Sample request handler class. """
+    """Sample request handler class."""
 
     # Expose the index method through the web. CherryPy will never
     # publish methods that don't have the exposed attribute set to True.
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of hello world app index URI."""
         # CherryPy will call this method for the root URI ("/") and send
         # its return value to the client. Because this is tutorial
         # lesson number 01, we'll just send something really simple.
diff --git a/cherrypy/tutorial/tut02_expose_methods.py b/cherrypy/tutorial/tut02_expose_methods.py
index 8afbf7d8b..52823dfb5 100644
--- a/cherrypy/tutorial/tut02_expose_methods.py
+++ b/cherrypy/tutorial/tut02_expose_methods.py
@@ -1,5 +1,5 @@
 """
-Tutorial - Multiple methods
+Tutorial - Multiple methods.
 
 This tutorial shows you how to link to other methods of your request
 handler.
@@ -11,15 +11,17 @@
 
 
 class HelloWorld:
+    """Hello world app."""
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of hello world app index URI."""
         # Let's link to another method here.
         return 'We have an <a href="show_msg">important message</a> for you!'
 
     @cherrypy.expose
     def show_msg(self):
-        # Here's the important message!
+        """Render a "Hello world!" message on ``/show_msg`` URI."""
         return 'Hello world!'
 
 
diff --git a/cherrypy/tutorial/tut03_get_and_post.py b/cherrypy/tutorial/tut03_get_and_post.py
index 0b3d46131..ab109be80 100644
--- a/cherrypy/tutorial/tut03_get_and_post.py
+++ b/cherrypy/tutorial/tut03_get_and_post.py
@@ -1,5 +1,5 @@
 """
-Tutorial - Passing variables
+Tutorial - Passing variables.
 
 This tutorial shows you how to pass GET/POST variables to methods.
 """
@@ -10,19 +10,22 @@
 
 
 class WelcomePage:
+    """Welcome page app."""
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of welcome app index URI."""
         # Ask for the user's name.
-        return '''
+        return """
             <form action="greetUser" method="GET">
             What is your name?
             <input type="text" name="name" />
             <input type="submit" />
-            </form>'''
+            </form>"""
 
     @cherrypy.expose
     def greetUser(self, name=None):
+        """Render a greeting or form on ``/greetUser`` URI."""
         # CherryPy passes all GET and POST variables as method parameters.
         # It doesn't make a difference where the variables come from, how
         # large their contents are, and so on.
@@ -30,7 +33,6 @@ def greetUser(self, name=None):
         # You can define default parameter values as usual. In this
         # example, the "name" parameter defaults to None so we can check
         # if a name was actually specified.
-
         if name:
             # Greet the user!
             return "Hey %s, what's up?" % name
diff --git a/cherrypy/tutorial/tut04_complex_site.py b/cherrypy/tutorial/tut04_complex_site.py
index 3caa1775d..fc81ac919 100644
--- a/cherrypy/tutorial/tut04_complex_site.py
+++ b/cherrypy/tutorial/tut04_complex_site.py
@@ -1,5 +1,5 @@
 """
-Tutorial - Multiple objects
+Tutorial - Multiple objects.
 
 This tutorial shows you how to create a site structure through multiple
 possibly nested request handler objects.
@@ -11,32 +11,38 @@
 
 
 class HomePage:
+    """Home page app."""
 
     @cherrypy.expose
     def index(self):
-        return '''
+        """Produce HTTP response body of home page app index URI."""
+        return """
             <p>Hi, this is the home page! Check out the other
             fun stuff on this site:</p>
 
             <ul>
                 <li><a href="/joke/">A silly joke</a></li>
                 <li><a href="/links/">Useful links</a></li>
-            </ul>'''
+            </ul>"""
 
 
 class JokePage:
+    """Joke app."""
 
     @cherrypy.expose
     def index(self):
-        return '''
+        """Produce HTTP response body of joke page app index URI."""
+        return """
             <p>"In Python, how do you create a string of random
             characters?" -- "Read a Perl file!"</p>
-            <p>[<a href="../">Return</a>]</p>'''
+            <p>[<a href="../">Return</a>]</p>"""
 
 
 class LinksPage:
+    """Links page app."""
 
     def __init__(self):
+        """Mount extra links page into the links page app."""
         # Request handler objects can create their own nested request
         # handler objects. Simply create them inside their __init__
         # methods!
@@ -44,16 +50,17 @@ def __init__(self):
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of links page app index URI."""
         # Note the way we link to the extra links page (and back).
         # As you can see, this object doesn't really care about its
         # absolute position in the site tree, since we use relative
         # links exclusively.
-        return '''
+        return """
             <p>Here are some useful links:</p>
 
             <ul>
                 <li>
-                    <a href="http://www.cherrypy.org">The CherryPy Homepage</a>
+                    <a href="http://www.cherrypy.dev">The CherryPy Homepage</a>
                 </li>
                 <li>
                     <a href="http://www.python.org">The Python Homepage</a>
@@ -64,23 +71,25 @@ def index(self):
             links <a href="./extra/">here</a>.</p>
 
             <p>[<a href="../">Return</a>]</p>
-        '''
+        """
 
 
 class ExtraLinksPage:
+    """Extra links app."""
 
     @cherrypy.expose
     def index(self):
+        """Render extra useful links."""
         # Note the relative link back to the Links page!
-        return '''
+        return """
             <p>Here are some extra useful links:</p>
 
             <ul>
                 <li><a href="http://del.icio.us">del.icio.us</a></li>
-                <li><a href="http://www.cherrypy.org">CherryPy</a></li>
+                <li><a href="http://www.cherrypy.dev">CherryPy</a></li>
             </ul>
 
-            <p>[<a href="../">Return to links page</a>]</p>'''
+            <p>[<a href="../">Return to links page</a>]</p>"""
 
 
 # Of course we can also mount request handler objects right here!
diff --git a/cherrypy/tutorial/tut05_derived_objects.py b/cherrypy/tutorial/tut05_derived_objects.py
index f626e03f0..d4417bc26 100644
--- a/cherrypy/tutorial/tut05_derived_objects.py
+++ b/cherrypy/tutorial/tut05_derived_objects.py
@@ -1,5 +1,5 @@
 """
-Tutorial - Object inheritance
+Tutorial - Object inheritance.
 
 You are free to derive your request handler classes from any base
 class you wish. In most real-world applications, you will probably
@@ -13,24 +13,28 @@ class you wish. In most real-world applications, you will probably
 
 
 class Page:
+    """Web page base class."""
+
     # Store the page title in a class attribute
     title = 'Untitled Page'
 
     def header(self):
-        return '''
+        """Render HTML layout header."""
+        return """
             <html>
             <head>
                 <title>%s</title>
             <head>
             <body>
             <h2>%s</h2>
-        ''' % (self.title, self.title)
+        """ % (self.title, self.title)
 
     def footer(self):
-        return '''
+        """Render HTML layout footer."""
+        return """
             </body>
             </html>
-        '''
+        """
 
     # Note that header and footer don't get their exposed attributes
     # set to True. This isn't necessary since the user isn't supposed
@@ -40,35 +44,50 @@ def footer(self):
 
 
 class HomePage(Page):
+    """Home page app."""
+
     # Different title for this page
     title = 'Tutorial 5'
 
     def __init__(self):
+        """Mount another page into the home page app."""
         # create a subpage
         self.another = AnotherPage()
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of home page app index URI."""
         # Note that we call the header and footer methods inherited
         # from the Page class!
-        return self.header() + '''
+        return (
+            self.header()
+            + """
             <p>
             Isn't this exciting? There's
             <a href="./another/">another page</a>, too!
             </p>
-        ''' + self.footer()
+        """
+            + self.footer()
+        )
 
 
 class AnotherPage(Page):
+    """Another page app."""
+
     title = 'Another Page'
 
     @cherrypy.expose
     def index(self):
-        return self.header() + '''
+        """Produce HTTP response body of another page app index URI."""
+        return (
+            self.header()
+            + """
             <p>
             And this is the amazing second page!
             </p>
-        ''' + self.footer()
+        """
+            + self.footer()
+        )
 
 
 tutconf = os.path.join(os.path.dirname(__file__), 'tutorial.conf')
diff --git a/cherrypy/tutorial/tut06_default_method.py b/cherrypy/tutorial/tut06_default_method.py
index 0ce4cabe8..33074979e 100644
--- a/cherrypy/tutorial/tut06_default_method.py
+++ b/cherrypy/tutorial/tut06_default_method.py
@@ -1,5 +1,5 @@
 """
-Tutorial - The default method
+Tutorial - The default method.
 
 Request handler objects can implement a method called "default" that
 is called when no other suitable method/object could be found.
@@ -22,20 +22,23 @@
 
 
 class UsersPage:
+    """The users app."""
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of the users app index URI."""
         # Since this is just a stupid little example, we'll simply
         # display a list of links to random, made-up users. In a real
         # application, this could be generated from a database result set.
-        return '''
+        return """
             <a href="./remi">Remi Delon</a><br/>
             <a href="./hendrik">Hendrik Mans</a><br/>
             <a href="./lorenzo">Lorenzo Lamas</a><br/>
-        '''
+        """
 
     @cherrypy.expose
     def default(self, user):
+        """Produce HTTP response body of the users app fallback URI."""
         # Here we react depending on the virtualPath -- the part of the
         # path that could not be mapped to an object method. In a real
         # application, we would probably do some database lookups here
diff --git a/cherrypy/tutorial/tut07_sessions.py b/cherrypy/tutorial/tut07_sessions.py
index 204322b58..aefc42e31 100644
--- a/cherrypy/tutorial/tut07_sessions.py
+++ b/cherrypy/tutorial/tut07_sessions.py
@@ -1,5 +1,5 @@
 """
-Tutorial - Sessions
+Tutorial - Sessions.
 
 Storing session data in CherryPy applications is very easy: cherrypy
 provides a dictionary called "session" that represents the session
@@ -14,11 +14,13 @@
 
 
 class HitCounter:
+    """Hit counter app."""
 
     _cp_config = {'tools.sessions.on': True}
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of hit counter app index URI."""
         # Increase the silly hit counter
         count = cherrypy.session.get('count', 0) + 1
 
@@ -26,10 +28,13 @@ def index(self):
         cherrypy.session['count'] = count
 
         # And display a silly hit count message!
-        return '''
+        return (
+            """
             During your current session, you've viewed this
             page %s times! Your life is a patio of fun!
-        ''' % count
+        """
+            % count
+        )
 
 
 tutconf = os.path.join(os.path.dirname(__file__), 'tutorial.conf')
diff --git a/cherrypy/tutorial/tut08_generators_and_yield.py b/cherrypy/tutorial/tut08_generators_and_yield.py
index 18f42f934..4e5500916 100644
--- a/cherrypy/tutorial/tut08_generators_and_yield.py
+++ b/cherrypy/tutorial/tut08_generators_and_yield.py
@@ -1,5 +1,5 @@
 """
-Bonus Tutorial: Using generators to return result bodies
+Bonus Tutorial: Using generators to return result bodies.
 
 Instead of returning a complete result string, you can use the yield
 statement to return one result part after another. This may be convenient
@@ -13,15 +13,19 @@
 
 
 class GeneratorDemo:
+    """HTTP response streaming app."""
 
     def header(self):
+        """Render HTML layout header."""
         return '<html><body><h2>Generators rule!</h2>'
 
     def footer(self):
+        """Render HTML layout footer."""
         return '</body></html>'
 
     @cherrypy.expose
     def index(self):
+        """Stream HTTP response body of generator app index URI."""
         # Let's make up a list of users for presentation purposes
         users = ['Remi', 'Carlos', 'Hendrik', 'Lorenzo Lamas']
 
diff --git a/cherrypy/tutorial/tut09_files.py b/cherrypy/tutorial/tut09_files.py
index 48585cbe1..bc88815ed 100644
--- a/cherrypy/tutorial/tut09_files.py
+++ b/cherrypy/tutorial/tut09_files.py
@@ -1,6 +1,5 @@
 """
-
-Tutorial: File upload and download
+Tutorial: File upload and download.
 
 Uploads
 -------
@@ -51,9 +50,11 @@
 
 
 class FileDemo(object):
+    """File upload app."""
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of file upload app index URI."""
         return """
         <html><body>
             <h2>Upload a file</h2>
@@ -68,6 +69,7 @@ def index(self):
 
     @cherrypy.expose
     def upload(self, myFile):
+        """Receive a file upload at ``/upload`` URI."""
         out = """<html>
         <body>
             myFile length: %s<br />
@@ -91,9 +93,14 @@ def upload(self, myFile):
 
     @cherrypy.expose
     def download(self):
+        """Send file to the HTTP client accessing ``/download`` URI."""
         path = os.path.join(absDir, 'pdf_file.pdf')
-        return static.serve_file(path, 'application/x-download',
-                                 'attachment', os.path.basename(path))
+        return static.serve_file(
+            path,
+            'application/x-download',
+            'attachment',
+            os.path.basename(path),
+        )
 
 
 tutconf = os.path.join(os.path.dirname(__file__), 'tutorial.conf')
diff --git a/cherrypy/tutorial/tut10_http_errors.py b/cherrypy/tutorial/tut10_http_errors.py
index 18f02fd0e..3110004b7 100644
--- a/cherrypy/tutorial/tut10_http_errors.py
+++ b/cherrypy/tutorial/tut10_http_errors.py
@@ -1,11 +1,9 @@
 """
-
-Tutorial: HTTP errors
+Tutorial: HTTP errors.
 
 HTTPError is used to return an error response to the client.
 CherryPy has lots of options regarding how such errors are
 logged, displayed, and formatted.
-
 """
 
 import os
@@ -18,13 +16,14 @@
 
 
 class HTTPErrorDemo(object):
+    """HTTP error representation app."""
 
     # Set a custom response for 403 errors.
-    _cp_config = {'error_page.403':
-                  os.path.join(curpath, 'custom_error.html')}
+    _cp_config = {'error_page.403': os.path.join(curpath, 'custom_error.html')}
 
     @cherrypy.expose
     def index(self):
+        """Produce HTTP response body of error display app index URI."""
         # display some links that will result in errors
         tracebacks = cherrypy.request.show_tracebacks
         if tracebacks:
@@ -32,7 +31,8 @@ def index(self):
         else:
             trace = 'on'
 
-        return """
+        return (
+            """
         <html><body>
             <p>Toggle tracebacks <a href="toggleTracebacks">%s</a></p>
             <p><a href="/doesNotExist">Click me; I'm a broken link!</a></p>
@@ -51,10 +51,13 @@ def index(self):
             <p><a href="/messageArg">You can also set the response body
             when you raise an error.</a></p>
         </body></html>
-        """ % trace
+        """
+            % trace
+        )
 
     @cherrypy.expose
     def toggleTracebacks(self):
+        """Switch tracebacks setting on ``/toggleTracebacks`` URI."""
         # simple function to toggle tracebacks on and off
         tracebacks = cherrypy.request.show_tracebacks
         cherrypy.config.update({'request.show_tracebacks': not tracebacks})
@@ -64,14 +67,18 @@ def toggleTracebacks(self):
 
     @cherrypy.expose
     def error(self, code):
+        """Respond with a given HTTP error."""
         # raise an error based on the get query
         raise cherrypy.HTTPError(status=code)
 
     @cherrypy.expose
     def messageArg(self):
-        message = ("If you construct an HTTPError with a 'message' "
-                   'argument, it wil be placed on the error page '
-                   '(underneath the status line by default).')
+        """Respond with an HTTP 500 and a custom message."""
+        message = (
+            "If you construct an HTTPError with a 'message' "
+            'argument, it wil be placed on the error page '
+            '(underneath the status line by default).'
+        )
         raise cherrypy.HTTPError(500, message=message)
 
 
diff --git a/conftest.py b/conftest.py
index b42322963..b2126c789 100644
--- a/conftest.py
+++ b/conftest.py
@@ -1,14 +1,6 @@
-"""test configuration for pytest."""
-
-import sys
-
+"""Test configuration for pytest."""
 
 collect_ignore = [
     # imports win32api, so not viable on some systems
     'cherrypy/process/win32.py',
 ]
-
-
-if sys.version_info < (3, 6):
-    # Modules in docs require Python 3.6
-    collect_ignore.append('docs')
diff --git a/dependencies/lock-files/dist-build-constraints.txt b/dependencies/lock-files/dist-build-constraints.txt
new file mode 100644
index 000000000..6ef52ad7c
--- /dev/null
+++ b/dependencies/lock-files/dist-build-constraints.txt
@@ -0,0 +1,16 @@
+#
+# This file is autogenerated by pip-compile with Python 3.12
+# by the following command:
+#
+#    tox r -e pip-compile-build-lock --
+#
+packaging==24.1
+    # via setuptools-scm
+setuptools-scm==8.1.0
+    # via awx-plugins-core (pyproject.toml::build-system.requires)
+
+# The following packages are considered to be unsafe in a requirements file:
+setuptools==73.0.0
+    # via
+    #   awx-plugins-core (pyproject.toml::build-system.requires)
+    #   setuptools-scm
diff --git a/docs/advanced.rst b/docs/advanced.rst
index d22230760..5cc335481 100644
--- a/docs/advanced.rst
+++ b/docs/advanced.rst
@@ -498,7 +498,7 @@ facility.
         status = '200 OK'
         response_headers = [('Content-type','text/plain')]
         start_response(status, response_headers)
-        return ['Hello world!']
+        return [b'Hello world!']
 
     cherrypy.tree.graft(raw_wsgi_app, '/')
 
diff --git a/docs/conf.py b/docs/conf.py
index c277b6e48..8a926aaa4 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -13,12 +13,7 @@
 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-from email import message_from_string
 import importlib
-import pkg_resources
-import sys
-
-assert sys.version_info > (3, 5), 'Python 3 required to build docs'
 
 
 def try_import(mod_name):
@@ -33,9 +28,9 @@ def get_supported_pythons(classifiers):
     """Return min and max supported Python version from meta as tuples."""
     PY_VER_CLASSIFIER = 'Programming Language :: Python :: '
     vers = filter(lambda c: c.startswith(PY_VER_CLASSIFIER), classifiers)
-    vers = map(lambda c: c[len(PY_VER_CLASSIFIER):], vers)
+    vers = map(lambda c: c[len(PY_VER_CLASSIFIER) :], vers)
     vers = filter(lambda c: c[0].isdigit() and '.' in c, vers)
-    vers = map(lambda c: tuple(c.split('.')), vers)
+    vers = map(lambda c: tuple(map(int, c.split('.'))), vers)
     vers = sorted(vers)
     del vers[1:-1]
     return vers
@@ -43,18 +38,17 @@ def get_supported_pythons(classifiers):
 
 custom_sphinx_theme = try_import('alabaster')
 
-prj_dist = pkg_resources.get_distribution('cherrypy')
-prj_pkg_info = prj_dist.get_metadata(prj_dist.PKG_INFO)
-prj_meta = message_from_string(prj_pkg_info)
+prj_meta = importlib.metadata.metadata('cherrypy')
 prj_author = prj_meta['Author']
 prj_license = prj_meta['License']
 prj_description = prj_meta['Description']
 prj_py_ver_range = get_supported_pythons(prj_meta.get_all('Classifier'))
 prj_py_min_supported, prj_py_max_supported = map(
-    lambda v: '.'.join(v), prj_py_ver_range
+    lambda v: '.'.join(map(str, v)),
+    prj_py_ver_range,
 )
 
-project = prj_dist.project_name
+project = prj_meta['Name']
 
 github_url = 'https://github.com'
 github_repo_org = project.lower()
@@ -80,29 +74,32 @@ def get_supported_pythons(classifiers):
 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
 extensions = [
+    # Stdlib extensions:
     'sphinx.ext.autodoc',
     'sphinx.ext.extlinks',
     'sphinx.ext.intersphinx',
     'sphinx.ext.todo',
     'sphinx.ext.viewcode',
     'sphinx.ext.napoleon',
+    # Third-party extensions:
+    'sphinxcontrib.apidoc',
     'rst.linker',
     'jaraco.packaging.sphinx',
 ]
 
 extlinks = {
-    'issue': (f'{github_repo_url}/issues/%s', '#'),
-    'pr': (f'{github_repo_url}/pull/%s', 'PR #'),
-    'commit': (f'{github_repo_url}/commit/%s', ''),
-    'cr-issue': (f'{cr_github_repo_url}/issues/%s', 'Cheroot #'),
-    'cr-pr': (f'{cr_github_repo_url}/pull/%s', 'Cheroot PR #'),
-    'gh': (f'{github_url}/%s', 'GitHub: '),
-    'user': (f'{github_sponsors_url}/%s', '@'),
+    'issue': (f'{github_repo_url}/issues/%s', '#%s'),
+    'pr': (f'{github_repo_url}/pull/%s', 'PR #%s'),
+    'commit': (f'{github_repo_url}/commit/%s', '%s'),
+    'cr-issue': (f'{cr_github_repo_url}/issues/%s', 'Cheroot #%s'),
+    'cr-pr': (f'{cr_github_repo_url}/pull/%s', 'Cheroot PR #%s'),
+    'gh': (f'{github_url}/%s', 'GitHub: %s'),
+    'user': (f'{github_sponsors_url}/%s', '@%s'),
 }
 
 intersphinx_mapping = {
     'python': ('https://docs.python.org/3', None),
-    'cheroot': ('https://cheroot.cherrypy.org/en/latest/', None),
+    'cheroot': ('https://cheroot.cherrypy.dev/en/latest/', None),
     'pytest-docs': ('https://docs.pytest.org/en/latest/', None),
 }
 
@@ -169,10 +166,16 @@ def get_supported_pythons(classifiers):
 # Custom sidebar templates, maps document names to template names.
 html_sidebars = {
     'index': [
-        'about.html', 'searchbox.html', 'navigation.html', 'python_2_eol.html',
+        'about.html',
+        'searchbox.html',
+        'navigation.html',
+        'python_2_eol.html',
     ],
     '**': [
-        'about.html', 'searchbox.html', 'navigation.html', 'python_2_eol.html',
+        'about.html',
+        'searchbox.html',
+        'navigation.html',
+        'python_2_eol.html',
     ],
 }
 
@@ -196,30 +199,6 @@ def get_supported_pythons(classifiers):
 ]
 
 
-def mock_pywin32():
-    """Mock pywin32 module.
-
-    Resulting in Linux hosts, including ReadTheDocs,
-    and other environments that don't have pywin32 can generate the docs
-    properly including the PDF version.
-    See:
-    http://read-the-docs.readthedocs.org/en/latest/faq.html#i-get-import-errors-on-libraries-that-depend-on-c-modules
-    """
-    if try_import('win32api'):
-        return
-
-    from unittest import mock
-
-    MOCK_MODULES = [
-        'win32api', 'win32con', 'win32event', 'win32service',
-        'win32serviceutil',
-    ]
-    for mod_name in MOCK_MODULES:
-        sys.modules[mod_name] = mock.MagicMock()
-
-
-mock_pywin32()
-
 link_files = {
     '../CHANGES.rst': dict(
         using=dict(
@@ -227,7 +206,7 @@ def mock_pywin32():
         ),
         replace=[
             dict(
-                pattern=r'^(?m)((?P<scm_version>v?\d+(\.\d+){1,2}))\n[-=]+\n',
+                pattern=r'(?m)^((?P<scm_version>v?\d+(\.\d+){1,2}))\n[-=]+\n',
                 with_scm='{text}\n{rev[timestamp]:%d %b %Y}\n',
             ),
         ],
@@ -238,3 +217,28 @@ def mock_pywin32():
 # Ref: https://github.com/python-attrs/attrs/pull/571/files\
 #      #diff-85987f48f1258d9ee486e3191495582dR82
 default_role = 'any'
+
+
+# -- Options for autodoc extension ---------------------------------------
+
+autodoc_mock_imports = [
+    'win32api',
+    'win32con',
+    'win32event',
+    'win32service',
+    'win32serviceutil',
+]
+
+
+# -- Options for apidoc extension ----------------------------------------
+
+apidoc_excluded_paths = []
+apidoc_extra_args = [
+    '--implicit-namespaces',
+    '--private',  # include “_private” modules
+]
+apidoc_module_dir = '../cherrypy'
+apidoc_module_first = False
+apidoc_output_dir = 'pkg'
+apidoc_separate_modules = True
+apidoc_toc_file = None
diff --git a/docs/contribute.rst b/docs/contribute.rst
index f00552938..f4ba3374d 100644
--- a/docs/contribute.rst
+++ b/docs/contribute.rst
@@ -6,7 +6,7 @@ The project actively encourages aspiring and experienced users to dive
 in and add their best contribution to the project.
 
 How can you contribute? Well, first search the `docs
-<https://docs.cherrypy.org>`_ and the `project page
+<https://docs.cherrypy.dev>`_ and the `project page
 <https://github.com/cherrypy/cherrypy>`_ to see if someone
 has already reported your issue.
 
diff --git a/docs/index.rst b/docs/index.rst
index bbd0fe6dd..15834b7e3 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -19,15 +19,20 @@ CherryPy — A Minimalist Python Web Framework
    development.rst
    glossary.rst
    history.rst
-   pkg/modules.rst
 
-`CherryPy <http://www.cherrypy.org>`_ is a pythonic, object-oriented web framework.
+.. toctree::
+   :hidden:
+   :caption: Reference
+
+   pkg/modules
+
+`CherryPy <http://www.cherrypy.dev>`_ is a pythonic, object-oriented web framework.
 
 CherryPy allows developers to build web applications in much the
 same way they would build any other object-oriented Python program.
 This results in smaller source code developed in less time.
 
-CherryPy is now more than ten years old and it is has proven to
+CherryPy is now more than ten years old, and it has proven to
 be fast and reliable. It is being used in production by many
 sites, from the simplest to the most demanding.
 
diff --git a/docs/pkg/.gitignore b/docs/pkg/.gitignore
new file mode 100644
index 000000000..d6b7ef32c
--- /dev/null
+++ b/docs/pkg/.gitignore
@@ -0,0 +1,2 @@
+*
+!.gitignore
diff --git a/docs/pkg/cherrypy.lib.rst b/docs/pkg/cherrypy.lib.rst
deleted file mode 100644
index 8df1261c3..000000000
--- a/docs/pkg/cherrypy.lib.rst
+++ /dev/null
@@ -1,142 +0,0 @@
-cherrypy.lib package
-====================
-
-Submodules
-----------
-
-cherrypy.lib.auth_basic module
-------------------------------
-
-.. automodule:: cherrypy.lib.auth_basic
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.auth_digest module
--------------------------------
-
-.. automodule:: cherrypy.lib.auth_digest
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.caching module
----------------------------
-
-.. automodule:: cherrypy.lib.caching
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.covercp module
----------------------------
-
-.. automodule:: cherrypy.lib.covercp
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.cpstats module
----------------------------
-
-.. automodule:: cherrypy.lib.cpstats
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.cptools module
----------------------------
-
-.. automodule:: cherrypy.lib.cptools
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.encoding module
-----------------------------
-
-.. automodule:: cherrypy.lib.encoding
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.gctools module
----------------------------
-
-.. automodule:: cherrypy.lib.gctools
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.httputil module
-----------------------------
-
-.. automodule:: cherrypy.lib.httputil
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.jsontools module
------------------------------
-
-.. automodule:: cherrypy.lib.jsontools
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.locking module
----------------------------
-
-.. automodule:: cherrypy.lib.locking
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.profiler module
-----------------------------
-
-.. automodule:: cherrypy.lib.profiler
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.reprconf module
-----------------------------
-
-.. automodule:: cherrypy.lib.reprconf
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.sessions module
-----------------------------
-
-.. automodule:: cherrypy.lib.sessions
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.static module
---------------------------
-
-.. automodule:: cherrypy.lib.static
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.lib.xmlrpcutil module
-------------------------------
-
-.. automodule:: cherrypy.lib.xmlrpcutil
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-
-Module contents
----------------
-
-.. automodule:: cherrypy.lib
-    :members:
-    :undoc-members:
-    :show-inheritance:
diff --git a/docs/pkg/cherrypy.process.rst b/docs/pkg/cherrypy.process.rst
deleted file mode 100644
index 86fa54363..000000000
--- a/docs/pkg/cherrypy.process.rst
+++ /dev/null
@@ -1,46 +0,0 @@
-cherrypy.process package
-========================
-
-Submodules
-----------
-
-cherrypy.process.plugins module
--------------------------------
-
-.. automodule:: cherrypy.process.plugins
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.process.servers module
--------------------------------
-
-.. automodule:: cherrypy.process.servers
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.process.win32 module
------------------------------
-
-.. automodule:: cherrypy.process.win32
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.process.wspbus module
-------------------------------
-
-.. automodule:: cherrypy.process.wspbus
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-
-Module contents
----------------
-
-.. automodule:: cherrypy.process
-    :members:
-    :undoc-members:
-    :show-inheritance:
diff --git a/docs/pkg/cherrypy.rst b/docs/pkg/cherrypy.rst
deleted file mode 100644
index 38599fa12..000000000
--- a/docs/pkg/cherrypy.rst
+++ /dev/null
@@ -1,33 +0,0 @@
-cherrypy package
-================
-
-Subpackages
------------
-
-.. toctree::
-
-    cherrypy.lib
-    cherrypy.process
-    cherrypy.scaffold
-    cherrypy.test
-    cherrypy.tutorial
-
-Submodules
-----------
-
-cherrypy.daemon module
-----------------------
-
-.. automodule:: cherrypy.daemon
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-
-Module contents
----------------
-
-.. automodule:: cherrypy
-    :members:
-    :undoc-members:
-    :show-inheritance:
diff --git a/docs/pkg/cherrypy.scaffold.rst b/docs/pkg/cherrypy.scaffold.rst
deleted file mode 100644
index c13adbf0d..000000000
--- a/docs/pkg/cherrypy.scaffold.rst
+++ /dev/null
@@ -1,10 +0,0 @@
-cherrypy.scaffold package
-=========================
-
-Module contents
----------------
-
-.. automodule:: cherrypy.scaffold
-    :members:
-    :undoc-members:
-    :show-inheritance:
diff --git a/docs/pkg/cherrypy.test.rst b/docs/pkg/cherrypy.test.rst
deleted file mode 100644
index de05e2923..000000000
--- a/docs/pkg/cherrypy.test.rst
+++ /dev/null
@@ -1,390 +0,0 @@
-cherrypy.test package
-=====================
-
-Submodules
-----------
-
-cherrypy.test.benchmark module
-------------------------------
-
-.. automodule:: cherrypy.test.benchmark
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.checkerdemo module
---------------------------------
-
-.. automodule:: cherrypy.test.checkerdemo
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.helper module
----------------------------
-
-.. automodule:: cherrypy.test.helper
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.logtest module
-----------------------------
-
-.. automodule:: cherrypy.test.logtest
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.modfastcgi module
--------------------------------
-
-.. automodule:: cherrypy.test.modfastcgi
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.modfcgid module
------------------------------
-
-.. automodule:: cherrypy.test.modfcgid
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.modpy module
---------------------------
-
-.. automodule:: cherrypy.test.modpy
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.modwsgi module
-----------------------------
-
-.. automodule:: cherrypy.test.modwsgi
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.sessiondemo module
---------------------------------
-
-.. automodule:: cherrypy.test.sessiondemo
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_auth_basic module
-------------------------------------
-
-.. automodule:: cherrypy.test.test_auth_basic
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_auth_digest module
--------------------------------------
-
-.. automodule:: cherrypy.test.test_auth_digest
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_bus module
------------------------------
-
-.. automodule:: cherrypy.test.test_bus
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_caching module
----------------------------------
-
-.. automodule:: cherrypy.test.test_caching
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_compat module
---------------------------------
-
-.. automodule:: cherrypy.test.test_compat
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_config module
---------------------------------
-
-.. automodule:: cherrypy.test.test_config
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_config_server module
----------------------------------------
-
-.. automodule:: cherrypy.test.test_config_server
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_conn module
-------------------------------
-
-.. automodule:: cherrypy.test.test_conn
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_core module
-------------------------------
-
-.. automodule:: cherrypy.test.test_core
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_dynamicobjectmapping module
-----------------------------------------------
-
-.. automodule:: cherrypy.test.test_dynamicobjectmapping
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_encoding module
-----------------------------------
-
-.. automodule:: cherrypy.test.test_encoding
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_etags module
--------------------------------
-
-.. automodule:: cherrypy.test.test_etags
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_http module
-------------------------------
-
-.. automodule:: cherrypy.test.test_http
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_httplib module
----------------------------------
-
-.. automodule:: cherrypy.test.test_httplib
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_iterator module
-----------------------------------
-
-.. automodule:: cherrypy.test.test_iterator
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_json module
-------------------------------
-
-.. automodule:: cherrypy.test.test_json
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_logging module
----------------------------------
-
-.. automodule:: cherrypy.test.test_logging
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_mime module
-------------------------------
-
-.. automodule:: cherrypy.test.test_mime
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_misc_tools module
-------------------------------------
-
-.. automodule:: cherrypy.test.test_misc_tools
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_objectmapping module
----------------------------------------
-
-.. automodule:: cherrypy.test.test_objectmapping
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_params module
---------------------------------
-
-.. automodule:: cherrypy.test.test_params
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_proxy module
--------------------------------
-
-.. automodule:: cherrypy.test.test_proxy
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_refleaks module
-----------------------------------
-
-.. automodule:: cherrypy.test.test_refleaks
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_request_obj module
--------------------------------------
-
-.. automodule:: cherrypy.test.test_request_obj
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_routes module
---------------------------------
-
-.. automodule:: cherrypy.test.test_routes
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_session module
----------------------------------
-
-.. automodule:: cherrypy.test.test_session
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_sessionauthenticate module
----------------------------------------------
-
-.. automodule:: cherrypy.test.test_sessionauthenticate
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_states module
---------------------------------
-
-.. automodule:: cherrypy.test.test_states
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_static module
---------------------------------
-
-.. automodule:: cherrypy.test.test_static
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_tools module
--------------------------------
-
-.. automodule:: cherrypy.test.test_tools
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_tutorials module
------------------------------------
-
-.. automodule:: cherrypy.test.test_tutorials
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_virtualhost module
--------------------------------------
-
-.. automodule:: cherrypy.test.test_virtualhost
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_wsgi_ns module
----------------------------------
-
-.. automodule:: cherrypy.test.test_wsgi_ns
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_wsgi_unix_socket module
-------------------------------------------
-
-.. automodule:: cherrypy.test.test_wsgi_unix_socket
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_wsgi_vhost module
-------------------------------------
-
-.. automodule:: cherrypy.test.test_wsgi_vhost
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_wsgiapps module
-----------------------------------
-
-.. automodule:: cherrypy.test.test_wsgiapps
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.test_xmlrpc module
---------------------------------
-
-.. automodule:: cherrypy.test.test_xmlrpc
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.test.webtest module
-----------------------------
-
-.. automodule:: cherrypy.test.webtest
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-
-Module contents
----------------
-
-.. automodule:: cherrypy.test
-    :members:
-    :undoc-members:
-    :show-inheritance:
diff --git a/docs/pkg/cherrypy.tutorial.rst b/docs/pkg/cherrypy.tutorial.rst
deleted file mode 100644
index 3676e0ba2..000000000
--- a/docs/pkg/cherrypy.tutorial.rst
+++ /dev/null
@@ -1,94 +0,0 @@
-cherrypy.tutorial package
-=========================
-
-Submodules
-----------
-
-cherrypy.tutorial.tut01_helloworld module
------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut01_helloworld
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut02_expose_methods module
----------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut02_expose_methods
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut03_get_and_post module
--------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut03_get_and_post
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut04_complex_site module
--------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut04_complex_site
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut05_derived_objects module
-----------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut05_derived_objects
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut06_default_method module
----------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut06_default_method
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut07_sessions module
----------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut07_sessions
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut08_generators_and_yield module
----------------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut08_generators_and_yield
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut09_files module
-------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut09_files
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-cherrypy.tutorial.tut10_http_errors module
-------------------------------------------
-
-.. automodule:: cherrypy.tutorial.tut10_http_errors
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-
-Module contents
----------------
-
-.. automodule:: cherrypy.tutorial
-    :members:
-    :undoc-members:
-    :show-inheritance:
diff --git a/docs/pkg/modules.rst b/docs/pkg/modules.rst
deleted file mode 100644
index 9c68b63a0..000000000
--- a/docs/pkg/modules.rst
+++ /dev/null
@@ -1,7 +0,0 @@
-Modules
-=======
-
-.. toctree::
-   :maxdepth: 4
-
-   cherrypy
diff --git a/man/cherryd.1 b/man/cherryd.1
index 1811660a1..4e838bbea 100644
--- a/man/cherryd.1
+++ b/man/cherryd.1
@@ -253,7 +253,7 @@ These are the built\-in environment configurations:
 fumanchu
 
 .nf
-cherrypy.org
+cherrypy.dev
 .fi
 
 .SH COPYRIGHT
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 000000000..247576ff0
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,125 @@
+[build-system]
+requires = [
+  # Essentials
+  "setuptools >= 61.2",
+
+  # Plugins
+  "setuptools-scm >= 7.0.0",
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "CherryPy"
+description = "Object-Oriented HTTP framework"
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Environment :: Web Environment",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Framework :: CherryPy",
+  "License :: OSI Approved :: BSD License",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: Implementation",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: Jython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+  "Topic :: Internet :: WWW/HTTP",
+  "Topic :: Internet :: WWW/HTTP :: Dynamic Content",
+  "Topic :: Internet :: WWW/HTTP :: HTTP Servers",
+  "Topic :: Internet :: WWW/HTTP :: WSGI",
+  "Topic :: Internet :: WWW/HTTP :: WSGI :: Application",
+  "Topic :: Internet :: WWW/HTTP :: WSGI :: Server",
+  "Topic :: Software Development :: Libraries :: Application Frameworks",
+]
+requires-python = ">= 3.9"
+dependencies = [
+  "cheroot >= 8.2.1",
+  "portend >= 2.1.1",
+  "more_itertools",
+  "filelock",
+  "jaraco.collections",
+  # pywin32 disabled while a build is unavailable. Ref #1920.
+  'pywin32 >= 227; sys_platform == "win32" and implementation_name == "cpython" and python_version < "3.10"',
+]
+dynamic = [
+  "version",
+]
+
+[[project.authors]]
+name = "CherryPy Team"
+email = "team@cherrypy.dev"
+
+[project.urls]
+Homepage = "https://cherrypy.dev"
+"Chat: Matrix" = "https://matrix.to/#/#cherrypy-space:matrix.org"
+"CI: GitHub" = "https://github.com/cherrypy/cherrypy/actions"
+"Docs: RTD" = "https://docs.cherrypy.dev"
+"GitHub: issues" = "https://github.com/cherrypy/cherrypy/issues"
+"GitHub: repo" = "https://github.com/cherrypy/cherrypy"
+"Tidelift: funding" = "https://tidelift.com/subscription/pkg/pypi-cherrypy?utm_source=pypi-cherrypy&utm_medium=referral&utm_campaign=pypi"
+
+[project.readme]
+file = "README.rst"
+content-type = "text/x-rst"
+
+[project.optional-dependencies]
+docs = [
+  "sphinx",
+  "docutils",
+  "alabaster",
+  "sphinxcontrib-apidoc >= 0.3.0",
+  "rst.linker >= 1.11",
+  "jaraco.packaging >= 3.2",
+]
+json = [
+  "simplejson",
+]
+routes_dispatcher = [
+  "routes >= 2.3.1",
+]
+ssl = [
+  "pyOpenSSL",
+]
+testing = [
+  "objgraph",  # cherrypy.lib.gctools
+  "pytest >= 5.3.5",
+  "pytest-cov",
+  "pytest-forked",
+  "pytest-rerunfailures",
+  "pytest-sugar",
+  "path",
+  "requests_toolbelt",
+  "pytest-services >= 2",
+  "setuptools",
+]
+memcached_session = [
+  # Enables memcached session support via `cherrypy[memcached_session]`
+  "python-memcached >= 1.58",
+]
+xcgi = [
+  "flup",
+]
+
+[project.scripts]
+cherryd = "cherrypy.__main__:run"
+
+[tool.setuptools]
+license-files = [
+  "LICENSE.md",
+]
+packages = [
+  "cherrypy",
+  "cherrypy.lib",
+  "cherrypy.tutorial",
+  "cherrypy.test",
+  "cherrypy.process",
+  "cherrypy.scaffold",
+]
+
+[tool.setuptools_scm]
diff --git a/pytest.ini b/pytest.ini
index 909f146c5..6ee0a59c1 100644
--- a/pytest.ini
+++ b/pytest.ini
@@ -1,57 +1,94 @@
 [pytest]
 addopts =
-    # `pytest-xdist`:
-    #--numprocesses=auto
+  # FIXME: Enable this once the test suite has no race conditions
+  # `pytest-xdist`:
+  # --numprocesses=auto
 
-    # `pytest-mon`:
-    # useful for live testing with `pytest-watch` during development:
-    #--testmon
+  # `pytest-mon`:
+  # Useful for live testing with `pytest-watch` during development:
+  #--testmon
 
-    # show 10 slowest invocations:
-    --durations=10
+  # Show 10 slowest invocations:
+  --durations=10
 
-    # a bit of verbosity doesn't hurt:
-    -v
+  # A bit of verbosity doesn't hurt:
+  -v
 
-    # report all the things == -rxXs:
-    -ra
+  # Report all the things == -rxXs:
+  -ra
 
-    # show values of the local vars in errors:
-    --showlocals
+  # Show values of the local vars in errors:
+  --showlocals
 
-    # autocollect and invoke the doctests from all modules:
-    --doctest-modules
+  # Autocollect and invoke the doctests from all modules:
+  # https://docs.pytest.org/en/stable/doctest.html
+  --doctest-modules
 
-    # dump the test results in junit format:
-    --junitxml=.test-results/pytest/results.xml
+  # `pytest-cov`:
+  # `pytest-cov`, "-p" preloads the module early:
+  -p pytest_cov
+  --no-cov-on-fail
+  --cov=cherrypy
+  --cov-branch
+  --cov-report=term-missing:skip-covered
+  --cov-context=test
+  --cov-config=.coveragerc
 
-    # `pytest-cov`:
-    --cov=cherrypy
-    --cov-report term-missing:skip-covered
-    --cov-report xml
-    # --cov-report xml:.test-results/pytest/cov.xml  # alternatively move it here
 doctest_optionflags = ALLOW_UNICODE ELLIPSIS
+
 filterwarnings =
-    error
-    ignore:Use cheroot.test.webtest:DeprecationWarning
-    ignore:This method will be removed in future versions.*:DeprecationWarning
-    ignore:Unable to verify that the server is bound on:UserWarning
-    ignore:Not importing directory .*.tox/py35/lib/python3.5/site-packages/(zc|repoze).* missing __init__:ImportWarning
-    # ref: https://github.com/mhammond/pywin32/issues/1256#issuecomment-527972824 :
-    ignore:the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses:DeprecationWarning
-    ignore:the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses:PendingDeprecationWarning
+  error
+
+  # pytest>=6.2.0 under Python 3.8:
+  # Ref: https://docs.pytest.org/en/stable/usage.html#unraisable
+  # Ref: https://github.com/pytest-dev/pytest/issues/5299
+  ignore:Exception ignored in. <socket.socket fd=-1, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=6>:pytest.PytestUnraisableExceptionWarning:_pytest.unraisableexception
+  ignore:Exception ignored in. <_io.FileIO .closed.>:pytest.PytestUnraisableExceptionWarning:_pytest.unraisableexception
+
+  ignore:Use cheroot.test.webtest:DeprecationWarning
+  ignore:This method will be removed in future versions.*:DeprecationWarning
+  ignore:Unable to verify that the server is bound on:UserWarning
+  # ref: https://github.com/mhammond/pywin32/issues/1256#issuecomment-527972824 :
+  ignore:the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses:DeprecationWarning
+  ignore:the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses:PendingDeprecationWarning
+
+  # TODO: Remove once `cheroot.webtest._open_url_once` is fixed to release
+  # TODO: connection properly.
+  ignore:unclosed <socket.socket fd=:ResourceWarning
+
+  # TODO: Remove once `cherrypy._cpreqbody.Part.file` is closed to release
+  # TODO: deterministically as well as similar places opening a file descriptor
+  # TODO: via `tempfile.TemporaryFile()` but never closing it.
+  # NOTE: This is most visible under PyPy.
+  ignore:unclosed file <_io.BufferedRandom name=:ResourceWarning
+
+  # TODO: Figure out how to ensure that the file descriptor open in
+  # TODO: `cherrypy.lib.static.serve_file()` is closed.
+  ignore:unclosed file <_io.BufferedReader name=:ResourceWarning
+
+  # Python 3.13 no longer ignores IOBase errors raised by the close(),
+  # which exposed a possible race condition in cheroot test class.
+  ignore:Exception ignored in. <function IOBase.__del__:pytest.PytestUnraisableExceptionWarning
+
 junit_duration_report = call
 junit_family = xunit2
 junit_suite_name = cherrypy_test_suite
+
+# A mapping of markers to their descriptions allowed in strict mode:
+markers =
+
 minversion = 5.3.5
+
+# Optimize pytest's lookup by restricting potentially deep dir tree scan:
 norecursedirs =
-    build
-    cherrypy.egg-info
-    dist
-    docs
-    .cache
-    .eggs
-    .git
-    .github
-    .tox
+  build
+  cherrypy.egg-info
+  dist
+  docs
+  .cache
+  .eggs
+  .git
+  .github
+  .tox
+
 testpaths = cherrypy/test/
diff --git a/requirements/tox-build-dists.in b/requirements/tox-build-dists.in
new file mode 100644
index 000000000..27f5471db
--- /dev/null
+++ b/requirements/tox-build-dists.in
@@ -0,0 +1 @@
+build ~= 0.9.0
diff --git a/setup.cfg b/setup.cfg
deleted file mode 100644
index 3d7a7f490..000000000
--- a/setup.cfg
+++ /dev/null
@@ -1,9 +0,0 @@
-[aliases]
-dists = clean --all sdist bdist_wheel
-
-[bdist_wheel]
-universal = 1
-
-[metadata]
-license_file = LICENSE.md
-long_description = file:README.rst
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 5c715e89f..000000000
--- a/setup.py
+++ /dev/null
@@ -1,113 +0,0 @@
-#! /usr/bin/env python
-"""CherryPy package setuptools installer."""
-
-import setuptools
-
-
-name = 'CherryPy'
-repo_slug = 'cherrypy/{}'.format(name.lower())
-repo_url = 'https://github.com/{}'.format(repo_slug)
-
-
-params = dict(
-    name=name,
-    use_scm_version=True,
-    description='Object-Oriented HTTP framework',
-    author='CherryPy Team',
-    author_email='team@cherrypy.org',
-    classifiers=[
-        'Development Status :: 5 - Production/Stable',
-        'Environment :: Web Environment',
-        'Intended Audience :: Developers',
-        'License :: Freely Distributable',
-        'Operating System :: OS Independent',
-        'Framework :: CherryPy',
-        'License :: OSI Approved :: BSD License',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 3',
-        'Programming Language :: Python :: 3.5',
-        'Programming Language :: Python :: 3.6',
-        'Programming Language :: Python :: 3.7',
-        'Programming Language :: Python :: 3.8',
-        'Programming Language :: Python :: Implementation',
-        'Programming Language :: Python :: Implementation :: CPython',
-        'Programming Language :: Python :: Implementation :: Jython',
-        'Programming Language :: Python :: Implementation :: PyPy',
-        'Topic :: Internet :: WWW/HTTP',
-        'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
-        'Topic :: Internet :: WWW/HTTP :: HTTP Servers',
-        'Topic :: Internet :: WWW/HTTP :: WSGI',
-        'Topic :: Internet :: WWW/HTTP :: WSGI :: Application',
-        'Topic :: Internet :: WWW/HTTP :: WSGI :: Server',
-        'Topic :: Software Development :: Libraries :: Application Frameworks',
-    ],
-    url='https://www.cherrypy.org',
-    project_urls={
-        'CI: AppVeyor': 'https://ci.appveyor.com/project/{}'.format(repo_slug),
-        'CI: Travis': 'https://travis-ci.org/{}'.format(repo_slug),
-        'CI: Circle': 'https://circleci.com/gh/{}'.format(repo_slug),
-        'Docs: RTD': 'https://docs.cherrypy.org',
-        'GitHub: issues': '{}/issues'.format(repo_url),
-        'GitHub: repo': repo_url,
-        'Tidelift: funding':
-        'https://tidelift.com/subscription/pkg/pypi-cherrypy'
-        '?utm_source=pypi-cherrypy&utm_medium=referral&utm_campaign=pypi',
-    },
-    packages=[
-        'cherrypy', 'cherrypy.lib',
-        'cherrypy.tutorial', 'cherrypy.test',
-        'cherrypy.process',
-        'cherrypy.scaffold',
-    ],
-    entry_points={'console_scripts': ['cherryd = cherrypy.__main__:run']},
-    include_package_data=True,
-    install_requires=[
-        'cheroot>=8.2.1',
-        'portend>=2.1.1',
-        'more_itertools',
-        'zc.lockfile',
-        'jaraco.collections',
-    ],
-    extras_require={
-        'docs': [
-            'sphinx',
-            'docutils',
-            'alabaster',
-            'rst.linker>=1.11',
-            'jaraco.packaging>=3.2',
-        ],
-        'json': ['simplejson'],
-        'routes_dispatcher': ['routes>=2.3.1'],
-        'ssl': ['pyOpenSSL'],
-        'testing': [
-            'coverage',  # inspects tests coverage
-            'codecov',   # sends tests coverage to codecov.io
-
-            # cherrypy.lib.gctools
-            'objgraph',
-
-            'pytest>=5.3.5',
-            'pytest-cov',
-            'pytest-forked',
-            'pytest-sugar',
-            'path.py',
-            'requests_toolbelt',
-            'pytest-services>=2',
-        ],
-        # Enables memcached session support via `cherrypy[memcached_session]`:
-        'memcached_session': ['python-memcached>=1.58'],
-        'xcgi': ['flup'],
-
-        # https://docs.cherrypy.org/en/latest/advanced.html?highlight=windows#windows-console-events
-        ':sys_platform == "win32" and implementation_name == "cpython"': [
-            'pywin32',
-        ],
-    },
-    setup_requires=[
-        'setuptools_scm',
-    ],
-    python_requires='>=3.5',
-)
-
-
-__name__ == '__main__' and setuptools.setup(**params)
diff --git a/tests/dist-check.py b/tests/dist-check.py
index 008a63d20..8434beab7 100644
--- a/tests/dist-check.py
+++ b/tests/dist-check.py
@@ -1,15 +1,12 @@
-"""
-Integration test to check the integrity of the
-distribution.
+"""Integration test to check the integrity of the distribution.
 
-This file is explicitly not named 'test_' to avoid
-being collected by pytest, but must instead be
-invoked explicitly (i.e. pytest tests/dist-check.py).
+This file is explicitly not named ``test_`` to avoid being collected by
+pytest, but must instead be invoked explicitly
+(i.e. ``pytest tests/dist-check.py``).
 
-This test cannot be invoked as part of the normal
-test suite nor can it be included in the normal test
-suite because it must import cherrypy late (after
-removing sys.path[0]).
+This test cannot be invoked as part of the normal test suite nor can it
+be included in the normal test suite because it must import cherrypy
+late (after removing ``sys.path[0]``).
 """
 
 import os
@@ -18,25 +15,26 @@
 import pytest
 
 
-@pytest.fixture(params=[
-    'favicon.ico',
-    'scaffold/static/made_with_cherrypy_small.png',
-    'tutorial/tutorial.conf',
-    'tutorial/custom_error.html',
-])
+@pytest.fixture(
+    params=[
+        'favicon.ico',
+        'scaffold/static/made_with_cherrypy_small.png',
+        'tutorial/tutorial.conf',
+        'tutorial/custom_error.html',
+    ],
+)
 def data_file_path(request):
-    'generates data file paths expected to be found in the package'
+    """Generate data file paths expected to be found in the package."""
     return request.param
 
 
 @pytest.fixture(autouse=True, scope='session')
 def remove_paths_to_checkout():
-    """Remove paths to ./cherrypy"""
+    """Remove paths to ``./cherrypy``."""
     to_remove = [
         path
         for path in sys.path
-        if os.path.isdir(path)
-        and os.path.samefile(path, os.path.curdir)
+        if os.path.isdir(path) and os.path.samefile(path, os.path.curdir)
     ]
     print('Removing', to_remove)
     list(map(sys.path.remove, to_remove))
@@ -44,11 +42,9 @@ def remove_paths_to_checkout():
 
 
 def test_data_files_installed(data_file_path):
-    """
-    Ensure that data file paths are available in the
-    installed package as expected.
-    """
+    """Ensure data file paths are available in the installed package."""
     import cherrypy
+
     root = os.path.dirname(cherrypy.__file__)
     fn = os.path.join(root, data_file_path)
     assert os.path.exists(fn), fn
@@ -57,9 +53,6 @@ def test_data_files_installed(data_file_path):
 
 
 def test_sanity():
-    """
-    Test the test to show that it does fail when a file
-    is missing.
-    """
+    """Test the test to show that it does fail when a file is missing."""
     with pytest.raises(Exception):
         test_data_files_installed('does not exist')
diff --git a/tox.ini b/tox.ini
index e8e9e6cdd..3632a5ac0 100644
--- a/tox.ini
+++ b/tox.ini
@@ -1,84 +1,251 @@
 [tox]
 envlist = python
-minversion = 2.4
+minversion = 4
+
+[python-cli-options]
+byte-warnings = -b
+byte-errors = -bb
+max-isolation = -E -s -I
+# some-isolation = -I
+# FIXME: Python 2 shim. Is this equivalent to the above?
+some-isolation = -E -s
+warnings-to-errors = -Werror
+
 
 [testenv]
 usedevelop = True
-commands_pre =
-    pip install -U setuptools
 commands =
-    pytest {posargs}
-    codecov -f coverage.xml -X gcov
+  {envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]some-isolation} \
+    -m pytest \
+      {tty:--color=yes} \
+      {posargs:--cov-report=html:{envtmpdir}{/}htmlcov{/}}
+commands_post =
+  -{envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]max-isolation} \
+    {[python-cli-options]warnings-to-errors} \
+    -c \
+      'import atexit, os, sys; \
+      os.getenv("GITHUB_ACTIONS") == "true" or sys.exit(); \
+      import coverage; \
+      gh_summary_fd = open(\
+        os.environ["GITHUB_STEP_SUMMARY"], encoding="utf-8", mode="a",\
+      ); \
+      atexit.register(gh_summary_fd.close); \
+      cov = coverage.Coverage(); \
+      cov.load(); \
+      cov.report(file=gh_summary_fd, output_format="markdown")'
+  {envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]max-isolation} \
+    {[python-cli-options]warnings-to-errors} \
+    -c \
+      'import os, pathlib, sys; \
+      os.getenv("GITHUB_ACTIONS") == "true" or sys.exit(); \
+      cov_report_arg_prefix = "--cov-report=xml:"; \
+      test_report_arg_prefix = "--junitxml="; \
+      cov_reports = [\
+        arg[len(cov_report_arg_prefix):] for arg in sys.argv \
+        if arg.startswith(cov_report_arg_prefix)\
+      ]; \
+      test_reports = [\
+        arg[len(test_report_arg_prefix):] for arg in sys.argv \
+        if arg.startswith(test_report_arg_prefix)\
+      ]; \
+      cov_report_file = cov_reports[-1] if cov_reports else None; \
+      test_report_file = test_reports[-1] if test_reports else None; \
+      gh_output_fd = open(\
+        os.environ["GITHUB_OUTPUT"], encoding="utf-8", mode="a",\
+      ); \
+      cov_report_file and \
+        print(f"cov-report-files={cov_report_file !s}", file=gh_output_fd); \
+      test_report_file and \
+        print(f"test-result-files={test_report_file !s}", file=gh_output_fd); \
+      print("codecov-flags=pytest", file=gh_output_fd); \
+      gh_output_fd.close()' \
+    {posargs}
+  # Print out the output coverage dir and a way to serve html:
+  {envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]max-isolation} \
+    {[python-cli-options]warnings-to-errors} \
+    -c\
+      'import pathlib, shlex, sys; \
+      cov_html_report_arg_prefix = "--cov-report=html:"; \
+      cov_html_reports = [\
+        arg[len(cov_html_report_arg_prefix):] for arg in sys.argv \
+        if arg.startswith(cov_html_report_arg_prefix)\
+      ]; \
+      cov_html_reports or sys.exit(); \
+      cov_html_report_dir = pathlib.Path(cov_html_reports[-1]); \
+      index_file = cov_html_report_dir / "index.html";\
+      index_file.exists() or sys.exit(); \
+      html_url = f"file://\{index_file\}";\
+      browse_cmd = shlex.join(("python3", "-Im", "webbrowser", html_url)); \
+      serve_cmd = shlex.join((\
+        "python3", "-Im", "http.server", \
+        "--directory", str(cov_html_report_dir), "0", \
+      )); \
+      print(f"\nTo open the HTML coverage report, run\n\n\
+      \t\{browse_cmd !s\}\n");\
+      print(f"To serve \
+      the HTML coverage report with a local web server, use\n\n\
+      \t\{serve_cmd !s\}\n")' \
+    {posargs:--cov-report=html:{envtmpdir}{/}htmlcov{/}}
 passenv =
   WEBTEST_INTERACTIVE
   CI
-  TRAVIS
-  TRAVIS_*
-  APPVEYOR
-  APPVEYOR_*
-  CIRCLECI
-  CIRCLE_*
 setenv =
-    WEBTEST_INTERACTIVE=false
+  WEBTEST_INTERACTIVE=false
 extras =
-    testing
-    routes_dispatcher
-    memcached_session
+  testing
+  routes_dispatcher
+  memcached_session
 whitelist_externals = mkdir
 
+
+[dists]
+setenv =
+  PIP_CONSTRAINT = {toxinidir}{/}dependencies{/}lock-files{/}dist-build-constraints.txt
+  PEP517_OUT_DIR = {env:PEP517_OUT_DIR:{toxinidir}{/}dist}
+
+
 [testenv:cheroot-master]
 deps = git+git://github.com/cherrypy/cheroot.git@master#egg=cheroot
 
 [testenv:pre-commit]
 deps =
-    pre-commit
+  pre-commit
 commands =
-    {envpython} -m pre_commit run --show-diff-on-failure {posargs:--all-files}
-
-    # Print out the advice of how to install pre-commit from this env into Git:
-    -{envpython} -c \
-    'cmd = "{envpython} -m pre_commit install"; scr_width = len(cmd) + 10; sep = "=" * scr_width; cmd_str = "    $ " + cmd; '\
-    'print("\n" + sep + "\nTo install pre-commit hooks into the Git repo, run:\n\n" + cmd_str + "\n\n" + sep + "\n")'
+  {envpython} -m pre_commit run --show-diff-on-failure {posargs:--all-files}
 
-[testenv:pre-commit-pep257]
-deps = pre-commit
-commands =
-    pre-commit run --config .pre-commit-config-pep257.yaml --all-files {posargs}
+  # Print out the advice of how to install pre-commit from this env into Git:
+  -{envpython} -c \
+  'cmd = "{envpython} -m pre_commit install"; scr_width = len(cmd) + 10; sep = "=" * scr_width; cmd_str = "    $ " + cmd; '\
+  'print("\n" + sep + "\nTo install pre-commit hooks into the Git repo, run:\n\n" + cmd_str + "\n\n" + sep + "\n")'
+commands_post =
 
 [testenv:dist-check]
 # ensure that package artifacts are installed as expected
 usedevelop = False
 commands =
-    pytest tests/dist-check.py {posargs}
-
-[testenv:setup-check]
-extras =
-    docs
-usedevelop = False
-commands =
-    python -m setup check --metadata --restructuredtext --strict --verbose
+  pytest tests/dist-check.py {posargs}
+commands_post =
 
 [testenv:build-docs]
 basepython = python3
 extras =
-    docs
-    testing
+  docs
+  testing
 changedir = docs
 # FIXME: Add -W option below once this issue is addressed:
 # https://github.com/jaraco/rst.linker/issues/7
 # And once all other warnings are gone.
 commands =
-    {envpython} -m sphinx \
-      -a \
-      -j auto \
-      -b html \
-      --color \
-      -n \
-      -d "{toxinidir}/build/html_docs_doctree" \
-      . \
-      "{toxinidir}/build/html"
-
-    # Print out the output docs dir and a way to serve html:
-    -{envpython} -c \
-    'import pathlib; docs_dir = pathlib.Path(r"{toxinidir}") / "build" / "html"; index_file = docs_dir / "index.html"; '\
-    'print("\n" + "=" * 120 + f"\n\nDocumentation available under `file://\{index_file\}`\n\nTo serve docs, use `python3 -m http.server --directory \{docs_dir\} 0`\n\n" + "=" * 120)'
+  {envpython} -m sphinx {posargs} \
+    -a \
+    -j auto \
+    -b html \
+    --color \
+    -n \
+    -d "{toxinidir}/build/html_docs_doctree" \
+    . \
+    "{toxinidir}/build/html"
+commands_post =
+  # Print out the output docs dir and a way to serve html:
+  -{envpython} -c \
+  'import pathlib; docs_dir = pathlib.Path(r"{toxinidir}") / "build" / "html"; index_file = docs_dir / "index.html"; '\
+  'print("\n" + "=" * 120 + f"\n\nDocumentation available under `file://\{index_file\}`\n\nTo serve docs, use `python3 -m http.server --directory \{docs_dir\} 0`\n\n" + "=" * 120)'
+
+
+[testenv:cleanup-dists]
+description =
+  Wipe the the dist{/} folder
+# NOTE: `package_env = none` is needed so it's possible to use `--installpkg`
+# NOTE: with the main `testenv`.
+# Ref: https://github.com/tox-dev/tox/issues/2442
+package_env = ❌ DUMMY NON-EXISTENT ENV NAME ❌
+usedevelop = false
+skip_install = true
+deps =
+setenv =
+  {[dists]setenv}
+commands_pre =
+commands =
+  {envpython} \
+  {[python-cli-options]byte-errors} \
+  {[python-cli-options]some-isolation} \
+  -c \
+    'import os, shutil, sys; dists_dir = os.getenv("PEP517_OUT_DIR"); shutil.rmtree(dists_dir, ignore_errors=True); sys.exit(os.path.exists(dists_dir))'
+commands_post =
+
+
+[testenv:build-dists]
+allowlist_externals =
+  env
+description =
+  Build dists and put them into
+  the `{env:PEP517_OUT_DIR}{/}` folder
+depends =
+  cleanup-dists
+platform = darwin|linux
+# NOTE: The custom command is here to allow resetting the global
+# NOTE: pip constraints env var.
+isolated_build = true
+# NOTE: `package_env = none` is needed so it's possible to use `--installpkg`
+# NOTE: with the main `testenv`.
+# Ref: https://github.com/tox-dev/tox/issues/2442
+package_env = ❌ DUMMY NON-EXISTENT ENV NAME ❌
+# `usedevelop = true` overrides `skip_install` instruction, it's unwanted
+usedevelop = false
+skip_install = true
+deps =
+  -rrequirements{/}tox-build-dists.in
+passenv =
+  PEP517_BUILD_ARGS
+setenv =
+  {[dists]setenv}
+commands_pre =
+commands =
+  # Starting with build v0.5.0, it builds wheel from sdist
+  # if no format arguments are passed. This makes sure that
+  # wheels are not dependent on the Git repo or anything
+  # external what may be missing from sdist.
+  {envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]some-isolation} \
+    -m build \
+      --outdir '{env:PEP517_OUT_DIR}{/}' \
+      {posargs:{env:PEP517_BUILD_ARGS:}} \
+      '{toxinidir}'
+commands_post =
+
+
+[testenv:metadata-validation]
+description =
+  Verify that dists under the `{env:PEP517_OUT_DIR}{/}` dir
+  have valid metadata
+depends =
+  build-dists
+deps =
+  setuptools-scm
+  twine
+usedevelop = false
+skip_install = true
+commands_pre =
+  {envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]some-isolation} \
+    -m setuptools_scm ls
+setenv =
+  {[dists]setenv}
+commands =
+  {envpython} \
+    {[python-cli-options]byte-errors} \
+    {[python-cli-options]some-isolation} \
+    -m twine check \
+      --strict \
+      {env:PEP517_OUT_DIR}{/}*
+commands_post =
diff --git a/toxfile.py b/toxfile.py
new file mode 100644
index 000000000..43437728d
--- /dev/null
+++ b/toxfile.py
@@ -0,0 +1,185 @@
+"""Project-local tox env customizations."""
+
+import platform
+import ssl
+from base64 import b64encode
+from hashlib import sha256
+from logging import getLogger
+from os import environ, getenv
+from pathlib import Path
+
+from tox.execute.request import StdinSource
+from tox.plugin import impl
+from tox.tox_env.api import ToxEnv
+
+
+IS_GITHUB_ACTIONS_RUNTIME = getenv('GITHUB_ACTIONS') == 'true'
+FILE_APPEND_MODE = 'a'
+UNICODE_ENCODING = 'utf-8'
+SYS_PLATFORM = platform.system()
+IS_WINDOWS = SYS_PLATFORM == 'Windows'
+
+
+logger = getLogger(__name__)
+
+
+def _log_debug_before_run_commands(msg: str) -> None:
+    logger.debug(
+        '%s%s> %s',  # noqa: WPS323
+        'toxfile',
+        ':tox_before_run_commands',
+        msg,
+    )
+
+
+def _log_info_before_run_commands(msg: str) -> None:
+    logger.info(
+        '%s%s> %s',  # noqa: WPS323
+        'toxfile',
+        ':tox_before_run_commands',
+        msg,
+    )
+
+
+def _log_warning_before_run_commands(msg: str) -> None:
+    logger.warning(
+        '%s%s> %s',  # noqa: WPS323
+        'toxfile',
+        ':tox_before_run_commands',
+        msg,
+    )
+
+
+@impl
+def tox_before_run_commands(tox_env: ToxEnv) -> None:  # noqa: WPS210, WPS213
+    """Display test runtime info when in GitHub Actions CI/CD.
+
+    This also injects ``SOURCE_DATE_EPOCH`` env var into build-dists.
+
+    :param tox_env: A tox environment object.
+    """
+    if tox_env.name == 'build-dists':
+        _log_debug_before_run_commands(
+            'Setting the Git HEAD-based epoch for reproducibility in GHA...',
+        )
+        git_executable = 'git'
+        git_log_cmd = (  # noqa: WPS317
+            git_executable,
+            '-c',
+            'core.pager=',  # prevents ANSI escape sequences
+            'log',
+            '-1',
+            '--pretty=%ct',  # noqa: WPS323
+        )
+        tox_env.conf['allowlist_externals'].append(git_executable)
+        git_log_outcome = tox_env.execute(git_log_cmd, StdinSource.OFF)
+        tox_env.conf['allowlist_externals'].pop()
+        if git_log_outcome.exit_code:
+            _log_warning_before_run_commands(
+                f'Failed to look up Git HEAD timestamp. {git_log_outcome!s}',
+            )
+            return
+
+        git_head_timestamp = git_log_outcome.out.strip()
+
+        _log_info_before_run_commands(
+            f'Setting `SOURCE_DATE_EPOCH={git_head_timestamp!s}` environment '
+            'variable to facilitate build reproducibility...',
+        )
+        tox_env.environment_variables['SOURCE_DATE_EPOCH'] = git_head_timestamp
+
+    if tox_env.name not in {'py', 'python'} or not IS_GITHUB_ACTIONS_RUNTIME:
+        _log_debug_before_run_commands(
+            'Not logging runtime info because this is not a test run on '
+            'GitHub Actions platform...',
+        )
+        return
+
+    _log_info_before_run_commands('INFO Logging runtime details...')
+
+    systeminfo_executable = 'systeminfo'
+    systeminfo_cmd = (systeminfo_executable,)
+    if IS_WINDOWS:
+        tox_env.conf['allowlist_externals'].append(systeminfo_executable)
+        tox_env.execute(systeminfo_cmd, stdin=StdinSource.OFF, show=True)
+        tox_env.conf['allowlist_externals'].pop()
+    else:
+        _log_debug_before_run_commands(
+            f'Not running {systeminfo_executable!s} because this is '
+            'not Windows...',
+        )
+
+    _log_info_before_run_commands('Logging platform information...')
+    print(  # noqa: T201, WPS421
+        'Current platform information:\n'
+        f'{platform.platform()=}'
+        f'{platform.system()=}'
+        f'{platform.version()=}'
+        f'{platform.uname()=}'
+        f'{platform.release()=}',
+    )
+
+    _log_info_before_run_commands('Logging current OpenSSL module...')
+    print(  # noqa: T201, WPS421
+        'Current OpenSSL module:\n'
+        f'{ssl.OPENSSL_VERSION=}\n'
+        f'{ssl.OPENSSL_VERSION_INFO=}\n'
+        f'{ssl.OPENSSL_VERSION_NUMBER=}',
+    )
+
+
+def _log_debug_after_run_commands(msg: str) -> None:
+    logger.debug(
+        '%s%s> %s',  # noqa: WPS323
+        'toxfile',
+        ':tox_after_run_commands',
+        msg,
+    )
+
+
+def _compute_sha256sum(file_path: Path) -> str:
+    return sha256(file_path.read_bytes()).hexdigest()
+
+
+def _produce_sha256sum_line(file_path: Path) -> str:
+    sha256_str = _compute_sha256sum(file_path)
+    return f'{sha256_str!s}  {file_path.name!s}'
+
+
+@impl
+def tox_after_run_commands(tox_env: ToxEnv) -> None:
+    """Compute combined dists hash post build-dists under GHA.
+
+    :param tox_env: A tox environment object.
+    """
+    if tox_env.name == 'build-dists' and IS_GITHUB_ACTIONS_RUNTIME:
+        _log_debug_after_run_commands(
+            'Computing and storing the base64 representation '
+            'of the combined dists SHA-256 hash in GHA...',
+        )
+        dists_dir_path = Path(__file__).parent / 'dist'
+        emulated_sha256sum_output = '\n'.join(
+            _produce_sha256sum_line(artifact_path)
+            for artifact_path in dists_dir_path.glob('*')
+        )
+        emulated_base64_w0_output = b64encode(
+            emulated_sha256sum_output.encode(),
+        ).decode()
+
+        with Path(environ['GITHUB_OUTPUT']).open(
+            encoding=UNICODE_ENCODING,
+            mode=FILE_APPEND_MODE,
+        ) as outputs_file:
+            print(  # noqa: T201, WPS421
+                'combined-dists-base64-encoded-sha256-hash='
+                f'{emulated_base64_w0_output!s}',
+                file=outputs_file,
+            )
+
+
+def tox_append_version_info() -> str:
+    """Produce text to be rendered in ``tox --version``.
+
+    :returns: A string with the plugin details.
+    """
+    return '[toxfile]'  # Broken: https://github.com/tox-dev/tox/issues/3508