Bump version

Resolve warning issue with error handler mismatch warning
2022-05-10 22:38:00 +03:00 · 2022-05-10 22:37:51 +03:00
259 changed files with 5157 additions and 17329 deletions
--- a/.black.toml
+++ b/.black.toml
@@ -0,0 +1,2 @@
+[tool.black]
+line-length = 79
--- a/.coveragerc
+++ b/.coveragerc
@@ -4,12 +4,11 @@ source = sanic
 omit =
    site-packages
    sanic/__main__.py
-    sanic/server/legacy.py
    sanic/compat.py
+    sanic/reloader_helpers.py
    sanic/simple.py
    sanic/utils.py
    sanic/cli
-    sanic/pages

 [html]
 directory = coverage
@@ -21,5 +20,12 @@ exclude_lines =
    noqa
    NOQA
    pragma: no cover
-    TYPE_CHECKING
+omit =
+    site-packages
+    sanic/__main__.py
+    sanic/compat.py
+    sanic/reloader_helpers.py
+    sanic/simple.py
+    sanic/utils.py
+    sanic/cli
 skip_empty = True
--- a/.github/ISSUE_TEMPLATE/bug-report.yml
+++ b/.github/ISSUE_TEMPLATE/bug-report.yml
@@ -1,78 +0,0 @@
-name: 🐞 Bug report
-description: Create a report to help us improve
-labels: ["bug", "triage"]
-body:
-  - type: checkboxes
-    id: existing
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the bug you encountered.
-      options:
-      - label: I have searched the existing issues
-        required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Describe the bug
-      description: A clear and concise description of what the bug is, make sure to paste any exceptions and tracebacks using markdown code-block syntax to make it easier to read.
-    validations:
-      required: true
-  - type: textarea
-    id: code
-    attributes:
-      label: Code snippet
-      description: |
-          Relevant source code, make sure to remove what is not necessary. Please try and format your code so that it is easier to read. For example:
-
-              ```python
-              from sanic import Sanic
-
-              app = Sanic("Example")
-              ```
-    validations:
-      required: false
-  - type: textarea
-    id: expected
-    attributes:
-      label: Expected Behavior
-      description: A concise description of what you expected to happen.
-    validations:
-      required: false
-  - type: dropdown
-    id: running
-    attributes:
-      label: How do you run Sanic?
-      options:
-        - Sanic CLI
-        - As a module
-        - As a script (`app.run` or `Sanic.serve`)
-        - ASGI
-    validations:
-      required: true
-  - type: dropdown
-    id: os
-    attributes:
-      label: Operating System
-      description: What OS?
-      options:
-        - Linux
-        - MacOS
-        - Windows
-        - Other (tell us in the description)
-    validations:
-      required: true
-  - type: input
-    id: version
-    attributes:
-      label: Sanic Version
-      description: Check startup logs or try `sanic --version`
-    validations:
-      required: true
-  - type: textarea
-    id: additional
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.
-    validations:
-      required: false
-
--- a/.github/ISSUE_TEMPLATE/bug_report.md
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,25 @@
+---
+name: Bug report
+about: Create a report to help us improve
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is, make sure to paste any exceptions and tracebacks.
+
+
+**Code snippet**
+Relevant source code, make sure to remove what is not necessary.
+
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+
+**Environment (please complete the following information):**
+ - OS: [e.g. iOS]
+ - Version [e.g. 0.8.3]
+
+
+**Additional context**
+Add any other context about the problem here.
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,8 +1,5 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
  - name: Questions and Help
    url: https://community.sanicframework.org/c/questions-and-help
    about: Do you need help with Sanic? Ask your questions here.
-  - name: Discussion and Support
-    url: https://discord.gg/FARQzAEMAA
-    about: For live discussion and support, checkout the Sanic Discord server.
--- a/.github/ISSUE_TEMPLATE/feature-request.yml
+++ b/.github/ISSUE_TEMPLATE/feature-request.yml
@@ -1,34 +0,0 @@
-name: 🌟 Feature request
-description: Suggest an enhancement for Sanic
-labels: ["feature request"]
-body:
-  - type: checkboxes
-    id: existing
-    attributes:
-      label: Is there an existing issue for this?
-      description: Please search to see if an issue already exists for the enhancement you are proposing.
-      options:
-      - label: I have searched the existing issues
-        required: true
-  - type: textarea
-    id: description
-    attributes:
-      label: Is your feature request related to a problem? Please describe.
-      description: A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-    validations:
-      required: false
-  - type: textarea
-    id: code
-    attributes:
-      label: Describe the solution you'd like
-      description: A clear and concise description of what you want to happen.
-    validations:
-      required: true
-  - type: textarea
-    id: additional
-    attributes:
-      label: Additional context
-      description: Add any other context about the problem here.
-    validations:
-      required: false
-
--- a/.github/ISSUE_TEMPLATE/feature_request.md
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,16 @@
+---
+name: Feature request
+about: Suggest an idea for Sanic
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+
+**Additional context**
+Add any other context or sample code about the feature request here.
--- a/.github/ISSUE_TEMPLATE/rfc.yml
+++ b/.github/ISSUE_TEMPLATE/rfc.yml
@@ -1,33 +0,0 @@
-name: 💡 Request for Comments
-description: Open an RFC for discussion
-labels: ["RFC"]
-body:
-  - type: input
-    id: compare
-    attributes:
-      label: Link to code
-      description: If available, share a [comparison](https://github.com/sanic-org/sanic/compare) from a POC branch to main
-      placeholder: https://github.com/sanic-org/sanic/compare/main...some-new-branch
-    validations:
-      required: false
-  - type: textarea
-    id: proposal
-    attributes:
-      label: Proposal
-      description: A thorough discussion of the proposal discussing the problem it solves, potential code, use cases, and impacts
-    validations:
-      required: true
-  - type: textarea
-    id: additional
-    attributes:
-      label: Additional context
-      description: Add any other context that is relevant
-    validations:
-      required: false
-  - type: checkboxes
-    id: breaking
-    attributes:
-      label: Is this a breaking change?
-      options:
-        - label: "Yes"
-          required: false
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -4,12 +4,10 @@ on:
  push:
    branches:
      - main
-      - current-release
      - "*LTS"
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]
  schedule:
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -3,14 +3,12 @@ on:
  push:
    branches:
      - main
-      - current-release
      - "*LTS"
    tags:
      - "!*" # Do not execute on tags
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
 jobs:
  test:
--- a/.github/workflows/pr-bandit.yml
+++ b/.github/workflows/pr-bandit.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

@@ -17,10 +16,10 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        config:
+          - { python-version: 3.7, tox-env: security}
          - { python-version: 3.8, tox-env: security}
          - { python-version: 3.9, tox-env: security}
          - { python-version: "3.10", tox-env: security}
-          - { python-version: "3.11", tox-env: security}
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2
--- a/.github/workflows/pr-docs.yml
+++ b/.github/workflows/pr-docs.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

@@ -15,7 +14,7 @@ jobs:
    strategy:
      matrix:
        config:
-          - {python-version: "3.10", tox-env: "docs"}
+          - {python-version: "3.8", tox-env: "docs"}
      fail-fast: false


--- a/.github/workflows/pr-linter.yml
+++ b/.github/workflows/pr-linter.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

@@ -17,7 +16,7 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        config:
-          - { python-version: "3.10", tox-env: lint}
+          - { python-version: 3.8, tox-env: lint}
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2
--- a/.github/workflows/pr-python-pypy.yml
+++ b/.github/workflows/pr-python-pypy.yml
@@ -5,11 +5,11 @@ on:
      tox-env:
        description: "Tox Env to run on the PyPy Infra"
        required: false
-        default: "pypy310"
+        default: "pypy37"
      pypy-version:
        description: "Version of PyPy to use"
        required: false
-        default: "pypy-3.10"
+        default: "pypy-3.7"
 jobs:
  testPyPy:
    name: ut-${{ matrix.config.tox-env }}-${{ matrix.os }}
--- a/.github/workflows/pr-python310.yml
+++ b/.github/workflows/pr-python310.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

--- a/.github/workflows/pr-python311.yml
+++ b/.github/workflows/pr-python311.yml
@@ -1,35 +1,24 @@
-name: Python 3.11 Tests
+name: Python 3.7 Tests
 on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

 jobs:
-  testPy311:
+  testPy37:
    if: github.event.pull_request.draft == false
    name: ut-${{ matrix.config.tox-env }}-${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
-      fail-fast: false
+      fail-fast: true
      matrix:
-        # os: [ubuntu-latest, macos-latest]
+        #         os: [ubuntu-latest, macos-latest]
        os: [ubuntu-latest]
        config:
-          - {
-              python-version: "3.11",
-              tox-env: py311,
-              ignore-error-flake: "false",
-              command-timeout: "0",
-            }
-          - {
-              python-version: "3.11",
-              tox-env: py311-no-ext,
-              ignore-error-flake: "true",
-              command-timeout: "600000",
-            }
+          - { python-version: 3.7, tox-env: py37 }
+          - { python-version: 3.7, tox-env: py37-no-ext }
    steps:
      - name: Checkout the Repository
        uses: actions/checkout@v2
@@ -42,7 +31,5 @@ jobs:
          test-infra-tool: tox
          test-infra-version: latest
          action: tests
-          test-additional-args: "-e=${{ matrix.config.tox-env }},-vv=''"
-          experimental-ignore-error: "${{ matrix.config.ignore-error-flake }}"
-          command-timeout: "${{ matrix.config.command-timeout }}"
+          test-additional-args: "-e=${{ matrix.config.tox-env }}"
          test-failure-retry: "3"
--- a/.github/workflows/pr-python38.yml
+++ b/.github/workflows/pr-python38.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

--- a/.github/workflows/pr-python39.yml
+++ b/.github/workflows/pr-python39.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

--- a/.github/workflows/pr-type-check.yml
+++ b/.github/workflows/pr-type-check.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

@@ -17,10 +16,10 @@ jobs:
      matrix:
        os: [ubuntu-latest]
        config:
+          # - { python-version: 3.7, tox-env: type-checking}
          - { python-version: 3.8, tox-env: type-checking}
          - { python-version: 3.9, tox-env: type-checking}
          - { python-version: "3.10", tox-env: type-checking}
-          - { python-version: "3.11", tox-env: type-checking}
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v2
--- a/.github/workflows/pr-windows.yml
+++ b/.github/workflows/pr-windows.yml
@@ -3,7 +3,6 @@ on:
  pull_request:
    branches:
      - main
-      - current-release
      - "*LTS"
    types: [opened, synchronize, reopened, ready_for_review]

@@ -16,10 +15,11 @@ jobs:
      fail-fast: false
      matrix:
        config:
+          - { python-version: 3.7, tox-env: py37-no-ext }
          - { python-version: 3.8, tox-env: py38-no-ext }
          - { python-version: 3.9, tox-env: py39-no-ext }
          - { python-version: "3.10", tox-env: py310-no-ext }
-          - { python-version: "3.11", tox-env: py310-no-ext }
+          - { python-version: pypy-3.7, tox-env: pypy37-no-ext }

    steps:
      - name: Checkout Repository
--- a/.github/workflows/publish-images.yml
+++ b/.github/workflows/publish-images.yml
@@ -14,7 +14,7 @@ jobs:
    strategy:
      fail-fast: true
      matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.7", "3.8", "3.9", "3.10"]

    steps:
      - name: Checkout repository
--- a/.github/workflows/publish-package.yml
+++ b/.github/workflows/publish-package.yml
@@ -1,39 +1,28 @@
-name: Upload Python Package
-
+name: Publish Artifacts
 on:
  release:
    types: [created]
-  workflow_dispatch:
+
 jobs:
-  build-n-publish:
-    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+  publishPythonPackage:
+    name: Publishing Sanic Release Artifacts
    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: true
+      matrix:
+        python-version: ["3.8"]
+
    steps:
-    - uses: actions/checkout@v3
-    - name: Set up Python
-      uses: actions/setup-python@v4
-      with:
-        python-version: "3.x"
-    - name: Install pypa/build
-      run: >-
-        python3 -m
-        pip install
-        build
-        --user
-    - name: Build a binary wheel and a source tarball
-      run: >-
-        python3 -m
-        build
-        --sdist
-        --wheel
-        --outdir dist/
-        .
-    # - name: Publish distribution 📦 to Test PyPI
-    #   uses: pypa/gh-action-pypi-publish@release/v1
-    #   with:
-    #     password: ${{ secrets.SANIC_TEST_PYPI_API_TOKEN }}
-    #     repository-url: https://test.pypi.org/legacy/
-    - name: Publish distribution 📦 to PyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        password: ${{ secrets.SANIC_PYPI_API_TOKEN }}
+      - name: Checkout Repository
+        uses: actions/checkout@v2
+
+      - name: Publish Python Package
+        uses: harshanarayana/custom-actions@main
+        with:
+          python-version: ${{ matrix.python-version }}
+          package-infra-name: "twine"
+          pypi-user: __token__
+          pypi-access-token: ${{ secrets.PYPI_ACCESS_TOKEN }}
+          action: "package-publish"
+          pypi-verify-metadata: "true"
--- a/.gitignore
+++ b/.gitignore
@@ -21,5 +21,4 @@ dist/*
 pip-wheel-metadata/
 .pytest_cache/*
 .venv/*
-venv/*
 .vscode/*
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -357,6 +357,11 @@ Version 20.12.0
    `#1993 <https://github.com/sanic-org/sanic/pull/1993>`_
    Add disable app registry

+Version 20.12.0
+---------------
+
+**Features**
+
  *
    `#1945 <https://github.com/sanic-org/sanic/pull/1945>`_
    Static route more verbose if file not found
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -55,7 +55,7 @@ further defined and clarified by project maintainers.
 ## Enforcement

 Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at adam@sanicframework.org. All
+reported by contacting the project team at sanic-maintainers@googlegroups.com. All
 complaints will be reviewed and investigated and will result in a response that
 is deemed necessary and appropriate to the circumstances. The project team is
 obligated to maintain confidentiality with regard to the reporter of an incident.
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -71,9 +71,9 @@ To execute only unittests, run ``tox`` with environment like so:

 .. code-block:: bash

-   tox -e py37 -v -- tests/test_config.py
+   tox -e py36 -v -- tests/test_config.py
   # or
-   tox -e py310 -v -- tests/test_config.py
+   tox -e py37 -v -- tests/test_config.py

 Run lint checks
 ---------------
--- a/6
+++ b/6
@@ -66,15 +66,15 @@ ifdef include_tests
 	isort -rc sanic tests
 else
 	$(info Sorting Imports)
-	isort -rc sanic tests
+	isort -rc sanic tests  --profile=black
 endif
 endif

 black:
-	black sanic tests
+	black --config ./.black.toml sanic tests

 isort:
-	isort sanic tests
+	isort sanic tests --profile=black

 pretty: black isort

--- a/README.rst
+++ b/README.rst
@@ -11,7 +11,7 @@ Sanic | Build fast. Run fast.
    :stub-columns: 1

    * - Build
-      - | |Py310Test| |Py39Test| |Py38Test|
+      - | |Py310Test| |Py39Test| |Py38Test| |Py37Test|
    * - Docs
      - | |UserGuide| |Documentation|
    * - Package
@@ -19,7 +19,7 @@ Sanic | Build fast. Run fast.
    * - Support
      - | |Forums| |Discord| |Awesome|
    * - Stats
-      - | |Monthly Downloads| |Weekly Downloads| |Conda downloads|
+      - | |Downloads| |WkDownloads| |Conda downloads|

 .. |UserGuide| image:: https://img.shields.io/badge/user%20guide-sanic-ff0068
   :target: https://sanicframework.org/
@@ -33,6 +33,8 @@ Sanic | Build fast. Run fast.
   :target: https://github.com/sanic-org/sanic/actions/workflows/pr-python39.yml
 .. |Py38Test| image:: https://github.com/sanic-org/sanic/actions/workflows/pr-python38.yml/badge.svg?branch=main
   :target: https://github.com/sanic-org/sanic/actions/workflows/pr-python38.yml
+.. |Py37Test| image:: https://github.com/sanic-org/sanic/actions/workflows/pr-python37.yml/badge.svg?branch=main
+   :target: https://github.com/sanic-org/sanic/actions/workflows/pr-python37.yml
 .. |Documentation| image:: https://readthedocs.org/projects/sanic/badge/?version=latest
   :target: http://sanic.readthedocs.io/en/latest/?badge=latest
 .. |PyPI| image:: https://img.shields.io/pypi/v/sanic.svg
@@ -50,23 +52,19 @@ Sanic | Build fast. Run fast.
 .. |Awesome| image:: https://cdn.rawgit.com/sindresorhus/awesome/d7305f38d29fed78fa85652e3a63e154dd8e8829/media/badge.svg
    :alt: Awesome Sanic List
    :target: https://github.com/mekicha/awesome-sanic
-.. |Monthly Downloads| image:: https://img.shields.io/pypi/dm/sanic.svg
+.. |Downloads| image:: https://pepy.tech/badge/sanic/month
    :alt: Downloads
    :target: https://pepy.tech/project/sanic
-.. |Weekly Downloads| image:: https://img.shields.io/pypi/dw/sanic.svg
+.. |WkDownloads| image:: https://pepy.tech/badge/sanic/week
    :alt: Downloads
    :target: https://pepy.tech/project/sanic
 .. |Conda downloads| image:: https://img.shields.io/conda/dn/conda-forge/sanic.svg
    :alt: Downloads
    :target: https://anaconda.org/conda-forge/sanic
-.. |Linode| image:: https://www.linode.com/wp-content/uploads/2021/01/Linode-Logo-Black.svg
-    :alt: Linode
-    :target: https://www.linode.com
-    :width: 200px

 .. end-badges

-Sanic is a **Python 3.8+** web server and web framework that's written to go fast. It allows the usage of the ``async/await`` syntax added in Python 3.5, which makes your code non-blocking and speedy.
+Sanic is a **Python 3.7+** web server and web framework that's written to go fast. It allows the usage of the ``async/await`` syntax added in Python 3.5, which makes your code non-blocking and speedy.

 Sanic is also ASGI compliant, so you can deploy it with an `alternative ASGI webserver <https://sanicframework.org/en/guide/deployment/running.html#asgi>`_.

@@ -79,7 +77,7 @@ The goal of the project is to provide a simple way to get up and running a highl
 Sponsor
 -------

-Check out `open collective <https://opencollective.com/sanic-org>`_ to learn more about helping to fund Sanic.
+Check out `open collective <https://opencollective.com/sanic-org>`_ to learn more about helping to fund Sanic. 

 Thanks to `Linode <https://www.linode.com>`_ for their contribution towards the development and community of Sanic.

@@ -104,6 +102,9 @@ Installation
  If you are running on a clean install of Fedora 28 or above, please make sure you have the ``redhat-rpm-config`` package installed in case if you want to
  use ``sanic`` with ``ujson`` dependency.

+.. note::
+
+  Windows support is currently "experimental" and on a best-effort basis. Multiple workers are also not currently supported on Windows (see `Issue #1517 <https://github.com/sanic-org/sanic/issues/1517>`_), but setting ``workers=1`` should launch the server successfully.

 Hello World Example
 -------------------
@@ -113,7 +114,7 @@ Hello World Example
    from sanic import Sanic
    from sanic.response import json

-    app = Sanic("my-hello-world-app")
+    app = Sanic("My Hello, world app")

    @app.route('/')
    async def test(request):
@@ -143,17 +144,17 @@ And, we can verify it is working: ``curl localhost:8000 -i``

 **Now, let's go build something fast!**

-Minimum Python version is 3.8. If you need Python 3.7 support, please use v22.12LTS.
+Minimum Python version is 3.7. If you need Python 3.6 support, please use v20.12LTS.

 Documentation
 -------------

-`User Guide <https://sanic.dev>`__ and `API Documentation <http://sanic.readthedocs.io/>`__.
+`User Guide <https://sanicframework.org>`__ and `API Documentation <http://sanic.readthedocs.io/>`__.

 Changelog
 ---------

-`Release Changelogs <https://sanic.readthedocs.io/en/stable/sanic/changelog.html>`__.
+`Release Changelogs <https://github.com/sanic-org/sanic/blob/master/CHANGELOG.rst>`__.


 Questions and Discussion
@@ -165,3 +166,8 @@ Contribution
 ------------

 We are always happy to have new contributions. We have `marked issues good for anyone looking to get started <https://github.com/sanic-org/sanic/issues?q=is%3Aopen+is%3Aissue+label%3Abeginner>`_, and welcome `questions on the forums <https://community.sanicframework.org/>`_. Please take a look at our `Contribution guidelines <https://github.com/sanic-org/sanic/blob/master/CONTRIBUTING.rst>`_.
+
+.. |Linode| image:: https://www.linode.com/wp-content/uploads/2021/01/Linode-Logo-Black.svg
+    :alt: Linode
+    :target: https://www.linode.com
+    :width: 200px
--- a/SECURITY.md
+++ b/SECURITY.md
@@ -4,42 +4,31 @@

 Sanic releases long term support release once a year in December. LTS releases receive bug and security updates for **24 months**. Interim releases throughout the year occur every three months, and are supported until the subsequent interim release.

+| Version | LTS           | Supported          |
+| ------- | ------------- | ------------------ |
+| 20.12   | until 2022-12 | :heavy_check_mark: |
+| 20.9    |               | :x:                |
+| 20.6    |               | :x:                |
+| 20.3    |               | :x:                |
+| 19.12   | until 2021-12 | :white_check_mark: |
+| 19.9    |               | :x:                |
+| 19.6    |               | :x:                |
+| 19.3    |               | :x:                |
+| 18.12   |               | :x:                |
+| 0.8.3   |               | :x:                |
+| 0.7.0   |               | :x:                |
+| 0.6.0   |               | :x:                |
+| 0.5.4   |               | :x:                |
+| 0.4.1   |               | :x:                |
+| 0.3.1   |               | :x:                |
+| 0.2.0   |               | :x:                |
+| 0.1.9   |               | :x:                |

-| Version | LTS           | Supported               |
-| ------- | ------------- | ----------------------- |
-| 22.12   | until 2024-12 | :white_check_mark:      |
-| 22.9    |               | :x:                     |
-| 22.6    |               | :x:                     |
-| 22.3    |               | :x:                     |
-| 21.12   | until 2023-12 | :ballot_box_with_check: |
-| 21.9    |               | :x:                     |
-| 21.6    |               | :x:                     |
-| 21.3    |               | :x:                     |
-| 20.12   |               | :x:                     |
-| 20.9    |               | :x:                     |
-| 20.6    |               | :x:                     |
-| 20.3    |               | :x:                     |
-| 19.12   |               | :x:                     |
-| 19.9    |               | :x:                     |
-| 19.6    |               | :x:                     |
-| 19.3    |               | :x:                     |
-| 18.12   |               | :x:                     |
-| 0.8.3   |               | :x:                     |
-| 0.7.0   |               | :x:                     |
-| 0.6.0   |               | :x:                     |
-| 0.5.4   |               | :x:                     |
-| 0.4.1   |               | :x:                     |
-| 0.3.1   |               | :x:                     |
-| 0.2.0   |               | :x:                     |
-| 0.1.9   |               | :x:                     |
-
-:ballot_box_with_check: = security/bug fixes 
-:white_check_mark: = full support
+:white_check_mark: = security/bug fixes
+:heavy_check_mark: = full support

 ## Reporting a Vulnerability

 If you discover a security vulnerability, we ask that you **do not** create an issue on GitHub. Instead, please [send a message to the core-devs](https://community.sanicframework.org/g/core-devs) on the community forums. Once logged in, you can send a message to the core-devs by clicking the message button.

-Alternatively, you can send a private message to Adam Hopkins on Discord. Find him on the [Sanic discord server](https://discord.gg/FARQzAEMAA).
-
 This will help to not publicize the issue until the team can address it and resolve it.
--- a/codecov.yml
+++ b/codecov.yml
@@ -4,7 +4,6 @@ coverage:
      default:
        target: auto
        threshold: 0.75
-        informational: true
    project:
      default:
        target: auto
@@ -15,10 +14,10 @@ codecov:
 ignore:
  - "sanic/__main__.py"
  - "sanic/compat.py"
+  - "sanic/reloader_helpers.py"
  - "sanic/simple.py"
  - "sanic/utils.py"
-  - "sanic/cli/"
-  - "sanic/pages/"
+  - "sanic/cli"
  - ".github/"
  - "changelogs/"
  - "docker/"
--- a/docs/_static/custom.css
+++ b/docs/_static/custom.css
@@ -2,12 +2,3 @@
 .wy-nav-top {
  background: #444444;
 }
-
-#changelog section {
-  padding-left: 3rem;
-}
-
-#changelog section h2,
-#changelog section h3 {
-  margin-left: -3rem;
-}
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -24,11 +24,7 @@ import sanic

 # -- General configuration ------------------------------------------------

-extensions = [
-    "sphinx.ext.autodoc",
-    "m2r2",
-    "enum_tools.autoenum",
-]
+extensions = ["sphinx.ext.autodoc", "m2r2"]

 templates_path = ["_templates"]

--- a/docs/index.rst
+++ b/docs/index.rst
@@ -9,7 +9,7 @@ API
 ===

 .. toctree::
-   :maxdepth: 3
+   :maxdepth: 2

   👥 User Guide <https://sanicframework.org/guide/>
   sanic/api_reference
--- a/docs/sanic/api/app.rst
+++ b/docs/sanic/api/app.rst
@@ -15,19 +15,3 @@ sanic.config
 .. automodule:: sanic.config
    :members:
    :show-inheritance:
-
-sanic.application.constants
---------------------------
-
-.. automodule:: sanic.application.constants
-    :exclude-members: StrEnum
-    :members:
-    :show-inheritance:
-    :inherited-members:
-
-sanic.application.state
-----------------------
-
-.. automodule:: sanic.application.state
-    :members:
-    :show-inheritance:
--- a/docs/sanic/api/core.rst
+++ b/docs/sanic/api/core.rst
@@ -17,14 +17,6 @@ sanic.handlers
    :show-inheritance:


-sanic.headers
--------------
-
-.. automodule:: sanic.headers
-    :members:
-    :show-inheritance:
-
-
 sanic.request
 -------------

--- a/docs/sanic/api/server.rst
+++ b/docs/sanic/api/server.rst
@@ -16,3 +16,10 @@ sanic.server
    :members:
    :show-inheritance:

+
+sanic.worker
+------------
+
+.. automodule:: sanic.worker
+    :members:
+    :show-inheritance:
--- a/docs/sanic/changelog.rst
+++ b/docs/sanic/changelog.rst
@@ -1,15 +1,6 @@
 📜 Changelog
 ============

-| 🔶 Current release
-| 🔷 In support release
-|
-
-.. mdinclude:: ./releases/23/23.6.md
-.. mdinclude:: ./releases/23/23.3.md
-.. mdinclude:: ./releases/22/22.12.md
-.. mdinclude:: ./releases/22/22.9.md
-.. mdinclude:: ./releases/22/22.6.md
 .. mdinclude:: ./releases/22/22.3.md
 .. mdinclude:: ./releases/21/21.12.md
 .. mdinclude:: ./releases/21/21.9.md
--- a/docs/sanic/releases/21/21.12.md
+++ b/docs/sanic/releases/21/21.12.md
@@ -1,12 +1,10 @@
-## Version 21.12.1 🔷
-
-_Current LTS version_
+## Version 21.12.1

 - [#2349](https://github.com/sanic-org/sanic/pull/2349) Only display MOTD on startup
 - [#2354](https://github.com/sanic-org/sanic/pull/2354) Ignore name argument in Python 3.7
 - [#2355](https://github.com/sanic-org/sanic/pull/2355) Add config.update support for all config values

-## Version 21.12.0 🔹
+## Version 21.12.0

 ### Features
 - [#2260](https://github.com/sanic-org/sanic/pull/2260) Allow early Blueprint registrations to still apply later added objects
--- a/docs/sanic/releases/22/22.12.md
+++ b/docs/sanic/releases/22/22.12.md
@@ -1,55 +0,0 @@
-## Version 22.12.0 🔷
-
-_Current version_
-
-### Features
-
- [#2569](https://github.com/sanic-org/sanic/pull/2569) Add `JSONResponse` class with some convenient methods when updating a response object
- [#2598](https://github.com/sanic-org/sanic/pull/2598) Change `uvloop` requirement to `>=0.15.0`
- [#2609](https://github.com/sanic-org/sanic/pull/2609) Add compatibility with `websockets` v11.0
- [#2610](https://github.com/sanic-org/sanic/pull/2610) Kill server early on worker error
-    - Raise deadlock timeout to 30s
- [#2617](https://github.com/sanic-org/sanic/pull/2617) Scale number of running server workers
- [#2621](https://github.com/sanic-org/sanic/pull/2621) [#2634](https://github.com/sanic-org/sanic/pull/2634) Send `SIGKILL` on subsequent `ctrl+c` to force worker exit
- [#2622](https://github.com/sanic-org/sanic/pull/2622) Add API to restart all workers from the multiplexer
- [#2624](https://github.com/sanic-org/sanic/pull/2624) Default to `spawn` for all subprocesses unless specifically set:
-    ```python
-    from sanic import Sanic
-    
-    Sanic.start_method = "fork"
-    ```
- [#2625](https://github.com/sanic-org/sanic/pull/2625) Filename normalisation of form-data/multipart file uploads
- [#2626](https://github.com/sanic-org/sanic/pull/2626) Move to HTTP Inspector:
-    - Remote access to inspect running Sanic instances
-    - TLS support for encrypted calls to Inspector
-    - Authentication to Inspector with API key
-    - Ability to extend Inspector with custom commands
- [#2632](https://github.com/sanic-org/sanic/pull/2632) Control order of restart operations
- [#2633](https://github.com/sanic-org/sanic/pull/2633) Move reload interval to class variable
- [#2636](https://github.com/sanic-org/sanic/pull/2636) Add `priority` to `register_middleware` method
- [#2639](https://github.com/sanic-org/sanic/pull/2639) Add `unquote` to `add_route` method
- [#2640](https://github.com/sanic-org/sanic/pull/2640) ASGI websockets to receive `text` or `bytes`
-
-
-### Bugfixes
-
- [#2607](https://github.com/sanic-org/sanic/pull/2607) Force socket shutdown before close to allow rebinding
- [#2590](https://github.com/sanic-org/sanic/pull/2590) Use actual `StrEnum` in Python 3.11+
- [#2615](https://github.com/sanic-org/sanic/pull/2615) Ensure middleware executes only once per request timeout
- [#2627](https://github.com/sanic-org/sanic/pull/2627) Crash ASGI application on lifespan failure
- [#2635](https://github.com/sanic-org/sanic/pull/2635) Resolve error with low-level server creation on Windows
-
-
-### Deprecations and Removals
-
- [#2608](https://github.com/sanic-org/sanic/pull/2608) [#2630](https://github.com/sanic-org/sanic/pull/2630) Signal conditions and triggers saved on `signal.extra` 
- [#2626](https://github.com/sanic-org/sanic/pull/2626) Move to HTTP Inspector
-    - 🚨 *BREAKING CHANGE*: Moves the Inspector to a Sanic app from a simple TCP socket with a custom protocol
-    - *DEPRECATE*: The `--inspect*` commands have been deprecated in favor of `inspect ...` commands
- [#2628](https://github.com/sanic-org/sanic/pull/2628) Replace deprecated `distutils.strtobool`
-
-
-### Developer infrastructure
-
- [#2612](https://github.com/sanic-org/sanic/pull/2612) Add CI testing for Python 3.11
-
--- a/docs/sanic/releases/22/22.6.md
+++ b/docs/sanic/releases/22/22.6.md
@@ -1,54 +0,0 @@
-## Version 22.6.2
-
-### Bugfixes
-
- [#2522](https://github.com/sanic-org/sanic/pull/2522) Always show server location in ASGI
-
-## Version 22.6.1
-
-### Bugfixes
-
- [#2477](https://github.com/sanic-org/sanic/pull/2477) Sanic static directory fails when folder name ends with ".."
-
-
-## Version 22.6.0
-
-### Features
- [#2378](https://github.com/sanic-org/sanic/pull/2378) Introduce HTTP/3 and autogeneration of TLS certificates in `DEBUG` mode
-    - 👶 *EARLY RELEASE FEATURE*: Serving Sanic over HTTP/3 is an early release feature. It does not yet fully cover the HTTP/3 spec, but instead aims for feature parity with Sanic's existing HTTP/1.1 server. Websockets, WebTransport, push responses are examples of some features not yet implemented.
-    - 📦 *EXTRA REQUIREMENT*: Not all HTTP clients are capable of interfacing with HTTP/3 servers. You may need to install a [HTTP/3 capable client](https://curl.se/docs/http3.html).
-    - 📦 *EXTRA REQUIREMENT*: In order to use TLS autogeneration, you must install either [mkcert](https://github.com/FiloSottile/mkcert) or [trustme](https://github.com/python-trio/trustme).
- [#2416](https://github.com/sanic-org/sanic/pull/2416) Add message to `task.cancel`
- [#2420](https://github.com/sanic-org/sanic/pull/2420) Add exception aliases for more consistent naming with standard HTTP response types (`BadRequest`, `MethodNotAllowed`, `RangeNotSatisfiable`)
- [#2432](https://github.com/sanic-org/sanic/pull/2432) Expose ASGI `scope` as a property on the `Request` object
- [#2438](https://github.com/sanic-org/sanic/pull/2438) Easier access to websocket class for annotation: `from sanic import Websocket`
- [#2439](https://github.com/sanic-org/sanic/pull/2439) New API for reading form values with options: `Request.get_form` 
- [#2445](https://github.com/sanic-org/sanic/pull/2445) Add custom `loads` function
- [#2447](https://github.com/sanic-org/sanic/pull/2447), [#2486](https://github.com/sanic-org/sanic/pull/2486) Improved API to support setting cache control headers
- [#2453](https://github.com/sanic-org/sanic/pull/2453) Move verbosity filtering to logger
- [#2475](https://github.com/sanic-org/sanic/pull/2475) Expose getter for current request using `Request.get_current()`
-
-### Bugfixes
- [#2448](https://github.com/sanic-org/sanic/pull/2448) Fix to allow running with `pythonw.exe` or places where there is no `sys.stdout`
- [#2451](https://github.com/sanic-org/sanic/pull/2451) Trigger `http.lifecycle.request` signal in ASGI mode
- [#2455](https://github.com/sanic-org/sanic/pull/2455) Resolve typing of stacked route definitions
- [#2463](https://github.com/sanic-org/sanic/pull/2463) Properly catch websocket CancelledError in websocket handler in Python 3.7
-
-### Deprecations and Removals
- [#2487](https://github.com/sanic-org/sanic/pull/2487) v22.6 deprecations and changes
-    1. Optional application registry
-    1. Execution of custom handlers after some part of response was sent
-    1. Configuring fallback handlers on the `ErrorHandler`
-    1. Custom `LOGO` setting
-    1. `sanic.response.stream`
-    1. `AsyncioServer.init`
-
-### Developer infrastructure
- [#2449](https://github.com/sanic-org/sanic/pull/2449) Clean up `black` and `isort` config
- [#2479](https://github.com/sanic-org/sanic/pull/2479) Fix some flappy tests
-
-### Improved Documentation
- [#2461](https://github.com/sanic-org/sanic/pull/2461) Update example to match current application naming standards
- [#2466](https://github.com/sanic-org/sanic/pull/2466) Better type annotation for `Extend`
- [#2485](https://github.com/sanic-org/sanic/pull/2485) Improved help messages in CLI
-
--- a/docs/sanic/releases/22/22.9.md
+++ b/docs/sanic/releases/22/22.9.md
@@ -1,74 +0,0 @@
-## Version 22.9.1
-
-### Features
-
- [#2585](https://github.com/sanic-org/sanic/pull/2585) Improved error message when no applications have been registered
-
-
-### Bugfixes
-
- [#2578](https://github.com/sanic-org/sanic/pull/2578) Add certificate loader for in process certificate creation
- [#2591](https://github.com/sanic-org/sanic/pull/2591) Do not use sentinel identity for `spawn` compatibility
- [#2592](https://github.com/sanic-org/sanic/pull/2592) Fix properties in nested blueprint groups
- [#2595](https://github.com/sanic-org/sanic/pull/2595) Introduce sleep interval on new worker reloader
-
-
-### Deprecations and Removals
-
-
-### Developer infrastructure
-
- [#2588](https://github.com/sanic-org/sanic/pull/2588) Markdown templates on issue forms
-
-
-### Improved Documentation
-
- [#2556](https://github.com/sanic-org/sanic/pull/2556) v22.9 documentation
- [#2582](https://github.com/sanic-org/sanic/pull/2582) Cleanup documentation on Windows support
-
-
-## Version 22.9.0
-
-### Features
-
- [#2445](https://github.com/sanic-org/sanic/pull/2445) Add custom loads function 
- [#2490](https://github.com/sanic-org/sanic/pull/2490) Make `WebsocketImplProtocol` async iterable
- [#2499](https://github.com/sanic-org/sanic/pull/2499) Sanic Server WorkerManager refactor
- [#2506](https://github.com/sanic-org/sanic/pull/2506) Use `pathlib` for path resolution (for static file serving)
- [#2508](https://github.com/sanic-org/sanic/pull/2508) Use `path.parts` instead of `match` (for static file serving)
- [#2513](https://github.com/sanic-org/sanic/pull/2513) Better request cancel handling
- [#2516](https://github.com/sanic-org/sanic/pull/2516) Add request properties for HTTP method info:
-    - `request.is_safe`
-    - `request.is_idempotent`
-    - `request.is_cacheable`
-    - *See* [MDN docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) *for more information about when these apply*
- [#2522](https://github.com/sanic-org/sanic/pull/2522) Always show server location in ASGI
- [#2526](https://github.com/sanic-org/sanic/pull/2526) Cache control support for static files for returning 304 when appropriate
- [#2533](https://github.com/sanic-org/sanic/pull/2533) Refactor `_static_request_handler`
- [#2540](https://github.com/sanic-org/sanic/pull/2540) Add signals before and after handler execution
-    - `http.handler.before`
-    - `http.handler.after`
- [#2542](https://github.com/sanic-org/sanic/pull/2542) Add *[redacted]* to CLI :)
- [#2546](https://github.com/sanic-org/sanic/pull/2546) Add deprecation warning filter
- [#2550](https://github.com/sanic-org/sanic/pull/2550) Middleware priority and performance enhancements
-
-### Bugfixes
-
- [#2495](https://github.com/sanic-org/sanic/pull/2495) Prevent directory traversion with static files
- [#2515](https://github.com/sanic-org/sanic/pull/2515) Do not apply double slash to paths in certain static dirs in Blueprints
-
-### Deprecations and Removals
-
- [#2525](https://github.com/sanic-org/sanic/pull/2525) Warn on duplicate route names, will be prevented outright in v23.3
- [#2537](https://github.com/sanic-org/sanic/pull/2537) Raise warning and deprecation notice on duplicate exceptions, will be prevented outright in v23.3
-
-### Developer infrastructure
-
- [#2504](https://github.com/sanic-org/sanic/pull/2504) Cleanup test suite
- [#2505](https://github.com/sanic-org/sanic/pull/2505) Replace Unsupported Python Version Number from the Contributing Doc
- [#2530](https://github.com/sanic-org/sanic/pull/2530) Do not include tests folder in installed package resolver
-
-### Improved Documentation
-
- [#2502](https://github.com/sanic-org/sanic/pull/2502) Fix a few typos
- [#2517](https://github.com/sanic-org/sanic/pull/2517) [#2536](https://github.com/sanic-org/sanic/pull/2536) Add some type hints
--- a/docs/sanic/releases/23/23.3.md
+++ b/docs/sanic/releases/23/23.3.md
@@ -1,53 +0,0 @@
-## Version 23.3.0
-
-### Features
- [#2545](https://github.com/sanic-org/sanic/pull/2545) Standardize init of exceptions for more consistent control of HTTP responses using exceptions
- [#2606](https://github.com/sanic-org/sanic/pull/2606) Decode headers as UTF-8 also in ASGI
- [#2646](https://github.com/sanic-org/sanic/pull/2646) Separate ASGI request and lifespan callables
- [#2659](https://github.com/sanic-org/sanic/pull/2659) Use ``FALLBACK_ERROR_FORMAT`` for handlers that return ``empty()``
- [#2662](https://github.com/sanic-org/sanic/pull/2662) Add basic file browser (HTML page) and auto-index serving
- [#2667](https://github.com/sanic-org/sanic/pull/2667) Nicer traceback formatting (HTML page)
- [#2668](https://github.com/sanic-org/sanic/pull/2668) Smarter error page rendering format selection; more reliant upon header and "common sense" defaults
- [#2680](https://github.com/sanic-org/sanic/pull/2680) Check the status of socket before shutting down with ``SHUT_RDWR``
- [#2687](https://github.com/sanic-org/sanic/pull/2687) Refresh ``Request.accept`` functionality to be more performant and spec-compliant
- [#2696](https://github.com/sanic-org/sanic/pull/2696) Add header accessors as properties
-    ```
-    Example-Field: Foo, Bar
-    Example-Field: Baz
-    ```
-    ```python
-    request.headers.example_field == "Foo, Bar,Baz"
-    ```
- [#2700](https://github.com/sanic-org/sanic/pull/2700) Simpler CLI targets
-
-    ```sh
-    $ sanic path.to.module:app          # global app instance
-    $ sanic path.to.module:create_app   # factory pattern
-    $ sanic ./path/to/directory/        # simple serve
-    ```
- [#2701](https://github.com/sanic-org/sanic/pull/2701) API to define a number of workers in managed processes
- [#2704](https://github.com/sanic-org/sanic/pull/2704) Add convenience for dynamic changes to routing
- [#2706](https://github.com/sanic-org/sanic/pull/2706) Add convenience methods for cookie creation and deletion
-    
-    ```python
-    response = text("...")
-    response.add_cookie("test", "It worked!", domain=".yummy-yummy-cookie.com")
-    ```
- [#2707](https://github.com/sanic-org/sanic/pull/2707) Simplified ``parse_content_header`` escaping to be RFC-compliant and remove outdated FF hack
- [#2710](https://github.com/sanic-org/sanic/pull/2710) Stricter charset handling and escaping of request URLs
- [#2711](https://github.com/sanic-org/sanic/pull/2711) Consume body on ``DELETE`` by default
- [#2719](https://github.com/sanic-org/sanic/pull/2719) Allow ``password`` to be passed to TLS context
- [#2720](https://github.com/sanic-org/sanic/pull/2720) Skip middleware on ``RequestCancelled``
- [#2721](https://github.com/sanic-org/sanic/pull/2721) Change access logging format to ``%s``
- [#2722](https://github.com/sanic-org/sanic/pull/2722) Add ``CertLoader`` as application option for directly controlling ``SSLContext`` objects
- [#2725](https://github.com/sanic-org/sanic/pull/2725) Worker sync state tolerance on race condition
-
-### Bugfixes
- [#2651](https://github.com/sanic-org/sanic/pull/2651) ASGI websocket to pass thru bytes as is
- [#2697](https://github.com/sanic-org/sanic/pull/2697) Fix comparison between datetime aware and naive in ``file`` when using ``If-Modified-Since``
-
-### Deprecations and Removals
- [#2666](https://github.com/sanic-org/sanic/pull/2666) Remove deprecated ``__blueprintname__`` property
-
-### Improved Documentation
- [#2712](https://github.com/sanic-org/sanic/pull/2712) Improved example using ``'https'`` to create the redirect
--- a/docs/sanic/releases/23/23.6.md
+++ b/docs/sanic/releases/23/23.6.md
@@ -1,33 +0,0 @@
-## Version 23.6.0  🔶
-
-### Features
- [#2670](https://github.com/sanic-org/sanic/pull/2670) Increase `KEEP_ALIVE_TIMEOUT` default to 120 seconds
- [#2716](https://github.com/sanic-org/sanic/pull/2716) Adding allow route overwrite option in blueprint
- [#2724](https://github.com/sanic-org/sanic/pull/2724) and [#2792](https://github.com/sanic-org/sanic/pull/2792) Add a new exception signal for ALL exceptions raised anywhere in application
- [#2727](https://github.com/sanic-org/sanic/pull/2727) Add name prefixing to BP groups
- [#2754](https://github.com/sanic-org/sanic/pull/2754) Update request type on middleware types
- [#2770](https://github.com/sanic-org/sanic/pull/2770) Better exception message on startup time application induced import error
- [#2776](https://github.com/sanic-org/sanic/pull/2776) Set multiprocessing start method early
- [#2785](https://github.com/sanic-org/sanic/pull/2785) Add custom typing to config and ctx objects
- [#2790](https://github.com/sanic-org/sanic/pull/2790) Add `request.client_ip`
-
-### Bugfixes
- [#2728](https://github.com/sanic-org/sanic/pull/2728) Fix traversals for intended results
- [#2729](https://github.com/sanic-org/sanic/pull/2729) Handle case when headers argument of ResponseStream constructor is None
- [#2737](https://github.com/sanic-org/sanic/pull/2737) Fix type annotation for `JSONREsponse` default content type
- [#2740](https://github.com/sanic-org/sanic/pull/2740) Use Sanic's serializer for JSON responses in the Inspector
- [#2760](https://github.com/sanic-org/sanic/pull/2760) Support for `Request.get_current` in ASGI mode
- [#2773](https://github.com/sanic-org/sanic/pull/2773) Alow Blueprint routes to explicitly define error_format
- [#2774](https://github.com/sanic-org/sanic/pull/2774) Resolve headers on different renderers
- [#2782](https://github.com/sanic-org/sanic/pull/2782) Resolve pypy compatibility issues
-
-### Deprecations and Removals
- [#2777](https://github.com/sanic-org/sanic/pull/2777) Remove Python 3.7 support
-
-### Developer infrastructure
- [#2766](https://github.com/sanic-org/sanic/pull/2766) Unpin setuptools version
- [#2779](https://github.com/sanic-org/sanic/pull/2779) Run keep alive tests in loop to get available port
-
-### Improved Documentation
- [#2741](https://github.com/sanic-org/sanic/pull/2741) Better documentation examples about running Sanic
-From that list, the items to highlight in the release notes:
--- a/examples/amending_request_object.py
+++ b/examples/amending_request_object.py
@@ -25,5 +25,5 @@ def key_exist_handler(request):

    return text("num does not exist in request")

-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8000, debug=True)
+
+app.run(host="0.0.0.0", port=8000, debug=True)
--- a/examples/blueprint_middlware_execution_order.py
+++ b/examples/blueprint_middlware_execution_order.py
@@ -50,5 +50,4 @@ def pop_handler(request):

 app.blueprint(bp, url_prefix="/bp")

-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8000, debug=True, auto_reload=False)
+app.run(host="0.0.0.0", port=8000, debug=True, auto_reload=False)
--- a/examples/blueprints.py
+++ b/examples/blueprints.py
@@ -37,5 +37,4 @@ app.blueprint(blueprint)
 app.blueprint(blueprint2)
 app.blueprint(blueprint3)

-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=9999, debug=True)
+app.run(host="0.0.0.0", port=9999, debug=True)
--- a/examples/http_redirect.py
+++ b/examples/http_redirect.py
@@ -29,7 +29,7 @@ def proxy(request, path):
        path=path,
        _server=https.config.SERVER_NAME,
        _external=True,
-        _scheme="https",
+        _scheme="http",
    )
    return response.redirect(url)

@@ -69,5 +69,5 @@ async def runner(app: Sanic, app_server: AsyncioServer):
        app.is_running = False
        app.is_stopping = True

-if __name__ == "__main__":
-    https.run(port=HTTPS_PORT, debug=True)
+
+https.run(port=HTTPS_PORT, debug=True)
--- a/examples/limit_concurrency.py
+++ b/examples/limit_concurrency.py
@@ -39,5 +39,4 @@ async def test(request):
        return json(response)


-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8000, workers=2)
+app.run(host="0.0.0.0", port=8000, workers=2)
--- a/examples/override_logging.py
+++ b/examples/override_logging.py
@@ -20,5 +20,4 @@ def test(request):
    return text("hey")


-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8000)
+app.run(host="0.0.0.0", port=8000)
--- a/examples/request_stream/client.py
+++ b/examples/request_stream/client.py
@@ -6,5 +6,5 @@ data = ""
 for i in range(1, 250000):
    data += str(i)

-r = requests.post("http://0.0.0.0:8000/stream", data=data)
+r = requests.post('http://0.0.0.0:8000/stream', data=data)
 print(r.text)
--- a/examples/request_timeout.py
+++ b/examples/request_timeout.py
@@ -20,5 +20,4 @@ def timeout(request, exception):
    return response.text("RequestTimeout from error_handler.", 408)


-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=8000)
+app.run(host="0.0.0.0", port=8000)
--- a/examples/run_async_advanced.py
+++ b/examples/run_async_advanced.py
@@ -35,34 +35,34 @@ async def after_server_stop(app, loop):
 async def test(request):
    return response.json({"answer": "42"})

-if __name__ == "__main__":
-    asyncio.set_event_loop(uvloop.new_event_loop())
-    serv_coro = app.create_server(
-        host="0.0.0.0", port=8000, return_asyncio_server=True
-    )
-    loop = asyncio.get_event_loop()
-    serv_task = asyncio.ensure_future(serv_coro, loop=loop)
-    signal(SIGINT, lambda s, f: loop.stop())
-    server: AsyncioServer = loop.run_until_complete(serv_task)
-    loop.run_until_complete(server.startup())

-    # When using app.run(), this actually triggers before the serv_coro.
-    # But, in this example, we are using the convenience method, even if it is
-    # out of order.
-    loop.run_until_complete(server.before_start())
-    loop.run_until_complete(server.after_start())
-    try:
-        loop.run_forever()
-    except KeyboardInterrupt:
-        loop.stop()
-    finally:
-        loop.run_until_complete(server.before_stop())
+asyncio.set_event_loop(uvloop.new_event_loop())
+serv_coro = app.create_server(
+    host="0.0.0.0", port=8000, return_asyncio_server=True
+)
+loop = asyncio.get_event_loop()
+serv_task = asyncio.ensure_future(serv_coro, loop=loop)
+signal(SIGINT, lambda s, f: loop.stop())
+server: AsyncioServer = loop.run_until_complete(serv_task)
+loop.run_until_complete(server.startup())

-        # Wait for server to close
-        close_task = server.close()
-        loop.run_until_complete(close_task)
+# When using app.run(), this actually triggers before the serv_coro.
+# But, in this example, we are using the convenience method, even if it is
+# out of order.
+loop.run_until_complete(server.before_start())
+loop.run_until_complete(server.after_start())
+try:
+    loop.run_forever()
+except KeyboardInterrupt:
+    loop.stop()
+finally:
+    loop.run_until_complete(server.before_stop())

-        # Complete all tasks on the loop
-        for connection in server.connections:
-            connection.close_if_idle()
-        loop.run_until_complete(server.after_stop())
+    # Wait for server to close
+    close_task = server.close()
+    loop.run_until_complete(close_task)
+
+    # Complete all tasks on the loop
+    for connection in server.connections:
+        connection.close_if_idle()
+    loop.run_until_complete(server.after_stop())
--- a/examples/unix_socket.py
+++ b/examples/unix_socket.py
@@ -1,3 +1,6 @@
+import os
+import socket
+
 from sanic import Sanic, response


@@ -10,4 +13,13 @@ async def test(request):


 if __name__ == "__main__":
-    app.run(unix="./uds_socket")
+    server_address = "./uds_socket"
+    # Make sure the socket does not already exist
+    try:
+        os.unlink(server_address)
+    except OSError:
+        if os.path.exists(server_address):
+            raise
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    sock.bind(server_address)
+    app.run(sock=sock)
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,29 +1,3 @@
 [build-system]
-requires = ["setuptools", "wheel"]
+requires = ["setuptools<60.0", "wheel"]
 build-backend = "setuptools.build_meta"
-
-[tool.black]
-line-length = 79
-
-[tool.isort]
-atomic = true
-default_section = "THIRDPARTY"
-include_trailing_comma = true
-known_first_party = "sanic"
-known_third_party = "pytest"
-line_length = 79
-lines_after_imports = 2
-lines_between_types = 1
-multi_line_output = 3
-profile = "black"
-
-[[tool.mypy.overrides]]
-module = [
-    "httptools.*",
-    "trustme.*",
-    "sanic_routing.*",
-    "aioquic.*",
-    "html5tagger.*",
-    "tracerite.*",
-]
-ignore_missing_imports = true
--- a/sanic/init.py
+++ b/sanic/init.py
@@ -1,86 +1,19 @@
-from types import SimpleNamespace
-
-from typing_extensions import TypeAlias
-
 from sanic.__version__ import __version__
 from sanic.app import Sanic
 from sanic.blueprints import Blueprint
-from sanic.config import Config
 from sanic.constants import HTTPMethod
-from sanic.exceptions import (
-    BadRequest,
-    ExpectationFailed,
-    FileNotFound,
-    Forbidden,
-    HeaderNotFound,
-    InternalServerError,
-    InvalidHeader,
-    MethodNotAllowed,
-    NotFound,
-    RangeNotSatisfiable,
-    SanicException,
-    ServerError,
-    ServiceUnavailable,
-    Unauthorized,
-)
 from sanic.request import Request
-from sanic.response import (
-    HTTPResponse,
-    empty,
-    file,
-    html,
-    json,
-    raw,
-    redirect,
-    text,
-)
-from sanic.server.websockets.impl import WebsocketImplProtocol as Websocket
+from sanic.response import HTTPResponse, html, json, text


-DefaultSanic: TypeAlias = "Sanic[Config, SimpleNamespace]"
-"""
-A type alias for a Sanic app with a default config and namespace.
-"""
-
-DefaultRequest: TypeAlias = Request[DefaultSanic, SimpleNamespace]
-"""
-A type alias for a request with a default Sanic app and namespace.
-"""
-
 __all__ = (
    "__version__",
-    # Common objects
    "Sanic",
-    "Config",
    "Blueprint",
    "HTTPMethod",
    "HTTPResponse",
    "Request",
-    "Websocket",
-    # Common types
-    "DefaultSanic",
-    "DefaultRequest",
-    # Common exceptions
-    "BadRequest",
-    "ExpectationFailed",
-    "FileNotFound",
-    "Forbidden",
-    "HeaderNotFound",
-    "InternalServerError",
-    "InvalidHeader",
-    "MethodNotAllowed",
-    "NotFound",
-    "RangeNotSatisfiable",
-    "SanicException",
-    "ServerError",
-    "ServiceUnavailable",
-    "Unauthorized",
-    # Common response methods
-    "empty",
-    "file",
    "html",
    "json",
-    "raw",
-    "redirect",
    "text",
 )
--- a/sanic/main.py
+++ b/sanic/main.py
@@ -6,10 +6,10 @@ if OS_IS_WINDOWS:
    enable_windows_color_support()


-def main(args=None):
+def main():
    cli = SanicCLI()
    cli.attach()
-    cli.run(args)
+    cli.run()


 if __name__ == "__main__":
--- a/sanic/version.py
+++ b/sanic/version.py
@@ -1 +1 @@
-__version__ = "23.6.0"
+__version__ = "22.3.2"
--- a/sanic/app.py
+++ b/sanic/app.py
--- a/sanic/application/constants.py
+++ b/sanic/application/constants.py
@@ -1,32 +0,0 @@
-from enum import Enum, IntEnum, auto
-
-
-class StrEnum(str, Enum):  # no cov
-    def _generate_next_value_(name: str, *args) -> str:  # type: ignore
-        return name.lower()
-
-    def __eq__(self, value: object) -> bool:
-        value = str(value).upper()
-        return super().__eq__(value)
-
-    def __hash__(self) -> int:
-        return hash(self.value)
-
-    def __str__(self) -> str:
-        return self.value
-
-
-class Server(StrEnum):
-    SANIC = auto()
-    ASGI = auto()
-
-
-class Mode(StrEnum):
-    PRODUCTION = auto()
-    DEBUG = auto()
-
-
-class ServerStage(IntEnum):
-    STOPPED = auto()
-    PARTIAL = auto()
-    SERVING = auto()
--- a/sanic/application/ext.py
+++ b/sanic/application/ext.py
@@ -5,9 +5,14 @@ from importlib import import_module
 from typing import TYPE_CHECKING


-if TYPE_CHECKING:
+if TYPE_CHECKING:  # no cov
    from sanic import Sanic

+    try:
+        from sanic_ext import Extend  # type: ignore
+    except ImportError:
+        ...
+

 def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
    if not app.config.AUTO_EXTEND:
@@ -17,7 +22,7 @@ def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
    with suppress(ModuleNotFoundError):
        sanic_ext = import_module("sanic_ext")

-    if not sanic_ext:  # no cov
+    if not sanic_ext:
        if fail:
            raise RuntimeError(
                "Sanic Extensions is not installed. You can add it to your "
@@ -28,7 +33,7 @@ def setup_ext(app: Sanic, *, fail: bool = False, **kwargs):
        return

    if not getattr(app, "_ext", None):
-        Ext = getattr(sanic_ext, "Extend")
+        Ext: Extend = getattr(sanic_ext, "Extend")
        app._ext = Ext(app, **kwargs)

        return app.ext
--- a/sanic/application/logo.py
+++ b/sanic/application/logo.py
@@ -3,8 +3,6 @@ import sys

 from os import environ

-from sanic.helpers import is_atty
-

 BASE_LOGO = """

@@ -40,15 +38,13 @@ FULL_COLOR_LOGO = """

 """  # noqa

-SVG_LOGO_SIMPLE = """<svg id=logo-simple viewBox="0 0 964 279"><desc>Sanic</desc><path d="M107 222c9-2 10-20 1-22s-20-2-30-2-17 7-16 14 6 10 15 10h30zm115-1c16-2 30-11 35-23s6-24 2-33-6-14-15-20-24-11-38-10c-7 3-10 13-5 19s17-1 24 4 15 14 13 24-5 15-14 18-50 0-74 0h-17c-6 4-10 15-4 20s16 2 23 3zM251 83q9-1 9-7 0-15-10-16h-13c-10 6-10 20 0 22zM147 60c-4 0-10 3-11 11s5 13 10 12 42 0 67 0c5-3 7-10 6-15s-4-8-9-8zm-33 1c-8 0-16 0-24 3s-20 10-25 20-6 24-4 36 15 22 26 27 78 8 94 3c4-4 4-12 0-18s-69 8-93-10c-8-7-9-23 0-30s12-10 20-10 12 2 16-3 1-15-5-18z" fill="#ff0d68"/><path d="M676 74c0-14-18-9-20 0s0 30 0 39 20 9 20 2zm-297-10c-12 2-15 12-23 23l-41 58H340l22-30c8-12 23-13 30-4s20 24 24 38-10 10-17 10l-68 2q-17 1-48 30c-7 6-10 20 0 24s15-8 20-13 20 -20 58-21h50 c20 2 33 9 52 30 8 10 24-4 16-13L384 65q-3-2-5-1zm131 0c-10 1-12 12-11 20v96c1 10-3 23 5 32s20-5 17-15c0-23-3-46 2-67 5-12 22-14 32-5l103 87c7 5 19 1 18-9v-64c-3-10-20-9-21 2s-20 22-30 13l-97-80c-5-4-10-10-18-10zM701 76v128c2 10 15 12 20 4s0-102 0-124s-20-18-20-7z M850 63c-35 0-69-2-86 15s-20 60-13 66 13 8 16 0 1-10 1-27 12-26 20-32 66-5 85-5 31 4 31-10-18-7-54-7M764 159c-6-2-15-2-16 12s19 37 33 43 23 8 25-4-4-11-11-14q-9-3-22-18c-4-7-3-16-10-19zM828 196c-4 0-8 1-10 5s-4 12 0 15 8 2 12 2h60c5 0 10-2 12-6 3-7-1-16-8-16z" fill="#1f1f1f"/></svg>"""  # noqa
-
 ansi_pattern = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")


 def get_logo(full=False, coffee=False):
    logo = (
        (FULL_COLOR_LOGO if full else (COFFEE_LOGO if coffee else COLOR_LOGO))
-        if is_atty()
+        if sys.stdout.isatty()
        else BASE_LOGO
    )

--- a/sanic/application/motd.py
+++ b/sanic/application/motd.py
@@ -1,10 +1,11 @@
+import sys
+
 from abc import ABC, abstractmethod
 from shutil import get_terminal_size
 from textwrap import indent, wrap
 from typing import Dict, Optional

 from sanic import __version__
-from sanic.helpers import is_atty
 from sanic.log import logger


@@ -35,7 +36,7 @@ class MOTD(ABC):
        data: Dict[str, str],
        extra: Dict[str, str],
    ) -> None:
-        motd_class = MOTDTTY if is_atty() else MOTDBasic
+        motd_class = MOTDTTY if sys.stdout.isatty() else MOTDBasic
        motd_class(logo, serve_location, data, extra).display()


@@ -80,23 +81,20 @@ class MOTDTTY(MOTD):
        )
        self.display_length = self.key_width + self.value_width + 2

-    def display(self, version=True, action="Goin' Fast", out=None):
-        if not out:
-            out = logger.info
-        header = "Sanic"
-        if version:
-            header += f" v{__version__}"
-        header = header.center(self.centering_length)
+    def display(self):
+        version = f"Sanic v{__version__}".center(self.centering_length)
        running = (
-            f"{action} @ {self.serve_location}" if self.serve_location else ""
+            f"Goin' Fast @ {self.serve_location}"
+            if self.serve_location
+            else ""
        ).center(self.centering_length)
-        length = len(header) + 2 - self.logo_line_length
+        length = len(version) + 2 - self.logo_line_length
        first_filler = "─" * (self.logo_line_length - 1)
        second_filler = "─" * length
        display_filler = "─" * (self.display_length + 2)
        lines = [
            f"\n┌{first_filler}─{second_filler}┐",
-            f"│ {header} │",
+            f"│ {version} │",
            f"│ {running} │",
            f"├{first_filler}┬{second_filler}┤",
        ]
@@ -110,7 +108,7 @@ class MOTDTTY(MOTD):
        self._render_fill(lines)

        lines.append(f"└{first_filler}┴{second_filler}┘\n")
-        out(indent("\n".join(lines), "  "))
+        logger.info(indent("\n".join(lines), "  "))

    def _render_data(self, lines, data, start):
        offset = 0
--- a/sanic/application/spinner.py
+++ b/sanic/application/spinner.py
@@ -1,86 +0,0 @@
-import os
-import sys
-import time
-
-from contextlib import contextmanager
-from queue import Queue
-from threading import Thread
-
-
-if os.name == "nt":  # noqa
-    import ctypes  # noqa
-
-    class _CursorInfo(ctypes.Structure):
-        _fields_ = [("size", ctypes.c_int), ("visible", ctypes.c_byte)]
-
-
-class Spinner:  # noqa
-    def __init__(self, message: str) -> None:
-        self.message = message
-        self.queue: Queue[int] = Queue()
-        self.spinner = self.cursor()
-        self.thread = Thread(target=self.run)
-
-    def start(self):
-        self.queue.put(1)
-        self.thread.start()
-        self.hide()
-
-    def run(self):
-        while self.queue.get():
-            output = f"\r{self.message} [{next(self.spinner)}]"
-            sys.stdout.write(output)
-            sys.stdout.flush()
-            time.sleep(0.1)
-            self.queue.put(1)
-
-    def stop(self):
-        self.queue.put(0)
-        self.thread.join()
-        self.show()
-
-    @staticmethod
-    def cursor():
-        while True:
-            for cursor in "|/-\\":
-                yield cursor
-
-    @staticmethod
-    def hide():
-        if os.name == "nt":
-            ci = _CursorInfo()
-            handle = ctypes.windll.kernel32.GetStdHandle(-11)
-            ctypes.windll.kernel32.GetConsoleCursorInfo(
-                handle, ctypes.byref(ci)
-            )
-            ci.visible = False
-            ctypes.windll.kernel32.SetConsoleCursorInfo(
-                handle, ctypes.byref(ci)
-            )
-        elif os.name == "posix":
-            sys.stdout.write("\033[?25l")
-            sys.stdout.flush()
-
-    @staticmethod
-    def show():
-        if os.name == "nt":
-            ci = _CursorInfo()
-            handle = ctypes.windll.kernel32.GetStdHandle(-11)
-            ctypes.windll.kernel32.GetConsoleCursorInfo(
-                handle, ctypes.byref(ci)
-            )
-            ci.visible = True
-            ctypes.windll.kernel32.SetConsoleCursorInfo(
-                handle, ctypes.byref(ci)
-            )
-        elif os.name == "posix":
-            sys.stdout.write("\033[?25h")
-            sys.stdout.flush()
-
-
-@contextmanager
-def loading(message: str = "Loading"):  # noqa
-    spinner = Spinner(message)
-    spinner.start()
-    yield
-    spinner.stop()
--- a/sanic/application/state.py
+++ b/sanic/application/state.py
@@ -3,20 +3,42 @@ from __future__ import annotations
 import logging

 from dataclasses import dataclass, field
+from enum import Enum, IntEnum, auto
 from pathlib import Path
 from socket import socket
 from ssl import SSLContext
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Set, Union

-from sanic.application.constants import Mode, Server, ServerStage
-from sanic.log import VerbosityFilter, logger
+from sanic.log import logger
 from sanic.server.async_server import AsyncioServer


-if TYPE_CHECKING:
+if TYPE_CHECKING:  # no cov
    from sanic import Sanic


+class StrEnum(str, Enum):
+    def _generate_next_value_(name: str, *args) -> str:  # type: ignore
+        return name.lower()
+
+
+class Server(StrEnum):
+    SANIC = auto()
+    ASGI = auto()
+    GUNICORN = auto()
+
+
+class Mode(StrEnum):
+    PRODUCTION = auto()
+    DEBUG = auto()
+
+
+class ServerStage(IntEnum):
+    STOPPED = auto()
+    PARTIAL = auto()
+    SERVING = auto()
+
+
@dataclass
 class ApplicationServerInfo:
    settings: Dict[str, Any]
@@ -69,9 +91,6 @@ class ApplicationState:
        if getattr(self.app, "configure_logging", False) and self.app.debug:
            logger.setLevel(logging.DEBUG)

-    def set_verbosity(self, value: int):
-        VerbosityFilter.verbosity = value
-
    @property
    def is_debug(self):
        return self.mode is Mode.DEBUG
--- a/sanic/asgi.py
+++ b/sanic/asgi.py
@@ -3,12 +3,13 @@ from __future__ import annotations
 import warnings

 from typing import TYPE_CHECKING, Optional
+from urllib.parse import quote

 from sanic.compat import Header
-from sanic.exceptions import BadRequest, ServerError
-from sanic.helpers import Default
+from sanic.exceptions import ServerError
+from sanic.helpers import _default
 from sanic.http import Stage
-from sanic.log import error_logger, logger
+from sanic.log import logger
 from sanic.models.asgi import ASGIReceive, ASGIScope, ASGISend, MockTransport
 from sanic.request import Request
 from sanic.response import BaseHTTPResponse
@@ -16,35 +17,35 @@ from sanic.server import ConnInfo
 from sanic.server.websockets.connection import WebSocketConnection


-if TYPE_CHECKING:
+if TYPE_CHECKING:  # no cov
    from sanic import Sanic


 class Lifespan:
-    def __init__(
-        self, sanic_app, scope: ASGIScope, receive: ASGIReceive, send: ASGISend
-    ) -> None:
-        self.sanic_app = sanic_app
-        self.scope = scope
-        self.receive = receive
-        self.send = send
+    def __init__(self, asgi_app: ASGIApp) -> None:
+        self.asgi_app = asgi_app

-        if "server.init.before" in self.sanic_app.signal_router.name_index:
-            logger.debug(
-                'You have set a listener for "before_server_start" '
-                "in ASGI mode. "
-                "It will be executed as early as possible, but not before "
-                "the ASGI server is started.",
-                extra={"verbosity": 1},
-            )
-        if "server.shutdown.after" in self.sanic_app.signal_router.name_index:
-            logger.debug(
-                'You have set a listener for "after_server_stop" '
-                "in ASGI mode. "
-                "It will be executed as late as possible, but not after "
-                "the ASGI server is stopped.",
-                extra={"verbosity": 1},
-            )
+        if self.asgi_app.sanic_app.state.verbosity > 0:
+            if (
+                "server.init.before"
+                in self.asgi_app.sanic_app.signal_router.name_index
+            ):
+                logger.debug(
+                    'You have set a listener for "before_server_start" '
+                    "in ASGI mode. "
+                    "It will be executed as early as possible, but not before "
+                    "the ASGI server is started."
+                )
+            if (
+                "server.shutdown.after"
+                in self.asgi_app.sanic_app.signal_router.name_index
+            ):
+                logger.debug(
+                    'You have set a listener for "after_server_stop" '
+                    "in ASGI mode. "
+                    "It will be executed as late as possible, but not after "
+                    "the ASGI server is stopped."
+                )

    async def startup(self) -> None:
        """
@@ -55,11 +56,11 @@ class Lifespan:
        in sequence since the ASGI lifespan protocol only supports a single
        startup event.
        """
-        await self.sanic_app._startup()
-        await self.sanic_app._server_event("init", "before")
-        await self.sanic_app._server_event("init", "after")
+        await self.asgi_app.sanic_app._startup()
+        await self.asgi_app.sanic_app._server_event("init", "before")
+        await self.asgi_app.sanic_app._server_event("init", "after")

-        if not isinstance(self.sanic_app.config.USE_UVLOOP, Default):
+        if self.asgi_app.sanic_app.config.USE_UVLOOP is not _default:
            warnings.warn(
                "You have set the USE_UVLOOP configuration option, but Sanic "
                "cannot control the event loop when running in ASGI mode."
@@ -75,33 +76,21 @@ class Lifespan:
        in sequence since the ASGI lifespan protocol only supports a single
        shutdown event.
        """
-        await self.sanic_app._server_event("shutdown", "before")
-        await self.sanic_app._server_event("shutdown", "after")
+        await self.asgi_app.sanic_app._server_event("shutdown", "before")
+        await self.asgi_app.sanic_app._server_event("shutdown", "after")

-    async def __call__(self) -> None:
-        while True:
-            message = await self.receive()
-            if message["type"] == "lifespan.startup":
-                try:
-                    await self.startup()
-                except Exception as e:
-                    error_logger.exception(e)
-                    await self.send(
-                        {"type": "lifespan.startup.failed", "message": str(e)}
-                    )
-                else:
-                    await self.send({"type": "lifespan.startup.complete"})
-            elif message["type"] == "lifespan.shutdown":
-                try:
-                    await self.shutdown()
-                except Exception as e:
-                    error_logger.exception(e)
-                    await self.send(
-                        {"type": "lifespan.shutdown.failed", "message": str(e)}
-                    )
-                else:
-                    await self.send({"type": "lifespan.shutdown.complete"})
-                return
+    async def __call__(
+        self, scope: ASGIScope, receive: ASGIReceive, send: ASGISend
+    ) -> None:
+        message = await receive()
+        if message["type"] == "lifespan.startup":
+            await self.startup()
+            await send({"type": "lifespan.startup.complete"})
+
+        message = await receive()
+        if message["type"] == "lifespan.shutdown":
+            await self.shutdown()
+            await send({"type": "lifespan.shutdown.complete"})


 class ASGIApp:
@@ -113,79 +102,66 @@ class ASGIApp:
    stage: Stage
    response: Optional[BaseHTTPResponse]

+    def __init__(self) -> None:
+        self.ws = None
+
    @classmethod
    async def create(
-        cls,
-        sanic_app: Sanic,
-        scope: ASGIScope,
-        receive: ASGIReceive,
-        send: ASGISend,
-    ) -> ASGIApp:
+        cls, sanic_app, scope: ASGIScope, receive: ASGIReceive, send: ASGISend
+    ) -> "ASGIApp":
        instance = cls()
-        instance.ws = None
        instance.sanic_app = sanic_app
        instance.transport = MockTransport(scope, receive, send)
        instance.transport.loop = sanic_app.loop
        instance.stage = Stage.IDLE
        instance.response = None
-        instance.sanic_app.state.is_started = True
        setattr(instance.transport, "add_task", sanic_app.loop.create_task)

-        try:
-            headers = Header(
-                [
-                    (
-                        key.decode("ASCII"),
-                        value.decode(errors="surrogateescape"),
-                    )
-                    for key, value in scope.get("headers", [])
-                ]
-            )
-        except UnicodeDecodeError:
-            raise BadRequest(
-                "Header names can only contain US-ASCII characters"
-            )
+        headers = Header(
+            [
+                (key.decode("latin-1"), value.decode("latin-1"))
+                for key, value in scope.get("headers", [])
+            ]
+        )
+        instance.lifespan = Lifespan(instance)

-        if scope["type"] == "http":
-            version = scope["http_version"]
-            method = scope["method"]
-        elif scope["type"] == "websocket":
-            version = "1.1"
-            method = "GET"
-
-            instance.ws = instance.transport.create_websocket_connection(
-                send, receive
-            )
+        if scope["type"] == "lifespan":
+            await instance.lifespan(scope, receive, send)
        else:
-            raise ServerError("Received unknown ASGI scope")
+            path = (
+                scope["path"][1:]
+                if scope["path"].startswith("/")
+                else scope["path"]
+            )
+            url = "/".join([scope.get("root_path", ""), quote(path)])
+            url_bytes = url.encode("latin-1")
+            url_bytes += b"?" + scope["query_string"]

-        url_bytes, query = scope["raw_path"], scope["query_string"]
-        if query:
-            # httpx ASGI client sends query string as part of raw_path
-            url_bytes = url_bytes.split(b"?", 1)[0]
-            # All servers send them separately
-            url_bytes = b"%b?%b" % (url_bytes, query)
+            if scope["type"] == "http":
+                version = scope["http_version"]
+                method = scope["method"]
+            elif scope["type"] == "websocket":
+                version = "1.1"
+                method = "GET"

-        request_class = sanic_app.request_class or Request
-        instance.request = request_class(
-            url_bytes,
-            headers,
-            version,
-            method,
-            instance.transport,
-            sanic_app,
-        )
-        request_class._current.set(instance.request)
-        instance.request.stream = instance  # type: ignore
-        instance.request_body = True
-        instance.request.conn_info = ConnInfo(instance.transport)
+                instance.ws = instance.transport.create_websocket_connection(
+                    send, receive
+                )
+            else:
+                raise ServerError("Received unknown ASGI scope")

-        await instance.sanic_app.dispatch(
-            "http.lifecycle.request",
-            inline=True,
-            context={"request": instance.request},
-            fail_not_found=False,
-        )
+            request_class = sanic_app.request_class or Request
+            instance.request = request_class(
+                url_bytes,
+                headers,
+                version,
+                method,
+                instance.transport,
+                sanic_app,
+            )
+            instance.request.stream = instance
+            instance.request_body = True
+            instance.request.conn_info = ConnInfo(instance.transport)

        return instance

@@ -250,7 +226,4 @@ class ASGIApp:
            self.stage = Stage.HANDLER
            await self.sanic_app.handle_request(self.request)
        except Exception as e:
-            try:
-                await self.sanic_app.handle_exception(self.request, e)
-            except Exception as exc:
-                await self.sanic_app.handle_exception(self.request, exc, False)
+            await self.sanic_app.handle_exception(self.request, e)
--- a/sanic/base/root.py
+++ b/sanic/base/root.py
@@ -1,6 +1,6 @@
 import re

-from typing import Any, Optional
+from typing import Any

 from sanic.base.meta import SanicMeta
 from sanic.exceptions import SanicException
@@ -9,7 +9,6 @@ from sanic.mixins.listeners import ListenerMixin
 from sanic.mixins.middleware import MiddlewareMixin
 from sanic.mixins.routes import RouteMixin
 from sanic.mixins.signals import SignalMixin
-from sanic.mixins.static import StaticMixin


 VALID_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_\-]*$")
@@ -17,7 +16,6 @@ VALID_NAME = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_\-]*$")

 class BaseSanic(
    RouteMixin,
-    StaticMixin,
    MiddlewareMixin,
    ListenerMixin,
    ExceptionMixin,
@@ -26,9 +24,7 @@ class BaseSanic(
 ):
    __slots__ = ("name",)

-    def __init__(
-        self, name: Optional[str] = None, *args: Any, **kwargs: Any
-    ) -> None:
+    def __init__(self, name: str = None, *args: Any, **kwargs: Any) -> None:
        class_name = self.__class__.__name__

        if name is None:
--- a/sanic/blueprint_group.py
+++ b/sanic/blueprint_group.py
@@ -5,7 +5,7 @@ from functools import partial
 from typing import TYPE_CHECKING, List, Optional, Union


-if TYPE_CHECKING:
+if TYPE_CHECKING:  # no cov
    from sanic.blueprints import Blueprint


@@ -65,7 +65,6 @@ class BlueprintGroup(MutableSequence):
        "_version",
        "_strict_slashes",
        "_version_prefix",
-        "_name_prefix",
    )

    def __init__(
@@ -74,7 +73,6 @@ class BlueprintGroup(MutableSequence):
        version: Optional[Union[int, str, float]] = None,
        strict_slashes: Optional[bool] = None,
        version_prefix: str = "/v",
-        name_prefix: Optional[str] = "",
    ):
        """
        Create a new Blueprint Group
@@ -89,7 +87,6 @@ class BlueprintGroup(MutableSequence):
        self._version = version
        self._version_prefix = version_prefix
        self._strict_slashes = strict_slashes
-        self._name_prefix = name_prefix

    @property
    def url_prefix(self) -> Optional[Union[int, str, float]]:
@@ -137,15 +134,6 @@ class BlueprintGroup(MutableSequence):
        """
        return self._version_prefix

-    @property
-    def name_prefix(self) -> Optional[str]:
-        """
-        Name prefix for the blueprint group
-
-        :return: str
-        """
-        return self._name_prefix
-
    def __iter__(self):
        """
        Tun the class Blueprint Group into an Iterable item
--- a/sanic/blueprints.py
+++ b/sanic/blueprints.py
@@ -21,8 +21,8 @@ from typing import (
    Union,
 )

-from sanic_routing.exceptions import NotFound
-from sanic_routing.route import Route
+from sanic_routing.exceptions import NotFound  # type: ignore
+from sanic_routing.route import Route  # type: ignore

 from sanic.base.root import BaseSanic
 from sanic.blueprint_group import BlueprintGroup
@@ -36,7 +36,7 @@ from sanic.models.handler_types import (
 )


-if TYPE_CHECKING:
+if TYPE_CHECKING:  # no cov
    from sanic import Sanic


@@ -93,8 +93,6 @@ class Blueprint(BaseSanic):
        "_future_listeners",
        "_future_exceptions",
        "_future_signals",
-        "_allow_route_overwrite",
-        "copied_from",
        "ctx",
        "exceptions",
        "host",
@@ -111,7 +109,7 @@ class Blueprint(BaseSanic):

    def __init__(
        self,
-        name: str,
+        name: str = None,
        url_prefix: Optional[str] = None,
        host: Optional[Union[List[str], str]] = None,
        version: Optional[Union[int, str, float]] = None,
@@ -120,8 +118,6 @@ class Blueprint(BaseSanic):
    ):
        super().__init__(name=name)
        self.reset()
-        self._allow_route_overwrite = False
-        self.copied_from = ""
        self.ctx = SimpleNamespace()
        self.host = host
        self.strict_slashes = strict_slashes
@@ -171,7 +167,6 @@ class Blueprint(BaseSanic):

    def reset(self):
        self._apps: Set[Sanic] = set()
-        self._allow_route_overwrite = False
        self.exceptions: List[RouteHandler] = []
        self.listeners: Dict[str, List[ListenerType[Any]]] = {}
        self.middlewares: List[MiddlewareType] = []
@@ -185,7 +180,6 @@ class Blueprint(BaseSanic):
        url_prefix: Optional[Union[str, Default]] = _default,
        version: Optional[Union[int, str, float, Default]] = _default,
        version_prefix: Union[str, Default] = _default,
-        allow_route_overwrite: Union[bool, Default] = _default,
        strict_slashes: Optional[Union[bool, Default]] = _default,
        with_registration: bool = True,
        with_ctx: bool = False,
@@ -219,7 +213,6 @@ class Blueprint(BaseSanic):
        self.reset()
        new_bp = deepcopy(self)
        new_bp.name = name
-        new_bp.copied_from = self.name

        if not isinstance(url_prefix, Default):
            new_bp.url_prefix = url_prefix
@@ -229,8 +222,6 @@ class Blueprint(BaseSanic):
            new_bp.strict_slashes = strict_slashes
        if not isinstance(version_prefix, Default):
            new_bp.version_prefix = version_prefix
-        if not isinstance(allow_route_overwrite, Default):
-            new_bp._allow_route_overwrite = allow_route_overwrite

        for key, value in attrs_backup.items():
            setattr(self, key, value)
@@ -256,7 +247,6 @@ class Blueprint(BaseSanic):
        version: Optional[Union[int, str, float]] = None,
        strict_slashes: Optional[bool] = None,
        version_prefix: str = "/v",
-        name_prefix: Optional[str] = "",
    ) -> BlueprintGroup:
        """
        Create a list of blueprints, optionally grouping them under a
@@ -282,7 +272,6 @@ class Blueprint(BaseSanic):
            version=version,
            strict_slashes=strict_slashes,
            version_prefix=version_prefix,
-            name_prefix=name_prefix,
        )
        for bp in chain(blueprints):
            bps.append(bp)
@@ -303,7 +292,6 @@ class Blueprint(BaseSanic):
        opt_version = options.get("version", None)
        opt_strict_slashes = options.get("strict_slashes", None)
        opt_version_prefix = options.get("version_prefix", self.version_prefix)
-        opt_name_prefix = options.get("name_prefix", None)
        error_format = options.get(
            "error_format", app.config.FALLBACK_ERROR_FORMAT
        )
@@ -316,12 +304,11 @@ class Blueprint(BaseSanic):

        # Routes
        for future in self._future_routes:
+            # attach the blueprint name to the handler so that it can be
+            # prefixed properly in the router
+            future.handler.__blueprintname__ = self.name
            # Prepend the blueprint URI prefix if available
-            uri = self._setup_uri(future.uri, url_prefix)
-
-            route_error_format = (
-                future.error_format if future.error_format else error_format
-            )
+            uri = url_prefix + future.uri if url_prefix else future.uri

            version_prefix = self.version_prefix
            for prefix in (
@@ -339,17 +326,14 @@ class Blueprint(BaseSanic):
                future.strict_slashes, opt_strict_slashes, self.strict_slashes
            )

-            name = future.name
-            if opt_name_prefix:
-                name = f"{opt_name_prefix}_{future.name}"
-            name = app._generate_name(name)
+            name = app._generate_name(future.name)
            host = future.host or self.host
            if isinstance(host, list):
                host = tuple(host)

            apply_route = FutureRoute(
                future.handler,
-                uri,
+                uri[1:] if uri.startswith("//") else uri,
                future.methods,
                host,
                strict_slashes,
@@ -362,7 +346,7 @@ class Blueprint(BaseSanic):
                future.unquote,
                future.static,
                version_prefix,
-                route_error_format,
+                error_format,
                future.route_context,
            )

@@ -370,19 +354,7 @@ class Blueprint(BaseSanic):
                continue

            registered.add(apply_route)
-            route = app._apply_route(
-                apply_route, overwrite=self._allow_route_overwrite
-            )
-
-            # If it is a copied BP, then make sure all of the names of routes
-            # matchup with the new BP name
-            if self.copied_from:
-                for r in route:
-                    r.name = r.name.replace(self.copied_from, self.name)
-                    r.extra.ident = r.extra.ident.replace(
-                        self.copied_from, self.name
-                    )
-
+            route = app._apply_route(apply_route)
            operation = (
                routes.extend if isinstance(route, list) else routes.append
            )
@@ -391,7 +363,7 @@ class Blueprint(BaseSanic):
        # Static Files
        for future in self._future_statics:
            # Prepend the blueprint URI prefix if available
-            uri = self._setup_uri(future.uri, url_prefix)
+            uri = url_prefix + future.uri if url_prefix else future.uri
            apply_route = FutureStatic(uri, *future[1:])

            if (self, apply_route) in app._future_registry:
@@ -434,7 +406,7 @@ class Blueprint(BaseSanic):

        self.routes += [route for route in routes if isinstance(route, Route)]
        self.websocket_routes += [
-            route for route in self.routes if route.extra.websocket
+            route for route in self.routes if route.ctx.websocket
        ]
        self.middlewares += middleware
        self.exceptions += exception_handlers
@@ -470,7 +442,7 @@ class Blueprint(BaseSanic):
            events.add(signal.ctx.event)

        return asyncio.wait(
-            [asyncio.create_task(event.wait()) for event in events],
+            [event.wait() for event in events],
            return_when=asyncio.FIRST_COMPLETED,
            timeout=timeout,
        )
@@ -484,18 +456,6 @@ class Blueprint(BaseSanic):
                break
        return value

-    @staticmethod
-    def _setup_uri(base: str, prefix: Optional[str]):
-        uri = base
-        if prefix:
-            uri = prefix
-            if base.startswith("/") and prefix.endswith("/"):
-                uri += base[1:]
-            else:
-                uri += base
-
-        return uri[1:] if uri.startswith("//") else uri
-
    @staticmethod
    def register_futures(
        apps: Set[Sanic], bp: Blueprint, futures: Sequence[Tuple[Any, ...]]
--- a/sanic/cli/app.py
+++ b/sanic/cli/app.py
@@ -2,19 +2,21 @@ import os
 import shutil
 import sys

-from argparse import Namespace
-from functools import partial
+from argparse import ArgumentParser, RawTextHelpFormatter
+from importlib import import_module
+from pathlib import Path
 from textwrap import indent
-from typing import List, Union
+from typing import Any, List, Union

 from sanic.app import Sanic
 from sanic.application.logo import get_logo
 from sanic.cli.arguments import Group
-from sanic.cli.base import SanicArgumentParser, SanicHelpFormatter
-from sanic.cli.inspector import make_inspector_parser
-from sanic.cli.inspector_client import InspectorClient
 from sanic.log import error_logger
-from sanic.worker.loader import AppLoader
+from sanic.simple import create_simple_server
+
+
+class SanicArgumentParser(ArgumentParser):
+    ...


 class SanicCLI:
@@ -23,22 +25,17 @@ class SanicCLI:
 {get_logo(True)}

 To start running a Sanic application, provide a path to the module, where
-app is a Sanic() instance in the global scope:
+app is a Sanic() instance:

    $ sanic path.to.server:app

-If the Sanic instance variable is called 'app', you can leave off the last
-part, and only provide a path to the module where the instance is:
-
-    $ sanic path.to.server
-
 Or, a path to a callable that returns a Sanic() instance:

-    $ sanic path.to.factory:create_app
+    $ sanic path.to.factory:create_app --factory

 Or, a path to a directory to run as a simple HTTP server:

-    $ sanic ./path/to/static
+    $ sanic ./path/to/static --simple
 """,
        prefix=" ",
    )
@@ -48,7 +45,7 @@ Or, a path to a directory to run as a simple HTTP server:
        self.parser = SanicArgumentParser(
            prog="sanic",
            description=self.DESCRIPTION,
-            formatter_class=lambda prog: SanicHelpFormatter(
+            formatter_class=lambda prog: RawTextHelpFormatter(
                prog,
                max_help_position=36 if width > 96 else 24,
                indent_increment=4,
@@ -60,37 +57,19 @@ Or, a path to a directory to run as a simple HTTP server:
        self.main_process = (
            os.environ.get("SANIC_RELOADER_PROCESS", "") != "true"
        )
-        self.args: Namespace = Namespace()
-        self.groups: List[Group] = []
-        self.inspecting = False
+        self.args: List[Any] = []

    def attach(self):
-        if len(sys.argv) > 1 and sys.argv[1] == "inspect":
-            self.inspecting = True
-            self.parser.description = get_logo(True)
-            make_inspector_parser(self.parser)
-            return
-
        for group in Group._registry:
-            instance = group.create(self.parser)
-            instance.attach()
-            self.groups.append(instance)
+            group.create(self.parser).attach()

-    def run(self, parse_args=None):
-        if self.inspecting:
-            self._inspector()
-            return
+    def run(self):
+        # This is to provide backwards compat -v to display version
+        legacy_version = len(sys.argv) == 2 and sys.argv[-1] == "-v"
+        parse_args = ["--version"] if legacy_version else None

-        legacy_version = False
        if not parse_args:
-            # This is to provide backwards compat -v to display version
-            legacy_version = len(sys.argv) == 2 and sys.argv[-1] == "-v"
-            parse_args = ["--version"] if legacy_version else None
-        elif parse_args == ["-v"]:
-            parse_args = ["--version"]
-
-        if not legacy_version:
-            parsed, unknown = self.parser.parse_known_args(args=parse_args)
+            parsed, unknown = self.parser.parse_known_args()
            if unknown and parsed.factory:
                for arg in unknown:
                    if arg.startswith("--"):
@@ -98,58 +77,16 @@ Or, a path to a directory to run as a simple HTTP server:

        self.args = self.parser.parse_args(args=parse_args)
        self._precheck()
-        app_loader = AppLoader(
-            self.args.target, self.args.factory, self.args.simple, self.args
-        )

        try:
-            app = self._get_app(app_loader)
+            app = self._get_app()
            kwargs = self._build_run_kwargs()
-        except ValueError as e:
-            error_logger.exception(f"Failed to run app: {e}")
-        else:
-            for http_version in self.args.http:
-                app.prepare(**kwargs, version=http_version)
-            if self.args.single:
-                serve = Sanic.serve_single
-            else:
-                serve = partial(Sanic.serve, app_loader=app_loader)
-            serve(app)
-
-    def _inspector(self):
-        args = sys.argv[2:]
-        self.args, unknown = self.parser.parse_known_args(args=args)
-        if unknown:
-            for arg in unknown:
-                if arg.startswith("--"):
-                    try:
-                        key, value = arg.split("=")
-                        key = key.lstrip("-")
-                    except ValueError:
-                        value = False if arg.startswith("--no-") else True
-                        key = (
-                            arg.replace("--no-", "")
-                            .lstrip("-")
-                            .replace("-", "_")
-                        )
-                    setattr(self.args, key, value)
-
-        kwargs = {**self.args.__dict__}
-        host = kwargs.pop("host")
-        port = kwargs.pop("port")
-        secure = kwargs.pop("secure")
-        raw = kwargs.pop("raw")
-        action = kwargs.pop("action") or "info"
-        api_key = kwargs.pop("api_key")
-        positional = kwargs.pop("positional", None)
-        if action == "<custom>" and positional:
-            action = positional[0]
-            if len(positional) > 1:
-                kwargs["args"] = positional[1:]
-        InspectorClient(host, port, secure, raw, api_key).do(action, **kwargs)
+            app.run(**kwargs)
+        except ValueError:
+            error_logger.exception("Failed to run app")

    def _precheck(self):
-        # Custom TLS mismatch handling for better diagnostics
+        # # Custom TLS mismatch handling for better diagnostics
        if self.main_process and (
            # one of cert/key missing
            bool(self.args.cert) != bool(self.args.key)
@@ -170,28 +107,67 @@ Or, a path to a directory to run as a simple HTTP server:
            error_logger.error(message)
            sys.exit(1)

-    def _get_app(self, app_loader: AppLoader):
+    def _get_app(self):
        try:
-            app = app_loader.load()
+            module_path = os.path.abspath(os.getcwd())
+            if module_path not in sys.path:
+                sys.path.append(module_path)
+
+            if self.args.simple:
+                path = Path(self.args.module)
+                app = create_simple_server(path)
+            else:
+                delimiter = ":" if ":" in self.args.module else "."
+                module_name, app_name = self.args.module.rsplit(delimiter, 1)
+
+                if module_name == "" and os.path.isdir(self.args.module):
+                    raise ValueError(
+                        "App not found.\n"
+                        "   Please use --simple if you are passing a "
+                        "directory to sanic.\n"
+                        f"   eg. sanic {self.args.module} --simple"
+                    )
+
+                if app_name.endswith("()"):
+                    self.args.factory = True
+                    app_name = app_name[:-2]
+
+                module = import_module(module_name)
+                app = getattr(module, app_name, None)
+                if self.args.factory:
+                    try:
+                        app = app(self.args)
+                    except TypeError:
+                        app = app()
+
+                app_type_name = type(app).__name__
+
+                if not isinstance(app, Sanic):
+                    if callable(app):
+                        solution = f"sanic {self.args.module} --factory"
+                        raise ValueError(
+                            "Module is not a Sanic app, it is a"
+                            f"{app_type_name}\n"
+                            "  If this callable returns a"
+                            f"Sanic instance try: \n{solution}"
+                        )
+
+                    raise ValueError(
+                        f"Module is not a Sanic app, it is a {app_type_name}\n"
+                        f"  Perhaps you meant {self.args.module}:app?"
+                    )
        except ImportError as e:
-            if app_loader.module_name.startswith(e.name):  # type: ignore
+            if module_name.startswith(e.name):
                error_logger.error(
                    f"No module named {e.name} found.\n"
                    "  Example File: project/sanic_server.py -> app\n"
                    "  Example Module: project.sanic_server.app"
                )
-                error_logger.error(
-                    "\nThe error below might have caused the above one:\n"
-                    f"{e.msg}"
-                )
-                sys.exit(1)
            else:
                raise e
        return app

    def _build_run_kwargs(self):
-        for group in self.groups:
-            group.prepare(self.args)
        ssl: Union[None, dict, str, list] = []
        if self.args.tlshost:
            ssl.append(None)
@@ -204,10 +180,8 @@ Or, a path to a directory to run as a simple HTTP server:
        elif len(ssl) == 1 and ssl[0] is not None:
            # Use only one cert, no TLSSelector.
            ssl = ssl[0]
-
        kwargs = {
            "access_log": self.args.access_log,
-            "coffee": self.args.coffee,
            "debug": self.args.debug,
            "fast": self.args.fast,
            "host": self.args.host,
@@ -218,8 +192,6 @@ Or, a path to a directory to run as a simple HTTP server:
            "unix": self.args.unix,
            "verbosity": self.args.verbosity or 0,
            "workers": self.args.workers,
-            "auto_tls": self.args.auto_tls,
-            "single_process": self.args.single,
        }

        for maybe_arg in ("auto_reload", "dev"):
@@ -229,5 +201,4 @@ Or, a path to a directory to run as a simple HTTP server:
        if self.args.path:
            kwargs["auto_reload"] = True
            kwargs["reload_dir"] = self.args.path
-
        return kwargs
--- a/sanic/cli/arguments.py
+++ b/sanic/cli/arguments.py
@@ -3,10 +3,9 @@ from __future__ import annotations
 from argparse import ArgumentParser, _ArgumentGroup
 from typing import List, Optional, Type, Union

-from sanic_routing import __version__ as __routing_version__
+from sanic_routing import __version__ as __routing_version__  # type: ignore

 from sanic import __version__
-from sanic.http.constants import HTTP


 class Group:
@@ -30,7 +29,7 @@ class Group:
        instance = cls(parser, cls.name)
        return instance

-    def add_bool_arguments(self, *args, nullable=False, **kwargs):
+    def add_bool_arguments(self, *args, **kwargs):
        group = self.container.add_mutually_exclusive_group()
        kwargs["help"] = kwargs["help"].capitalize()
        group.add_argument(*args, action="store_true", **kwargs)
@@ -38,12 +37,6 @@ class Group:
        group.add_argument(
            "--no-" + args[0][2:], *args[1:], action="store_false", **kwargs
        )
-        if nullable:
-            params = {args[0][2:].replace("-", "_"): None}
-            group.set_defaults(**params)
-
-    def prepare(self, args) -> None:
-        ...


 class GeneralGroup(Group):
@@ -57,15 +50,11 @@ class GeneralGroup(Group):
        )

        self.container.add_argument(
-            "target",
+            "module",
            help=(
-                "Path to your Sanic app instance.\n"
-                "\tExample: path.to.server:app\n"
-                "If running a Simple Server, path to directory to serve.\n"
-                "\tExample: ./\n"
-                "Additionally, this can be a path to a factory function\n"
-                "that returns a Sanic app instance.\n"
-                "\tExample: path.to.server:create_app\n"
+                "Path to your Sanic app. Example: path.to.server:app\n"
+                "If running a Simple Server, path to directory to serve. "
+                "Example: ./\n"
            ),
        )

@@ -74,8 +63,7 @@ class ApplicationGroup(Group):
    name = "Application"

    def attach(self):
-        group = self.container.add_mutually_exclusive_group()
-        group.add_argument(
+        self.container.add_argument(
            "--factory",
            action="store_true",
            help=(
@@ -83,7 +71,7 @@ class ApplicationGroup(Group):
                "i.e. a () -> <Sanic app> callable"
            ),
        )
-        group.add_argument(
+        self.container.add_argument(
            "-s",
            "--simple",
            dest="simple",
@@ -95,44 +83,6 @@ class ApplicationGroup(Group):
        )


-class HTTPVersionGroup(Group):
-    name = "HTTP version"
-
-    def attach(self):
-        http_values = [http.value for http in HTTP.__members__.values()]
-
-        self.container.add_argument(
-            "--http",
-            dest="http",
-            action="append",
-            choices=http_values,
-            type=int,
-            help=(
-                "Which HTTP version to use: HTTP/1.1 or HTTP/3. Value should\n"
-                "be either 1, or 3. [default 1]"
-            ),
-        )
-        self.container.add_argument(
-            "-1",
-            dest="http",
-            action="append_const",
-            const=1,
-            help=("Run Sanic server using HTTP/1.1"),
-        )
-        self.container.add_argument(
-            "-3",
-            dest="http",
-            action="append_const",
-            const=3,
-            help=("Run Sanic server using HTTP/3"),
-        )
-
-    def prepare(self, args):
-        if not args.http:
-            args.http = [1]
-        args.http = tuple(sorted(set(map(HTTP, args.http)), reverse=True))
-
-
 class SocketGroup(Group):
    name = "Socket binding"

@@ -142,6 +92,7 @@ class SocketGroup(Group):
            "--host",
            dest="host",
            type=str,
+            default="127.0.0.1",
            help="Host address [default 127.0.0.1]",
        )
        self.container.add_argument(
@@ -149,6 +100,7 @@ class SocketGroup(Group):
            "--port",
            dest="port",
            type=int,
+            default=8000,
            help="Port to serve on [default 8000]",
        )
        self.container.add_argument(
@@ -215,17 +167,8 @@ class WorkerGroup(Group):
            action="store_true",
            help="Set the number of workers to max allowed",
        )
-        group.add_argument(
-            "--single-process",
-            dest="single",
-            action="store_true",
-            help="Do not use multiprocessing, run server in a single process",
-        )
        self.add_bool_arguments(
-            "--access-logs",
-            dest="access_log",
-            help="display access logs",
-            default=None,
+            "--access-logs", dest="access_log", help="display access logs"
        )


@@ -237,7 +180,11 @@ class DevelopmentGroup(Group):
            "--debug",
            dest="debug",
            action="store_true",
-            help="Run the server in debug mode",
+            help=(
+                "Run the server in DEBUG mode. It includes DEBUG logging,\n"
+                "additional context on exceptions, and other settings\n"
+                "not-safe for PRODUCTION, but helpful for debugging problems."
+            ),
        )
        self.container.add_argument(
            "-r",
@@ -262,16 +209,7 @@ class DevelopmentGroup(Group):
            "--dev",
            dest="dev",
            action="store_true",
-            help=("debug + auto reload"),
-        )
-        self.container.add_argument(
-            "--auto-tls",
-            dest="auto_tls",
-            action="store_true",
-            help=(
-                "Create a temporary TLS certificate for local development "
-                "(requires mkcert or trustme)"
-            ),
+            help=("debug + auto reload."),
        )


@@ -279,12 +217,6 @@ class OutputGroup(Group):
    name = "Output"

    def attach(self):
-        self.add_bool_arguments(
-            "--coffee",
-            dest="coffee",
-            default=False,
-            help="Uhm, coffee?",
-        )
        self.add_bool_arguments(
            "--motd",
            dest="motd",
--- a/sanic/cli/base.py
+++ b/sanic/cli/base.py
@@ -1,35 +0,0 @@
-from argparse import (
-    SUPPRESS,
-    Action,
-    ArgumentParser,
-    RawTextHelpFormatter,
-    _SubParsersAction,
-)
-from typing import Any
-
-
-class SanicArgumentParser(ArgumentParser):
-    def _check_value(self, action: Action, value: Any) -> None:
-        if isinstance(action, SanicSubParsersAction):
-            return
-        super()._check_value(action, value)
-
-
-class SanicHelpFormatter(RawTextHelpFormatter):
-    def add_usage(self, usage, actions, groups, prefix=None):
-        if not usage:
-            usage = SUPPRESS
-            # Add one linebreak, but not two
-            self.add_text("\x1b[1A")
-        super().add_usage(usage, actions, groups, prefix)
-
-
-class SanicSubParsersAction(_SubParsersAction):
-    def __call__(self, parser, namespace, values, option_string=None):
-        self._name_parser_map
-        parser_name = values[0]
-        if parser_name not in self._name_parser_map:
-            self._name_parser_map[parser_name] = parser
-            values = ["<custom>", *values]
-
-        super().__call__(parser, namespace, values, option_string)
--- a/sanic/cli/inspector.py
+++ b/sanic/cli/inspector.py
@@ -1,105 +0,0 @@
-from argparse import ArgumentParser
-
-from sanic.application.logo import get_logo
-from sanic.cli.base import SanicHelpFormatter, SanicSubParsersAction
-
-
-def _add_shared(parser: ArgumentParser) -> None:
-    parser.add_argument(
-        "--host",
-        "-H",
-        default="localhost",
-        help="Inspector host address [default 127.0.0.1]",
-    )
-    parser.add_argument(
-        "--port",
-        "-p",
-        default=6457,
-        type=int,
-        help="Inspector port [default 6457]",
-    )
-    parser.add_argument(
-        "--secure",
-        "-s",
-        action="store_true",
-        help="Whether to access the Inspector via TLS encryption",
-    )
-    parser.add_argument("--api-key", "-k", help="Inspector authentication key")
-    parser.add_argument(
-        "--raw",
-        action="store_true",
-        help="Whether to output the raw response information",
-    )
-
-
-class InspectorSubParser(ArgumentParser):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        _add_shared(self)
-        if not self.description:
-            self.description = ""
-        self.description = get_logo(True) + self.description
-
-
-def make_inspector_parser(parser: ArgumentParser) -> None:
-    _add_shared(parser)
-    subparsers = parser.add_subparsers(
-        action=SanicSubParsersAction,
-        dest="action",
-        description=(
-            "Run one or none of the below subcommands. Using inspect without "
-            "a subcommand will fetch general information about the state "
-            "of the application instance.\n\n"
-            "Or, you can optionally follow inspect with a subcommand. "
-            "If you have created a custom "
-            "Inspector instance, then you can run custom commands. See "
-            "https://sanic.dev/en/guide/deployment/inspector.html "
-            "for more details."
-        ),
-        title="  Subcommands",
-        parser_class=InspectorSubParser,
-    )
-    reloader = subparsers.add_parser(
-        "reload",
-        help="Trigger a reload of the server workers",
-        formatter_class=SanicHelpFormatter,
-    )
-    reloader.add_argument(
-        "--zero-downtime",
-        action="store_true",
-        help=(
-            "Whether to wait for the new process to be online before "
-            "terminating the old"
-        ),
-    )
-    subparsers.add_parser(
-        "shutdown",
-        help="Shutdown the application and all processes",
-        formatter_class=SanicHelpFormatter,
-    )
-    scale = subparsers.add_parser(
-        "scale",
-        help="Scale the number of workers",
-        formatter_class=SanicHelpFormatter,
-    )
-    scale.add_argument(
-        "replicas",
-        type=int,
-        help="Number of workers requested",
-    )
-
-    custom = subparsers.add_parser(
-        "<custom>",
-        help="Run a custom command",
-        description=(
-            "keyword arguments:\n  When running a custom command, you can "
-            "add keyword arguments by appending them to your command\n\n"
-            "\tsanic inspect foo --one=1 --two=2"
-        ),
-        formatter_class=SanicHelpFormatter,
-    )
-    custom.add_argument(
-        "positional",
-        nargs="*",
-        help="Add one or more non-keyword args to your custom command",
-    )
--- a/sanic/cli/inspector_client.py
+++ b/sanic/cli/inspector_client.py
@@ -1,119 +0,0 @@
-from __future__ import annotations
-
-import sys
-
-from http.client import RemoteDisconnected
-from textwrap import indent
-from typing import Any, Dict, Optional
-from urllib.error import URLError
-from urllib.request import Request as URequest
-from urllib.request import urlopen
-
-from sanic.application.logo import get_logo
-from sanic.application.motd import MOTDTTY
-from sanic.log import Colors
-
-
-try:  # no cov
-    from ujson import dumps, loads
-except ModuleNotFoundError:  # no cov
-    from json import dumps, loads  # type: ignore
-
-
-class InspectorClient:
-    def __init__(
-        self,
-        host: str,
-        port: int,
-        secure: bool,
-        raw: bool,
-        api_key: Optional[str],
-    ) -> None:
-        self.scheme = "https" if secure else "http"
-        self.host = host
-        self.port = port
-        self.raw = raw
-        self.api_key = api_key
-
-        for scheme in ("http", "https"):
-            full = f"{scheme}://"
-            if self.host.startswith(full):
-                self.scheme = scheme
-                self.host = self.host[len(full) :]  # noqa E203
-
-    def do(self, action: str, **kwargs: Any) -> None:
-        if action == "info":
-            self.info()
-            return
-        result = self.request(action, **kwargs).get("result")
-        if result:
-            out = (
-                dumps(result)
-                if isinstance(result, (list, dict))
-                else str(result)
-            )
-            sys.stdout.write(out + "\n")
-
-    def info(self) -> None:
-        out = sys.stdout.write
-        response = self.request("", "GET")
-        if self.raw or not response:
-            return
-        data = response["result"]
-        display = data.pop("info")
-        extra = display.pop("extra", {})
-        display["packages"] = ", ".join(display["packages"])
-        MOTDTTY(get_logo(), self.base_url, display, extra).display(
-            version=False,
-            action="Inspecting",
-            out=out,
-        )
-        for name, info in data["workers"].items():
-            info = "\n".join(
-                f"\t{key}: {Colors.BLUE}{value}{Colors.END}"
-                for key, value in info.items()
-            )
-            out(
-                "\n"
-                + indent(
-                    "\n".join(
-                        [
-                            f"{Colors.BOLD}{Colors.SANIC}{name}{Colors.END}",
-                            info,
-                        ]
-                    ),
-                    "  ",
-                )
-                + "\n"
-            )
-
-    def request(self, action: str, method: str = "POST", **kwargs: Any) -> Any:
-        url = f"{self.base_url}/{action}"
-        params: Dict[str, Any] = {"method": method, "headers": {}}
-        if kwargs:
-            params["data"] = dumps(kwargs).encode()
-            params["headers"]["content-type"] = "application/json"
-        if self.api_key:
-            params["headers"]["authorization"] = f"Bearer {self.api_key}"
-        request = URequest(url, **params)
-
-        try:
-            with urlopen(request) as response:  # nosec B310
-                raw = response.read()
-                loaded = loads(raw)
-                if self.raw:
-                    sys.stdout.write(dumps(loaded.get("result")) + "\n")
-                    return {}
-                return loaded
-        except (URLError, RemoteDisconnected) as e:
-            sys.stderr.write(
-                f"{Colors.RED}Could not connect to inspector at: "
-                f"{Colors.YELLOW}{self.base_url}{Colors.END}\n"
-                "Either the application is not running, or it did not start "
-                f"an inspector instance.\n{e}\n"
-            )
-            sys.exit(1)
-
-    @property
-    def base_url(self):
-        return f"{self.scheme}://{self.host}:{self.port}"
--- a/sanic/compat.py
+++ b/sanic/compat.py
@@ -1,30 +1,13 @@
 import asyncio
 import os
-import platform
 import signal
-import sys

-from contextlib import contextmanager
-from enum import Enum
-from typing import Awaitable, Union
+from sys import argv

 from multidict import CIMultiDict  # type: ignore

-from sanic.helpers import Default
-from sanic.log import error_logger
-
-
-if sys.version_info < (3, 8):  # no cov
-    StartMethod = Union[Default, str]
-else:  # no cov
-    from typing import Literal
-
-    StartMethod = Union[
-        Default, Literal["fork"], Literal["forkserver"], Literal["spawn"]
-    ]

 OS_IS_WINDOWS = os.name == "nt"
-PYPY_IMPLEMENTATION = platform.python_implementation() == "PyPy"
 UVLOOP_INSTALLED = False

 try:
@@ -34,40 +17,6 @@ try:
 except ImportError:
    pass

-# Python 3.11 changed the way Enum formatting works for mixed-in types.
-if sys.version_info < (3, 11, 0):
-
-    class StrEnum(str, Enum):
-        pass
-
-else:
-    from enum import StrEnum  # type: ignore # noqa
-
-
-class UpperStrEnum(StrEnum):
-    def _generate_next_value_(name, start, count, last_values):
-        return name.upper()
-
-    def __eq__(self, value: object) -> bool:
-        value = str(value).upper()
-        return super().__eq__(value)
-
-    def __hash__(self) -> int:
-        return hash(self.value)
-
-    def __str__(self) -> str:
-        return self.value
-
-
-@contextmanager
-def use_context(method: StartMethod):
-    from sanic import Sanic
-
-    orig = Sanic.start_method
-    Sanic.start_method = method
-    yield
-    Sanic.start_method = orig
-

 def enable_windows_color_support():
    import ctypes
@@ -76,38 +25,6 @@ def enable_windows_color_support():
    kernel.SetConsoleMode(kernel.GetStdHandle(-11), 7)


-def pypy_os_module_patch() -> None:
-    """
-    The PyPy os module is missing the 'readlink' function, which causes issues
-    withaiofiles. This workaround replaces the missing 'readlink' function
-    with 'os.path.realpath', which serves the same purpose.
-    """
-    if hasattr(os, "readlink"):
-        error_logger.warning(
-            "PyPy: Skipping patching of the os module as it appears the "
-            "'readlink' function has been added."
-        )
-        return
-
-    module = sys.modules["os"]
-    module.readlink = os.path.realpath  # type: ignore
-
-
-def pypy_windows_set_console_cp_patch() -> None:
-    """
-    A patch function for PyPy on Windows that sets the console code page to
-    UTF-8 encodingto allow for proper handling of non-ASCII characters. This
-    function uses ctypes to call the Windows API functions SetConsoleCP and
-    SetConsoleOutputCP to set the code page.
-    """
-    from ctypes import windll  # type: ignore
-
-    code: int = windll.kernel32.GetConsoleOutputCP()
-    if code != 65001:
-        windll.kernel32.SetConsoleCP(65001)
-        windll.kernel32.SetConsoleOutputCP(65001)
-
-
 class Header(CIMultiDict):
    """
    Container used for both request and response headers. It is a subclass of
@@ -121,13 +38,7 @@ class Header(CIMultiDict):
    <https://multidict.readthedocs.io/en/stable/multidict.html#multidict>`_
    for more details about how to use the object. In general, it should work
    very similar to a regular dictionary.
-    """  # noqa: E501
-
-    def __getattr__(self, key: str) -> str:
-        if key.startswith("_"):
-            return self.__getattribute__(key)
-        key = key.rstrip("_").replace("_", "-")
-        return ",".join(self.getall(key, default=[]))
+    """

    def get_all(self, key: str):
        """
@@ -136,23 +47,17 @@ class Header(CIMultiDict):
        return self.getall(key, default=[])


-use_trio = sys.argv[0].endswith("hypercorn") and "trio" in sys.argv
+use_trio = argv[0].endswith("hypercorn") and "trio" in argv

 if use_trio:  # pragma: no cover
    import trio  # type: ignore

-    def stat_async(path) -> Awaitable[os.stat_result]:
+    def stat_async(path):
        return trio.Path(path).stat()

    open_async = trio.open_file
    CancelledErrors = tuple([asyncio.CancelledError, trio.Cancelled])
 else:
-    if PYPY_IMPLEMENTATION:
-        pypy_os_module_patch()
-
-        if OS_IS_WINDOWS:
-            pypy_windows_set_console_cp_patch()
-
    from aiofiles import open as aio_open  # type: ignore
    from aiofiles.os import stat as stat_async  # type: ignore  # noqa: F401

--- a/sanic/config.py
+++ b/sanic/config.py
@@ -1,82 +1,56 @@
 from __future__ import annotations

-import sys
-
-from abc import ABCMeta
 from inspect import getmembers, isclass, isdatadescriptor
 from os import environ
 from pathlib import Path
 from typing import Any, Callable, Dict, Optional, Sequence, Union
-from warnings import filterwarnings

-from sanic.constants import LocalCertCreator
 from sanic.errorpages import DEFAULT_FORMAT, check_error_format
 from sanic.helpers import Default, _default
 from sanic.http import Http
-from sanic.log import error_logger
+from sanic.log import deprecation, error_logger
 from sanic.utils import load_module_from_file_location, str_to_bool


-if sys.version_info >= (3, 8):
-    from typing import Literal
-
-    FilterWarningType = Union[
-        Literal["default"],
-        Literal["error"],
-        Literal["ignore"],
-        Literal["always"],
-        Literal["module"],
-        Literal["once"],
-    ]
-else:
-    FilterWarningType = str
-
 SANIC_PREFIX = "SANIC_"


 DEFAULT_CONFIG = {
    "_FALLBACK_ERROR_FORMAT": _default,
-    "ACCESS_LOG": False,
+    "ACCESS_LOG": True,
    "AUTO_EXTEND": True,
    "AUTO_RELOAD": False,
    "EVENT_AUTOREGISTER": False,
-    "DEPRECATION_FILTER": "once",
    "FORWARDED_FOR_HEADER": "X-Forwarded-For",
    "FORWARDED_SECRET": None,
-    "GRACEFUL_SHUTDOWN_TIMEOUT": 15.0,
-    "INSPECTOR": False,
-    "INSPECTOR_HOST": "localhost",
-    "INSPECTOR_PORT": 6457,
-    "INSPECTOR_TLS_KEY": _default,
-    "INSPECTOR_TLS_CERT": _default,
-    "INSPECTOR_API_KEY": "",
-    "KEEP_ALIVE_TIMEOUT": 120,
+    "GRACEFUL_SHUTDOWN_TIMEOUT": 15.0,  # 15 sec
+    "KEEP_ALIVE_TIMEOUT": 5,  # 5 seconds
    "KEEP_ALIVE": True,
-    "LOCAL_CERT_CREATOR": LocalCertCreator.AUTO,
-    "LOCAL_TLS_KEY": _default,
-    "LOCAL_TLS_CERT": _default,
-    "LOCALHOST": "localhost",
    "MOTD": True,
    "MOTD_DISPLAY": {},
    "NOISY_EXCEPTIONS": False,
    "PROXIES_COUNT": None,
    "REAL_IP_HEADER": None,
-    "REQUEST_BUFFER_SIZE": 65536,
-    "REQUEST_MAX_HEADER_SIZE": 8192,  # Cannot exceed 16384
+    "REGISTER": True,
+    "REQUEST_BUFFER_SIZE": 65536,  # 64 KiB
+    "REQUEST_MAX_HEADER_SIZE": 8192,  # 8 KiB, but cannot exceed 16384
    "REQUEST_ID_HEADER": "X-Request-ID",
-    "REQUEST_MAX_SIZE": 100_000_000,
-    "REQUEST_TIMEOUT": 60,
-    "RESPONSE_TIMEOUT": 60,
-    "TLS_CERT_PASSWORD": "",
-    "TOUCHUP": _default,
+    "REQUEST_MAX_SIZE": 100000000,  # 100 megabytes
+    "REQUEST_TIMEOUT": 60,  # 60 seconds
+    "RESPONSE_TIMEOUT": 60,  # 60 seconds
+    "TOUCHUP": True,
    "USE_UVLOOP": _default,
-    "WEBSOCKET_MAX_SIZE": 2**20,  # 1 MiB
+    "WEBSOCKET_MAX_SIZE": 2**20,  # 1 megabyte
    "WEBSOCKET_PING_INTERVAL": 20,
    "WEBSOCKET_PING_TIMEOUT": 20,
 }

+# These values will be removed from the Config object in v22.6 and moved
+# to the application state
+DEPRECATED_CONFIG = ("SERVER_RUNNING", "RELOADER_PROCESS", "RELOADED_FILES")

-class DescriptorMeta(ABCMeta):
+
+class DescriptorMeta(type):
    def __init__(cls, *_):
        cls.__setters__ = {name for name, _ in getmembers(cls, cls._is_setter)}

@@ -90,27 +64,17 @@ class Config(dict, metaclass=DescriptorMeta):
    AUTO_EXTEND: bool
    AUTO_RELOAD: bool
    EVENT_AUTOREGISTER: bool
-    DEPRECATION_FILTER: FilterWarningType
    FORWARDED_FOR_HEADER: str
    FORWARDED_SECRET: Optional[str]
    GRACEFUL_SHUTDOWN_TIMEOUT: float
-    INSPECTOR: bool
-    INSPECTOR_HOST: str
-    INSPECTOR_PORT: int
-    INSPECTOR_TLS_KEY: Union[Path, str, Default]
-    INSPECTOR_TLS_CERT: Union[Path, str, Default]
-    INSPECTOR_API_KEY: str
    KEEP_ALIVE_TIMEOUT: int
    KEEP_ALIVE: bool
-    LOCAL_CERT_CREATOR: Union[str, LocalCertCreator]
-    LOCAL_TLS_KEY: Union[Path, str, Default]
-    LOCAL_TLS_CERT: Union[Path, str, Default]
-    LOCALHOST: str
+    NOISY_EXCEPTIONS: bool
    MOTD: bool
    MOTD_DISPLAY: Dict[str, str]
-    NOISY_EXCEPTIONS: bool
    PROXIES_COUNT: Optional[int]
    REAL_IP_HEADER: Optional[str]
+    REGISTER: bool
    REQUEST_BUFFER_SIZE: int
    REQUEST_MAX_HEADER_SIZE: int
    REQUEST_ID_HEADER: str
@@ -118,8 +82,7 @@ class Config(dict, metaclass=DescriptorMeta):
    REQUEST_TIMEOUT: int
    RESPONSE_TIMEOUT: int
    SERVER_NAME: str
-    TLS_CERT_PASSWORD: str
-    TOUCHUP: Union[Default, bool]
+    TOUCHUP: bool
    USE_UVLOOP: Union[Default, bool]
    WEBSOCKET_MAX_SIZE: int
    WEBSOCKET_PING_INTERVAL: int
@@ -127,9 +90,7 @@ class Config(dict, metaclass=DescriptorMeta):

    def __init__(
        self,
-        defaults: Optional[
-            Dict[str, Union[str, bool, int, float, None]]
-        ] = None,
+        defaults: Dict[str, Union[str, bool, int, float, None]] = None,
        env_prefix: Optional[str] = SANIC_PREFIX,
        keep_alive: Optional[bool] = None,
        *,
@@ -137,9 +98,9 @@ class Config(dict, metaclass=DescriptorMeta):
    ):
        defaults = defaults or {}
        super().__init__({**DEFAULT_CONFIG, **defaults})
-        self._configure_warnings()

        self._converters = [str, str_to_bool, float, int]
+        self._LOGO = ""

        if converters:
            for converter in converters:
@@ -158,19 +119,19 @@ class Config(dict, metaclass=DescriptorMeta):
        self._check_error_format()
        self._init = True

-    def __getattr__(self, attr: Any):
+    def __getattr__(self, attr):
        try:
            return self[attr]
        except KeyError as ke:
            raise AttributeError(f"Config has no '{ke.args[0]}'")

-    def __setattr__(self, attr: str, value: Any) -> None:
+    def __setattr__(self, attr, value) -> None:
        self.update({attr: value})

-    def __setitem__(self, attr: str, value: Any) -> None:
+    def __setitem__(self, attr, value) -> None:
        self.update({attr: value})

-    def update(self, *other: Any, **kwargs: Any) -> None:
+    def update(self, *other, **kwargs) -> None:
        kwargs.update({k: v for item in other for k, v in dict(item).items()})
        setters: Dict[str, Any] = {
            k: kwargs.pop(k)
@@ -196,19 +157,21 @@ class Config(dict, metaclass=DescriptorMeta):
                "REQUEST_MAX_SIZE",
            ):
                self._configure_header_size()
+            elif attr == "LOGO":
+                self._LOGO = value
+                deprecation(
+                    "Setting the config.LOGO is deprecated and will no longer "
+                    "be supported starting in v22.6.",
+                    22.6,
+                )

-        if attr == "LOCAL_CERT_CREATOR" and not isinstance(
-            self.LOCAL_CERT_CREATOR, LocalCertCreator
-        ):
-            self.LOCAL_CERT_CREATOR = LocalCertCreator[
-                self.LOCAL_CERT_CREATOR.upper()
-            ]
-        elif attr == "DEPRECATION_FILTER":
-            self._configure_warnings()
+    @property
+    def LOGO(self):
+        return self._LOGO

    @property
    def FALLBACK_ERROR_FORMAT(self) -> str:
-        if isinstance(self._FALLBACK_ERROR_FORMAT, Default):
+        if self._FALLBACK_ERROR_FORMAT is _default:
            return DEFAULT_FORMAT
        return self._FALLBACK_ERROR_FORMAT

@@ -216,7 +179,7 @@ class Config(dict, metaclass=DescriptorMeta):
    def FALLBACK_ERROR_FORMAT(self, value):
        self._check_error_format(value)
        if (
-            not isinstance(self._FALLBACK_ERROR_FORMAT, Default)
+            self._FALLBACK_ERROR_FORMAT is not _default
            and value != self._FALLBACK_ERROR_FORMAT
        ):
            error_logger.warning(
@@ -232,13 +195,6 @@ class Config(dict, metaclass=DescriptorMeta):
            self.REQUEST_MAX_SIZE,
        )

-    def _configure_warnings(self):
-        filterwarnings(
-            self.DEPRECATION_FILTER,
-            category=DeprecationWarning,
-            module=r"sanic.*",
-        )
-
    def _check_error_format(self, format: Optional[str] = None):
        check_error_format(format or self.FALLBACK_ERROR_FORMAT)

@@ -246,9 +202,7 @@ class Config(dict, metaclass=DescriptorMeta):
        """
        Looks for prefixed environment variables and applies them to the
        configuration if present. This is called automatically when Sanic
-        starts up to load environment variables into config. Environment
-        variables should start with the defined prefix and should only
-        contain uppercase letters.
+        starts up to load environment variables into config.

        It will automatically hydrate the following types:

@@ -274,9 +228,12 @@ class Config(dict, metaclass=DescriptorMeta):
        `See user guide re: config
        <https://sanicframework.org/guide/deployment/configuration.html>`__
        """
+        lower_case_var_found = False
        for key, value in environ.items():
-            if not key.startswith(prefix) or not key.isupper():
+            if not key.startswith(prefix):
                continue
+            if not key.isupper():
+                lower_case_var_found = True

            _, config_key = key.split(prefix, 1)

@@ -286,6 +243,12 @@ class Config(dict, metaclass=DescriptorMeta):
                    break
                except ValueError:
                    pass
+        if lower_case_var_found:
+            deprecation(
+                "Lowercase environment variables will not be "
+                "loaded into Sanic config beginning in v22.9.",
+                22.9,
+            )

    def update_config(self, config: Union[bytes, str, dict, Any]):
        """
--- a/sanic/constants.py
+++ b/sanic/constants.py
@@ -1,9 +1,20 @@
-from enum import auto
-
-from sanic.compat import UpperStrEnum
+from enum import Enum, auto


-class HTTPMethod(UpperStrEnum):
+class HTTPMethod(str, Enum):
+    def _generate_next_value_(name, start, count, last_values):
+        return name.upper()
+
+    def __eq__(self, value: object) -> bool:
+        value = str(value).upper()
+        return super().__eq__(value)
+
+    def __hash__(self) -> int:
+        return hash(self.value)
+
+    def __str__(self) -> str:
+        return self.value
+
    GET = auto()
    POST = auto()
    PUT = auto()
@@ -13,22 +24,5 @@ class HTTPMethod(UpperStrEnum):
    DELETE = auto()


-class LocalCertCreator(UpperStrEnum):
-    AUTO = auto()
-    TRUSTME = auto()
-    MKCERT = auto()
-
-
 HTTP_METHODS = tuple(HTTPMethod.__members__.values())
-SAFE_HTTP_METHODS = (HTTPMethod.GET, HTTPMethod.HEAD, HTTPMethod.OPTIONS)
-IDEMPOTENT_HTTP_METHODS = (
-    HTTPMethod.GET,
-    HTTPMethod.HEAD,
-    HTTPMethod.PUT,
-    HTTPMethod.DELETE,
-    HTTPMethod.OPTIONS,
-)
-CACHEABLE_HTTP_METHODS = (HTTPMethod.GET, HTTPMethod.HEAD)
 DEFAULT_HTTP_CONTENT_TYPE = "application/octet-stream"
-DEFAULT_LOCAL_TLS_KEY = "key.pem"
-DEFAULT_LOCAL_TLS_CERT = "cert.pem"
--- a/sanic/cookies.py
+++ b/sanic/cookies.py
@@ -0,0 +1,156 @@
+import re
+import string
+
+from datetime import datetime
+from typing import Dict
+
+
+DEFAULT_MAX_AGE = 0
+
+# ------------------------------------------------------------ #
+#  SimpleCookie
+# ------------------------------------------------------------ #
+
+# Straight up copied this section of dark magic from SimpleCookie
+
+_LegalChars = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~:"
+_UnescapedChars = _LegalChars + " ()/<=>?@[]{}"
+
+_Translator = {
+    n: "\\%03o" % n for n in set(range(256)) - set(map(ord, _UnescapedChars))
+}
+_Translator.update({ord('"'): '\\"', ord("\\"): "\\\\"})
+
+
+def _quote(str):
+    r"""Quote a string for use in a cookie header.
+    If the string does not need to be double-quoted, then just return the
+    string.  Otherwise, surround the string in doublequotes and quote
+    (with a \) special characters.
+    """
+    if str is None or _is_legal_key(str):
+        return str
+    else:
+        return '"' + str.translate(_Translator) + '"'
+
+
+_is_legal_key = re.compile("[%s]+" % re.escape(_LegalChars)).fullmatch
+
+# ------------------------------------------------------------ #
+#  Custom SimpleCookie
+# ------------------------------------------------------------ #
+
+
+class CookieJar(dict):
+    """
+    CookieJar dynamically writes headers as cookies are added and removed
+    It gets around the limitation of one header per name by using the
+    MultiHeader class to provide a unique key that encodes to Set-Cookie.
+    """
+
+    def __init__(self, headers):
+        super().__init__()
+        self.headers: Dict[str, str] = headers
+        self.cookie_headers: Dict[str, str] = {}
+        self.header_key: str = "Set-Cookie"
+
+    def __setitem__(self, key, value):
+        # If this cookie doesn't exist, add it to the header keys
+        if not self.cookie_headers.get(key):
+            cookie = Cookie(key, value)
+            cookie["path"] = "/"
+            self.cookie_headers[key] = self.header_key
+            self.headers.add(self.header_key, cookie)
+            return super().__setitem__(key, cookie)
+        else:
+            self[key].value = value
+
+    def __delitem__(self, key):
+        if key not in self.cookie_headers:
+            self[key] = ""
+            self[key]["max-age"] = 0
+        else:
+            cookie_header = self.cookie_headers[key]
+            # remove it from header
+            cookies = self.headers.popall(cookie_header)
+            for cookie in cookies:
+                if cookie.key != key:
+                    self.headers.add(cookie_header, cookie)
+            del self.cookie_headers[key]
+            return super().__delitem__(key)
+
+
+class Cookie(dict):
+    """A stripped down version of Morsel from SimpleCookie #gottagofast"""
+
+    _keys = {
+        "expires": "expires",
+        "path": "Path",
+        "comment": "Comment",
+        "domain": "Domain",
+        "max-age": "Max-Age",
+        "secure": "Secure",
+        "httponly": "HttpOnly",
+        "version": "Version",
+        "samesite": "SameSite",
+    }
+    _flags = {"secure", "httponly"}
+
+    def __init__(self, key, value):
+        if key in self._keys:
+            raise KeyError("Cookie name is a reserved word")
+        if not _is_legal_key(key):
+            raise KeyError("Cookie key contains illegal characters")
+        self.key = key
+        self.value = value
+        super().__init__()
+
+    def __setitem__(self, key, value):
+        if key not in self._keys:
+            raise KeyError("Unknown cookie property")
+        if value is not False:
+            if key.lower() == "max-age":
+                if not str(value).isdigit():
+                    raise ValueError("Cookie max-age must be an integer")
+            elif key.lower() == "expires":
+                if not isinstance(value, datetime):
+                    raise TypeError(
+                        "Cookie 'expires' property must be a datetime"
+                    )
+            return super().__setitem__(key, value)
+
+    def encode(self, encoding):
+        """
+        Encode the cookie content in a specific type of encoding instructed
+        by the developer. Leverages the :func:`str.encode` method provided
+        by python.
+
+        This method can be used to encode and embed ``utf-8`` content into
+        the cookies.
+
+        :param encoding: Encoding to be used with the cookie
+        :return: Cookie encoded in a codec of choosing.
+        :except: UnicodeEncodeError
+        """
+        return str(self).encode(encoding)
+
+    def __str__(self):
+        """Format as a Set-Cookie header value."""
+        output = ["%s=%s" % (self.key, _quote(self.value))]
+        for key, value in self.items():
+            if key == "max-age":
+                try:
+                    output.append("%s=%d" % (self._keys[key], value))
+                except TypeError:
+                    output.append("%s=%s" % (self._keys[key], value))
+            elif key == "expires":
+                output.append(
+                    "%s=%s"
+                    % (self._keys[key], value.strftime("%a, %d-%b-%Y %T GMT"))
+                )
+            elif key in self._flags and self[key]:
+                output.append(self._keys[key])
+            else:
+                output.append("%s=%s" % (self._keys[key], value))
+
+        return "; ".join(output)
--- a/sanic/cookies/init.py
+++ b/sanic/cookies/init.py
@@ -1,4 +0,0 @@
-from .response import Cookie, CookieJar
-
-
-__all__ = ("Cookie", "CookieJar")
--- a/sanic/cookies/request.py
+++ b/sanic/cookies/request.py
@@ -1,119 +0,0 @@
-import re
-
-from typing import Any, Dict, List, Optional
-
-from sanic.cookies.response import Cookie
-from sanic.log import deprecation
-from sanic.request.parameters import RequestParameters
-
-
-COOKIE_NAME_RESERVED_CHARS = re.compile(
-    '[\x00-\x1F\x7F-\xFF()<>@,;:\\\\"/[\\]?={} \x09]'
-)
-OCTAL_PATTERN = re.compile(r"\\[0-3][0-7][0-7]")
-QUOTE_PATTERN = re.compile(r"[\\].")
-
-
-def _unquote(str):  # no cov
-    if str is None or len(str) < 2:
-        return str
-    if str[0] != '"' or str[-1] != '"':
-        return str
-
-    str = str[1:-1]
-
-    i = 0
-    n = len(str)
-    res = []
-    while 0 <= i < n:
-        o_match = OCTAL_PATTERN.search(str, i)
-        q_match = QUOTE_PATTERN.search(str, i)
-        if not o_match and not q_match:
-            res.append(str[i:])
-            break
-        # else:
-        j = k = -1
-        if o_match:
-            j = o_match.start(0)
-        if q_match:
-            k = q_match.start(0)
-        if q_match and (not o_match or k < j):
-            res.append(str[i:k])
-            res.append(str[k + 1])
-            i = k + 2
-        else:
-            res.append(str[i:j])
-            res.append(chr(int(str[j + 1 : j + 4], 8)))  # noqa: E203
-            i = j + 4
-    return "".join(res)
-
-
-def parse_cookie(raw: str):
-    cookies: Dict[str, List] = {}
-
-    for token in raw.split(";"):
-        name, __, value = token.partition("=")
-        name = name.strip()
-        value = value.strip()
-
-        if not name:
-            continue
-
-        if COOKIE_NAME_RESERVED_CHARS.search(name):  # no cov
-            continue
-
-        if len(value) > 2 and value[0] == '"' and value[-1] == '"':  # no cov
-            value = _unquote(value)
-
-        if name in cookies:
-            cookies[name].append(value)
-        else:
-            cookies[name] = [value]
-
-    return cookies
-
-
-class CookieRequestParameters(RequestParameters):
-    def __getitem__(self, key: str) -> Optional[str]:
-        deprecation(
-            f"You are accessing cookie key '{key}', which is currently in "
-            "compat mode returning a single cookie value. Starting in v24.3 "
-            "accessing a cookie value like this will return a list of values. "
-            "To avoid this behavior and continue accessing a single value, "
-            f"please upgrade from request.cookies['{key}'] to "
-            f"request.cookies.get('{key}'). See more details: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#request-cookies",  # noqa
-            24.3,
-        )
-        try:
-            value = self._get_prefixed_cookie(key)
-        except KeyError:
-            value = super().__getitem__(key)
-        return value[0]
-
-    def __getattr__(self, key: str) -> str:
-        if key.startswith("_"):
-            return self.__getattribute__(key)
-        key = key.rstrip("_").replace("_", "-")
-        return str(self.get(key, ""))
-
-    def get(self, name: str, default: Optional[Any] = None) -> Optional[Any]:
-        try:
-            return self._get_prefixed_cookie(name)[0]
-        except KeyError:
-            return super().get(name, default)
-
-    def getlist(
-        self, name: str, default: Optional[Any] = None
-    ) -> Optional[Any]:
-        try:
-            return self._get_prefixed_cookie(name)
-        except KeyError:
-            return super().getlist(name, default)
-
-    def _get_prefixed_cookie(self, name: str) -> Any:
-        getitem = super().__getitem__
-        try:
-            return getitem(f"{Cookie.HOST_PREFIX}{name}")
-        except KeyError:
-            return getitem(f"{Cookie.SECURE_PREFIX}{name}")
--- a/sanic/cookies/response.py
+++ b/sanic/cookies/response.py
@@ -1,617 +0,0 @@
-from __future__ import annotations
-
-import re
-import string
-import sys
-
-from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
-
-from sanic.exceptions import ServerError
-from sanic.log import deprecation
-
-
-if TYPE_CHECKING:
-    from sanic.compat import Header
-
-if sys.version_info < (3, 8):  # no cov
-    SameSite = str
-else:  # no cov
-    from typing import Literal
-
-    SameSite = Union[
-        Literal["Strict"],
-        Literal["Lax"],
-        Literal["None"],
-        Literal["strict"],
-        Literal["lax"],
-        Literal["none"],
-    ]
-
-DEFAULT_MAX_AGE = 0
-SAMESITE_VALUES = ("strict", "lax", "none")
-
-LEGAL_CHARS = string.ascii_letters + string.digits + "!#$%&'*+-.^_`|~:"
-UNESCAPED_CHARS = LEGAL_CHARS + " ()/<=>?@[]{}"
-TRANSLATOR = {ch: f"\\{ch:03o}" for ch in bytes(range(32)) + b'";\\\x7F'}
-
-
-def _quote(str):  # no cov
-    r"""Quote a string for use in a cookie header.
-    If the string does not need to be double-quoted, then just return the
-    string.  Otherwise, surround the string in doublequotes and quote
-    (with a \) special characters.
-    """
-    if str is None or _is_legal_key(str):
-        return str
-    else:
-        return f'"{str.translate(TRANSLATOR)}"'
-
-
-_is_legal_key = re.compile("[%s]+" % re.escape(LEGAL_CHARS)).fullmatch
-
-
-# In v24.3, we should remove this as being a subclass of dict
-class CookieJar(dict):
-    """
-    CookieJar dynamically writes headers as cookies are added and removed
-    It gets around the limitation of one header per name by using the
-    MultiHeader class to provide a unique key that encodes to Set-Cookie.
-    """
-
-    HEADER_KEY = "Set-Cookie"
-
-    def __init__(self, headers: Header):
-        super().__init__()
-        self.headers = headers
-
-    def __setitem__(self, key, value):
-        # If this cookie doesn't exist, add it to the header keys
-        deprecation(
-            "Setting cookie values using the dict pattern has been "
-            "deprecated. You should instead use the cookies.add_cookie "
-            "method. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            0,
-        )
-        if key not in self:
-            self.add_cookie(key, value, secure=False, samesite=None)
-        else:
-            self[key].value = value
-
-    def __delitem__(self, key):
-        deprecation(
-            "Deleting cookie values using the dict pattern has been "
-            "deprecated. You should instead use the cookies.delete_cookie "
-            "method. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            0,
-        )
-        if key in self:
-            super().__delitem__(key)
-        self.delete_cookie(key)
-
-    def __len__(self):  # no cov
-        return len(self.cookies)
-
-    def __getitem__(self, key: str) -> Cookie:
-        deprecation(
-            "Accessing cookies from the CookieJar by dict key is deprecated. "
-            "You should instead use the cookies.get_cookie method. "
-            "To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            0,
-        )
-        return super().__getitem__(key)
-
-    def __iter__(self):  # no cov
-        deprecation(
-            "Iterating over the CookieJar has been deprecated and will be "
-            "removed in v24.3. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            24.3,
-        )
-        return super().__iter__()
-
-    def keys(self):  # no cov
-        deprecation(
-            "Accessing CookieJar.keys() has been deprecated and will be "
-            "removed in v24.3. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            24.3,
-        )
-        return super().keys()
-
-    def values(self):  # no cov
-        deprecation(
-            "Accessing CookieJar.values() has been deprecated and will be "
-            "removed in v24.3. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            24.3,
-        )
-        return super().values()
-
-    def items(self):  # no cov
-        deprecation(
-            "Accessing CookieJar.items() has been deprecated and will be "
-            "removed in v24.3. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            24.3,
-        )
-        return super().items()
-
-    def get(self, *args, **kwargs):  # no cov
-        deprecation(
-            "Accessing cookies from the CookieJar using get is deprecated "
-            "and will be removed in v24.3. You should instead use the "
-            "cookies.get_cookie method. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            24.3,
-        )
-        return super().get(*args, **kwargs)
-
-    def pop(self, key, *args, **kwargs):  # no cov
-        deprecation(
-            "Using CookieJar.pop() has been deprecated and will be "
-            "removed in v24.3. To learn more, please see: "
-            "https://sanic.dev/en/guide/release-notes/v23.3.html#response-cookies",  # noqa
-            24.3,
-        )
-        self.delete(key)
-        return super().pop(key, *args, **kwargs)
-
-    @property
-    def header_key(self):  # no cov
-        deprecation(
-            "The CookieJar.header_key property has been deprecated and will "
-            "be removed in version 24.3. Use CookieJar.HEADER_KEY. ",
-            24.3,
-        )
-        return CookieJar.HEADER_KEY
-
-    @property
-    def cookie_headers(self) -> Dict[str, str]:  # no cov
-        deprecation(
-            "The CookieJar.coookie_headers property has been deprecated "
-            "and will be removed in version 24.3. If you need to check if a "
-            "particular cookie key has been set, use CookieJar.has_cookie.",
-            24.3,
-        )
-        return {key: self.header_key for key in self}
-
-    @property
-    def cookies(self) -> List[Cookie]:
-        return self.headers.getall(self.HEADER_KEY)
-
-    def get_cookie(
-        self,
-        key: str,
-        path: str = "/",
-        domain: Optional[str] = None,
-        host_prefix: bool = False,
-        secure_prefix: bool = False,
-    ) -> Optional[Cookie]:
-        for cookie in self.cookies:
-            if (
-                cookie.key == Cookie.make_key(key, host_prefix, secure_prefix)
-                and cookie.path == path
-                and cookie.domain == domain
-            ):
-                return cookie
-        return None
-
-    def has_cookie(
-        self,
-        key: str,
-        path: str = "/",
-        domain: Optional[str] = None,
-        host_prefix: bool = False,
-        secure_prefix: bool = False,
-    ) -> bool:
-        for cookie in self.cookies:
-            if (
-                cookie.key == Cookie.make_key(key, host_prefix, secure_prefix)
-                and cookie.path == path
-                and cookie.domain == domain
-            ):
-                return True
-        return False
-
-    def add_cookie(
-        self,
-        key: str,
-        value: str,
-        *,
-        path: str = "/",
-        domain: Optional[str] = None,
-        secure: bool = True,
-        max_age: Optional[int] = None,
-        expires: Optional[datetime] = None,
-        httponly: bool = False,
-        samesite: Optional[SameSite] = "Lax",
-        partitioned: bool = False,
-        comment: Optional[str] = None,
-        host_prefix: bool = False,
-        secure_prefix: bool = False,
-    ) -> Cookie:
-        """
-        Add a cookie to the CookieJar
-
-        :param key: Key of the cookie
-        :type key: str
-        :param value: Value of the cookie
-        :type value: str
-        :param path: Path of the cookie, defaults to None
-        :type path: Optional[str], optional
-        :param domain: Domain of the cookie, defaults to None
-        :type domain: Optional[str], optional
-        :param secure: Whether to set it as a secure cookie, defaults to True
-        :type secure: bool
-        :param max_age: Max age of the cookie in seconds; if set to 0 a
-            browser should delete it, defaults to None
-        :type max_age: Optional[int], optional
-        :param expires: When the cookie expires; if set to None browsers
-            should set it as a session cookie, defaults to None
-        :type expires: Optional[datetime], optional
-        :param httponly: Whether to set it as HTTP only, defaults to False
-        :type httponly: bool
-        :param samesite: How to set the samesite property, should be
-            strict, lax or none (case insensitive), defaults to Lax
-        :type samesite: Optional[SameSite], optional
-        :param partitioned: Whether to set it as partitioned, defaults to False
-        :type partitioned: bool
-        :param comment: A cookie comment, defaults to None
-        :type comment: Optional[str], optional
-        :param host_prefix: Whether to add __Host- as a prefix to the key.
-            This requires that path="/", domain=None, and secure=True,
-            defaults to False
-        :type host_prefix: bool
-        :param secure_prefix: Whether to add __Secure- as a prefix to the key.
-            This requires that secure=True, defaults to False
-        :type secure_prefix: bool
-        :return: The instance of the created cookie
-        :rtype: Cookie
-        """
-        cookie = Cookie(
-            key,
-            value,
-            path=path,
-            expires=expires,
-            comment=comment,
-            domain=domain,
-            max_age=max_age,
-            secure=secure,
-            httponly=httponly,
-            samesite=samesite,
-            partitioned=partitioned,
-            host_prefix=host_prefix,
-            secure_prefix=secure_prefix,
-        )
-        self.headers.add(self.HEADER_KEY, cookie)
-
-        # This should be removed in v24.3
-        super().__setitem__(key, cookie)
-
-        return cookie
-
-    def delete_cookie(
-        self,
-        key: str,
-        *,
-        path: str = "/",
-        domain: Optional[str] = None,
-        host_prefix: bool = False,
-        secure_prefix: bool = False,
-    ) -> None:
-        """
-        Delete a cookie
-
-        This will effectively set it as Max-Age: 0, which a browser should
-        interpret it to mean: "delete the cookie".
-
-        Since it is a browser/client implementation, your results may vary
-        depending upon which client is being used.
-
-        :param key: The key to be deleted
-        :type key: str
-        :param path: Path of the cookie, defaults to None
-        :type path: Optional[str], optional
-        :param domain: Domain of the cookie, defaults to None
-        :type domain: Optional[str], optional
-        :param host_prefix: Whether to add __Host- as a prefix to the key.
-            This requires that path="/", domain=None, and secure=True,
-            defaults to False
-        :type host_prefix: bool
-        :param secure_prefix: Whether to add __Secure- as a prefix to the key.
-            This requires that secure=True, defaults to False
-        :type secure_prefix: bool
-        """
-        # remove it from header
-        cookies: List[Cookie] = self.headers.popall(self.HEADER_KEY, [])
-        for cookie in cookies:
-            if (
-                cookie.key != Cookie.make_key(key, host_prefix, secure_prefix)
-                or cookie.path != path
-                or cookie.domain != domain
-            ):
-                self.headers.add(self.HEADER_KEY, cookie)
-
-        # This should be removed in v24.3
-        try:
-            super().__delitem__(key)
-        except KeyError:
-            ...
-
-        self.add_cookie(
-            key=key,
-            value="",
-            path=path,
-            domain=domain,
-            max_age=0,
-            samesite=None,
-            host_prefix=host_prefix,
-            secure_prefix=secure_prefix,
-        )
-
-
-# In v24.3, we should remove this as being a subclass of dict
-# Instead, it should be an object with __slots__
-# All of the current property accessors should be removed in favor
-# of actual slotted properties.
-class Cookie(dict):
-    """A stripped down version of Morsel from SimpleCookie"""
-
-    HOST_PREFIX = "__Host-"
-    SECURE_PREFIX = "__Secure-"
-
-    _keys = {
-        "path": "Path",
-        "comment": "Comment",
-        "domain": "Domain",
-        "max-age": "Max-Age",
-        "expires": "expires",
-        "samesite": "SameSite",
-        "version": "Version",
-        "secure": "Secure",
-        "httponly": "HttpOnly",
-        "partitioned": "Partitioned",
-    }
-    _flags = {"secure", "httponly", "partitioned"}
-
-    def __init__(
-        self,
-        key: str,
-        value: str,
-        *,
-        path: str = "/",
-        domain: Optional[str] = None,
-        secure: bool = True,
-        max_age: Optional[int] = None,
-        expires: Optional[datetime] = None,
-        httponly: bool = False,
-        samesite: Optional[SameSite] = "Lax",
-        partitioned: bool = False,
-        comment: Optional[str] = None,
-        host_prefix: bool = False,
-        secure_prefix: bool = False,
-    ):
-        if key in self._keys:
-            raise KeyError("Cookie name is a reserved word")
-        if not _is_legal_key(key):
-            raise KeyError("Cookie key contains illegal characters")
-        if host_prefix:
-            if not secure:
-                raise ServerError(
-                    "Cannot set host_prefix on a cookie without secure=True"
-                )
-            if path != "/":
-                raise ServerError(
-                    "Cannot set host_prefix on a cookie unless path='/'"
-                )
-            if domain:
-                raise ServerError(
-                    "Cannot set host_prefix on a cookie with a defined domain"
-                )
-        elif secure_prefix and not secure:
-            raise ServerError(
-                "Cannot set secure_prefix on a cookie without secure=True"
-            )
-        if partitioned and not host_prefix:
-            # This is technically possible, but it is not advisable so we will
-            # take a stand and say "don't shoot yourself in the foot"
-            raise ServerError(
-                "Cannot create a partitioned cookie without "
-                "also setting host_prefix=True"
-            )
-
-        self.key = self.make_key(key, host_prefix, secure_prefix)
-        self.value = value
-        super().__init__()
-
-        # This is a temporary solution while this object is a dict. We update
-        # all of the values in bulk, except for the values that have
-        # key-specific validation in _set_value
-        self.update(
-            {
-                "path": path,
-                "comment": comment,
-                "domain": domain,
-                "secure": secure,
-                "httponly": httponly,
-                "partitioned": partitioned,
-                "expires": None,
-                "max-age": None,
-                "samesite": None,
-            }
-        )
-        if expires is not None:
-            self._set_value("expires", expires)
-        if max_age is not None:
-            self._set_value("max-age", max_age)
-        if samesite is not None:
-            self._set_value("samesite", samesite)
-
-    def __setitem__(self, key, value):
-        deprecation(
-            "Setting values on a Cookie object as a dict has been deprecated. "
-            "This feature will be removed in v24.3. You should instead set "
-            f"values on cookies as object properties: cookie.{key}=... ",
-            24.3,
-        )
-        self._set_value(key, value)
-
-    # This is a temporary method for backwards compat and should be removed
-    # in v24.3 when this is no longer a dict
-    def _set_value(self, key: str, value: Any) -> None:
-        if key not in self._keys:
-            raise KeyError("Unknown cookie property: %s=%s" % (key, value))
-
-        if value is not None:
-            if key.lower() == "max-age" and not str(value).isdigit():
-                raise ValueError("Cookie max-age must be an integer")
-            elif key.lower() == "expires" and not isinstance(value, datetime):
-                raise TypeError("Cookie 'expires' property must be a datetime")
-            elif key.lower() == "samesite":
-                if value.lower() not in SAMESITE_VALUES:
-                    raise TypeError(
-                        "Cookie 'samesite' property must "
-                        f"be one of: {','.join(SAMESITE_VALUES)}"
-                    )
-                value = value.title()
-
-        super().__setitem__(key, value)
-
-    def encode(self, encoding):
-        """
-        Encode the cookie content in a specific type of encoding instructed
-        by the developer. Leverages the :func:`str.encode` method provided
-        by python.
-
-        This method can be used to encode and embed ``utf-8`` content into
-        the cookies.
-
-        :param encoding: Encoding to be used with the cookie
-        :return: Cookie encoded in a codec of choosing.
-        :except: UnicodeEncodeError
-        """
-        deprecation(
-            "Direct encoding of a Cookie object has been deprecated and will "
-            "be removed in v24.3.",
-            24.3,
-        )
-        return str(self).encode(encoding)
-
-    def __str__(self):
-        """Format as a Set-Cookie header value."""
-        output = ["%s=%s" % (self.key, _quote(self.value))]
-        key_index = list(self._keys)
-        for key, value in sorted(
-            self.items(), key=lambda x: key_index.index(x[0])
-        ):
-            if value is not None and value is not False:
-                if key == "max-age":
-                    try:
-                        output.append("%s=%d" % (self._keys[key], value))
-                    except TypeError:
-                        output.append("%s=%s" % (self._keys[key], value))
-                elif key == "expires":
-                    output.append(
-                        "%s=%s"
-                        % (
-                            self._keys[key],
-                            value.strftime("%a, %d-%b-%Y %T GMT"),
-                        )
-                    )
-                elif key in self._flags:
-                    output.append(self._keys[key])
-                else:
-                    output.append("%s=%s" % (self._keys[key], value))
-
-        return "; ".join(output)
-
-    @property
-    def path(self) -> str:  # no cov
-        return self["path"]
-
-    @path.setter
-    def path(self, value: str) -> None:  # no cov
-        self._set_value("path", value)
-
-    @property
-    def expires(self) -> Optional[datetime]:  # no cov
-        return self.get("expires")
-
-    @expires.setter
-    def expires(self, value: datetime) -> None:  # no cov
-        self._set_value("expires", value)
-
-    @property
-    def comment(self) -> Optional[str]:  # no cov
-        return self.get("comment")
-
-    @comment.setter
-    def comment(self, value: str) -> None:  # no cov
-        self._set_value("comment", value)
-
-    @property
-    def domain(self) -> Optional[str]:  # no cov
-        return self.get("domain")
-
-    @domain.setter
-    def domain(self, value: str) -> None:  # no cov
-        self._set_value("domain", value)
-
-    @property
-    def max_age(self) -> Optional[int]:  # no cov
-        return self.get("max-age")
-
-    @max_age.setter
-    def max_age(self, value: int) -> None:  # no cov
-        self._set_value("max-age", value)
-
-    @property
-    def secure(self) -> bool:  # no cov
-        return self.get("secure", False)
-
-    @secure.setter
-    def secure(self, value: bool) -> None:  # no cov
-        self._set_value("secure", value)
-
-    @property
-    def httponly(self) -> bool:  # no cov
-        return self.get("httponly", False)
-
-    @httponly.setter
-    def httponly(self, value: bool) -> None:  # no cov
-        self._set_value("httponly", value)
-
-    @property
-    def samesite(self) -> Optional[SameSite]:  # no cov
-        return self.get("samesite")
-
-    @samesite.setter
-    def samesite(self, value: SameSite) -> None:  # no cov
-        self._set_value("samesite", value)
-
-    @property
-    def partitioned(self) -> bool:  # no cov
-        return self.get("partitioned", False)
-
-    @partitioned.setter
-    def partitioned(self, value: bool) -> None:  # no cov
-        self._set_value("partitioned", value)
-
-    @classmethod
-    def make_key(
-        cls, key: str, host_prefix: bool = False, secure_prefix: bool = False
-    ) -> str:
-        if host_prefix and secure_prefix:
-            raise ServerError(
-                "Both host_prefix and secure_prefix were requested. "
-                "A cookie should have only one prefix."
-            )
-        elif host_prefix:
-            key = cls.HOST_PREFIX + key
-        elif secure_prefix:
-            key = cls.SECURE_PREFIX + key
-        return key
--- a/sanic/errorpages.py
+++ b/sanic/errorpages.py
@@ -12,7 +12,6 @@ Setting ``app.config.FALLBACK_ERROR_FORMAT = "auto"`` will enable a switch that
 will attempt to provide an appropriate response format based upon the
 request type.
 """
-from __future__ import annotations

 import sys
 import typing as t
@@ -20,11 +19,10 @@ import typing as t
 from functools import partial
 from traceback import extract_tb

-from sanic.exceptions import BadRequest, SanicException
+from sanic.exceptions import InvalidUsage, SanicException
 from sanic.helpers import STATUS_CODES
-from sanic.log import deprecation, logger
-from sanic.pages.error import ErrorPage
-from sanic.response import html, json, text
+from sanic.request import Request
+from sanic.response import HTTPResponse, html, json, text


 dumps: t.Callable[..., str]
@@ -35,15 +33,13 @@ try:
 except ImportError:  # noqa
    from json import dumps

-if t.TYPE_CHECKING:
-    from sanic import HTTPResponse, Request

 DEFAULT_FORMAT = "auto"
-FALLBACK_TEXT = """\
-The application encountered an unexpected error and could not continue.\
-"""
+FALLBACK_TEXT = (
+    "The server encountered an internal error and "
+    "cannot complete your request."
+)
 FALLBACK_STATUS = 500
-JSON = "application/json"


 class BaseRenderer:
@@ -92,10 +88,8 @@ class BaseRenderer:
            self.full
            if self.debug and not getattr(self.exception, "quiet", False)
            else self.minimal
-        )()
-        output.status = self.status
-        output.headers.update(self.headers)
-        return output
+        )
+        return output()

    def minimal(self) -> HTTPResponse:  # noqa
        """
@@ -119,18 +113,134 @@ class HTMLRenderer(BaseRenderer):
    The default fallback type.
    """

+    TRACEBACK_STYLE = """
+        html { font-family: sans-serif }
+        h2 { color: #888; }
+        .tb-wrapper p, dl, dd { margin: 0 }
+        .frame-border { margin: 1rem }
+        .frame-line > *, dt, dd { padding: 0.3rem 0.6rem }
+        .frame-line, dl { margin-bottom: 0.3rem }
+        .frame-code, dd { font-size: 16px; padding-left: 4ch }
+        .tb-wrapper, dl { border: 1px solid #eee }
+        .tb-header,.obj-header {
+            background: #eee; padding: 0.3rem; font-weight: bold
+        }
+        .frame-descriptor, dt { background: #e2eafb; font-size: 14px }
+    """
+    TRACEBACK_WRAPPER_HTML = (
+        "<div class=tb-header>{exc_name}: {exc_value}</div>"
+        "<div class=tb-wrapper>{frame_html}</div>"
+    )
+    TRACEBACK_BORDER = (
+        "<div class=frame-border>"
+        "The above exception was the direct cause of the following exception:"
+        "</div>"
+    )
+    TRACEBACK_LINE_HTML = (
+        "<div class=frame-line>"
+        "<p class=frame-descriptor>"
+        "File {0.filename}, line <i>{0.lineno}</i>, "
+        "in <code><b>{0.name}</b></code>"
+        "<p class=frame-code><code>{0.line}</code>"
+        "</div>"
+    )
+    OBJECT_WRAPPER_HTML = (
+        "<div class=obj-header>{title}</div>"
+        "<dl class={obj_type}>{display_html}</dl>"
+    )
+    OBJECT_DISPLAY_HTML = "<dt>{key}</dt><dd><code>{value}</code></dd>"
+    OUTPUT_HTML = (
+        "<!DOCTYPE html><html lang=en>"
+        "<meta charset=UTF-8><title>{title}</title>\n"
+        "<style>{style}</style>\n"
+        "<h1>{title}</h1><p>{text}\n"
+        "{body}"
+    )
+
    def full(self) -> HTTPResponse:
-        page = ErrorPage(
-            debug=self.debug,
-            title=super().title,
-            text=super().text,
-            request=self.request,
-            exc=self.exception,
+        return html(
+            self.OUTPUT_HTML.format(
+                title=self.title,
+                text=self.text,
+                style=self.TRACEBACK_STYLE,
+                body=self._generate_body(full=True),
+            ),
+            status=self.status,
        )
-        return html(page.render())

    def minimal(self) -> HTTPResponse:
-        return self.full()
+        return html(
+            self.OUTPUT_HTML.format(
+                title=self.title,
+                text=self.text,
+                style=self.TRACEBACK_STYLE,
+                body=self._generate_body(full=False),
+            ),
+            status=self.status,
+            headers=self.headers,
+        )
+
+    @property
+    def text(self):
+        return escape(super().text)
+
+    @property
+    def title(self):
+        return escape(f"⚠️ {super().title}")
+
+    def _generate_body(self, *, full):
+        lines = []
+        if full:
+            _, exc_value, __ = sys.exc_info()
+            exceptions = []
+            while exc_value:
+                exceptions.append(self._format_exc(exc_value))
+                exc_value = exc_value.__cause__
+
+            traceback_html = self.TRACEBACK_BORDER.join(reversed(exceptions))
+            appname = escape(self.request.app.name)
+            name = escape(self.exception.__class__.__name__)
+            value = escape(self.exception)
+            path = escape(self.request.path)
+            lines += [
+                f"<h2>Traceback of {appname} " "(most recent call last):</h2>",
+                f"{traceback_html}",
+                "<div class=summary><p>",
+                f"<b>{name}: {value}</b> "
+                f"while handling path <code>{path}</code>",
+                "</div>",
+            ]
+
+        for attr, display in (("context", True), ("extra", bool(full))):
+            info = getattr(self.exception, attr, None)
+            if info and display:
+                lines.append(self._generate_object_display(info, attr))
+
+        return "\n".join(lines)
+
+    def _generate_object_display(
+        self, obj: t.Dict[str, t.Any], descriptor: str
+    ) -> str:
+        display = "".join(
+            self.OBJECT_DISPLAY_HTML.format(key=key, value=value)
+            for key, value in obj.items()
+        )
+        return self.OBJECT_WRAPPER_HTML.format(
+            title=descriptor.title(),
+            display_html=display,
+            obj_type=descriptor.lower(),
+        )
+
+    def _format_exc(self, exc):
+        frames = extract_tb(exc.__traceback__)
+        frame_html = "".join(
+            self.TRACEBACK_LINE_HTML.format(frame) for frame in frames
+        )
+        return self.TRACEBACK_WRAPPER_HTML.format(
+            exc_name=escape(exc.__class__.__name__),
+            exc_value=escape(exc),
+            frame_html=frame_html,
+        )


 class TextRenderer(BaseRenderer):
@@ -148,7 +258,8 @@ class TextRenderer(BaseRenderer):
                text=self.text,
                bar=("=" * len(self.title)),
                body=self._generate_body(full=True),
-            )
+            ),
+            status=self.status,
        )

    def minimal(self) -> HTTPResponse:
@@ -158,7 +269,9 @@ class TextRenderer(BaseRenderer):
                text=self.text,
                bar=("=" * len(self.title)),
                body=self._generate_body(full=False),
-            )
+            ),
+            status=self.status,
+            headers=self.headers,
        )

    @property
@@ -217,11 +330,11 @@ class JSONRenderer(BaseRenderer):

    def full(self) -> HTTPResponse:
        output = self._generate_output(full=True)
-        return json(output, dumps=self.dumps)
+        return json(output, status=self.status, dumps=self.dumps)

    def minimal(self) -> HTTPResponse:
        output = self._generate_output(full=False)
-        return json(output, dumps=self.dumps)
+        return json(output, status=self.status, dumps=self.dumps)

    def _generate_output(self, *, full):
        output = {
@@ -275,26 +388,32 @@ def escape(text):
    return f"{text}".replace("&", "&amp;").replace("<", "&lt;")


-MIME_BY_CONFIG = {
-    "text": "text/plain",
-    "json": "application/json",
-    "html": "text/html",
+RENDERERS_BY_CONFIG = {
+    "html": HTMLRenderer,
+    "json": JSONRenderer,
+    "text": TextRenderer,
 }
-CONFIG_BY_MIME = {v: k for k, v in MIME_BY_CONFIG.items()}
+
 RENDERERS_BY_CONTENT_TYPE = {
    "text/plain": TextRenderer,
    "application/json": JSONRenderer,
    "multipart/form-data": HTMLRenderer,
    "text/html": HTMLRenderer,
 }
+CONTENT_TYPE_BY_RENDERERS = {
+    v: k for k, v in RENDERERS_BY_CONTENT_TYPE.items()
+}

-# Handler source code is checked for which response types it returns with the
-# route error_format="auto" (default) to determine which format to use.
 RESPONSE_MAPPING = {
+    "empty": "html",
    "json": "json",
    "text": "text",
+    "raw": "text",
    "html": "html",
-    "JSONResponse": "json",
+    "file": "html",
+    "file_stream": "text",
+    "stream": "text",
+    "redirect": "html",
    "text/plain": "text",
    "text/html": "html",
    "application/json": "json",
@@ -302,7 +421,7 @@ RESPONSE_MAPPING = {


 def check_error_format(format):
-    if format not in MIME_BY_CONFIG and format != "auto":
+    if format not in RENDERERS_BY_CONFIG and format != "auto":
        raise SanicException(f"Unknown format: {format}")


@@ -312,73 +431,103 @@ def exception_response(
    debug: bool,
    fallback: str,
    base: t.Type[BaseRenderer],
-    renderer: t.Optional[t.Type[BaseRenderer]] = None,
+    renderer: t.Type[t.Optional[BaseRenderer]] = None,
 ) -> HTTPResponse:
    """
    Render a response for the default FALLBACK exception handler.
    """
+    content_type = None
+
    if not renderer:
-        mt = guess_mime(request, fallback)
-        renderer = RENDERERS_BY_CONTENT_TYPE.get(mt, base)
+        # Make sure we have something set
+        renderer = base
+        render_format = fallback
+
+        if request:
+            # If there is a request, try and get the format
+            # from the route
+            if request.route:
+                try:
+                    if request.route.ctx.error_format:
+                        render_format = request.route.ctx.error_format
+                except AttributeError:
+                    ...
+
+            content_type = request.headers.getone("content-type", "").split(
+                ";"
+            )[0]
+
+            acceptable = request.accept
+
+            # If the format is auto still, make a guess
+            if render_format == "auto":
+                # First, if there is an Accept header, check if text/html
+                # is the first option
+                # According to MDN Web Docs, all major browsers use text/html
+                # as the primary value in Accept (with the exception of IE 8,
+                # and, well, if you are supporting IE 8, then you have bigger
+                # problems to concern yourself with than what default exception
+                # renderer is used)
+                # Source:
+                # https://developer.mozilla.org/en-US/docs/Web/HTTP/Content_negotiation/List_of_default_Accept_values
+
+                if acceptable and acceptable[0].match(
+                    "text/html",
+                    allow_type_wildcard=False,
+                    allow_subtype_wildcard=False,
+                ):
+                    renderer = HTMLRenderer
+
+                # Second, if there is an Accept header, check if
+                # application/json is an option, or if the content-type
+                # is application/json
+                elif (
+                    acceptable
+                    and acceptable.match(
+                        "application/json",
+                        allow_type_wildcard=False,
+                        allow_subtype_wildcard=False,
+                    )
+                    or content_type == "application/json"
+                ):
+                    renderer = JSONRenderer
+
+                # Third, if there is no Accept header, assume we want text.
+                # The likely use case here is a raw socket.
+                elif not acceptable:
+                    renderer = TextRenderer
+                else:
+                    # Fourth, look to see if there was a JSON body
+                    # When in this situation, the request is probably coming
+                    # from curl, an API client like Postman or Insomnia, or a
+                    # package like requests or httpx
+                    try:
+                        # Give them the benefit of the doubt if they did:
+                        # $ curl localhost:8000 -d '{"foo": "bar"}'
+                        # And provide them with JSONRenderer
+                        renderer = JSONRenderer if request.json else base
+                    except InvalidUsage:
+                        renderer = base
+            else:
+                renderer = RENDERERS_BY_CONFIG.get(render_format, renderer)
+
+            # Lastly, if there is an Accept header, make sure
+            # our choice is okay
+            if acceptable:
+                type_ = CONTENT_TYPE_BY_RENDERERS.get(renderer)  # type: ignore
+                if type_ and type_ not in acceptable:
+                    # If the renderer selected is not in the Accept header
+                    # look through what is in the Accept header, and select
+                    # the first option that matches. Otherwise, just drop back
+                    # to the original default
+                    for accept in acceptable:
+                        mtype = f"{accept.type_}/{accept.subtype}"
+                        maybe = RENDERERS_BY_CONTENT_TYPE.get(mtype)
+                        if maybe:
+                            renderer = maybe
+                            break
+                    else:
+                        renderer = base

    renderer = t.cast(t.Type[BaseRenderer], renderer)
    return renderer(request, exception, debug).render()
-
-
-def guess_mime(req: Request, fallback: str) -> str:
-    # Attempt to find a suitable MIME format for the response.
-    # Insertion-ordered map of formats["html"] = "source of that suggestion"
-    formats = {}
-    name = ""
-    # Route error_format (by magic from handler code if auto, the default)
-    if req.route:
-        name = req.route.name
-        f = req.route.extra.error_format
-        if f in MIME_BY_CONFIG:
-            formats[f] = name
-
-    if not formats and fallback in MIME_BY_CONFIG:
-        formats[fallback] = "FALLBACK_ERROR_FORMAT"
-
-    # If still not known, check for the request for clues of JSON
-    if not formats and fallback == "auto" and req.accept.match(JSON):
-        if JSON in req.accept:  # Literally, not wildcard
-            formats["json"] = "request.accept"
-        elif JSON in req.headers.getone("content-type", ""):
-            formats["json"] = "content-type"
-        # DEPRECATION: Remove this block in 24.3
-        else:
-            c = None
-            try:
-                c = req.json
-            except BadRequest:
-                pass
-            if c:
-                formats["json"] = "request.json"
-                deprecation(
-                    "Response type was determined by the JSON content of "
-                    "the request. This behavior is deprecated and will be "
-                    "removed in v24.3. Please specify the format either by\n"
-                    f'  error_format="json" on route {name}, by\n'
-                    '  FALLBACK_ERROR_FORMAT = "json", or by adding header\n'
-                    "  accept: application/json to your requests.",
-                    24.3,
-                )
-
-    # Any other supported formats
-    if fallback == "auto":
-        for k in MIME_BY_CONFIG:
-            if k not in formats:
-                formats[k] = "any"
-
-    mimes = [MIME_BY_CONFIG[k] for k in formats]
-    m = req.accept.match(*mimes)
-    if m:
-        format = CONFIG_BY_MIME[m.mime]
-        source = formats[format]
-        logger.debug(
-            f"The client accepts {m.header}, using '{format}' from {source}"
-        )
-    else:
-        logger.debug(f"No format found, the client accepts {req.accept!r}")
-    return m.mime
--- a/sanic/exceptions.py
+++ b/sanic/exceptions.py
@@ -1,301 +1,96 @@
-from asyncio import CancelledError, Protocol
-from os import PathLike
-from typing import Any, Dict, Optional, Sequence, Union
+from typing import Any, Dict, Optional, Union

 from sanic.helpers import STATUS_CODES


-class RequestCancelled(CancelledError):
-    quiet = True
-
-
-class ServerKilled(Exception):
-    """
-    Exception Sanic server uses when killing a server process for something
-    unexpected happening.
-    """
-
-
 class SanicException(Exception):
-    """
-    Generic exception that will generate an HTTP response when raised
-    in the context of a request lifecycle.
-
-    Usually it is best practice to use one of the more specific exceptions
-    than this generic. Even when trying to raise a 500, it is generally
-    preferrable to use :class:`.ServerError`
-
-    .. code-block:: python
-
-        raise SanicException(
-            "Something went wrong",
-            status_code=999,
-            context={
-                "info": "Some additional details",
-            },
-            headers={
-                "X-Foo": "bar"
-            }
-        )
-
-    :param message: The message to be sent to the client. If ``None``
-        then the appropriate HTTP response status message will be used
-        instead, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param status_code: The HTTP response code to send, if applicable. If
-        ``None``, then it will be 500, defaults to None
-    :type status_code: Optional[int], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
-    """
-
-    status_code: int = 500
-    quiet: Optional[bool] = False
-    headers: Dict[str, str] = {}
    message: str = ""

    def __init__(
        self,
        message: Optional[Union[str, bytes]] = None,
        status_code: Optional[int] = None,
-        *,
        quiet: Optional[bool] = None,
        context: Optional[Dict[str, Any]] = None,
        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
    ) -> None:
        self.context = context
        self.extra = extra
-        status_code = status_code or getattr(
-            self.__class__, "status_code", None
-        )
-        quiet = quiet or getattr(self.__class__, "quiet", None)
-        headers = headers or getattr(self.__class__, "headers", {})
        if message is None:
            if self.message:
                message = self.message
-            elif status_code:
+            elif status_code is not None:
                msg: bytes = STATUS_CODES.get(status_code, b"")
                message = msg.decode("utf8")

        super().__init__(message)

-        self.status_code = status_code or self.status_code
-        self.quiet = quiet
-        self.headers = headers
+        if status_code is not None:
+            self.status_code = status_code
+
+        # quiet=None/False/True with None meaning choose by status
+        if quiet or quiet is None and status_code not in (None, 500):
+            self.quiet = True


-class HTTPException(SanicException):
-    """
-    A base class for other exceptions and should not be called directly.
-    """
-
-    def __init__(
-        self,
-        message: Optional[Union[str, bytes]] = None,
-        *,
-        quiet: Optional[bool] = None,
-        context: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-    ) -> None:
-        super().__init__(
-            message,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-            headers=headers,
-        )
-
-
-class NotFound(HTTPException):
+class NotFound(SanicException):
    """
    **Status**: 404 Not Found
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Not Found' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 404
    quiet = True


-class BadRequest(HTTPException):
+class InvalidUsage(SanicException):
    """
    **Status**: 400 Bad Request
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Bad Request' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 400
    quiet = True


-InvalidUsage = BadRequest
-BadURL = BadRequest
+class BadURL(InvalidUsage):
+    ...


-class MethodNotAllowed(HTTPException):
+class MethodNotSupported(SanicException):
    """
    **Status**: 405 Method Not Allowed
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Method Not Allowed' will be sent,
-        defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param method: The HTTP method that was used, defaults to  an empty string
-    :type method: Optional[str], optional
-    :param allowed_methods: The HTTP methods that can be used instead of the
-        one that was attempted
-    :type allowed_methods: Optional[Sequence[str]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 405
    quiet = True

-    def __init__(
-        self,
-        message: Optional[Union[str, bytes]] = None,
-        method: str = "",
-        allowed_methods: Optional[Sequence[str]] = None,
-        *,
-        quiet: Optional[bool] = None,
-        context: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            message,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-            headers=headers,
-        )
-        if allowed_methods:
-            self.headers = {
-                **self.headers,
-                "Allow": ", ".join(allowed_methods),
-            }
-        self.method = method
-        self.allowed_methods = allowed_methods
+    def __init__(self, message, method, allowed_methods):
+        super().__init__(message)
+        self.headers = {"Allow": ", ".join(allowed_methods)}


-MethodNotSupported = MethodNotAllowed
-
-
-class ServerError(HTTPException):
+class ServerError(SanicException):
    """
    **Status**: 500 Internal Server Error
-
-    A general server-side error has occurred. If no other HTTP exception is
-    appropriate, then this should be used
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Internal Server Error' will be sent,
-         defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 500


-InternalServerError = ServerError
-
-
-class ServiceUnavailable(HTTPException):
+class ServiceUnavailable(SanicException):
    """
    **Status**: 503 Service Unavailable

    The server is currently unavailable (because it is overloaded or
    down for maintenance). Generally, this is a temporary state.
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Bad Request' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 503
    quiet = True


-class URLBuildError(HTTPException):
+class URLBuildError(ServerError):
    """
    **Status**: 500 Internal Server Error
-
-    An exception used by Sanic internals when unable to build a URL.
    """

    status_code = 500
@@ -304,241 +99,80 @@ class URLBuildError(HTTPException):
 class FileNotFound(NotFound):
    """
    **Status**: 404 Not Found
-
-    A specific form of :class:`.NotFound` that is specifically when looking
-    for a file on the file system at a known path.
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Not Found' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param path: The path, if any, to the file that could not
-        be found, defaults to None
-    :type path: Optional[PathLike], optional
-    :param relative_url: A relative URL of the file, defaults to None
-    :type relative_url: Optional[str], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

-    def __init__(
-        self,
-        message: Optional[Union[str, bytes]] = None,
-        path: Optional[PathLike] = None,
-        relative_url: Optional[str] = None,
-        *,
-        quiet: Optional[bool] = None,
-        context: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            message,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-            headers=headers,
-        )
+    def __init__(self, message, path, relative_url):
+        super().__init__(message)
        self.path = path
        self.relative_url = relative_url


-class RequestTimeout(HTTPException):
-    """
-    The Web server (running the Web site) thinks that there has been too
+class RequestTimeout(SanicException):
+    """The Web server (running the Web site) thinks that there has been too
    long an interval of time between 1) the establishment of an IP
    connection (socket) between the client and the server and
    2) the receipt of any data on that socket, so the server has dropped
    the connection. The socket connection has actually been lost - the Web
    server has 'timed out' on that particular socket connection.
-
-    This is an internal exception thrown by Sanic and should not be used
-    directly.
    """

    status_code = 408
    quiet = True


-class PayloadTooLarge(HTTPException):
+class PayloadTooLarge(SanicException):
    """
    **Status**: 413 Payload Too Large
-
-    This is an internal exception thrown by Sanic and should not be used
-    directly.
    """

    status_code = 413
    quiet = True


-class HeaderNotFound(BadRequest):
+class HeaderNotFound(InvalidUsage):
    """
    **Status**: 400 Bad Request
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Bad Request' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """


-class InvalidHeader(BadRequest):
+class InvalidHeader(InvalidUsage):
    """
    **Status**: 400 Bad Request
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Bad Request' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """


-class ContentRange(Protocol):
-    total: int
-
-
-class RangeNotSatisfiable(HTTPException):
+class ContentRangeError(SanicException):
    """
    **Status**: 416 Range Not Satisfiable
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Range Not Satisfiable' will be sent,
-        defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param content_range: An object meeting the :class:`.ContentRange` protocol
-        that has a ``total`` property, defaults to None
-    :type content_range: Optional[ContentRange], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 416
    quiet = True

-    def __init__(
-        self,
-        message: Optional[Union[str, bytes]] = None,
-        content_range: Optional[ContentRange] = None,
-        *,
-        quiet: Optional[bool] = None,
-        context: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            message,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-            headers=headers,
-        )
-        if content_range is not None:
-            self.headers = {
-                **self.headers,
-                "Content-Range": f"bytes */{content_range.total}",
-            }
+    def __init__(self, message, content_range):
+        super().__init__(message)
+        self.headers = {"Content-Range": f"bytes */{content_range.total}"}


-ContentRangeError = RangeNotSatisfiable
-
-
-class ExpectationFailed(HTTPException):
+class HeaderExpectationFailed(SanicException):
    """
    **Status**: 417 Expectation Failed
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Expectation Failed' will be sent,
-        defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 417
    quiet = True


-HeaderExpectationFailed = ExpectationFailed
-
-
-class Forbidden(HTTPException):
+class Forbidden(SanicException):
    """
    **Status**: 403 Forbidden
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Forbidden' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 403
    quiet = True


-class InvalidRangeType(RangeNotSatisfiable):
+class InvalidRangeType(ContentRangeError):
    """
    **Status**: 416 Range Not Satisfiable
    """
@@ -547,33 +181,20 @@ class InvalidRangeType(RangeNotSatisfiable):
    quiet = True


-class PyFileError(SanicException):
-    def __init__(
-        self,
-        file,
-        status_code: Optional[int] = None,
-        *,
-        quiet: Optional[bool] = None,
-        context: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-    ):
-        super().__init__(
-            "could not execute config file %s" % file,
-            status_code=status_code,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-            headers=headers,
-        )
+class PyFileError(Exception):
+    def __init__(self, file):
+        super().__init__("could not execute config file %s", file)


-class Unauthorized(HTTPException):
+class Unauthorized(SanicException):
    """
    **Status**: 401 Unauthorized

-    When present, additional keyword arguments may be used to complete
-    the WWW-Authentication header.
+    :param message: Message describing the exception.
+    :param status_code: HTTP Status code.
+    :param scheme: Name of the authentication scheme to be used.
+
+    When present, kwargs is used to complete the WWW-Authentication header.

    Examples::

@@ -598,58 +219,21 @@ class Unauthorized(HTTPException):
        raise Unauthorized("Auth required.",
                           scheme="Bearer",
                           realm="Restricted Area")
-
-    :param message: The message to be sent to the client. If ``None``
-        then the HTTP status 'Bad Request' will be sent, defaults to None
-    :type message: Optional[Union[str, bytes]], optional
-    :param scheme: Name of the authentication scheme to be used.
-    :type scheme: Optional[str], optional
-    :param quiet: When ``True``, the error traceback will be suppressed
-        from the logs, defaults to None
-    :type quiet: Optional[bool], optional
-    :param context: Additional mapping of key/value data that will be
-        sent to the client upon exception, defaults to None
-    :type context: Optional[Dict[str, Any]], optional
-    :param extra: Additional mapping of key/value data that will NOT be
-        sent to the client when in PRODUCTION mode, defaults to None
-    :type extra: Optional[Dict[str, Any]], optional
-    :param headers: Additional headers that should be sent with the HTTP
-        response, defaults to None
-    :type headers: Optional[Dict[str, Any]], optional
    """

    status_code = 401
    quiet = True

-    def __init__(
-        self,
-        message: Optional[Union[str, bytes]] = None,
-        scheme: Optional[str] = None,
-        *,
-        quiet: Optional[bool] = None,
-        context: Optional[Dict[str, Any]] = None,
-        extra: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, Any]] = None,
-        **challenges,
-    ):
-        super().__init__(
-            message,
-            quiet=quiet,
-            context=context,
-            extra=extra,
-            headers=headers,
-        )
+    def __init__(self, message, status_code=None, scheme=None, **kwargs):
+        super().__init__(message, status_code)

        # if auth-scheme is specified, set "WWW-Authenticate" header
        if scheme is not None:
-            values = [
-                '{!s}="{!s}"'.format(k, v) for k, v in challenges.items()
-            ]
+            values = ['{!s}="{!s}"'.format(k, v) for k, v in kwargs.items()]
            challenge = ", ".join(values)

            self.headers = {
-                **self.headers,
-                "WWW-Authenticate": f"{scheme} {challenge}".rstrip(),
+                "WWW-Authenticate": f"{scheme} {challenge}".rstrip()
            }


--- a/sanic/handlers.py
+++ b/sanic/handlers.py
@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple, Type, Union
+
+from sanic.config import Config
+from sanic.errorpages import (
+    DEFAULT_FORMAT,
+    BaseRenderer,
+    TextRenderer,
+    exception_response,
+)
+from sanic.exceptions import (
+    ContentRangeError,
+    HeaderNotFound,
+    InvalidRangeType,
+    SanicException,
+)
+from sanic.helpers import Default, _default
+from sanic.log import deprecation, error_logger
+from sanic.models.handler_types import RouteHandler
+from sanic.response import text
+
+
+class ErrorHandler:
+    """
+    Provide :class:`sanic.app.Sanic` application with a mechanism to handle
+    and process any and all uncaught exceptions in a way the application
+    developer will set fit.
+
+    This error handling framework is built into the core that can be extended
+    by the developers to perform a wide range of tasks from recording the error
+    stats to reporting them to an external service that can be used for
+    realtime alerting system.
+
+    """
+
+    def __init__(
+        self,
+        fallback: Union[str, Default] = _default,
+        base: Type[BaseRenderer] = TextRenderer,
+    ):
+        self.cached_handlers: Dict[
+            Tuple[Type[BaseException], Optional[str]], Optional[RouteHandler]
+        ] = {}
+        self.debug = False
+        self._fallback = fallback
+        self.base = base
+
+        if fallback is not _default:
+            self._warn_fallback_deprecation()
+
+    @property
+    def fallback(self):  # no cov
+        # This is for backwards compat and can be removed in v22.6
+        if self._fallback is _default:
+            return DEFAULT_FORMAT
+        return self._fallback
+
+    @fallback.setter
+    def fallback(self, value: str):  # no cov
+        self._warn_fallback_deprecation()
+        if not isinstance(value, str):
+            raise SanicException(
+                f"Cannot set error handler fallback to: value={value}"
+            )
+        self._fallback = value
+
+    @staticmethod
+    def _warn_fallback_deprecation():
+        deprecation(
+            "Setting the ErrorHandler fallback value directly is "
+            "deprecated and no longer supported. This feature will "
+            "be removed in v22.6. Instead, use "
+            "app.config.FALLBACK_ERROR_FORMAT.",
+            22.6,
+        )
+
+    @classmethod
+    def _get_fallback_value(cls, error_handler: ErrorHandler, config: Config):
+        if error_handler._fallback is not _default:
+            if config._FALLBACK_ERROR_FORMAT == error_handler._fallback:
+                return error_handler.fallback
+
+            error_logger.warning(
+                "Conflicting error fallback values were found in the "
+                "error handler and in the app.config while handling an "
+                "exception. Using the value from app.config."
+            )
+        return config.FALLBACK_ERROR_FORMAT
+
+    @classmethod
+    def finalize(
+        cls,
+        error_handler: ErrorHandler,
+        config: Config,
+        fallback: Optional[str] = None,
+    ):
+        if fallback:
+            deprecation(
+                "Setting the ErrorHandler fallback value via finalize() "
+                "is deprecated and no longer supported. This feature will "
+                "be removed in v22.6. Instead, use "
+                "app.config.FALLBACK_ERROR_FORMAT.",
+                22.6,
+            )
+
+        if not fallback:
+            fallback = config.FALLBACK_ERROR_FORMAT
+
+        if fallback != DEFAULT_FORMAT:
+            if error_handler._fallback is not _default:
+                error_logger.warning(
+                    f"Setting the fallback value to {fallback}. This changes "
+                    "the current non-default value "
+                    f"'{error_handler._fallback}'."
+                )
+            error_handler._fallback = fallback
+
+        if not isinstance(error_handler, cls):
+            error_logger.warning(
+                f"Error handler is non-conforming: {type(error_handler)}"
+            )
+
+    def _full_lookup(self, exception, route_name: Optional[str] = None):
+        return self.lookup(exception, route_name)
+
+    def add(self, exception, handler, route_names: Optional[List[str]] = None):
+        """
+        Add a new exception handler to an already existing handler object.
+
+        :param exception: Type of exception that need to be handled
+        :param handler: Reference to the method that will handle the exception
+
+        :type exception: :class:`sanic.exceptions.SanicException` or
+            :class:`Exception`
+        :type handler: ``function``
+
+        :return: None
+        """
+        if route_names:
+            for route in route_names:
+                self.cached_handlers[(exception, route)] = handler
+        else:
+            self.cached_handlers[(exception, None)] = handler
+
+    def lookup(self, exception, route_name: Optional[str] = None):
+        """
+        Lookup the existing instance of :class:`ErrorHandler` and fetch the
+        registered handler for a specific type of exception.
+
+        This method leverages a dict lookup to speedup the retrieval process.
+
+        :param exception: Type of exception
+
+        :type exception: :class:`sanic.exceptions.SanicException` or
+            :class:`Exception`
+
+        :return: Registered function if found ``None`` otherwise
+        """
+        exception_class = type(exception)
+
+        for name in (route_name, None):
+            exception_key = (exception_class, name)
+            handler = self.cached_handlers.get(exception_key)
+            if handler:
+                return handler
+
+        for name in (route_name, None):
+            for ancestor in type.mro(exception_class):
+                exception_key = (ancestor, name)
+                if exception_key in self.cached_handlers:
+                    handler = self.cached_handlers[exception_key]
+                    self.cached_handlers[
+                        (exception_class, route_name)
+                    ] = handler
+                    return handler
+
+                if ancestor is BaseException:
+                    break
+        self.cached_handlers[(exception_class, route_name)] = None
+        handler = None
+        return handler
+
+    _lookup = _full_lookup
+
+    def response(self, request, exception):
+        """Fetches and executes an exception handler and returns a response
+        object
+
+        :param request: Instance of :class:`sanic.request.Request`
+        :param exception: Exception to handle
+
+        :type request: :class:`sanic.request.Request`
+        :type exception: :class:`sanic.exceptions.SanicException` or
+            :class:`Exception`
+
+        :return: Wrap the return value obtained from :func:`default`
+            or registered handler for that type of exception.
+        """
+        route_name = request.name if request else None
+        handler = self._lookup(exception, route_name)
+        response = None
+        try:
+            if handler:
+                response = handler(request, exception)
+            if response is None:
+                response = self.default(request, exception)
+        except Exception:
+            try:
+                url = repr(request.url)
+            except AttributeError:  # no cov
+                url = "unknown"
+            response_message = (
+                "Exception raised in exception handler " '"%s" for uri: %s'
+            )
+            error_logger.exception(response_message, handler.__name__, url)
+
+            if self.debug:
+                return text(response_message % (handler.__name__, url), 500)
+            else:
+                return text("An error occurred while handling an error", 500)
+        return response
+
+    def default(self, request, exception):
+        """
+        Provide a default behavior for the objects of :class:`ErrorHandler`.
+        If a developer chooses to extent the :class:`ErrorHandler` they can
+        provide a custom implementation for this method to behave in a way
+        they see fit.
+
+        :param request: Incoming request
+        :param exception: Exception object
+
+        :type request: :class:`sanic.request.Request`
+        :type exception: :class:`sanic.exceptions.SanicException` or
+            :class:`Exception`
+        :return:
+        """
+        self.log(request, exception)
+        fallback = ErrorHandler._get_fallback_value(self, request.app.config)
+        return exception_response(
+            request,
+            exception,
+            debug=self.debug,
+            base=self.base,
+            fallback=fallback,
+        )
+
+    @staticmethod
+    def log(request, exception):
+        quiet = getattr(exception, "quiet", False)
+        noisy = getattr(request.app.config, "NOISY_EXCEPTIONS", False)
+        if quiet is False or noisy is True:
+            try:
+                url = repr(request.url)
+            except AttributeError:  # no cov
+                url = "unknown"
+
+            error_logger.exception(
+                "Exception occurred while handling uri: %s", url
+            )
+
+
+class ContentRangeHandler:
+    """
+    A mechanism to parse and process the incoming request headers to
+    extract the content range information.
+
+    :param request: Incoming api request
+    :param stats: Stats related to the content
+
+    :type request: :class:`sanic.request.Request`
+    :type stats: :class:`posix.stat_result`
+
+    :ivar start: Content Range start
+    :ivar end: Content Range end
+    :ivar size: Length of the content
+    :ivar total: Total size identified by the :class:`posix.stat_result`
+        instance
+    :ivar ContentRangeHandler.headers: Content range header ``dict``
+    """
+
+    __slots__ = ("start", "end", "size", "total", "headers")
+
+    def __init__(self, request, stats):
+        self.total = stats.st_size
+        _range = request.headers.getone("range", None)
+        if _range is None:
+            raise HeaderNotFound("Range Header Not Found")
+        unit, _, value = tuple(map(str.strip, _range.partition("=")))
+        if unit != "bytes":
+            raise InvalidRangeType(
+                "%s is not a valid Range Type" % (unit,), self
+            )
+        start_b, _, end_b = tuple(map(str.strip, value.partition("-")))
+        try:
+            self.start = int(start_b) if start_b else None
+        except ValueError:
+            raise ContentRangeError(
+                "'%s' is invalid for Content Range" % (start_b,), self
+            )
+        try:
+            self.end = int(end_b) if end_b else None
+        except ValueError:
+            raise ContentRangeError(
+                "'%s' is invalid for Content Range" % (end_b,), self
+            )
+        if self.end is None:
+            if self.start is None:
+                raise ContentRangeError(
+                    "Invalid for Content Range parameters", self
+                )
+            else:
+                # this case represents `Content-Range: bytes 5-`
+                self.end = self.total - 1
+        else:
+            if self.start is None:
+                # this case represents `Content-Range: bytes -5`
+                self.start = self.total - self.end
+                self.end = self.total - 1
+        if self.start >= self.end:
+            raise ContentRangeError(
+                "Invalid for Content Range parameters", self
+            )
+        self.size = self.end - self.start + 1
+        self.headers = {
+            "Content-Range": "bytes %s-%s/%s"
+            % (self.start, self.end, self.total)
+        }
+
+    def __bool__(self):
+        return self.size > 0
--- a/sanic/handlers/init.py
+++ b/sanic/handlers/init.py
@@ -1,10 +0,0 @@
-from .content_range import ContentRangeHandler
-from .directory import DirectoryHandler
-from .error import ErrorHandler
-
-
-__all__ = (
-    "ContentRangeHandler",
-    "DirectoryHandler",
-    "ErrorHandler",
-)
--- a/sanic/handlers/content_range.py
+++ b/sanic/handlers/content_range.py
@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-from sanic.exceptions import (
-    HeaderNotFound,
-    InvalidRangeType,
-    RangeNotSatisfiable,
-)
-
-
-class ContentRangeHandler:
-    """
-    A mechanism to parse and process the incoming request headers to
-    extract the content range information.
-
-    :param request: Incoming api request
-    :param stats: Stats related to the content
-
-    :type request: :class:`sanic.request.Request`
-    :type stats: :class:`posix.stat_result`
-
-    :ivar start: Content Range start
-    :ivar end: Content Range end
-    :ivar size: Length of the content
-    :ivar total: Total size identified by the :class:`posix.stat_result`
-        instance
-    :ivar ContentRangeHandler.headers: Content range header ``dict``
-    """
-
-    __slots__ = ("start", "end", "size", "total", "headers")
-
-    def __init__(self, request, stats):
-        self.total = stats.st_size
-        _range = request.headers.getone("range", None)
-        if _range is None:
-            raise HeaderNotFound("Range Header Not Found")
-        unit, _, value = tuple(map(str.strip, _range.partition("=")))
-        if unit != "bytes":
-            raise InvalidRangeType(
-                "%s is not a valid Range Type" % (unit,), self
-            )
-        start_b, _, end_b = tuple(map(str.strip, value.partition("-")))
-        try:
-            self.start = int(start_b) if start_b else None
-        except ValueError:
-            raise RangeNotSatisfiable(
-                "'%s' is invalid for Content Range" % (start_b,), self
-            )
-        try:
-            self.end = int(end_b) if end_b else None
-        except ValueError:
-            raise RangeNotSatisfiable(
-                "'%s' is invalid for Content Range" % (end_b,), self
-            )
-        if self.end is None:
-            if self.start is None:
-                raise RangeNotSatisfiable(
-                    "Invalid for Content Range parameters", self
-                )
-            else:
-                # this case represents `Content-Range: bytes 5-`
-                self.end = self.total - 1
-        else:
-            if self.start is None:
-                # this case represents `Content-Range: bytes -5`
-                self.start = self.total - self.end
-                self.end = self.total - 1
-        if self.start >= self.end:
-            raise RangeNotSatisfiable(
-                "Invalid for Content Range parameters", self
-            )
-        self.size = self.end - self.start + 1
-        self.headers = {
-            "Content-Range": "bytes %s-%s/%s"
-            % (self.start, self.end, self.total)
-        }
-
-    def __bool__(self):
-        return hasattr(self, "size") and self.size > 0
--- a/sanic/handlers/directory.py
+++ b/sanic/handlers/directory.py
@@ -1,84 +0,0 @@
-from __future__ import annotations
-
-from datetime import datetime
-from operator import itemgetter
-from pathlib import Path
-from stat import S_ISDIR
-from typing import Dict, Iterable, Optional, Sequence, Union, cast
-
-from sanic.exceptions import NotFound
-from sanic.pages.directory_page import DirectoryPage, FileInfo
-from sanic.request import Request
-from sanic.response import file, html, redirect
-
-
-class DirectoryHandler:
-    def __init__(
-        self,
-        uri: str,
-        directory: Path,
-        directory_view: bool = False,
-        index: Optional[Union[str, Sequence[str]]] = None,
-    ) -> None:
-        if isinstance(index, str):
-            index = [index]
-        elif index is None:
-            index = []
-        self.base = uri.strip("/")
-        self.directory = directory
-        self.directory_view = directory_view
-        self.index = tuple(index)
-
-    async def handle(self, request: Request, path: str):
-        current = path.strip("/")[len(self.base) :].strip("/")  # noqa: E203
-        for file_name in self.index:
-            index_file = self.directory / current / file_name
-            if index_file.is_file():
-                return await file(index_file)
-
-        if self.directory_view:
-            return self._index(
-                self.directory / current, path, request.app.debug
-            )
-
-        if self.index:
-            raise NotFound("File not found")
-
-        raise IsADirectoryError(f"{self.directory.as_posix()} is a directory")
-
-    def _index(self, location: Path, path: str, debug: bool):
-        # Remove empty path elements, append slash
-        if "//" in path or not path.endswith("/"):
-            return redirect(
-                "/" + "".join([f"{p}/" for p in path.split("/") if p])
-            )
-
-        # Render file browser
-        page = DirectoryPage(self._iter_files(location), path, debug)
-        return html(page.render())
-
-    def _prepare_file(self, path: Path) -> Dict[str, Union[int, str]]:
-        stat = path.stat()
-        modified = (
-            datetime.fromtimestamp(stat.st_mtime)
-            .isoformat()[:19]
-            .replace("T", " ")
-        )
-        is_dir = S_ISDIR(stat.st_mode)
-        icon = "📁" if is_dir else "📄"
-        file_name = path.name
-        if is_dir:
-            file_name += "/"
-        return {
-            "priority": is_dir * -1,
-            "file_name": file_name,
-            "icon": icon,
-            "file_access": modified,
-            "file_size": stat.st_size,
-        }
-
-    def _iter_files(self, location: Path) -> Iterable[FileInfo]:
-        prepared = [self._prepare_file(f) for f in location.iterdir()]
-        for item in sorted(prepared, key=itemgetter("priority", "file_name")):
-            del item["priority"]
-            yield cast(FileInfo, item)
--- a/sanic/handlers/error.py
+++ b/sanic/handlers/error.py
@@ -1,190 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, List, Optional, Tuple, Type
-
-from sanic.errorpages import BaseRenderer, TextRenderer, exception_response
-from sanic.exceptions import ServerError
-from sanic.log import error_logger
-from sanic.models.handler_types import RouteHandler
-from sanic.request.types import Request
-from sanic.response import text
-from sanic.response.types import HTTPResponse
-
-
-class ErrorHandler:
-    """
-    Provide :class:`sanic.app.Sanic` application with a mechanism to handle
-    and process any and all uncaught exceptions in a way the application
-    developer will set fit.
-
-    This error handling framework is built into the core that can be extended
-    by the developers to perform a wide range of tasks from recording the error
-    stats to reporting them to an external service that can be used for
-    realtime alerting system.
-    """
-
-    def __init__(
-        self,
-        base: Type[BaseRenderer] = TextRenderer,
-    ):
-        self.cached_handlers: Dict[
-            Tuple[Type[BaseException], Optional[str]], Optional[RouteHandler]
-        ] = {}
-        self.debug = False
-        self.base = base
-
-    def _full_lookup(self, exception, route_name: Optional[str] = None):
-        return self.lookup(exception, route_name)
-
-    def _add(
-        self,
-        key: Tuple[Type[BaseException], Optional[str]],
-        handler: RouteHandler,
-    ) -> None:
-        if key in self.cached_handlers:
-            exc, name = key
-            if name is None:
-                name = "__ALL_ROUTES__"
-
-            message = (
-                f"Duplicate exception handler definition on: route={name} "
-                f"and exception={exc}"
-            )
-            raise ServerError(message)
-        self.cached_handlers[key] = handler
-
-    def add(self, exception, handler, route_names: Optional[List[str]] = None):
-        """
-        Add a new exception handler to an already existing handler object.
-
-        :param exception: Type of exception that need to be handled
-        :param handler: Reference to the method that will handle the exception
-
-        :type exception: :class:`sanic.exceptions.SanicException` or
-            :class:`Exception`
-        :type handler: ``function``
-
-        :return: None
-        """
-        if route_names:
-            for route in route_names:
-                self._add((exception, route), handler)
-        else:
-            self._add((exception, None), handler)
-
-    def lookup(self, exception, route_name: Optional[str] = None):
-        """
-        Lookup the existing instance of :class:`ErrorHandler` and fetch the
-        registered handler for a specific type of exception.
-
-        This method leverages a dict lookup to speedup the retrieval process.
-
-        :param exception: Type of exception
-
-        :type exception: :class:`sanic.exceptions.SanicException` or
-            :class:`Exception`
-
-        :return: Registered function if found ``None`` otherwise
-        """
-        exception_class = type(exception)
-
-        for name in (route_name, None):
-            exception_key = (exception_class, name)
-            handler = self.cached_handlers.get(exception_key)
-            if handler:
-                return handler
-
-        for name in (route_name, None):
-            for ancestor in type.mro(exception_class):
-                exception_key = (ancestor, name)
-                if exception_key in self.cached_handlers:
-                    handler = self.cached_handlers[exception_key]
-                    self.cached_handlers[
-                        (exception_class, route_name)
-                    ] = handler
-                    return handler
-
-                if ancestor is BaseException:
-                    break
-        self.cached_handlers[(exception_class, route_name)] = None
-        handler = None
-        return handler
-
-    _lookup = _full_lookup
-
-    def response(self, request, exception):
-        """Fetches and executes an exception handler and returns a response
-        object
-
-        :param request: Instance of :class:`sanic.request.Request`
-        :param exception: Exception to handle
-
-        :type request: :class:`sanic.request.Request`
-        :type exception: :class:`sanic.exceptions.SanicException` or
-            :class:`Exception`
-
-        :return: Wrap the return value obtained from :func:`default`
-            or registered handler for that type of exception.
-        """
-        route_name = request.name if request else None
-        handler = self._lookup(exception, route_name)
-        response = None
-        try:
-            if handler:
-                response = handler(request, exception)
-            if response is None:
-                response = self.default(request, exception)
-        except Exception:
-            try:
-                url = repr(request.url)
-            except AttributeError:  # no cov
-                url = "unknown"
-            response_message = (
-                "Exception raised in exception handler " '"%s" for uri: %s'
-            )
-            error_logger.exception(response_message, handler.__name__, url)
-
-            if self.debug:
-                return text(response_message % (handler.__name__, url), 500)
-            else:
-                return text("An error occurred while handling an error", 500)
-        return response
-
-    def default(self, request: Request, exception: Exception) -> HTTPResponse:
-        """
-        Provide a default behavior for the objects of :class:`ErrorHandler`.
-        If a developer chooses to extent the :class:`ErrorHandler` they can
-        provide a custom implementation for this method to behave in a way
-        they see fit.
-
-        :param request: Incoming request
-        :param exception: Exception object
-
-        :type request: :class:`sanic.request.Request`
-        :type exception: :class:`sanic.exceptions.SanicException` or
-            :class:`Exception`
-        :return:
-        """
-        self.log(request, exception)
-        fallback = request.app.config.FALLBACK_ERROR_FORMAT
-        return exception_response(
-            request,
-            exception,
-            debug=self.debug,
-            base=self.base,
-            fallback=fallback,
-        )
-
-    @staticmethod
-    def log(request, exception):
-        quiet = getattr(exception, "quiet", False)
-        noisy = getattr(request.app.config, "NOISY_EXCEPTIONS", False)
-        if quiet is False or noisy is True:
-            try:
-                url = repr(request.url)
-            except AttributeError:  # no cov
-                url = "unknown"
-
-            error_logger.exception(
-                "Exception occurred while handling uri: %s", url
-            )
--- a/sanic/headers.py
+++ b/sanic/headers.py
@@ -19,6 +19,7 @@ OptionsIterable = Iterable[Tuple[str, str]]  # May contain duplicate keys

 _token, _quoted = r"([\w!#$%&'*+\-.^_`|~]+)", r'"([^"]*)"'
 _param = re.compile(rf";\s*{_token}=(?:{_token}|{_quoted})", re.ASCII)
+_firefox_quote_escape = re.compile(r'\\"(?!; |\s*$)')
 _ipv6 = "(?:[0-9A-Fa-f]{0,4}:){2,7}[0-9A-Fa-f]{0,4}"
 _ipv6_re = re.compile(_ipv6)
 _host_re = re.compile(
@@ -32,96 +33,143 @@ _host_re = re.compile(
 # For more information, consult ../tests/test_requests.py


-class MediaType:
-    """A media type, as used in the Accept header."""
+def parse_arg_as_accept(f):
+    def func(self, other, *args, **kwargs):
+        if not isinstance(other, Accept) and other:
+            other = Accept.parse(other)
+        return f(self, other, *args, **kwargs)
+
+    return func
+
+
+class MediaType(str):
+    def __new__(cls, value: str):
+        return str.__new__(cls, value)
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+        self.is_wildcard = self.check_if_wildcard(value)
+
+    def __eq__(self, other):
+        if self.is_wildcard:
+            return True
+
+        if self.match(other):
+            return True
+
+        other_is_wildcard = (
+            other.is_wildcard
+            if isinstance(other, MediaType)
+            else self.check_if_wildcard(other)
+        )
+
+        return other_is_wildcard
+
+    def match(self, other):
+        other_value = other.value if isinstance(other, MediaType) else other
+        return self.value == other_value
+
+    @staticmethod
+    def check_if_wildcard(value):
+        return value == "*"
+
+
+class Accept(str):
+    def __new__(cls, value: str, *args, **kwargs):
+        return str.__new__(cls, value)

    def __init__(
        self,
-        type_: str,
-        subtype: str,
-        **params: str,
+        value: str,
+        type_: MediaType,
+        subtype: MediaType,
+        *,
+        q: str = "1.0",
+        **kwargs: str,
    ):
-        self.type = type_
+        qvalue = float(q)
+        if qvalue > 1 or qvalue < 0:
+            raise InvalidHeader(
+                f"Accept header qvalue must be between 0 and 1, not: {qvalue}"
+            )
+        self.value = value
+        self.type_ = type_
        self.subtype = subtype
-        self.q = float(params.get("q", "1.0"))
-        self.params = params
-        self.mime = f"{type_}/{subtype}"
-        self.key = (
-            -1 * self.q,
-            -1 * len(self.params),
-            self.subtype == "*",
-            self.type == "*",
-        )
+        self.qvalue = qvalue
+        self.params = kwargs

-    def __repr__(self):
-        return self.mime + "".join(f";{k}={v}" for k, v in self.params.items())
+    def _compare(self, other, method):
+        try:
+            return method(self.qvalue, other.qvalue)
+        except (AttributeError, TypeError):
+            return NotImplemented

-    def __eq__(self, other):
-        """Check for mime (str or MediaType) identical type/subtype.
-        Parameters such as q are not considered."""
-        if isinstance(other, str):
-            # Give a friendly reminder if str contains parameters
-            if ";" in other:
-                raise ValueError("Use match() to compare with parameters")
-            return self.mime == other
-        if isinstance(other, MediaType):
-            # Ignore parameters silently with MediaType objects
-            return self.mime == other.mime
-        return NotImplemented
+    @parse_arg_as_accept
+    def __lt__(self, other: Union[str, Accept]):
+        return self._compare(other, lambda s, o: s < o)

+    @parse_arg_as_accept
+    def __le__(self, other: Union[str, Accept]):
+        return self._compare(other, lambda s, o: s <= o)
+
+    @parse_arg_as_accept
+    def __eq__(self, other: Union[str, Accept]):  # type: ignore
+        return self._compare(other, lambda s, o: s == o)
+
+    @parse_arg_as_accept
+    def __ge__(self, other: Union[str, Accept]):
+        return self._compare(other, lambda s, o: s >= o)
+
+    @parse_arg_as_accept
+    def __gt__(self, other: Union[str, Accept]):
+        return self._compare(other, lambda s, o: s > o)
+
+    @parse_arg_as_accept
+    def __ne__(self, other: Union[str, Accept]):  # type: ignore
+        return self._compare(other, lambda s, o: s != o)
+
+    @parse_arg_as_accept
    def match(
        self,
-        mime_with_params: Union[str, MediaType],
-    ) -> Optional[MediaType]:
-        """Check if this media type matches the given mime type/subtype.
-        Wildcards are supported both ways on both type and subtype.
-        If mime contains a semicolon, optionally followed by parameters,
-        the parameters of the two media types must match exactly.
-        Note:  Use the `==` operator instead to check for literal matches
-        without expanding wildcards.
-        @param media_type: A type/subtype string to match.
-        @return `self` if the media types are compatible, else `None`
-        """
-        mt = (
-            MediaType._parse(mime_with_params)
-            if isinstance(mime_with_params, str)
-            else mime_with_params
-        )
-        return (
-            self
-            if (
-                mt
-                # All parameters given in the other media type must match
-                and all(self.params.get(k) == v for k, v in mt.params.items())
-                # Subtype match
-                and (
-                    self.subtype == mt.subtype
-                    or self.subtype == "*"
-                    or mt.subtype == "*"
-                )
-                # Type match
-                and (
-                    self.type == mt.type or self.type == "*" or mt.type == "*"
-                )
+        other,
+        *,
+        allow_type_wildcard: bool = True,
+        allow_subtype_wildcard: bool = True,
+    ) -> bool:
+        type_match = (
+            self.type_ == other.type_
+            if allow_type_wildcard
+            else (
+                self.type_.match(other.type_)
+                and not self.type_.is_wildcard
+                and not other.type_.is_wildcard
+            )
+        )
+        subtype_match = (
+            self.subtype == other.subtype
+            if allow_subtype_wildcard
+            else (
+                self.subtype.match(other.subtype)
+                and not self.subtype.is_wildcard
+                and not other.subtype.is_wildcard
            )
-            else None
        )

-    @property
-    def has_wildcard(self) -> bool:
-        """Return True if this media type has a wildcard in it."""
-        return any(part == "*" for part in (self.subtype, self.type))
+        return type_match and subtype_match

    @classmethod
-    def _parse(cls, mime_with_params: str) -> Optional[MediaType]:
-        mtype = mime_with_params.strip()
-        if "/" not in mime_with_params:
-            return None
+    def parse(cls, raw: str) -> Accept:
+        invalid = False
+        mtype = raw.strip()

-        mime, *raw_params = mtype.split(";")
-        type_, subtype = mime.split("/", 1)
-        if not type_ or not subtype:
-            raise ValueError(f"Invalid media type: {mtype}")
+        try:
+            media, *raw_params = mtype.split(";")
+            type_, subtype = media.split("/")
+        except ValueError:
+            invalid = True
+
+        if invalid or not type_ or not subtype:
+            raise InvalidHeader(f"Header contains invalid Accept value: {raw}")

        params = dict(
            [
@@ -130,160 +178,46 @@ class MediaType:
            ]
        )

-        return cls(type_.lstrip(), subtype.rstrip(), **params)
+        return cls(mtype, MediaType(type_), MediaType(subtype), **params)


-class Matched:
-    """A matching result of a MIME string against a header."""
+class AcceptContainer(list):
+    def __contains__(self, o: object) -> bool:
+        return any(item.match(o) for item in self)

-    def __init__(self, mime: str, header: Optional[MediaType]):
-        self.mime = mime
-        self.header = header
-
-    def __repr__(self):
-        return f"<{self} matched {self.header}>" if self else "<no match>"
-
-    def __str__(self):
-        return self.mime
-
-    def __bool__(self):
-        return self.header is not None
-
-    def __eq__(self, other: Any) -> bool:
-        try:
-            comp, other_accept = self._compare(other)
-        except TypeError:
-            return False
-
-        return bool(
-            comp
-            and (
-                (self.header and other_accept.header)
-                or (not self.header and not other_accept.header)
+    def match(
+        self,
+        o: object,
+        *,
+        allow_type_wildcard: bool = True,
+        allow_subtype_wildcard: bool = True,
+    ) -> bool:
+        return any(
+            item.match(
+                o,
+                allow_type_wildcard=allow_type_wildcard,
+                allow_subtype_wildcard=allow_subtype_wildcard,
            )
+            for item in self
        )

-    def _compare(self, other) -> Tuple[bool, Matched]:
-        if isinstance(other, str):
-            parsed = Matched.parse(other)
-            if self.mime == other:
-                return True, parsed
-            other = parsed
-
-        if isinstance(other, Matched):
-            return self.header == other.header, other
-
-        raise TypeError(
-            "Comparison not supported between unequal "
-            f"mime types of '{self.mime}' and '{other}'"
-        )
-
-    def match(self, other: Union[str, Matched]) -> Optional[Matched]:
-        accept = Matched.parse(other) if isinstance(other, str) else other
-        if not self.header or not accept.header:
-            return None
-        if self.header.match(accept.header):
-            return accept
-        return None
-
-    @classmethod
-    def parse(cls, raw: str) -> Matched:
-        media_type = MediaType._parse(raw)
-        return cls(raw, media_type)
-
-
-class AcceptList(list):
-    """A list of media types, as used in the Accept header.
-
-    The Accept header entries are listed in order of preference, starting
-    with the most preferred. This class is a list of `MediaType` objects,
-    that encapsulate also the q value or any other parameters.
-
-    Two separate methods are provided for searching the list:
-    - 'match' for finding the most preferred match (wildcards supported)
-    -  operator 'in' for checking explicit matches (wildcards as literals)
-    """
-
-    def match(self, *mimes: str, accept_wildcards=True) -> Matched:
-        """Find a media type accepted by the client.
-
-        This method can be used to find which of the media types requested by
-        the client is most preferred against the ones given as arguments.
-
-        The ordering of preference is set by:
-        1. The order set by RFC 7231, s. 5.3.2, giving a higher priority
-            to q values and more specific type definitions,
-        2. The order of the arguments (first is most preferred), and
-        3. The first matching entry on the Accept header.
-
-        Wildcards are matched both ways. A match is usually found, as the
-        Accept headers typically include `*/*`, in particular if the header
-        is missing, is not manually set, or if the client is a browser.
-
-        Note: the returned object behaves as a string of the mime argument
-        that matched, and is empty/falsy if no match was found. The matched
-        header entry `MediaType` or `None` is available as the `m` attribute.
-
-        @param mimes: Any MIME types to search for in order of preference.
-        @param accept_wildcards: Match Accept entries with wildcards in them.
-        @return A match object with the mime string and the MediaType object.
-        """
-        a = sorted(
-            (-acc.q, i, j, mime, acc)
-            for j, acc in enumerate(self)
-            if accept_wildcards or not acc.has_wildcard
-            for i, mime in enumerate(mimes)
-            if acc.match(mime)
-        )
-        return Matched(*(a[0][-2:] if a else ("", None)))
-
-    def __str__(self):
-        """Format as Accept header value (parsed, not original)."""
-        return ", ".join(str(m) for m in self)
-
-
-def parse_accept(accept: Optional[str]) -> AcceptList:
-    """Parse an Accept header and order the acceptable media types in
-    according to RFC 7231, s. 5.3.2
-    https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
-    """
-    if not accept:
-        if accept == "":
-            return AcceptList()  # Empty header, accept nothing
-        accept = "*/*"  # No header means that all types are accepted
-    try:
-        a = [
-            mt
-            for mt in [MediaType._parse(mtype) for mtype in accept.split(",")]
-            if mt
-        ]
-        if not a:
-            raise ValueError
-        return AcceptList(sorted(a, key=lambda x: x.key))
-    except ValueError:
-        raise InvalidHeader(f"Invalid header value in Accept: {accept}")
-

 def parse_content_header(value: str) -> Tuple[str, Options]:
    """Parse content-type and content-disposition header values.

-    E.g. `form-data; name=upload; filename="file.txt"` to
+    E.g. 'form-data; name=upload; filename=\"file.txt\"' to
    ('form-data', {'name': 'upload', 'filename': 'file.txt'})

    Mostly identical to cgi.parse_header and werkzeug.parse_options_header
-    but runs faster and handles special characters better.
-
-    Unescapes %22 to `"` and %0D%0A to `\n` in field values.
+    but runs faster and handles special characters better. Unescapes quotes.
    """
+    value = _firefox_quote_escape.sub("%22", value)
    pos = value.find(";")
    if pos == -1:
        options: Dict[str, Union[int, str]] = {}
    else:
        options = {
-            m.group(1)
-            .lower(): (m.group(2) or m.group(3))
-            .replace("%22", '"')
-            .replace("%0D%0A", "\n")
+            m.group(1).lower(): m.group(2) or m.group(3).replace("%22", '"')
            for m in _param.finditer(value[pos:])
        }
        value = value[:pos]
@@ -434,9 +368,37 @@ def format_http1_response(status: int, headers: HeaderBytesIterable) -> bytes:
    return ret


+def _sort_accept_value(accept: Accept):
+    return (
+        accept.qvalue,
+        len(accept.params),
+        accept.subtype != "*",
+        accept.type_ != "*",
+    )
+
+
+def parse_accept(accept: str) -> AcceptContainer:
+    """Parse an Accept header and order the acceptable media types in
+    accorsing to RFC 7231, s. 5.3.2
+    https://datatracker.ietf.org/doc/html/rfc7231#section-5.3.2
+    """
+    media_types = accept.split(",")
+    accept_list: List[Accept] = []
+
+    for mtype in media_types:
+        if not mtype:
+            continue
+
+        accept_list.append(Accept.parse(mtype))
+
+    return AcceptContainer(
+        sorted(accept_list, key=_sort_accept_value, reverse=True)
+    )
+
+
 def parse_credentials(
    header: Optional[str],
-    prefixes: Optional[Union[List, Tuple, Set]] = None,
+    prefixes: Union[List, Tuple, Set] = None,
 ) -> Tuple[Optional[str], Optional[str]]:
    """Parses any header with the aim to retrieve any credentials from it."""
    if not prefixes or not isinstance(prefixes, (list, tuple, set)):
--- a/sanic/helpers.py
+++ b/sanic/helpers.py
@@ -1,7 +1,5 @@
 """Defines basics of HTTP standard."""

-import sys
-
 from importlib import import_module
 from inspect import ismodule
 from typing import Dict
@@ -159,10 +157,6 @@ def import_string(module_name, package=None):
    return obj()


-def is_atty() -> bool:
-    return bool(sys.stdout and sys.stdout.isatty())
-
-
 class Default:
    """
    It is used to replace `None` or `object()` as a sentinel
--- a/sanic/http/http1.py
+++ b/sanic/http/http1.py
@@ -3,53 +3,71 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Optional


-if TYPE_CHECKING:
+if TYPE_CHECKING:  # no cov
    from sanic.request import Request
    from sanic.response import BaseHTTPResponse

 from asyncio import CancelledError, sleep
+from enum import Enum

 from sanic.compat import Header
 from sanic.exceptions import (
-    BadRequest,
-    ExpectationFailed,
+    HeaderExpectationFailed,
+    InvalidUsage,
    PayloadTooLarge,
-    RequestCancelled,
    ServerError,
    ServiceUnavailable,
 )
 from sanic.headers import format_http1_response
 from sanic.helpers import has_message_body
-from sanic.http.constants import Stage
-from sanic.http.stream import Stream
 from sanic.log import access_logger, error_logger, logger
 from sanic.touchup import TouchUpMeta


+class Stage(Enum):
+    """
+    Enum for representing the stage of the request/response cycle
+
+    | ``IDLE``  Waiting for request
+    | ``REQUEST``  Request headers being received
+    | ``HANDLER``  Headers done, handler running
+    | ``RESPONSE``  Response headers sent, body in progress
+    | ``FAILED``  Unrecoverable state (error while sending response)
+    |
+    """
+
+    IDLE = 0  # Waiting for request
+    REQUEST = 1  # Request headers being received
+    HANDLER = 3  # Headers done, handler running
+    RESPONSE = 4  # Response headers sent, body in progress
+    FAILED = 100  # Unrecoverable state (error while sending response)
+
+
 HTTP_CONTINUE = b"HTTP/1.1 100 Continue\r\n\r\n"


-class Http(Stream, metaclass=TouchUpMeta):
+class Http(metaclass=TouchUpMeta):
    """
-    Internal helper for managing the HTTP/1.1 request/response cycle
+    Internal helper for managing the HTTP request/response cycle

    :raises ServerError:
    :raises PayloadTooLarge:
    :raises Exception:
-    :raises BadRequest:
-    :raises ExpectationFailed:
+    :raises InvalidUsage:
+    :raises HeaderExpectationFailed:
    :raises RuntimeError:
    :raises ServerError:
    :raises ServerError:
-    :raises BadRequest:
-    :raises BadRequest:
-    :raises BadRequest:
+    :raises InvalidUsage:
+    :raises InvalidUsage:
+    :raises InvalidUsage:
    :raises PayloadTooLarge:
    :raises RuntimeError:
    """

    HEADER_CEILING = 16_384
    HEADER_MAX_SIZE = 0
+
    __touchup__ = (
        "http1_request_header",
        "http1_response_header",
@@ -71,6 +89,7 @@ class Http(Stream, metaclass=TouchUpMeta):
        "request_body",
        "request_bytes",
        "request_bytes_left",
+        "request_max_size",
        "response",
        "response_func",
        "response_size",
@@ -132,7 +151,7 @@ class Http(Stream, metaclass=TouchUpMeta):

                if self.stage is Stage.RESPONSE:
                    await self.response.send(end_stream=True)
-            except CancelledError as exc:
+            except CancelledError:
                # Write an appropriate response before exiting
                if not self.protocol.transport:
                    logger.info(
@@ -140,11 +159,7 @@ class Http(Stream, metaclass=TouchUpMeta):
                        "stopped. Transport is closed."
                    )
                    return
-                e = (
-                    RequestCancelled()
-                    if self.protocol.conn_info.lost
-                    else (self.exception or exc)
-                )
+                e = self.exception or ServiceUnavailable("Cancelled")
                self.exception = None
                self.keep_alive = False
                await self.error_response(e)
@@ -233,21 +248,16 @@ class Http(Stream, metaclass=TouchUpMeta):

                headers.append(h)
        except Exception:
-            raise BadRequest("Bad Request")
+            raise InvalidUsage("Bad Request")

        headers_instance = Header(headers)
        self.upgrade_websocket = (
            headers_instance.getone("upgrade", "").lower() == "websocket"
        )

-        try:
-            url_bytes = self.url.encode("ASCII")
-        except UnicodeEncodeError:
-            raise BadRequest("URL may only contain US-ASCII characters.")
-
        # Prepare a Request object
        request = self.protocol.request_class(
-            url_bytes=url_bytes,
+            url_bytes=self.url.encode(),
            headers=headers_instance,
            head=bytes(head),
            version=protocol[5:],
@@ -255,7 +265,6 @@ class Http(Stream, metaclass=TouchUpMeta):
            transport=self.protocol.transport,
            app=self.protocol.app,
        )
-        self.protocol.request_class._current.set(request)
        await self.dispatch(
            "http.lifecycle.request",
            inline=True,
@@ -272,7 +281,7 @@ class Http(Stream, metaclass=TouchUpMeta):
                if expect.lower() == "100-continue":
                    self.expecting_continue = True
                else:
-                    raise ExpectationFailed(f"Unknown Expect: {expect}")
+                    raise HeaderExpectationFailed(f"Unknown Expect: {expect}")

            if headers.getone("transfer-encoding", None) == "chunked":
                self.request_body = "chunked"
@@ -343,12 +352,6 @@ class Http(Stream, metaclass=TouchUpMeta):
            self.response_func = self.head_response_ignored

        headers["connection"] = "keep-alive" if self.keep_alive else "close"
-
-        # This header may be removed or modified by the AltSvcCheck Touchup
-        # service. At server start, we either remove this header from ever
-        # being assigned, or we change the value as required.
-        headers["alt-svc"] = ""
-
        ret = format_http1_response(status, res.processed_headers)
        if data:
            ret += data
@@ -433,15 +436,7 @@ class Http(Stream, metaclass=TouchUpMeta):
            if self.request is None:
                self.create_empty_request()

-            request_middleware = not isinstance(
-                exception, (ServiceUnavailable, RequestCancelled)
-            )
-            try:
-                await app.handle_exception(
-                    self.request, exception, request_middleware
-                )
-            except Exception as e:
-                await app.handle_exception(self.request, e, False)
+            await app.handle_exception(self.request, exception)

    def create_empty_request(self) -> None:
        """
@@ -450,18 +445,9 @@ class Http(Stream, metaclass=TouchUpMeta):
        bogus response for error handling use.
        """

-        # Reformat any URL already received with \xHH escapes for better logs
-        url_bytes = (
-            self.url.encode(errors="surrogateescape")
-            .decode("ASCII", errors="backslashreplace")
-            .encode("ASCII")
-            if self.url
-            else b"*"
-        )
-
        # FIXME: Avoid this by refactoring error handling and response code
        self.request = self.protocol.request_class(
-            url_bytes=url_bytes,
+            url_bytes=self.url.encode() if self.url else b"*",
            headers=Header({}),
            version="1.1",
            method="NONE",
@@ -524,7 +510,7 @@ class Http(Stream, metaclass=TouchUpMeta):

                if len(buf) > 64:
                    self.keep_alive = False
-                    raise BadRequest("Bad chunked encoding")
+                    raise InvalidUsage("Bad chunked encoding")

                await self._receive_more()

@@ -532,14 +518,14 @@ class Http(Stream, metaclass=TouchUpMeta):
                size = int(buf[2:pos].split(b";", 1)[0].decode(), 16)
            except Exception:
                self.keep_alive = False
-                raise BadRequest("Bad chunked encoding")
+                raise InvalidUsage("Bad chunked encoding")

            if size <= 0:
                self.request_body = None

                if size < 0:
                    self.keep_alive = False
-                    raise BadRequest("Bad chunked encoding")
+                    raise InvalidUsage("Bad chunked encoding")

                # Consume CRLF, chunk size 0 and the two CRLF that follow
                pos += 4
--- a/sanic/http/init.py
+++ b/sanic/http/init.py
@@ -1,6 +0,0 @@
-from .constants import Stage
-from .http1 import Http
-from .http3 import Http3
-
-
-__all__ = ("Http", "Stage", "Http3")
--- a/sanic/http/constants.py
+++ b/sanic/http/constants.py
@@ -1,29 +0,0 @@
-from enum import Enum, IntEnum
-
-
-class Stage(Enum):
-    """
-    Enum for representing the stage of the request/response cycle
-
-    | ``IDLE``  Waiting for request
-    | ``REQUEST``  Request headers being received
-    | ``HANDLER``  Headers done, handler running
-    | ``RESPONSE``  Response headers sent, body in progress
-    | ``FAILED``  Unrecoverable state (error while sending response)
-    |
-    """
-
-    IDLE = 0  # Waiting for request
-    REQUEST = 1  # Request headers being received
-    HANDLER = 3  # Headers done, handler running
-    RESPONSE = 4  # Response headers sent, body in progress
-    FAILED = 100  # Unrecoverable state (error while sending response)
-
-
-class HTTP(IntEnum):
-    VERSION_1 = 1
-    VERSION_3 = 3
-
-    def display(self) -> str:
-        value = 1.1 if self.value == 1 else self.value
-        return f"HTTP/{value}"
--- a/sanic/http/http3.py
+++ b/sanic/http/http3.py
@@ -1,426 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-
-from abc import ABC, abstractmethod
-from ssl import SSLContext
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Union,
-    cast,
-)
-
-from sanic.compat import Header
-from sanic.constants import LocalCertCreator
-from sanic.exceptions import (
-    BadRequest,
-    PayloadTooLarge,
-    SanicException,
-    ServerError,
-)
-from sanic.helpers import has_message_body
-from sanic.http.constants import Stage
-from sanic.http.stream import Stream
-from sanic.http.tls.context import CertSelector, SanicSSLContext
-from sanic.log import Colors, logger
-from sanic.models.protocol_types import TransportProtocol
-from sanic.models.server_types import ConnInfo
-
-
-try:
-    from aioquic.h0.connection import H0_ALPN, H0Connection
-    from aioquic.h3.connection import H3_ALPN, H3Connection
-    from aioquic.h3.events import (
-        DatagramReceived,
-        DataReceived,
-        H3Event,
-        HeadersReceived,
-        WebTransportStreamDataReceived,
-    )
-    from aioquic.quic.configuration import QuicConfiguration
-    from aioquic.tls import SessionTicket
-
-    HTTP3_AVAILABLE = True
-except ModuleNotFoundError:  # no cov
-    HTTP3_AVAILABLE = False
-
-if TYPE_CHECKING:
-    from sanic import Sanic
-    from sanic.request import Request
-    from sanic.response import BaseHTTPResponse
-    from sanic.server.protocols.http_protocol import Http3Protocol
-
-    HttpConnection = Union[H0Connection, H3Connection]
-
-
-class HTTP3Transport(TransportProtocol):
-    __slots__ = ("_protocol",)
-
-    def __init__(self, protocol: Http3Protocol):
-        self._protocol = protocol
-
-    def get_protocol(self) -> Http3Protocol:
-        return self._protocol
-
-    def get_extra_info(self, info: str, default: Any = None) -> Any:
-        if (
-            info in ("socket", "sockname", "peername")
-            and self._protocol._transport
-        ):
-            return self._protocol._transport.get_extra_info(info, default)
-        elif info == "network_paths":
-            return self._protocol._quic._network_paths
-        elif info == "ssl_context":
-            return self._protocol.app.state.ssl
-        return default
-
-
-class Receiver(ABC):
-    future: asyncio.Future
-
-    def __init__(self, transmit, protocol, request: Request) -> None:
-        self.transmit = transmit
-        self.protocol = protocol
-        self.request = request
-
-    @abstractmethod
-    async def run(self):  # no cov
-        ...
-
-
-class HTTPReceiver(Receiver, Stream):
-    stage: Stage
-    request: Request
-
-    def __init__(self, *args, **kwargs) -> None:
-        super().__init__(*args, **kwargs)
-        self.request_body = None
-        self.stage = Stage.IDLE
-        self.headers_sent = False
-        self.response: Optional[BaseHTTPResponse] = None
-        self.request_max_size = self.protocol.request_max_size
-        self.request_bytes = 0
-
-    async def run(self, exception: Optional[Exception] = None):
-        self.stage = Stage.HANDLER
-        self.head_only = self.request.method.upper() == "HEAD"
-
-        if exception:
-            logger.info(  # no cov
-                f"{Colors.BLUE}[exception]: "
-                f"{Colors.RED}{exception}{Colors.END}",
-                exc_info=True,
-                extra={"verbosity": 1},
-            )
-            await self.error_response(exception)
-        else:
-            try:
-                logger.info(  # no cov
-                    f"{Colors.BLUE}[request]:{Colors.END} {self.request}",
-                    extra={"verbosity": 1},
-                )
-                await self.protocol.request_handler(self.request)
-            except Exception as e:  # no cov
-                # This should largely be handled within the request handler.
-                # But, just in case...
-                await self.run(e)
-        self.stage = Stage.IDLE
-
-    async def error_response(self, exception: Exception) -> None:
-        """
-        Handle response when exception encountered
-        """
-        # From request and handler states we can respond, otherwise be silent
-        app = self.protocol.app
-
-        await app.handle_exception(self.request, exception)
-
-    def _prepare_headers(
-        self, response: BaseHTTPResponse
-    ) -> List[Tuple[bytes, bytes]]:
-        size = len(response.body) if response.body else 0
-        headers = response.headers
-        status = response.status
-
-        if not has_message_body(status) and (
-            size
-            or "content-length" in headers
-            or "transfer-encoding" in headers
-        ):
-            headers.pop("content-length", None)
-            headers.pop("transfer-encoding", None)
-            logger.warning(  # no cov
-                f"Message body set in response on {self.request.path}. "
-                f"A {status} response may only have headers, no body."
-            )
-        elif "content-length" not in headers:
-            if size:
-                headers["content-length"] = size
-            else:
-                headers["transfer-encoding"] = "chunked"
-
-        headers = [
-            (b":status", str(response.status).encode()),
-            *response.processed_headers,
-        ]
-        return headers
-
-    def send_headers(self) -> None:
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[send]: {Colors.GREEN}HEADERS{Colors.END}",
-            extra={"verbosity": 2},
-        )
-        if not self.response:
-            raise RuntimeError("no response")
-
-        response = self.response
-        headers = self._prepare_headers(response)
-
-        self.protocol.connection.send_headers(
-            stream_id=self.request.stream_id,
-            headers=headers,
-        )
-        self.headers_sent = True
-        self.stage = Stage.RESPONSE
-
-        if self.response.body and not self.head_only:
-            self._send(self.response.body, False)
-        elif self.head_only:
-            self.future.cancel()
-
-    def respond(self, response: BaseHTTPResponse) -> BaseHTTPResponse:
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[respond]:{Colors.END} {response}",
-            extra={"verbosity": 2},
-        )
-
-        if self.stage is not Stage.HANDLER:
-            self.stage = Stage.FAILED
-            raise RuntimeError("Response already started")
-
-        # Disconnect any earlier but unused response object
-        if self.response is not None:
-            self.response.stream = None
-
-        self.response, response.stream = response, self
-
-        return response
-
-    def receive_body(self, data: bytes) -> None:
-        self.request_bytes += len(data)
-        if self.request_bytes > self.request_max_size:
-            raise PayloadTooLarge("Request body exceeds the size limit")
-
-        self.request.body += data
-
-    async def send(self, data: bytes, end_stream: bool) -> None:
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[send]: {Colors.GREEN}data={data.decode()} "
-            f"end_stream={end_stream}{Colors.END}",
-            extra={"verbosity": 2},
-        )
-        self._send(data, end_stream)
-
-    def _send(self, data: bytes, end_stream: bool) -> None:
-        if not self.headers_sent:
-            self.send_headers()
-        if self.stage is not Stage.RESPONSE:
-            raise ServerError(f"not ready to send: {self.stage}")
-
-        # Chunked
-        if (
-            self.response
-            and self.response.headers.get("transfer-encoding") == "chunked"
-        ):
-            size = len(data)
-            if end_stream:
-                data = (
-                    b"%x\r\n%b\r\n0\r\n\r\n" % (size, data)
-                    if size
-                    else b"0\r\n\r\n"
-                )
-            elif size:
-                data = b"%x\r\n%b\r\n" % (size, data)
-
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[transmitting]{Colors.END}",
-            extra={"verbosity": 2},
-        )
-        self.protocol.connection.send_data(
-            stream_id=self.request.stream_id,
-            data=data,
-            end_stream=end_stream,
-        )
-        self.transmit()
-
-        if end_stream:
-            self.stage = Stage.IDLE
-
-
-class WebsocketReceiver(Receiver):  # noqa
-    async def run(self):
-        ...
-
-
-class WebTransportReceiver(Receiver):  # noqa
-    async def run(self):
-        ...
-
-
-class Http3:
-    """
-    Internal helper for managing the HTTP/3 request/response cycle
-    """
-
-    if HTTP3_AVAILABLE:
-        HANDLER_PROPERTY_MAPPING = {
-            DataReceived: "stream_id",
-            HeadersReceived: "stream_id",
-            DatagramReceived: "flow_id",
-            WebTransportStreamDataReceived: "session_id",
-        }
-
-    def __init__(
-        self,
-        protocol: Http3Protocol,
-        transmit: Callable[[], None],
-    ) -> None:
-        self.protocol = protocol
-        self.transmit = transmit
-        self.receivers: Dict[int, Receiver] = {}
-
-    def http_event_received(self, event: H3Event) -> None:
-        logger.debug(  # no cov
-            f"{Colors.BLUE}[http_event_received]: "
-            f"{Colors.YELLOW}{event}{Colors.END}",
-            extra={"verbosity": 2},
-        )
-        receiver, created_new = self.get_or_make_receiver(event)
-        receiver = cast(HTTPReceiver, receiver)
-
-        if isinstance(event, HeadersReceived) and created_new:
-            receiver.future = asyncio.ensure_future(receiver.run())
-        elif isinstance(event, DataReceived):
-            try:
-                receiver.receive_body(event.data)
-            except Exception as e:
-                receiver.future.cancel()
-                receiver.future = asyncio.ensure_future(receiver.run(e))
-        else:
-            ...  # Intentionally here to help out Touchup
-            logger.debug(  # no cov
-                f"{Colors.RED}DOING NOTHING{Colors.END}",
-                extra={"verbosity": 2},
-            )
-
-    def get_or_make_receiver(self, event: H3Event) -> Tuple[Receiver, bool]:
-        if (
-            isinstance(event, HeadersReceived)
-            and event.stream_id not in self.receivers
-        ):
-            request = self._make_request(event)
-            receiver = HTTPReceiver(self.transmit, self.protocol, request)
-            request.stream = receiver
-
-            self.receivers[event.stream_id] = receiver
-            return receiver, True
-        else:
-            ident = getattr(event, self.HANDLER_PROPERTY_MAPPING[type(event)])
-            return self.receivers[ident], False
-
-    def get_receiver_by_stream_id(self, stream_id: int) -> Receiver:
-        return self.receivers[stream_id]
-
-    def _make_request(self, event: HeadersReceived) -> Request:
-        try:
-            headers = Header(
-                (
-                    (k.decode("ASCII"), v.decode(errors="surrogateescape"))
-                    for k, v in event.headers
-                )
-            )
-        except UnicodeDecodeError:
-            raise BadRequest(
-                "Header names may only contain US-ASCII characters."
-            )
-        method = headers[":method"]
-        path = headers[":path"]
-        scheme = headers.pop(":scheme", "")
-        authority = headers.pop(":authority", "")
-
-        if authority:
-            headers["host"] = authority
-
-        try:
-            url_bytes = path.encode("ASCII")
-        except UnicodeEncodeError:
-            raise BadRequest("URL may only contain US-ASCII characters.")
-
-        transport = HTTP3Transport(self.protocol)
-        request = self.protocol.request_class(
-            url_bytes,
-            headers,
-            "3",
-            method,
-            transport,
-            self.protocol.app,
-            b"",
-        )
-        request.conn_info = ConnInfo(transport)
-        request._stream_id = event.stream_id
-        request._scheme = scheme
-
-        return request
-
-
-class SessionTicketStore:
-    """
-    Simple in-memory store for session tickets.
-    """
-
-    def __init__(self) -> None:
-        self.tickets: Dict[bytes, SessionTicket] = {}
-
-    def add(self, ticket: SessionTicket) -> None:
-        self.tickets[ticket.ticket] = ticket
-
-    def pop(self, label: bytes) -> Optional[SessionTicket]:
-        return self.tickets.pop(label, None)
-
-
-def get_config(
-    app: Sanic, ssl: Union[SanicSSLContext, CertSelector, SSLContext]
-):
-    # TODO:
-    # - proper selection needed if service with multiple certs insted of
-    #   just taking the first
-    if isinstance(ssl, CertSelector):
-        ssl = cast(SanicSSLContext, ssl.sanic_select[0])
-    if app.config.LOCAL_CERT_CREATOR is LocalCertCreator.TRUSTME:
-        raise SanicException(
-            "Sorry, you cannot currently use trustme as a local certificate "
-            "generator for an HTTP/3 server. This is not yet supported. You "
-            "should be able to use mkcert instead. For more information, see: "
-            "https://github.com/aiortc/aioquic/issues/295."
-        )
-    if not isinstance(ssl, SanicSSLContext):
-        raise SanicException("SSLContext is not SanicSSLContext")
-
-    config = QuicConfiguration(
-        alpn_protocols=H3_ALPN + H0_ALPN + ["siduck"],
-        is_client=False,
-        max_datagram_frame_size=65536,
-    )
-    password = app.config.TLS_CERT_PASSWORD or None
-
-    config.load_cert_chain(
-        ssl.sanic["cert"], ssl.sanic["key"], password=password
-    )
-
-    return config
--- a/sanic/http/stream.py
+++ b/sanic/http/stream.py
@@ -1,27 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional, Tuple, Union
-
-from sanic.http.constants import Stage
-
-
-if TYPE_CHECKING:
-    from sanic.response import BaseHTTPResponse
-    from sanic.server.protocols.http_protocol import HttpProtocol
-
-
-class Stream:
-    stage: Stage
-    response: Optional[BaseHTTPResponse]
-    protocol: HttpProtocol
-    url: Optional[str]
-    request_body: Optional[bytes]
-    request_max_size: Union[int, float]
-
-    __touchup__: Tuple[str, ...] = tuple()
-    __slots__ = ("request_max_size",)
-
-    def respond(
-        self, response: BaseHTTPResponse
-    ) -> BaseHTTPResponse:  # no cov
-        raise NotImplementedError("Not implemented")
--- a/sanic/http/tls/init.py
+++ b/sanic/http/tls/init.py
@@ -1,5 +0,0 @@
-from .context import process_to_context
-from .creators import get_ssl_context
-
-
-__all__ = ("get_ssl_context", "process_to_context")
--- a/sanic/http/tls/creators.py
+++ b/sanic/http/tls/creators.py
@@ -1,289 +0,0 @@
-from __future__ import annotations
-
-import ssl
-import subprocess
-import sys
-
-from abc import ABC, abstractmethod
-from contextlib import suppress
-from pathlib import Path
-from tempfile import mkdtemp
-from types import ModuleType
-from typing import TYPE_CHECKING, Optional, Tuple, Type, Union, cast
-
-from sanic.application.constants import Mode
-from sanic.application.spinner import loading
-from sanic.constants import (
-    DEFAULT_LOCAL_TLS_CERT,
-    DEFAULT_LOCAL_TLS_KEY,
-    LocalCertCreator,
-)
-from sanic.exceptions import SanicException
-from sanic.helpers import Default
-from sanic.http.tls.context import CertSimple, SanicSSLContext
-
-
-try:
-    import trustme
-
-    TRUSTME_INSTALLED = True
-except (ImportError, ModuleNotFoundError):
-    trustme = ModuleType("trustme")
-    TRUSTME_INSTALLED = False
-
-if TYPE_CHECKING:
-    from sanic import Sanic
-
-
-# Only allow secure ciphers, notably leaving out AES-CBC mode
-# OpenSSL chooses ECDSA or RSA depending on the cert in use
-CIPHERS_TLS12 = [
-    "ECDHE-ECDSA-CHACHA20-POLY1305",
-    "ECDHE-ECDSA-AES256-GCM-SHA384",
-    "ECDHE-ECDSA-AES128-GCM-SHA256",
-    "ECDHE-RSA-CHACHA20-POLY1305",
-    "ECDHE-RSA-AES256-GCM-SHA384",
-    "ECDHE-RSA-AES128-GCM-SHA256",
-]
-
-
-def _make_path(maybe_path: Union[Path, str], tmpdir: Optional[Path]) -> Path:
-    if isinstance(maybe_path, Path):
-        return maybe_path
-    else:
-        path = Path(maybe_path)
-        if not path.exists():
-            if not tmpdir:
-                raise RuntimeError("Reached an unknown state. No tmpdir.")
-            return tmpdir / maybe_path
-
-    return path
-
-
-def get_ssl_context(
-    app: Sanic, ssl: Optional[ssl.SSLContext]
-) -> ssl.SSLContext:
-    if ssl:
-        return ssl
-
-    if app.state.mode is Mode.PRODUCTION:
-        raise SanicException(
-            "Cannot run Sanic as an HTTPS server in PRODUCTION mode "
-            "without passing a TLS certificate. If you are developing "
-            "locally, please enable DEVELOPMENT mode and Sanic will "
-            "generate a localhost TLS certificate. For more information "
-            "please see: https://sanic.dev/en/guide/deployment/development."
-            "html#automatic-tls-certificate."
-        )
-
-    creator = CertCreator.select(
-        app,
-        cast(LocalCertCreator, app.config.LOCAL_CERT_CREATOR),
-        app.config.LOCAL_TLS_KEY,
-        app.config.LOCAL_TLS_CERT,
-    )
-    context = creator.generate_cert(app.config.LOCALHOST)
-    return context
-
-
-class CertCreator(ABC):
-    def __init__(self, app, key, cert) -> None:
-        self.app = app
-        self.key = key
-        self.cert = cert
-        self.tmpdir = None
-
-        if isinstance(self.key, Default) or isinstance(self.cert, Default):
-            self.tmpdir = Path(mkdtemp())
-
-        key = (
-            DEFAULT_LOCAL_TLS_KEY
-            if isinstance(self.key, Default)
-            else self.key
-        )
-        cert = (
-            DEFAULT_LOCAL_TLS_CERT
-            if isinstance(self.cert, Default)
-            else self.cert
-        )
-
-        self.key_path = _make_path(key, self.tmpdir)
-        self.cert_path = _make_path(cert, self.tmpdir)
-
-    @abstractmethod
-    def check_supported(self) -> None:  # no cov
-        ...
-
-    @abstractmethod
-    def generate_cert(self, localhost: str) -> ssl.SSLContext:  # no cov
-        ...
-
-    @classmethod
-    def select(
-        cls,
-        app: Sanic,
-        cert_creator: LocalCertCreator,
-        local_tls_key,
-        local_tls_cert,
-    ) -> CertCreator:
-        creator: Optional[CertCreator] = None
-
-        cert_creator_options: Tuple[
-            Tuple[Type[CertCreator], LocalCertCreator], ...
-        ] = (
-            (MkcertCreator, LocalCertCreator.MKCERT),
-            (TrustmeCreator, LocalCertCreator.TRUSTME),
-        )
-        for creator_class, local_creator in cert_creator_options:
-            creator = cls._try_select(
-                app,
-                creator,
-                creator_class,
-                local_creator,
-                cert_creator,
-                local_tls_key,
-                local_tls_cert,
-            )
-            if creator:
-                break
-
-        if not creator:
-            raise SanicException(
-                "Sanic could not find package to create a TLS certificate. "
-                "You must have either mkcert or trustme installed. See "
-                "https://sanic.dev/en/guide/deployment/development.html"
-                "#automatic-tls-certificate for more details."
-            )
-
-        return creator
-
-    @staticmethod
-    def _try_select(
-        app: Sanic,
-        creator: Optional[CertCreator],
-        creator_class: Type[CertCreator],
-        creator_requirement: LocalCertCreator,
-        creator_requested: LocalCertCreator,
-        local_tls_key,
-        local_tls_cert,
-    ):
-        if creator or (
-            creator_requested is not LocalCertCreator.AUTO
-            and creator_requested is not creator_requirement
-        ):
-            return creator
-
-        instance = creator_class(app, local_tls_key, local_tls_cert)
-        try:
-            instance.check_supported()
-        except SanicException:
-            if creator_requested is creator_requirement:
-                raise
-            else:
-                return None
-
-        return instance
-
-
-class MkcertCreator(CertCreator):
-    def check_supported(self) -> None:
-        try:
-            subprocess.run(  # nosec B603 B607
-                ["mkcert", "-help"],
-                check=True,
-                stderr=subprocess.DEVNULL,
-                stdout=subprocess.DEVNULL,
-            )
-        except Exception as e:
-            raise SanicException(
-                "Sanic is attempting to use mkcert to generate local TLS "
-                "certificates since you did not supply a certificate, but "
-                "one is required. Sanic cannot proceed since mkcert does not "
-                "appear to be installed. Alternatively, you can use trustme. "
-                "Please install mkcert, trustme, or supply TLS certificates "
-                "to proceed. Installation instructions can be found here: "
-                "https://github.com/FiloSottile/mkcert.\n"
-                "Find out more information about your options here: "
-                "https://sanic.dev/en/guide/deployment/development.html#"
-                "automatic-tls-certificate"
-            ) from e
-
-    def generate_cert(self, localhost: str) -> ssl.SSLContext:
-        try:
-            if not self.cert_path.exists():
-                message = "Generating TLS certificate"
-                # TODO: Validate input for security
-                with loading(message):
-                    cmd = [
-                        "mkcert",
-                        "-key-file",
-                        str(self.key_path),
-                        "-cert-file",
-                        str(self.cert_path),
-                        localhost,
-                    ]
-                    resp = subprocess.run(  # nosec B603
-                        cmd,
-                        check=True,
-                        stdout=subprocess.PIPE,
-                        stderr=subprocess.STDOUT,
-                        text=True,
-                    )
-                sys.stdout.write("\r" + " " * (len(message) + 4))
-                sys.stdout.flush()
-                sys.stdout.write(resp.stdout)
-        finally:
-
-            @self.app.main_process_stop
-            async def cleanup(*_):  # no cov
-                if self.tmpdir:
-                    with suppress(FileNotFoundError):
-                        self.key_path.unlink()
-                        self.cert_path.unlink()
-                    self.tmpdir.rmdir()
-
-        context = CertSimple(self.cert_path, self.key_path)
-        context.sanic["creator"] = "mkcert"
-        context.sanic["localhost"] = localhost
-        SanicSSLContext.create_from_ssl_context(context)
-
-        return context
-
-
-class TrustmeCreator(CertCreator):
-    def check_supported(self) -> None:
-        if not TRUSTME_INSTALLED:
-            raise SanicException(
-                "Sanic is attempting to use trustme to generate local TLS "
-                "certificates since you did not supply a certificate, but "
-                "one is required. Sanic cannot proceed since trustme does not "
-                "appear to be installed. Alternatively, you can use mkcert. "
-                "Please install mkcert, trustme, or supply TLS certificates "
-                "to proceed. Installation instructions can be found here: "
-                "https://github.com/python-trio/trustme.\n"
-                "Find out more information about your options here: "
-                "https://sanic.dev/en/guide/deployment/development.html#"
-                "automatic-tls-certificate"
-            )
-
-    def generate_cert(self, localhost: str) -> ssl.SSLContext:
-        context = SanicSSLContext.create_from_ssl_context(
-            ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
-        )
-        context.sanic = {
-            "cert": self.cert_path.absolute(),
-            "key": self.key_path.absolute(),
-        }
-        ca = trustme.CA()
-        server_cert = ca.issue_cert(localhost)
-        server_cert.configure_cert(context)
-        ca.configure_trust(context)
-
-        ca.cert_pem.write_to_path(str(self.cert_path.absolute()))
-        server_cert.private_key_and_cert_chain_pem.write_to_path(
-            str(self.key_path.absolute())
-        )
-        context.sanic["creator"] = "trustme"
-        context.sanic["localhost"] = localhost
-
-        return context
--- a/sanic/log.py
+++ b/sanic/log.py
@@ -2,22 +2,9 @@ import logging
 import sys

 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict
+from typing import Any, Dict
 from warnings import warn

-from sanic.helpers import is_atty
-
-
-# Python 3.11 changed the way Enum formatting works for mixed-in types.
-if sys.version_info < (3, 11, 0):
-
-    class StrEnum(str, Enum):
-        pass
-
-else:
-    if not TYPE_CHECKING:
-        from enum import StrEnum
-

 LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
    version=1,
@@ -36,12 +23,6 @@ LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
            "propagate": True,
            "qualname": "sanic.access",
        },
-        "sanic.server": {
-            "level": "INFO",
-            "handlers": ["console"],
-            "propagate": True,
-            "qualname": "sanic.server",
-        },
    },
    handlers={
        "console": {
@@ -62,91 +43,47 @@ LOGGING_CONFIG_DEFAULTS: Dict[str, Any] = dict(  # no cov
    },
    formatters={
        "generic": {
-            "format": "%(asctime)s [%(process)s] [%(levelname)s] %(message)s",
+            "format": "%(asctime)s [%(process)d] [%(levelname)s] %(message)s",
            "datefmt": "[%Y-%m-%d %H:%M:%S %z]",
            "class": "logging.Formatter",
        },
        "access": {
            "format": "%(asctime)s - (%(name)s)[%(levelname)s][%(host)s]: "
-            + "%(request)s %(message)s %(status)s %(byte)s",
+            + "%(request)s %(message)s %(status)d %(byte)d",
            "datefmt": "[%Y-%m-%d %H:%M:%S %z]",
            "class": "logging.Formatter",
        },
    },
 )
-"""
-Defult logging configuration
-"""


-class Colors(StrEnum):  # no cov
+class Colors(str, Enum):  # no cov
    END = "\033[0m"
-    BOLD = "\033[1m"
-    BLUE = "\033[34m"
-    GREEN = "\033[32m"
-    PURPLE = "\033[35m"
-    RED = "\033[31m"
-    SANIC = "\033[38;2;255;13;104m"
+    BLUE = "\033[01;34m"
+    GREEN = "\033[01;32m"
    YELLOW = "\033[01;33m"
+    RED = "\033[01;31m"


-class VerbosityFilter(logging.Filter):
-    verbosity: int = 0
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        verbosity = getattr(record, "verbosity", 0)
-        return verbosity <= self.verbosity
-
-
-_verbosity_filter = VerbosityFilter()
-
 logger = logging.getLogger("sanic.root")  # no cov
 """
 General Sanic logger
 """
-logger.addFilter(_verbosity_filter)

 error_logger = logging.getLogger("sanic.error")  # no cov
 """
 Logger used by Sanic for error logging
 """
-error_logger.addFilter(_verbosity_filter)

 access_logger = logging.getLogger("sanic.access")  # no cov
 """
 Logger used by Sanic for access logging
 """
-access_logger.addFilter(_verbosity_filter)
-
-server_logger = logging.getLogger("sanic.server")  # no cov
-"""
-Logger used by Sanic for server related messages
-"""
-logger.addFilter(_verbosity_filter)


 def deprecation(message: str, version: float):  # no cov
-    """
-    Add a deprecation notice
-
-    Example when a feature is being removed. In this case, version
-    should be AT LEAST next version + 2
-
-        deprecation("Helpful message", 99.9)
-
-    Example when a feature is deprecated but not being removed:
-
-        deprecation("Helpful message", 0)
-
-    :param message: The message of the notice
-    :type message: str
-    :param version: The version when the feature will be removed. If it is
-      not being removed, then set version=0.
-    :type version: float
-    """
-    version_display = f" v{version}" if version else ""
-    version_info = f"[DEPRECATION{version_display}] "
-    if is_atty():
+    version_info = f"[DEPRECATION v{version}] "
+    if sys.stdout.isatty():
        version_info = f"{Colors.RED}{version_info}"
        message = f"{Colors.YELLOW}{message}{Colors.END}"
    warn(version_info + message, DeprecationWarning)
--- a/sanic/middleware.py
+++ b/sanic/middleware.py
@@ -1,69 +0,0 @@
-from __future__ import annotations
-
-from collections import deque
-from enum import IntEnum, auto
-from itertools import count
-from typing import Deque, Sequence, Union
-
-from sanic.models.handler_types import MiddlewareType
-
-
-class MiddlewareLocation(IntEnum):
-    REQUEST = auto()
-    RESPONSE = auto()
-
-
-class Middleware:
-    _counter = count()
-
-    __slots__ = ("func", "priority", "location", "definition")
-
-    def __init__(
-        self,
-        func: MiddlewareType,
-        location: MiddlewareLocation,
-        priority: int = 0,
-    ) -> None:
-        self.func = func
-        self.priority = priority
-        self.location = location
-        self.definition = next(Middleware._counter)
-
-    def __call__(self, *args, **kwargs):
-        return self.func(*args, **kwargs)
-
-    def __hash__(self) -> int:
-        return hash(self.func)
-
-    def __repr__(self) -> str:
-        return (
-            f"{self.__class__.__name__}("
-            f"func=<function {self.func.__name__}>, "
-            f"priority={self.priority}, "
-            f"location={self.location.name})"
-        )
-
-    @property
-    def order(self):
-        return (self.priority, -self.definition)
-
-    @classmethod
-    def convert(
-        cls,
-        *middleware_collections: Sequence[Union[Middleware, MiddlewareType]],
-        location: MiddlewareLocation,
-    ) -> Deque[Middleware]:
-        return deque(
-            [
-                middleware
-                if isinstance(middleware, Middleware)
-                else Middleware(middleware, location)
-                for collection in middleware_collections
-                for middleware in collection
-            ]
-        )
-
-    @classmethod
-    def reset_count(cls):
-        cls._counter = count()
-        cls.count = next(cls._counter)
--- a/sanic/mixins/base.py
+++ b/sanic/mixins/base.py
@@ -1,35 +0,0 @@
-from typing import Optional
-
-from sanic.base.meta import SanicMeta
-
-
-class BaseMixin(metaclass=SanicMeta):
-    name: str
-    strict_slashes: Optional[bool]
-
-    def _generate_name(self, *objects) -> str:
-        name = None
-
-        for obj in objects:
-            if obj:
-                if isinstance(obj, str):
-                    name = obj
-                    break
-
-                try:
-                    name = obj.name
-                except AttributeError:
-                    try:
-                        name = obj.__name__
-                    except AttributeError:
-                        continue
-                else:
-                    break
-
-        if not name:  # noqa
-            raise ValueError("Could not generate a name for handler")
-
-        if not name.startswith(f"{self.name}."):
-            name = f"{self.name}.{name}"
-
-        return name
--- a/sanic/mixins/exceptions.py
+++ b/sanic/mixins/exceptions.py
@@ -38,15 +38,3 @@ class ExceptionMixin(metaclass=SanicMeta):
            return handler

        return decorator
-
-    def all_exceptions(self, handler):
-        """
-        This method enables the process of creating a global exception
-        handler for the current blueprint under question.
-
-        :param handler: A coroutine function to handle exceptions
-
-        :return a decorated method to handle global exceptions for any
-            route registered under this blueprint.
-        """
-        return self.exception(Exception)(handler)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Adam Hopkins	8aecbdb52c	Bump version	2022-05-10 22:38:00 +03:00
Adam Hopkins	3a1a9f071d	Resolve warning issue with error handler mismatch warning	2022-05-10 22:37:51 +03:00