merge app and request context (#5812 )

merge app and request context
Merge branch 'stable'
2025-09-19 16:45:27 -07:00 · 2025-09-19 16:43:53 -07:00 · 2025-08-19 14:09:56 -07:00 · 2025-08-19 14:03:43 -07:00 · 2025-08-19 13:57:47 -07:00 · 2025-08-19 13:56:49 -07:00
65 changed files with 1900 additions and 1894 deletions
--- a/.github/workflows/pre-commit.yaml
+++ b/.github/workflows/pre-commit.yaml
@ -7,8 +7,8 @@ jobs:
  main:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca # v6.0.1
+      - uses: astral-sh/setup-uv@d9e0f98d3fc6adb07d1e3d37f3043649ddad06a1 # v6.5.0
        with:
          enable-cache: true
          prune-cache: false
@ -16,7 +16,7 @@ jobs:
        id: setup-python
        with:
          python-version-file: pyproject.toml
-      - uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
+      - uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
        with:
          path: ~/.cache/pre-commit
          key: pre-commit|${{ hashFiles('pyproject.toml', '.pre-commit-config.yaml') }}
--- a/.github/workflows/publish.yaml
+++ b/.github/workflows/publish.yaml
@ -6,10 +6,12 @@ jobs:
  build:
    runs-on: ubuntu-latest
    outputs:
-      hash: ${{ steps.hash.outputs.hash }}
+      artifact-id: ${{ steps.upload-artifact.outputs.artifact-id }}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca # v6.0.1
+        with:
          persist-credentials: false
      - uses: astral-sh/setup-uv@d9e0f98d3fc6adb07d1e3d37f3043649ddad06a1 # v6.5.0
        with:
          enable-cache: true
          prune-cache: false
@ -18,38 +20,28 @@ jobs:
          python-version-file: pyproject.toml
      - run: echo "SOURCE_DATE_EPOCH=$(git log -1 --pretty=%ct)" >> $GITHUB_ENV
      - run: uv build
      - name: generate hash
        id: hash
        run: cd dist && echo "hash=$(sha256sum * | base64 -w0)" >> $GITHUB_OUTPUT
      - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
        id: upload-artifact
        with:
-          path: ./dist
+          name: dist
-  provenance:
+          path: dist/
-    needs: [build]
+          if-no-files-found: error
    permissions:
      actions: read
      id-token: write
      contents: write
    # Can't pin with hash due to how this workflow works.
    uses: slsa-framework/slsa-github-generator/.github/workflows/generator_generic_slsa3.yml@v2.1.0
    with:
      base64-subjects: ${{ needs.build.outputs.hash }}
  create-release:
-    needs: [provenance]
+    needs: [build]
    runs-on: ubuntu-latest
    permissions:
      contents: write
    steps:
-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+      - uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
        with:
          artifact-ids: ${{ needs.build.outputs.artifact-id }}
          path: dist/
      - name: create release
-        run: >
+        run: gh release create --draft --repo ${{ github.repository }} ${{ github.ref_name }} dist/*
          gh release create --draft --repo ${{ github.repository }}
          ${{ github.ref_name }}
          *.intoto.jsonl/* artifact/*
        env:
          GH_TOKEN: ${{ github.token }}
  publish-pypi:
-    needs: [provenance]
+    needs: [build]
    environment:
      name: publish
      url: https://pypi.org/project/Flask/${{ github.ref_name }}
@ -57,7 +49,10 @@ jobs:
    permissions:
      id-token: write
    steps:
-      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
+      - uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
        with:
          artifact-ids: ${{ needs.build.outputs.artifact-id }}
          path: dist/
      - uses: pypa/gh-action-pypi-publish@76f52bc884231f62b9a034ebfe128415bbaabdfc # v1.12.4
        with:
-          packages-dir: artifact/
+          packages-dir: "dist/"
--- a/.github/workflows/tests.yaml
+++ b/.github/workflows/tests.yaml
@ -19,13 +19,12 @@ jobs:
          - {python: '3.12'}
          - {python: '3.11'}
          - {python: '3.10'}
          - {python: '3.9'}
          - {name: PyPy, python: 'pypy-3.11', tox: pypy3.11}
          - {name: Minimum Versions, python: '3.13', tox: tests-min}
          - {name: Development Versions, python: '3.10', tox: tests-dev}
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca # v6.0.1
+      - uses: astral-sh/setup-uv@d9e0f98d3fc6adb07d1e3d37f3043649ddad06a1 # v6.5.0
        with:
          enable-cache: true
          prune-cache: false
@ -36,8 +35,8 @@ jobs:
  typing:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-      - uses: astral-sh/setup-uv@6b9c6063abd6010835644d4c2e1bef4cf5cd0fca # v6.0.1
+      - uses: astral-sh/setup-uv@d9e0f98d3fc6adb07d1e3d37f3043649ddad06a1 # v6.5.0
        with:
          enable-cache: true
          prune-cache: false
@ -45,7 +44,7 @@ jobs:
        with:
          python-version-file: pyproject.toml
      - name: cache mypy
-        uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3
+        uses: actions/cache@0400d5f644dc74513175e3cd8d07132dd4860809 # v4.2.4
        with:
          path: ./.mypy_cache
          key: mypy|${{ hashFiles('pyproject.toml') }}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -1,15 +1,15 @@
 repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: 24e02b24b8ab2b7c76225602d13fa60e12d114e6  # frozen: v0.11.9
+    rev: 54a455f7ce629598b7535ff828fd5fb796f4b83f  # frozen: v0.12.9
    hooks:
      - id: ruff
      - id: ruff-format
  - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 14ac15b122e538e407d036ff45e3895b7cf4a2bf  # frozen: 0.7.3
+    rev: f9572a6b06237978e1d52fad0ae55bac5e36da26  # frozen: 0.8.12
    hooks:
      - id: uv-lock
  - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: cef0300fd0fc4d2a87a85fa2093c6b283ea36f4b  # frozen: v5.0.0
+    rev: 3e8a8703264a2f4a69428a0aa4dcb512790b2c8c  # frozen: v6.0.0
    hooks:
      - id: check-merge-conflict
      - id: debug-statements
--- a/CHANGES.rst
+++ b/CHANGES.rst
@ -1,3 +1,29 @@
 Version 3.2.0
 -------------
 Unreleased
 -   Drop support for Python 3.9. :pr:`5730`
 -   Remove previously deprecated code: ``__version__``. :pr:`5648`
 -   ``RequestContext`` has merged with ``AppContext``. ``RequestContext`` is now
    a deprecated alias. If an app context is already pushed, it is not reused
    when dispatching a request. This greatly simplifies the internal code for tracking
    the active context. :issue:`5639`
 -   ``template_filter``, ``template_test``, and ``template_global`` decorators
    can be used without parentheses. :issue:`5729`
 Version 3.1.2
 -------------
 Released 2025-08-19
 -   ``stream_with_context`` does not fail inside async views. :issue:`5774`
 -   When using ``follow_redirects`` in the test client, the final state
    of ``session`` is correct. :issue:`5786`
 -   Relax type hint for passing bytes IO to ``send_file``. :issue:`5776`
 Version 3.1.1
 -------------
@ -5,9 +31,9 @@ Released 2025-05-13
 -   Fix signing key selection order when key rotation is enabled via
    ``SECRET_KEY_FALLBACKS``. :ghsa:`4grg-w6v8-c28g`
-   Fix type hint for `cli_runner.invoke`. :issue:`5645`
+-   Fix type hint for ``cli_runner.invoke``. :issue:`5645`
 -   ``flask --help`` loads the app and plugins first to make sure all commands
-    are shown. :issue:5673`
+    are shown. :issue:`5673`
 -   Mark sans-io base class as being able to handle views that return
    ``AsyncIterable``. This is not accurate for Flask, but makes typing easier
    for Quart. :pr:`5659`
@ -1365,7 +1391,7 @@ Released 2011-09-29, codename Rakija
    of Flask itself and no longer of the test client. This cleaned up
    some internal logic and lowers the odds of runaway request contexts
    in unittests.
-   Fixed the Jinja2 environment's ``list_templates`` method not
+-   Fixed the Jinja environment's ``list_templates`` method not
    returning the correct names when blueprints or modules were
    involved.
@ -1451,7 +1477,7 @@ Released 2010-12-31
 -   Fixed an issue where the default ``OPTIONS`` response was not
    exposing all valid methods in the ``Allow`` header.
-   Jinja2 template loading syntax now allows "./" in front of a
+-   Jinja template loading syntax now allows "./" in front of a
    template load path. Previously this caused issues with module
    setups.
 -   Fixed an issue where the subdomain setting for modules was ignored
--- a/README.md
+++ b/README.md
@ -1,3 +1,5 @@
 <div align="center"><img src="https://raw.githubusercontent.com/pallets/flask/refs/heads/stable/docs/_static/flask-name.svg" alt="" height="150"></div>
 # Flask
 Flask is a lightweight [WSGI] web application framework. It is designed
--- a/docs/_static/flask-horizontal.png
+++ b/docs/_static/flask-horizontal.png
--- a/docs/_static/flask-icon.svg
+++ b/docs/_static/flask-icon.svg
@ -0,0 +1,15 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg width="100%" height="100%" viewBox="0 0 500 500" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
    <rect id="Icon" x="0" y="0" width="500" height="500" style="fill:none;"/>
    <clipPath id="_clip1">
        <rect x="0" y="0" width="500" height="500"/>
    </clipPath>
    <g clip-path="url(#_clip1)">
        <g>
            <path d="M224.446,59.975c-0.056,-4.151 -0.483,-5.543 -2.7,-6.823c-2.104,-1.393 -5.288,-1.421 -8.329,-0.085l-204.674,87.64c-3.042,1.336 -5.913,4.008 -7.448,6.908c-1.535,2.899 -1.705,5.97 -0.511,8.158l17.084,31.384l0.228,0.369c1.847,2.928 6.026,3.696 10.29,1.82l1.251,-0.54c5.344,22.4 14.1,50.429 25.783,70.413l178.294,-79.794c-2.559,-23.14 -9.552,-89.602 -9.268,-119.479l0,0.029Z" style="fill:#3babc3;fill-rule:nonzero;"/>
            <path d="M238.603,205.776l-171.698,76.838c10.091,19.132 22.542,39.428 37.722,58.986c50.429,-25.698 100.887,-51.396 151.316,-77.094c-3.269,-8.471 -6.452,-17.653 -17.34,-58.73Z" style="fill:#3babc3;fill-rule:nonzero;"/>
            <path d="M497.601,388.846l-12.139,-18.535c-1.819,-2.018 -4.633,-2.786 -7.106,-1.791l-15.578,5.999c-1.848,-2.047 -4.52,-2.815 -7.135,-1.791c-5.089,1.99 -10.206,4.008 -15.294,5.998c-1.649,0.625 -2.104,1.847 -1.791,3.439l0.995,4.861c-28.711,3.099 -77.236,1.564 -120.701,-32.577c-19.216,-15.066 -37.239,-36.386 -52.277,-66.206l-144.75,73.768c26.466,29.08 59.697,54.864 100.973,70.385c57.422,21.633 130.593,23.679 222.838,-13.475l0.512,2.616c0.455,2.928 3.98,6.026 8.755,4.15l15.323,-5.97c5.258,-1.99 5.287,-6.026 4.519,-8.641l19.729,-7.704c2.217,-0.853 9.096,-6.169 3.183,-14.526l-0.056,-0Z" style="fill:#3babc3;fill-rule:nonzero;"/>
        </g>
    </g>
 </svg>
--- a/docs/_static/flask-logo.svg
+++ b/docs/_static/flask-logo.svg
@ -0,0 +1,17 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg width="100%" height="100%" viewBox="0 0 500 500" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
    <rect id="Logo" x="0" y="0" width="500" height="500" style="fill:none;"/>
    <g>
        <path id="Box" d="M500,50l0,400c0,27.596 -22.404,50 -50,50l-400,0c-27.596,0 -50,-22.404 -50,-50l0,-400c0,-27.596 22.404,-50 50,-50l400,0c27.596,0 50,22.404 50,50Z" style="fill:url(#_Linear1);"/>
        <path id="Shadow" d="M500,398.646l0,51.354c0,27.596 -22.404,50 -50,50l-94.111,0l-170.452,-170.451c13.541,12.279 29.511,22.845 48.242,29.888c34.453,12.98 78.356,14.208 133.703,-8.084l0.307,1.569c0.273,1.757 2.388,3.616 5.253,2.49l9.193,-3.582c3.156,-1.194 3.173,-3.616 2.712,-5.185l11.837,-4.622c1.331,-0.512 5.458,-3.701 1.91,-8.716l-0.034,0l-7.283,-11.12c-1.091,-1.211 -2.78,-1.672 -4.264,-1.075l-9.346,3.599c-1.109,-1.228 -2.712,-1.688 -4.281,-1.074c-3.054,1.194 -6.124,2.404 -9.177,3.598c-0.989,0.376 -1.262,1.109 -1.074,2.064l0.597,2.917c-17.227,1.859 -46.342,0.938 -72.421,-19.547c-11.53,-9.039 -22.343,-21.831 -31.366,-39.723l-83.923,42.769l-13.246,-10.755c30.258,-15.419 60.532,-30.837 90.79,-46.256c-1.961,-5.083 -3.872,-10.592 -10.404,-35.238l-98.082,43.893l-11.828,-11.828l106.976,-47.876c-1.534,-13.88 -5.728,-53.736 -5.56,-71.67l-0,-0.017c-0.027,-1.894 -0.184,-2.827 -0.85,-3.504l266.182,266.182Zm-388.562,-185.436c1.272,1.164 3.414,1.356 5.594,0.397l0.75,-0.324c0.645,2.703 1.373,5.543 2.181,8.452l-8.525,-8.525Z" style="fill:#3b808b;"/>
        <g id="Icon">
            <path d="M234.668,135.985c-0.034,-2.49 -0.29,-3.326 -1.62,-4.094c-1.263,-0.835 -3.173,-0.852 -4.998,-0.051l-122.804,52.584c-1.825,0.802 -3.548,2.405 -4.469,4.145c-0.921,1.74 -1.023,3.582 -0.307,4.895l10.251,18.83l0.136,0.222c1.109,1.757 3.616,2.217 6.175,1.091l0.75,-0.324c3.207,13.441 8.46,30.258 15.47,42.248l106.976,-47.876c-1.535,-13.884 -5.731,-53.761 -5.56,-71.687l-0,0.017Z" style="fill:#fff;fill-rule:nonzero;"/>
            <path d="M243.162,223.466l-103.019,46.103c6.055,11.478 13.525,23.656 22.633,35.391c30.258,-15.419 60.532,-30.837 90.79,-46.256c-1.961,-5.083 -3.872,-10.592 -10.404,-35.238Z" style="fill:#fff;fill-rule:nonzero;"/>
            <path d="M398.56,333.307l-7.283,-11.12c-1.091,-1.211 -2.78,-1.672 -4.264,-1.075l-9.346,3.599c-1.109,-1.228 -2.712,-1.688 -4.281,-1.074c-3.054,1.194 -6.124,2.404 -9.177,3.598c-0.989,0.376 -1.262,1.109 -1.074,2.064l0.597,2.917c-17.227,1.859 -46.342,0.938 -72.421,-19.547c-11.53,-9.039 -22.343,-21.831 -31.366,-39.723l-86.85,44.26c15.879,17.449 35.818,32.919 60.584,42.231c34.453,12.98 78.356,14.208 133.703,-8.084l0.307,1.569c0.273,1.757 2.388,3.616 5.253,2.49l9.193,-3.582c3.156,-1.194 3.173,-3.616 2.712,-5.185l11.837,-4.622c1.331,-0.512 5.458,-3.701 1.91,-8.716l-0.034,0Z" style="fill:#fff;fill-rule:nonzero;"/>
        </g>
    </g>
    <defs>
        <linearGradient id="_Linear1" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(3.06162e-14,500,-500,3.06162e-14,267.59,0)"><stop offset="0" style="stop-color:#bdddeb;stop-opacity:1"/><stop offset="1" style="stop-color:#53a9d1;stop-opacity:1"/></linearGradient>
    </defs>
 </svg>
--- a/docs/_static/flask-name.svg
+++ b/docs/_static/flask-name.svg
@ -0,0 +1,23 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
 <svg width="100%" height="100%" viewBox="0 0 706 300" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
    <g>
        <path id="Name" d="M420.35,117.6l-37.65,-0c-4.4,-0 -7.475,0.85 -9.225,2.55c-1.75,1.7 -2.625,4.65 -2.625,8.85l-0,14.85l39.15,-0l-1.5,18.6l-37.65,-0l-0,43.35l-20.85,-0l-0,-85.05c-0,-7.9 1.725,-13.5 5.175,-16.8c3.45,-3.3 9.375,-4.95 17.775,-4.95l47.4,-0l0,18.6Z" style="fill-rule:nonzero;"/>
        <path d="M455.75,205.8l-19.5,0.15l-0,-112.95l19.5,-0l-0,112.8Z" style="fill-rule:nonzero;"/>
        <path d="M535.7,205.8l-13.05,-0l-6,-10.35l-20.85,11.25c-11.6,-0 -19.4,-4.2 -23.4,-12.6c-2,-4.1 -3.375,-8.525 -4.125,-13.275c-0.75,-4.75 -1.125,-9.7 -1.125,-14.85c-0,-5.15 0.05,-8.95 0.15,-11.4c0.1,-2.45 0.35,-5.3 0.75,-8.55c0.4,-3.25 0.975,-5.975 1.725,-8.175c0.75,-2.2 1.825,-4.475 3.225,-6.825c1.4,-2.35 3.1,-4.225 5.1,-5.625c4.5,-3.1 10.35,-4.65 17.55,-4.65l20.55,-0l19.5,-1.2l-0,86.25Zm-19.5,-27.3l-0,-40.2l-14.85,-0c-5.5,-0 -9.325,2.1 -11.475,6.3c-2.15,4.2 -3.225,10.475 -3.225,18.825c-0,8.35 1.025,14.225 3.075,17.625c2.05,3.4 5.925,5.1 11.625,5.1l14.85,-7.65Z" style="fill-rule:nonzero;"/>
        <path d="M615.65,182.1l0,2.25c-0.6,7.5 -3.775,13.15 -9.525,16.95c-5.75,3.8 -12.925,5.7 -21.525,5.7c-12.7,-0 -21.6,-2.3 -26.7,-6.9c-4.7,-4.2 -7.05,-10.4 -7.05,-18.6l0,-1.8l17.7,0c0,4.6 1.2,7.75 3.6,9.45c2.4,1.7 6.55,2.55 12.45,2.55c8,0 12,-2.9 12,-8.7c0,-4.8 -1.4,-8 -4.2,-9.6c-1.3,-0.8 -2.95,-1.4 -4.95,-1.8l-15.15,-2.55c-13.2,-2.1 -19.8,-10.35 -19.8,-24.75c0,-8 2.925,-14.225 8.775,-18.675c5.85,-4.45 13.275,-6.675 22.275,-6.675c20.5,0 30.75,8.85 30.75,26.55l0,1.95l-16.95,0c-0.2,-4.7 -1.45,-7.9 -3.75,-9.6c-2.3,-1.7 -5.525,-2.55 -9.675,-2.55c-4.15,0 -7.275,0.825 -9.375,2.475c-2.1,1.65 -3.15,3.475 -3.15,5.475c0,5.7 2.3,8.95 6.9,9.75l18.15,3.3c12.8,2.4 19.2,11 19.2,25.8Z" style="fill-rule:nonzero;"/>
        <path d="M705.65,205.8l-23.4,-0l-22.5,-30.3l-8.55,12.15l0,18.15l-19.5,-0l0,-112.8l19.5,-0l0,71.25l27.3,-40.65l22.05,-0l-28.05,38.4l33.15,43.8Z" style="fill-rule:nonzero;"/>
        <g id="Logo">
            <path id="Box" d="M300,30l0,240c0,16.557 -13.443,30 -30,30l-240,-0c-16.557,-0 -30,-13.443 -30,-30l0,-240c0,-16.557 13.443,-30 30,-30l240,0c16.557,0 30,13.443 30,30Z" style="fill:url(#_Linear1);"/>
            <path id="Shadow" d="M300,239.188l0,30.812c0,16.557 -13.443,30 -30,30l-56.467,-0l-102.271,-102.271c8.125,7.368 17.707,13.707 28.945,17.933c20.672,7.788 47.014,8.525 80.222,-4.85l0.184,0.941c0.164,1.054 1.433,2.17 3.152,1.494l5.516,-2.149c1.893,-0.716 1.904,-2.169 1.627,-3.111l7.103,-2.773c0.798,-0.307 3.274,-2.221 1.146,-5.23l-0.021,0l-4.37,-6.672c-0.655,-0.727 -1.668,-1.003 -2.558,-0.645l-5.608,2.16c-0.665,-0.737 -1.627,-1.013 -2.569,-0.645c-1.832,0.716 -3.674,1.443 -5.505,2.159c-0.594,0.225 -0.758,0.665 -0.645,1.239l0.358,1.749c-10.336,1.116 -27.805,0.563 -43.452,-11.727c-6.918,-5.424 -13.406,-13.099 -18.82,-23.835l-50.354,25.662l-7.947,-6.453c18.154,-9.251 36.319,-18.502 54.474,-27.754c-1.177,-3.049 -2.323,-6.355 -6.243,-21.143l-58.849,26.336l-7.097,-7.096l64.186,-28.726c-0.921,-8.328 -3.437,-32.242 -3.336,-43.002l-0,-0.01c-0.016,-1.137 -0.111,-1.697 -0.51,-2.103l159.709,159.71Zm-233.137,-111.262c0.763,0.699 2.048,0.814 3.356,0.238l0.45,-0.194c0.387,1.622 0.824,3.325 1.309,5.071l-5.115,-5.115Z" style="fill:#3b808b;"/>
            <g id="Icon">
                <path d="M140.801,81.591c-0.021,-1.494 -0.174,-1.996 -0.972,-2.456c-0.758,-0.502 -1.904,-0.512 -2.999,-0.031l-73.683,31.551c-1.095,0.481 -2.128,1.443 -2.681,2.486c-0.552,1.044 -0.614,2.149 -0.184,2.937l6.151,11.298l0.081,0.133c0.666,1.055 2.17,1.331 3.705,0.655l0.45,-0.194c1.924,8.064 5.076,18.155 9.282,25.349l64.186,-28.726c-0.921,-8.33 -3.439,-32.257 -3.336,-43.012l-0,0.01Z" style="fill:#fff;fill-rule:nonzero;"/>
                <path d="M145.897,134.079l-61.811,27.662c3.633,6.887 8.115,14.194 13.58,21.235c18.154,-9.251 36.319,-18.502 54.474,-27.754c-1.177,-3.049 -2.323,-6.355 -6.243,-21.143Z" style="fill:#fff;fill-rule:nonzero;"/>
                <path d="M239.136,199.984l-4.37,-6.672c-0.655,-0.727 -1.668,-1.003 -2.558,-0.645l-5.608,2.16c-0.665,-0.737 -1.627,-1.013 -2.569,-0.645c-1.832,0.716 -3.674,1.443 -5.505,2.159c-0.594,0.225 -0.758,0.665 -0.645,1.239l0.358,1.749c-10.336,1.116 -27.805,0.563 -43.452,-11.727c-6.918,-5.424 -13.406,-13.099 -18.82,-23.835l-52.11,26.557c9.528,10.469 21.491,19.751 36.35,25.338c20.672,7.788 47.014,8.525 80.222,-4.85l0.184,0.941c0.164,1.054 1.433,2.17 3.152,1.494l5.516,-2.149c1.893,-0.716 1.904,-2.169 1.627,-3.111l7.103,-2.773c0.798,-0.307 3.274,-2.221 1.146,-5.23l-0.021,0Z" style="fill:#fff;fill-rule:nonzero;"/>
            </g>
        </g>
    </g>
    <defs>
        <linearGradient id="_Linear1" x1="0" y1="0" x2="1" y2="0" gradientUnits="userSpaceOnUse" gradientTransform="matrix(1.83697e-14,300,-300,1.83697e-14,160.554,0)"><stop offset="0" style="stop-color:#bdddeb;stop-opacity:1"/><stop offset="1" style="stop-color:#53a9d1;stop-opacity:1"/></linearGradient>
    </defs>
 </svg>
--- a/docs/_static/flask-vertical.png
+++ b/docs/_static/flask-vertical.png
--- a/docs/_static/shortcut-icon.png
+++ b/docs/_static/shortcut-icon.png
--- a/docs/api.rst
+++ b/docs/api.rst
@ -31,17 +31,15 @@ Incoming Request Data
    :inherited-members:
    :exclude-members: json_module
-.. attribute:: request
+.. data:: request
-   To access incoming request data, you can use the global `request`
+    A proxy to the request data for the current request, an instance of
-   object. Flask parses incoming request data for you and gives you
+    :class:`.Request`.
   access to it through that global object. Internally Flask makes
   sure that you always get the correct data for the active thread if you
   are in a multithreaded environment.
-   This is a proxy. See :ref:`notes-on-proxies` for more information.
+    This is only available when a :doc:`request context </appcontext>` is
    active.
-   The request object is an instance of a :class:`~flask.Request`.
+    This is a proxy. See :ref:`context-visibility` for more information.
 Response Objects
@ -62,40 +60,33 @@ does this is by using a signed cookie. The user can look at the session
 contents, but can't modify it unless they know the secret key, so make sure to
 set that to something complex and unguessable.
-To access the current session you can use the :class:`session` object:
+To access the current session you can use the :data:`.session` proxy.
-.. class:: session
+.. data:: session
-   The session object works pretty much like an ordinary dict, with the
+    A proxy to the session data for the current request, an instance of
-   difference that it keeps track of modifications.
+    :class:`.SessionMixin`.
-   This is a proxy. See :ref:`notes-on-proxies` for more information.
+    This is only available when a :doc:`request context </appcontext>` is
    active.
-   The following attributes are interesting:
+    This is a proxy. See :ref:`context-visibility` for more information.
-   .. attribute:: new
+    The session object works like a dict but tracks assignment and access to its
    keys. It cannot track modifications to mutable values, you need to set
    :attr:`~.SessionMixin.modified` manually when modifying a list, dict, etc.
-      ``True`` if the session is new, ``False`` otherwise.
+    .. code-block:: python
-   .. attribute:: modified
+          # appending to a list is not detected
-
+          session["numbers"].append(42)
      ``True`` if the session object detected a modification. Be advised
      that modifications on mutable structures are not picked up
      automatically, in that situation you have to explicitly set the
      attribute to ``True`` yourself. Here an example::
          # this change is not picked up because a mutable object (here
          # a list) is changed.
          session['objects'].append(42)
          # so mark it as modified yourself
          session.modified = True
-   .. attribute:: permanent
+    The session is persisted across requests using a cookie. By default the
-
+    users's browser will clear the cookie when it is closed. Set
-      If set to ``True`` the session lives for
+    :attr:`~.SessionMixin.permanent` to ``True`` to persist the cookie for
-      :attr:`~flask.Flask.permanent_session_lifetime` seconds. The
+    :data:`PERMANENT_SESSION_LIFETIME`.
      default is 31 days. If set to ``False`` (which is the default) the
      session will be deleted when the user closes the browser.
 Session Interface
@ -158,20 +149,21 @@ another, a global variable is not good enough because it would break in
 threaded environments. Flask provides you with a special object that
 ensures it is only valid for the active request and that will return
 different values for each request. In a nutshell: it does the right
-thing, like it does for :class:`request` and :class:`session`.
+thing, like it does for :data:`.request` and :data:`.session`.
 .. data:: g
-    A namespace object that can store data during an
+    A proxy to a namespace object used to store data during a single request or
-    :doc:`application context </appcontext>`. This is an instance of
+    app context. An instance of :attr:`.Flask.app_ctx_globals_class`, which
-    :attr:`Flask.app_ctx_globals_class`, which defaults to
+    defaults to :class:`._AppCtxGlobals`.
    :class:`ctx._AppCtxGlobals`.
-    This is a good place to store resources during a request. For
+    This is a good place to store resources during a request. For example, a
-    example, a ``before_request`` function could load a user object from
+    :meth:`~.Flask.before_request` function could load a user object from a
-    a session id, then set ``g.user`` to be used in the view function.
+    session id, then set ``g.user`` to be used in the view function.
-    This is a proxy. See :ref:`notes-on-proxies` for more information.
+    This is only available when an :doc:`app context </appcontext>` is active.
    This is a proxy. See :ref:`context-visibility` for more information.
    .. versionchanged:: 0.10
        Bound to the application context instead of the request context.
@ -185,17 +177,16 @@ Useful Functions and Classes
 .. data:: current_app
-    A proxy to the application handling the current request. This is
+    A proxy to the :class:`.Flask` application handling the current request or
-    useful to access the application without needing to import it, or if
+    other activity.
    it can't be imported, such as when using the application factory
    pattern or in blueprints and extensions.
-    This is only available when an
+    This is useful to access the application without needing to import it, or if
-    :doc:`application context </appcontext>` is pushed. This happens
+    it can't be imported, such as when using the application factory pattern or
-    automatically during requests and CLI commands. It can be controlled
+    in blueprints and extensions.
    manually with :meth:`~flask.Flask.app_context`.
-    This is a proxy. See :ref:`notes-on-proxies` for more information.
+    This is only available when an :doc:`app context </appcontext>` is active.
    This is a proxy. See :ref:`context-visibility` for more information.
 .. autofunction:: has_request_context
@ -299,31 +290,31 @@ Stream Helpers
 Useful Internals
 ----------------
 .. autoclass:: flask.ctx.RequestContext
   :members:
 .. data:: flask.globals.request_ctx
    The current :class:`~flask.ctx.RequestContext`. If a request context
    is not active, accessing attributes on this proxy will raise a
    ``RuntimeError``.
    This is an internal object that is essential to how Flask handles
    requests. Accessing this should not be needed in most cases. Most
    likely you want :data:`request` and :data:`session` instead.
 .. autoclass:: flask.ctx.AppContext
   :members:
 .. data:: flask.globals.app_ctx
-    The current :class:`~flask.ctx.AppContext`. If an app context is not
+    A proxy to the active :class:`.AppContext`.
    active, accessing attributes on this proxy will raise a
    ``RuntimeError``.
-    This is an internal object that is essential to how Flask handles
+    This is an internal object that is essential to how Flask handles requests.
-    requests. Accessing this should not be needed in most cases. Most
+    Accessing this should not be needed in most cases. Most likely you want
-    likely you want :data:`current_app` and :data:`g` instead.
+    :data:`.current_app`, :data:`.g`, :data:`.request`, and :data:`.session` instead.
    This is only available when a :doc:`request context </appcontext>` is
    active.
    This is a proxy. See :ref:`context-visibility` for more information.
 .. class:: flask.ctx.RequestContext
    .. deprecated:: 3.2
        Merged with :class:`AppContext`. This alias will be removed in Flask 4.0.
 .. data:: flask.globals.request_ctx
    .. deprecated:: 3.2
        Merged with :data:`.app_ctx`. This alias will be removed in Flask 4.0.
 .. autoclass:: flask.blueprints.BlueprintSetupState
   :members:
--- a/docs/appcontext.rst
+++ b/docs/appcontext.rst
@ -1,74 +1,63 @@
-.. currentmodule:: flask
+The App and Request Context
 ===========================
-The Application Context
+The context keeps track of data and objects during a request, CLI command, or
-=======================
+other activity. Rather than passing this data around to every function, the
 :data:`.current_app`, :data:`.g`, :data:`.request`, and :data:`.session` proxies
 are accessed instead.
-The application context keeps track of the application-level data during
+When handling a request, the context is referred to as the "request context"
-a request, CLI command, or other activity. Rather than passing the
+because it contains request data in addition to application data. Otherwise,
-application around to each function, the :data:`current_app` and
+such as during a CLI command, it is referred to as the "app context". During an
-:data:`g` proxies are accessed instead.
+app context, :data:`.current_app` and :data:`.g` are available, while during a
 request context :data:`.request` and :data:`.session` are also available.
 This is similar to :doc:`/reqcontext`, which keeps track of
 request-level data during a request. A corresponding application context
 is pushed when a request context is pushed.
 Purpose of the Context
 ----------------------
-The :class:`Flask` application object has attributes, such as
+The context and proxies help solve two development issues: circular imports, and
-:attr:`~Flask.config`, that are useful to access within views and
+passing around global data during a request.
 :doc:`CLI commands </cli>`. However, importing the ``app`` instance
 within the modules in your project is prone to circular import issues.
 When using the :doc:`app factory pattern </patterns/appfactories>` or
 writing reusable :doc:`blueprints </blueprints>` or
 :doc:`extensions </extensions>` there won't be an ``app`` instance to
 import at all.
-Flask solves this issue with the *application context*. Rather than
+The :class:`.Flask` application object has attributes, such as
-referring to an ``app`` directly, you use the :data:`current_app`
+:attr:`~.Flask.config`, that are useful to access within views and other
-proxy, which points to the application handling the current activity.
+functions. However, importing the ``app`` instance within the modules in your
 project is prone to circular import issues. When using the
 :doc:`app factory pattern </patterns/appfactories>` or writing reusable
 :doc:`blueprints </blueprints>` or :doc:`extensions </extensions>` there won't
 be an ``app`` instance to import at all.
-Flask automatically *pushes* an application context when handling a
+When the application handles a request, it creates a :class:`.Request` object.
-request. View functions, error handlers, and other functions that run
+Because a *worker* handles only one request at a time, the request data can be
-during a request will have access to :data:`current_app`.
+considered global to that worker during that request. Passing it as an argument
 through every function during the request becomes verbose and redundant.
-Flask will also automatically push an app context when running CLI
+Flask solves these issues with the *active context* pattern. Rather than
-commands registered with :attr:`Flask.cli` using ``@app.cli.command()``.
+importing an ``app`` directly, or having to pass it and the request through to
 every single function, you import and access the proxies, which point to the
 currently active application and request data. This is sometimes referred to
 as "context local" data.
-Lifetime of the Context
+Context During Setup
-----------------------
+--------------------
-The application context is created and destroyed as necessary. When a
+If you try to access :data:`.current_app`, :data:`.g`, or anything that uses it,
-Flask application begins handling a request, it pushes an application
+outside an app context, you'll get this error message:
 context and a :doc:`request context </reqcontext>`. When the request
 ends it pops the request context then the application context.
 Typically, an application context will have the same lifetime as a
 request.
 See :doc:`/reqcontext` for more information about how the contexts work
 and the full life cycle of a request.
 Manually Push a Context
 -----------------------
 If you try to access :data:`current_app`, or anything that uses it,
 outside an application context, you'll get this error message:
 .. code-block:: pytb
    RuntimeError: Working outside of application context.
-    This typically means that you attempted to use functionality that
+    Attempted to use functionality that expected a current application to be
-    needed to interface with the current application object in some way.
+    set. To solve this, set up an app context using 'with app.app_context()'.
-    To solve this, set up an application context with app.app_context().
+    See the documentation on app context for more information.
 If you see that error while configuring your application, such as when
-initializing an extension, you can push a context manually since you
+initializing an extension, you can push a context manually since you have direct
-have direct access to the ``app``. Use :meth:`~Flask.app_context` in a
+access to the ``app``. Use :meth:`.Flask.app_context` in a ``with`` block.
-``with`` block, and everything that runs in the block will have access
+
-to :data:`current_app`. ::
+.. code-block:: python
    def create_app():
        app = Flask(__name__)
@ -78,70 +67,120 @@ to :data:`current_app`. ::
        return app
-If you see that error somewhere else in your code not related to
+If you see that error somewhere else in your code not related to setting up the
-configuring the application, it most likely indicates that you should
+application, it most likely indicates that you should move that code into a view
-move that code into a view function or CLI command.
+function or CLI command.
-Storing Data
+Context During Testing
------------
+----------------------
-The application context is a good place to store common data during a
+See :doc:`/testing` for detailed information about managing the context during
-request or CLI command. Flask provides the :data:`g object <g>` for this
+tests.
 purpose. It is a simple namespace object that has the same lifetime as
 an application context.
-.. note::
+If you try to access :data:`.request`, :data:`.session`, or anything that uses
-    The ``g`` name stands for "global", but that is referring to the
+it, outside a request context, you'll get this error message:
    data being global *within a context*. The data on ``g`` is lost
    after the context ends, and it is not an appropriate place to store
    data between requests. Use the :data:`session` or a database to
    store data across requests.
-A common use for :data:`g` is to manage resources during a request.
+.. code-block:: pytb
-1.  ``get_X()`` creates resource ``X`` if it does not exist, caching it
+    RuntimeError: Working outside of request context.
    as ``g.X``.
 2.  ``teardown_X()`` closes or otherwise deallocates the resource if it
    exists. It is registered as a :meth:`~Flask.teardown_appcontext`
    handler.
-For example, you can manage a database connection using this pattern::
+    Attempted to use functionality that expected an active HTTP request. See the
    documentation on request context for more information.
-    from flask import g
+This will probably only happen during tests. If you see that error somewhere
 else in your code not related to testing, it most likely indicates that you
 should move that code into a view function.
-    def get_db():
+The primary way to solve this is to use :meth:`.Flask.test_client` to simulate
-        if 'db' not in g:
+a full request.
            g.db = connect_to_database()
-        return g.db
+If you only want to unit test one function, rather than a full request, use
 :meth:`.Flask.test_request_context` in a ``with`` block.
-    @app.teardown_appcontext
+.. code-block:: python
    def teardown_db(exception):
        db = g.pop('db', None)
-        if db is not None:
+    def generate_report(year):
-            db.close()
+        format = request.args.get("format")
        ...
-During a request, every call to ``get_db()`` will return the same
+    with app.test_request_context(
-connection, and it will be closed automatically at the end of the
+        "/make_report/2017", query_string={"format": "short"}
-request.
+    ):
-
+        generate_report()
 You can use :class:`~werkzeug.local.LocalProxy` to make a new context
 local from ``get_db()``::
    from werkzeug.local import LocalProxy
    db = LocalProxy(get_db)
 Accessing ``db`` will call ``get_db`` internally, in the same way that
 :data:`current_app` works.
-Events and Signals
+.. _context-visibility:
 ------------------
-The application will call functions registered with :meth:`~Flask.teardown_appcontext`
+Visibility of the Context
-when the application context is popped.
+-------------------------
-The following signals are sent: :data:`appcontext_pushed`,
+The context will have the same lifetime as an activity, such as a request, CLI
-:data:`appcontext_tearing_down`, and :data:`appcontext_popped`.
+command, or ``with`` block. Various callbacks and signals registered with the
 app will be run during the context.
 When a Flask application handles a request, it pushes a requet context
 to set the active application and request data. When it handles a CLI command,
 it pushes an app context to set the active application. When the activity ends,
 it pops that context. Proxy objects like :data:`.request`, :data:`.session`,
 :data:`.g`, and :data:`.current_app`, are accessible while the context is pushed
 and active, and are not accessible after the context is popped.
 The context is unique to each thread (or other worker type). The proxies cannot
 be passed to another worker, which has a different context space and will not
 know about the active context in the parent's space.
 Besides being scoped to each worker, the proxy object has a separate type and
 identity than the proxied real object. In some cases you'll need access to the
 real object, rather than the proxy. Use the
 :meth:`~.LocalProxy._get_current_object` method in those cases.
 .. code-block:: python
    app = current_app._get_current_object()
    my_signal.send(app)
 Lifcycle of the Context
 -----------------------
 Flask dispatches a request in multiple stages which can affect the request,
 response, and how errors are handled. See :doc:`/lifecycle` for a list of all
 the steps, callbacks, and signals during each request. The following are the
 steps directly related to the context.
 -   The app context is pushed, the proxies are available.
 -   The :data:`.appcontext_pushed` signal is sent.
 -   The request is dispatched.
 -   Any :meth:`.Flask.teardown_request` decorated functions are called.
 -   The :data:`.request_tearing_down` signal is sent.
 -   Any :meth:`.Flask.teardown_appcontext` decorated functions are called.
 -   The :data:`.appcontext_tearing_down` signal is sent.
 -   The app context is popped, the proxies are no longer available.
 -   The :data:`.appcontext_popped` signal is sent.
 The teardown callbacks are called by the context when it is popped. They are
 called even if there is an unhandled exception during dispatch. They may be
 called multiple times in some test scenarios. This means there is no guarantee
 that any other parts of the request dispatch have run. Be sure to write these
 functions in a way that does not depend on other callbacks and will not fail.
 How the Context Works
 ---------------------
 Context locals are implemented using Python's :mod:`contextvars` and Werkzeug's
 :class:`~werkzeug.local.LocalProxy`. Python's contextvars are a low level
 structure to manage data local to a thread or coroutine. ``LocalProxy`` wraps
 the contextvar so that access to any attributes and methods is forwarded to the
 object stored in the contextvar.
 The context is tracked like a stack, with the active context at the top of the
 stack. Flask manages pushing and popping contexts during requests, CLI commands,
 testing, ``with`` blocks, etc. The proxies access attributes on the active
 context.
 Because it is a stack, other contexts may be pushed to change the proxies during
 an already active context. This is not a common pattern, but can be used in
 advanced use cases. For example, a Flask application can be used as WSGI
 middleware, calling another wrapped Flask app from a view.
--- a/docs/conf.py
+++ b/docs/conf.py
@ -58,8 +58,8 @@ html_sidebars = {
 }
 singlehtml_sidebars = {"index": ["project.html", "localtoc.html", "ethicalads.html"]}
 html_static_path = ["_static"]
-html_favicon = "_static/shortcut-icon.png"
+html_favicon = "_static/flask-icon.svg"
-html_logo = "_static/flask-vertical.png"
+html_logo = "_static/flask-logo.svg"
 html_title = f"Flask Documentation ({version})"
 html_show_sourcelink = False
--- a/docs/contributing.rst
+++ b/docs/contributing.rst
@ -1,7 +1,7 @@
 Contributing
 ============
-See the Pallets `detailed contributing documentation <_contrib>`_ for many ways
+See the Pallets `detailed contributing documentation <contrib_>`_ for many ways
 to contribute, including reporting issues, requesting features, asking or
 answering questions, and making PRs.
--- a/docs/design.rst
+++ b/docs/design.rst
@ -96,10 +96,10 @@ is ambiguous.
 One Template Engine
 -------------------
-Flask decides on one template engine: Jinja2.  Why doesn't Flask have a
+Flask decides on one template engine: Jinja.  Why doesn't Flask have a
 pluggable template engine interface?  You can obviously use a different
-template engine, but Flask will still configure Jinja2 for you.  While
+template engine, but Flask will still configure Jinja for you.  While
-that limitation that Jinja2 is *always* configured will probably go away,
+that limitation that Jinja is *always* configured will probably go away,
 the decision to bundle one template engine and use that will not.
 Template engines are like programming languages and each of those engines
@ -107,7 +107,7 @@ has a certain understanding about how things work.  On the surface they
 all work the same: you tell the engine to evaluate a template with a set
 of variables and take the return value as string.
-But that's about where similarities end. Jinja2 for example has an
+But that's about where similarities end. Jinja for example has an
 extensive filter system, a certain way to do template inheritance,
 support for reusable blocks (macros) that can be used from inside
 templates and also from Python code, supports iterative template
@ -118,8 +118,8 @@ other hand treats templates similar to Python modules.
 When it comes to connecting a template engine with an application or
 framework there is more than just rendering templates.  For instance,
-Flask uses Jinja2's extensive autoescaping support.  Also it provides
+Flask uses Jinja's extensive autoescaping support.  Also it provides
-ways to access macros from Jinja2 templates.
+ways to access macros from Jinja templates.
 A template abstraction layer that would not take the unique features of
 the template engines away is a science on its own and a too large
@ -150,7 +150,7 @@ authentication technologies, and more. Flask may be "micro", but it's ready for
 production use on a variety of needs.
 Why does Flask call itself a microframework and yet it depends on two
-libraries (namely Werkzeug and Jinja2).  Why shouldn't it?  If we look
+libraries (namely Werkzeug and Jinja).  Why shouldn't it?  If we look
 over to the Ruby side of web development there we have a protocol very
 similar to WSGI.  Just that it's called Rack there, but besides that it
 looks very much like a WSGI rendition for Ruby.  But nearly all
@ -169,19 +169,20 @@ infrastructure, packages with dependencies are no longer an issue and
 there are very few reasons against having libraries that depend on others.
-Thread Locals
+Context Locals
-------------
+--------------
-Flask uses thread local objects (context local objects in fact, they
+Flask uses special context locals and proxies to provide access to the
-support greenlet contexts as well) for request, session and an extra
+current app and request data to any code running during a request, CLI command,
-object you can put your own things on (:data:`~flask.g`).  Why is that and
+etc. Context locals are specific to the worker handling the activity, such as a
-isn't that a bad idea?
+thread, process, coroutine, or greenlet.
-Yes it is usually not such a bright idea to use thread locals.  They cause
+The context and proxies help solve two development issues: circular imports, and
-troubles for servers that are not based on the concept of threads and make
+passing around global data. :data:`.current_app: can be used to access the
-large applications harder to maintain.  However Flask is just not designed
+application object without needing to import the app object directly, avoiding
-for large applications or asynchronous servers.  Flask wants to make it
+circular import issues. :data:`.request`, :data:`.session`, and :data`.g` can be
-quick and easy to write a traditional web application.
+imported to access the current data for the request, rather than needing to
 pass them as arguments through every single function in your project.
 Async/await and ASGI support
@ -208,7 +209,7 @@ What Flask is, What Flask is Not
 Flask will never have a database layer.  It will not have a form library
 or anything else in that direction.  Flask itself just bridges to Werkzeug
-to implement a proper WSGI application and to Jinja2 to handle templating.
+to implement a proper WSGI application and to Jinja to handle templating.
 It also binds to a few common standard library packages such as logging.
 Everything else is up for extensions.
--- a/docs/extensiondev.rst
+++ b/docs/extensiondev.rst
@ -67,7 +67,7 @@ application instance.
 It is important that the app is not stored on the extension, don't do
 ``self.app = app``. The only time the extension should have direct
 access to an app is during ``init_app``, otherwise it should use
-:data:`current_app`.
+:data:`.current_app`.
 This allows the extension to support the application factory pattern,
 avoids circular import issues when importing the extension instance
@ -105,7 +105,7 @@ during an extension's ``init_app`` method.
 A common pattern is to use :meth:`~Flask.before_request` to initialize
 some data or a connection at the beginning of each request, then
 :meth:`~Flask.teardown_request` to clean it up at the end. This can be
-stored on :data:`g`, discussed more below.
+stored on :data:`.g`, discussed more below.
 A more lazy approach is to provide a method that initializes and caches
 the data or connection. For example, a ``ext.get_db`` method could
@ -179,13 +179,12 @@ name as a prefix, or as a namespace.
    g._hello = SimpleNamespace()
    g._hello.user_id = 2
-The data in ``g`` lasts for an application context. An application
+The data in ``g`` lasts for an application context. An application context is
-context is active when a request context is, or when a CLI command is
+active during a request, CLI command, or ``with app.app_context()`` block. If
-run. If you're storing something that should be closed, use
+you're storing something that should be closed, use
-:meth:`~flask.Flask.teardown_appcontext` to ensure that it gets closed
+:meth:`~flask.Flask.teardown_appcontext` to ensure that it gets closed when the
-when the application context ends. If it should only be valid during a
+app context ends. If it should only be valid during a request, or would not be
-request, or would not be used in the CLI outside a request, use
+used in the CLI outside a request, use :meth:`~flask.Flask.teardown_request`.
 :meth:`~flask.Flask.teardown_request`.
 Views and Models
@ -294,11 +293,13 @@ ecosystem remain consistent and compatible.
    indicate minimum compatibility support. For example,
    ``sqlalchemy>=1.4``.
 9.  Indicate the versions of Python supported using ``python_requires=">=version"``.
-    Flask itself supports Python >=3.9 as of October 2024, and this will update
+    Flask and Pallets policy is to support all Python versions that are not
-    over time.
+    within six months of end of life (EOL). See Python's `EOL calendar`_ for
    timing.
 .. _PyPI: https://pypi.org/search/?c=Framework+%3A%3A+Flask
 .. _Discord Chat: https://discord.gg/pallets
 .. _GitHub Discussions: https://github.com/pallets/flask/discussions
 .. _Official Pallets Themes: https://pypi.org/project/Pallets-Sphinx-Themes/
 .. _Pallets-Eco: https://github.com/pallets-eco
 .. _EOL calendar: https://devguide.python.org/versions/
--- a/docs/index.rst
+++ b/docs/index.rst
@ -3,8 +3,9 @@
 Welcome to Flask
 ================
-.. image:: _static/flask-horizontal.png
+.. image:: _static/flask-name.svg
    :align: center
    :height: 200px
 Welcome to Flask's documentation. Flask is a lightweight WSGI web application framework.
 It is designed to make getting started quick and easy, with the ability to scale up to
@ -51,7 +52,6 @@ community-maintained extensions to add even more functionality.
   views
   lifecycle
   appcontext
   reqcontext
   blueprints
   extensions
   cli
--- a/docs/installation.rst
+++ b/docs/installation.rst
@ -5,7 +5,7 @@ Installation
 Python Version
 --------------
-We recommend using the latest version of Python. Flask supports Python 3.9 and newer.
+We recommend using the latest version of Python. Flask supports Python 3.10 and newer.
 Dependencies
--- a/docs/lifecycle.rst
+++ b/docs/lifecycle.rst
@ -117,15 +117,12 @@ the view function, and pass the return value back to the server. But there are m
 parts that you can use to customize its behavior.
 #.  WSGI server calls the Flask object, which calls :meth:`.Flask.wsgi_app`.
-#.  A :class:`.RequestContext` object is created. This converts the WSGI ``environ``
+#.  An :class:`.AppContext` object is created. This converts the WSGI ``environ``
-    dict into a :class:`.Request` object. It also creates an :class:`AppContext` object.
+    dict into a :class:`.Request` object.
-#.  The :doc:`app context <appcontext>` is pushed, which makes :data:`.current_app` and
+#.  The :doc:`app context <appcontext>` is pushed, which makes
-    :data:`.g` available.
+    :data:`.current_app`, :data:`.g`, :data:`.request`, and :data:`.session`
    available.
 #.  The :data:`.appcontext_pushed` signal is sent.
 #.  The :doc:`request context <reqcontext>` is pushed, which makes :attr:`.request` and
    :class:`.session` available.
 #.  The session is opened, loading any existing session data using the app's
    :attr:`~.Flask.session_interface`, an instance of :class:`.SessionInterface`.
 #.  The URL is matched against the URL rules registered with the :meth:`~.Flask.route`
    decorator during application setup. If there is no match, the error - usually a 404,
    405, or redirect - is stored to be handled later.
@ -141,7 +138,8 @@ parts that you can use to customize its behavior.
    called to handle the error and return a response.
 #.  Whatever returned a response value - a before request function, the view, or an
    error handler, that value is converted to a :class:`.Response` object.
-#.  Any :func:`~.after_this_request` decorated functions are called, then cleared.
+#.  Any :func:`~.after_this_request` decorated functions are called, which can modify
    the response object. They are then cleared.
 #.  Any :meth:`~.Flask.after_request` decorated functions are called, which can modify
    the response object.
 #.  The session is saved, persisting any modified session data using the app's
@ -154,14 +152,19 @@ parts that you can use to customize its behavior.
 #.  The response object's status, headers, and body are returned to the WSGI server.
 #.  Any :meth:`~.Flask.teardown_request` decorated functions are called.
 #.  The :data:`.request_tearing_down` signal is sent.
 #.  The request context is popped, :attr:`.request` and :class:`.session` are no longer
    available.
 #.  Any :meth:`~.Flask.teardown_appcontext` decorated functions are called.
 #.  The :data:`.appcontext_tearing_down` signal is sent.
-#.  The app context is popped, :data:`.current_app` and :data:`.g` are no longer
+#.  The app context is popped, :data:`.current_app`, :data:`.g`, :data:`.request`,
-    available.
+    and :data:`.session` are no longer available.
 #.  The :data:`.appcontext_popped` signal is sent.
 When executing a CLI command or plain app context without request data, the same
 order of steps is followed, omitting the steps that refer to the request.
 A :class:`Blueprint` can add handlers for these events that are specific to the
 blueprint. The handlers for a blueprint will run if the blueprint
 owns the route that matches the request.
 There are even more decorators and customization points than this, but that aren't part
 of every request lifecycle. They're more specific to certain things you might use during
 a request, such as templates, building URLs, or handling JSON data. See the rest of this
--- a/docs/patterns/sqlalchemy.rst
+++ b/docs/patterns/sqlalchemy.rst
@ -131,9 +131,8 @@ Here is an example :file:`database.py` module for your application::
    def init_db():
        metadata.create_all(bind=engine)
-As in the declarative approach, you need to close the session after
+As in the declarative approach, you need to close the session after each app
-each request or application context shutdown.  Put this into your
+context. Put this into your application module::
 application module::
    from yourapplication.database import db_session
--- a/docs/patterns/sqlite3.rst
+++ b/docs/patterns/sqlite3.rst
@ -1,9 +1,9 @@
 Using SQLite 3 with Flask
 =========================
-In Flask you can easily implement the opening of database connections on
+You can implement a few functions to work with a SQLite connection during a
-demand and closing them when the context dies (usually at the end of the
+request context. The connection is created the first time it's accessed,
-request).
+reused on subsequent access, until it is closed when the request context ends.
 Here is a simple example of how you can use SQLite 3 with Flask::
--- a/docs/patterns/streaming.rst
+++ b/docs/patterns/streaming.rst
@ -29,7 +29,7 @@ debug environments with profilers and other things you might have enabled.
 Streaming from Templates
 ------------------------
-The Jinja2 template engine supports rendering a template piece by
+The Jinja template engine supports rendering a template piece by
 piece, returning an iterator of strings. Flask provides the
 :func:`~flask.stream_template` and :func:`~flask.stream_template_string`
 functions to make this easier to use.
@ -49,13 +49,13 @@ the template.
 Streaming with Context
 ----------------------
-The :data:`~flask.request` will not be active while the generator is
+The :data:`.request` proxy will not be active while the generator is
-running, because the view has already returned at that point. If you try
+running, because the app has already returned control to the WSGI server at that
-to access ``request``, you'll get a ``RuntimeError``.
+point. If you try to access ``request``, you'll get a ``RuntimeError``.
 If your generator function relies on data in ``request``, use the
-:func:`~flask.stream_with_context` wrapper. This will keep the request
+:func:`.stream_with_context` wrapper. This will keep the request context active
-context active during the generator.
+during the generator.
 .. code-block:: python
--- a/docs/patterns/wtforms.rst
+++ b/docs/patterns/wtforms.rst
@ -99,7 +99,7 @@ WTForm's field function, which renders the field for us.  The keyword
 arguments will be inserted as HTML attributes.  So, for example, you can
 call ``render_field(form.username, class='username')`` to add a class to
 the input element.  Note that WTForms returns standard Python strings,
-so we have to tell Jinja2 that this data is already HTML-escaped with
+so we have to tell Jinja that this data is already HTML-escaped with
 the ``|safe`` filter.
 Here is the :file:`register.html` template for the function we used above, which
--- a/docs/quickstart.rst
+++ b/docs/quickstart.rst
@ -139,18 +139,16 @@ how you're using untrusted data.
 .. code-block:: python
    from flask import request
    from markupsafe import escape
-    @app.route("/<name>")
+    @app.route("/hello")
-    def hello(name):
+    def hello():
        name = request.args.get("name", "Flask")
        return f"Hello, {escape(name)}!"
-If a user managed to submit the name ``<script>alert("bad")</script>``,
+If a user submits ``/hello?name=<script>alert("bad")</script>``, escaping causes
-escaping causes it to be rendered as text, rather than running the
+it to be rendered as text, rather than running the script in the user's browser.
 script in the user's browser.
 ``<name>`` in the route captures a value from the URL and passes it to
 the view function. These variable rules are explained below.
 Routing
@ -260,7 +258,7 @@ Why would you want to build URLs using the URL reversing function
 For example, here we use the :meth:`~flask.Flask.test_request_context` method
 to try out :func:`~flask.url_for`. :meth:`~flask.Flask.test_request_context`
 tells Flask to behave as though it's handling a request even while we use a
-Python shell. See :ref:`context-locals`.
+Python shell. See :doc:`/appcontext`.
 .. code-block:: python
@ -354,7 +352,7 @@ Rendering Templates
 Generating HTML from within Python is not fun, and actually pretty
 cumbersome because you have to do the HTML escaping on your own to keep
-the application secure.  Because of that Flask configures the `Jinja2
+the application secure.  Because of that Flask configures the `Jinja
 <https://palletsprojects.com/p/jinja/>`_ template engine for you automatically.
 Templates can be used to generate any type of text file. For web applications, you'll
@ -394,8 +392,8 @@ package it's actually inside your package:
        /templates
            /hello.html
-For templates you can use the full power of Jinja2 templates.  Head over
+For templates you can use the full power of Jinja templates.  Head over
-to the official `Jinja2 Template Documentation
+to the official `Jinja Template Documentation
 <https://jinja.palletsprojects.com/templates/>`_ for more information.
 Here is an example template:
@ -451,105 +449,58 @@ Here is a basic introduction to how the :class:`~markupsafe.Markup` class works:
 Accessing Request Data
 ----------------------
-For web applications it's crucial to react to the data a client sends to
+For web applications it's crucial to react to the data a client sends to the
-the server.  In Flask this information is provided by the global
+server. In Flask this information is provided by the global :data:`.request`
-:class:`~flask.request` object.  If you have some experience with Python
+object, which is an instance of :class:`.Request`. This object has many
-you might be wondering how that object can be global and how Flask
+attributes and methods to work with the incoming request data, but here is a
-manages to still be threadsafe.  The answer is context locals:
+broad overview. First it needs to be imported.
-
+.. code-block:: python
 .. _context-locals:
 Context Locals
 ``````````````
 .. admonition:: Insider Information
   If you want to understand how that works and how you can implement
   tests with context locals, read this section, otherwise just skip it.
 Certain objects in Flask are global objects, but not of the usual kind.
 These objects are actually proxies to objects that are local to a specific
 context.  What a mouthful.  But that is actually quite easy to understand.
 Imagine the context being the handling thread.  A request comes in and the
 web server decides to spawn a new thread (or something else, the
 underlying object is capable of dealing with concurrency systems other
 than threads).  When Flask starts its internal request handling it
 figures out that the current thread is the active context and binds the
 current application and the WSGI environments to that context (thread).
 It does that in an intelligent way so that one application can invoke another
 application without breaking.
 So what does this mean to you?  Basically you can completely ignore that
 this is the case unless you are doing something like unit testing.  You
 will notice that code which depends on a request object will suddenly break
 because there is no request object.  The solution is creating a request
 object yourself and binding it to the context.  The easiest solution for
 unit testing is to use the :meth:`~flask.Flask.test_request_context`
 context manager.  In combination with the ``with`` statement it will bind a
 test request so that you can interact with it.  Here is an example::
    from flask import request
-    with app.test_request_context('/hello', method='POST'):
+If you have some experience with Python you might be wondering how that object
-        # now you can do something with the request until the
+can be global when Flask handles multiple requests at a time. The answer is
-        # end of the with block, such as basic assertions:
+that :data:`.request` is actually a proxy, pointing at whatever request is
-        assert request.path == '/hello'
+currently being handled by a given worker, which is managed interanlly by Flask
-        assert request.method == 'POST'
+and Python. See :doc:`/appcontext` for much more information.
-The other possibility is passing a whole WSGI environment to the
+The current request method is available in the :attr:`~.Request.method`
-:meth:`~flask.Flask.request_context` method::
+attribute. To access form data (data transmitted in a ``POST`` or ``PUT``
 request), use the :attr:`~flask.Request.form` attribute, which behaves like a
 dict.
-    with app.request_context(environ):
+.. code-block:: python
        assert request.method == 'POST'
-The Request Object
+    @app.route("/login", methods=["GET", "POST"])
 ``````````````````
 The request object is documented in the API section and we will not cover
 it here in detail (see :class:`~flask.Request`). Here is a broad overview of
 some of the most common operations.  First of all you have to import it from
 the ``flask`` module::
    from flask import request
 The current request method is available by using the
 :attr:`~flask.Request.method` attribute.  To access form data (data
 transmitted in a ``POST`` or ``PUT`` request) you can use the
 :attr:`~flask.Request.form` attribute.  Here is a full example of the two
 attributes mentioned above::
    @app.route('/login', methods=['POST', 'GET'])
    def login():
        error = None
-        if request.method == 'POST':
+
-            if valid_login(request.form['username'],
+        if request.method == "POST":
-                           request.form['password']):
+            if valid_login(request.form["username"], request.form["password"]):
-                return log_the_user_in(request.form['username'])
+                return store_login(request.form["username"])
            else:
-                error = 'Invalid username/password'
+                error = "Invalid username or password"
        # the code below is executed if the request method
        # was GET or the credentials were invalid
        return render_template('login.html', error=error)
-What happens if the key does not exist in the ``form`` attribute?  In that
+        # Executed if the request method was GET or the credentials were invalid.
-case a special :exc:`KeyError` is raised.  You can catch it like a
+        return render_template("login.html", error=error)
 standard :exc:`KeyError` but if you don't do that, a HTTP 400 Bad Request
 error page is shown instead.  So for many situations you don't have to
 deal with that problem.
-To access parameters submitted in the URL (``?key=value``) you can use the
+If the key does not exist in ``form``, a special :exc:`KeyError` is raised. You
-:attr:`~flask.Request.args` attribute::
+can catch it like a normal ``KeyError``, otherwise it will return a HTTP 400
 Bad Request error page. You can also use the
 :meth:`~werkzeug.datastructures.MultiDict.get` method to get a default
 instead of an error.
 To access parameters submitted in the URL (``?key=value``), use the
 :attr:`~.Request.args` attribute. Key errors behave the same as ``form``,
 returning a 400 response if not caught.
 .. code-block:: python
    searchword = request.args.get('key', '')
-We recommend accessing URL parameters with `get` or by catching the
+For a full list of methods and attributes of the request object, see the
-:exc:`KeyError` because users might change the URL and presenting them a 400
+:class:`~.Request` documentation.
 bad request page in that case is not user friendly.
 For a full list of methods and attributes of the request object, head over
 to the :class:`~flask.Request` documentation.
 File Uploads
--- a/docs/reqcontext.rst
+++ b/docs/reqcontext.rst
@ -1,243 +1,6 @@
-.. currentmodule:: flask
+:orphan:
 The Request Context
 ===================
-The request context keeps track of the request-level data during a
+Obsolete, see :doc:`/appcontext` instead.
 request. Rather than passing the request object to each function that
 runs during a request, the :data:`request` and :data:`session` proxies
 are accessed instead.
 This is similar to :doc:`/appcontext`, which keeps track of the
 application-level data independent of a request. A corresponding
 application context is pushed when a request context is pushed.
 Purpose of the Context
 ----------------------
 When the :class:`Flask` application handles a request, it creates a
 :class:`Request` object based on the environment it received from the
 WSGI server. Because a *worker* (thread, process, or coroutine depending
 on the server) handles only one request at a time, the request data can
 be considered global to that worker during that request. Flask uses the
 term *context local* for this.
 Flask automatically *pushes* a request context when handling a request.
 View functions, error handlers, and other functions that run during a
 request will have access to the :data:`request` proxy, which points to
 the request object for the current request.
 Lifetime of the Context
 -----------------------
 When a Flask application begins handling a request, it pushes a request
 context, which also pushes an :doc:`app context </appcontext>`. When the
 request ends it pops the request context then the application context.
 The context is unique to each thread (or other worker type).
 :data:`request` cannot be passed to another thread, the other thread has
 a different context space and will not know about the request the parent
 thread was pointing to.
 Context locals are implemented using Python's :mod:`contextvars` and
 Werkzeug's :class:`~werkzeug.local.LocalProxy`. Python manages the
 lifetime of context vars automatically, and local proxy wraps that
 low-level interface to make the data easier to work with.
 Manually Push a Context
 -----------------------
 If you try to access :data:`request`, or anything that uses it, outside
 a request context, you'll get this error message:
 .. code-block:: pytb
    RuntimeError: Working outside of request context.
    This typically means that you attempted to use functionality that
    needed an active HTTP request. Consult the documentation on testing
    for information about how to avoid this problem.
 This should typically only happen when testing code that expects an
 active request. One option is to use the
 :meth:`test client <Flask.test_client>` to simulate a full request. Or
 you can use :meth:`~Flask.test_request_context` in a ``with`` block, and
 everything that runs in the block will have access to :data:`request`,
 populated with your test data. ::
    def generate_report(year):
        format = request.args.get("format")
        ...
    with app.test_request_context(
        "/make_report/2017", query_string={"format": "short"}
    ):
        generate_report()
 If you see that error somewhere else in your code not related to
 testing, it most likely indicates that you should move that code into a
 view function.
 For information on how to use the request context from the interactive
 Python shell, see :doc:`/shell`.
 How the Context Works
 ---------------------
 The :meth:`Flask.wsgi_app` method is called to handle each request. It
 manages the contexts during the request. Internally, the request and
 application contexts work like stacks. When contexts are pushed, the
 proxies that depend on them are available and point at information from
 the top item.
 When the request starts, a :class:`~ctx.RequestContext` is created and
 pushed, which creates and pushes an :class:`~ctx.AppContext` first if
 a context for that application is not already the top context. While
 these contexts are pushed, the :data:`current_app`, :data:`g`,
 :data:`request`, and :data:`session` proxies are available to the
 original thread handling the request.
 Other contexts may be pushed to change the proxies during a request.
 While this is not a common pattern, it can be used in advanced
 applications to, for example, do internal redirects or chain different
 applications together.
 After the request is dispatched and a response is generated and sent,
 the request context is popped, which then pops the application context.
 Immediately before they are popped, the :meth:`~Flask.teardown_request`
 and :meth:`~Flask.teardown_appcontext` functions are executed. These
 execute even if an unhandled exception occurred during dispatch.
 .. _callbacks-and-errors:
 Callbacks and Errors
 --------------------
 Flask dispatches a request in multiple stages which can affect the
 request, response, and how errors are handled. The contexts are active
 during all of these stages.
 A :class:`Blueprint` can add handlers for these events that are specific
 to the blueprint. The handlers for a blueprint will run if the blueprint
 owns the route that matches the request.
 #.  Before each request, :meth:`~Flask.before_request` functions are
    called. If one of these functions return a value, the other
    functions are skipped. The return value is treated as the response
    and the view function is not called.
 #.  If the :meth:`~Flask.before_request` functions did not return a
    response, the view function for the matched route is called and
    returns a response.
 #.  The return value of the view is converted into an actual response
    object and passed to the :meth:`~Flask.after_request`
    functions. Each function returns a modified or new response object.
 #.  After the response is returned, the contexts are popped, which calls
    the :meth:`~Flask.teardown_request` and
    :meth:`~Flask.teardown_appcontext` functions. These functions are
    called even if an unhandled exception was raised at any point above.
 If an exception is raised before the teardown functions, Flask tries to
 match it with an :meth:`~Flask.errorhandler` function to handle the
 exception and return a response. If no error handler is found, or the
 handler itself raises an exception, Flask returns a generic
 ``500 Internal Server Error`` response. The teardown functions are still
 called, and are passed the exception object.
 If debug mode is enabled, unhandled exceptions are not converted to a
 ``500`` response and instead are propagated to the WSGI server. This
 allows the development server to present the interactive debugger with
 the traceback.
 Teardown Callbacks
 ~~~~~~~~~~~~~~~~~~
 The teardown callbacks are independent of the request dispatch, and are
 instead called by the contexts when they are popped. The functions are
 called even if there is an unhandled exception during dispatch, and for
 manually pushed contexts. This means there is no guarantee that any
 other parts of the request dispatch have run first. Be sure to write
 these functions in a way that does not depend on other callbacks and
 will not fail.
 During testing, it can be useful to defer popping the contexts after the
 request ends, so that their data can be accessed in the test function.
 Use the :meth:`~Flask.test_client` as a ``with`` block to preserve the
 contexts until the ``with`` block exits.
 .. code-block:: python
    from flask import Flask, request
    app = Flask(__name__)
    @app.route('/')
    def hello():
        print('during view')
        return 'Hello, World!'
    @app.teardown_request
    def show_teardown(exception):
        print('after with block')
    with app.test_request_context():
        print('during with block')
    # teardown functions are called after the context with block exits
    with app.test_client() as client:
        client.get('/')
        # the contexts are not popped even though the request ended
        print(request.path)
    # the contexts are popped and teardown functions are called after
    # the client with block exits
 Signals
 ~~~~~~~
 The following signals are sent:
 #.  :data:`request_started` is sent before the :meth:`~Flask.before_request` functions
    are called.
 #.  :data:`request_finished` is sent after the :meth:`~Flask.after_request` functions
    are called.
 #.  :data:`got_request_exception` is sent when an exception begins to be handled, but
    before an :meth:`~Flask.errorhandler` is looked up or called.
 #.  :data:`request_tearing_down` is sent after the :meth:`~Flask.teardown_request`
    functions are called.
 .. _notes-on-proxies:
 Notes On Proxies
 ----------------
 Some of the objects provided by Flask are proxies to other objects. The
 proxies are accessed in the same way for each worker thread, but
 point to the unique object bound to each worker behind the scenes as
 described on this page.
 Most of the time you don't have to care about that, but there are some
 exceptions where it is good to know that this object is actually a proxy:
 -   The proxy objects cannot fake their type as the actual object types.
    If you want to perform instance checks, you have to do that on the
    object being proxied.
 -   The reference to the proxied object is needed in some situations,
    such as sending :doc:`signals` or passing data to a background
    thread.
 If you need to access the underlying object that is proxied, use the
 :meth:`~werkzeug.local.LocalProxy._get_current_object` method::
    app = current_app._get_current_object()
    my_signal.send(app)
--- a/docs/server.rst
+++ b/docs/server.rst
@ -77,7 +77,7 @@ following example shows that process id 6847 is using port 5000.
 macOS Monterey and later automatically starts a service that uses port
 5000. You can choose to disable this service instead of using a different port by
-searching for "AirPlay Receiver" in System Preferences and toggling it off.
+searching for "AirPlay Receiver" in System Settings and toggling it off.
 Deferred Errors on Reload
--- a/docs/shell.rst
+++ b/docs/shell.rst
@ -1,56 +1,37 @@
 Working with the Shell
 ======================
-.. versionadded:: 0.3
+One of the reasons everybody loves Python is the interactive shell. It allows
 you to play around with code in real time and immediately get results back.
 Flask provides the ``flask shell`` CLI command to start an interactive Python
 shell with some setup done to make working with the Flask app easier.
-One of the reasons everybody loves Python is the interactive shell.  It
+.. code-block:: text
 basically allows you to execute Python commands in real time and
 immediately get results back.  Flask itself does not come with an
 interactive shell, because it does not require any specific setup upfront,
 just import your application and start playing around.
-There are however some handy helpers to make playing around in the shell a
+    $ flask shell
 more pleasant experience.  The main issue with interactive console
 sessions is that you're not triggering a request like a browser does which
 means that :data:`~flask.g`, :data:`~flask.request` and others are not
 available.  But the code you want to test might depend on them, so what
 can you do?
 This is where some helper functions come in handy.  Keep in mind however
 that these functions are not only there for interactive shell usage, but
 also for unit testing and other situations that require a faked request
 context.
 Generally it's recommended that you read :doc:`reqcontext` first.
 Command Line Interface
 ----------------------
 Starting with Flask 0.11 the recommended way to work with the shell is the
 ``flask shell`` command which does a lot of this automatically for you.
 For instance the shell is automatically initialized with a loaded
 application context.
 For more information see :doc:`/cli`.
 Creating a Request Context
 --------------------------
 ``flask shell`` pushes an app context automatically, so :data:`.current_app` and
 :data:`.g` are already available. However, there is no HTTP request being
 handled in the shell, so :data:`.request` and :data:`.session` are not yet
 available.
 The easiest way to create a proper request context from the shell is by
 using the :attr:`~flask.Flask.test_request_context` method which creates
 us a :class:`~flask.ctx.RequestContext`:
 >>> ctx = app.test_request_context()
-Normally you would use the ``with`` statement to make this request object
+Normally you would use the ``with`` statement to make this context active, but
-active, but in the shell it's easier to use the
+in the shell it's easier to call :meth:`~.RequestContext.push` and
-:meth:`~flask.ctx.RequestContext.push` and
+:meth:`~.RequestContext.pop` manually:
 :meth:`~flask.ctx.RequestContext.pop` methods by hand:
 >>> ctx.push()
-From that point onwards you can work with the request object until you
+From that point onwards you can work with the request object until you call
-call `pop`:
+``pop``:
 >>> ctx.pop()
--- a/docs/signals.rst
+++ b/docs/signals.rst
@ -144,11 +144,10 @@ function, you can pass ``current_app._get_current_object()`` as sender.
 Signals and Flask's Request Context
 -----------------------------------
-Signals fully support :doc:`reqcontext` when receiving signals.
+Context-local proxies are available between :data:`~flask.request_started` and
-Context-local variables are consistently available between
+:data:`~flask.request_finished`, so you can rely on :class:`flask.g` and others
-:data:`~flask.request_started` and :data:`~flask.request_finished`, so you can
+as needed. Note the limitations described in :ref:`signals-sending` and the
-rely on :class:`flask.g` and others as needed.  Note the limitations described
+:data:`~flask.request_tearing_down` signal.
 in :ref:`signals-sending` and the :data:`~flask.request_tearing_down` signal.
 Decorator Based Signal Subscriptions
--- a/docs/templating.rst
+++ b/docs/templating.rst
@ -1,21 +1,21 @@
 Templates
 =========
-Flask leverages Jinja2 as its template engine.  You are obviously free to use
+Flask leverages Jinja as its template engine.  You are obviously free to use
-a different template engine, but you still have to install Jinja2 to run
+a different template engine, but you still have to install Jinja to run
 Flask itself.  This requirement is necessary to enable rich extensions.
-An extension can depend on Jinja2 being present.
+An extension can depend on Jinja being present.
-This section only gives a very quick introduction into how Jinja2
+This section only gives a very quick introduction into how Jinja
 is integrated into Flask.  If you want information on the template
-engine's syntax itself, head over to the official `Jinja2 Template
+engine's syntax itself, head over to the official `Jinja Template
 Documentation <https://jinja.palletsprojects.com/templates/>`_ for
 more information.
 Jinja Setup
 -----------
-Unless customized, Jinja2 is configured by Flask as follows:
+Unless customized, Jinja is configured by Flask as follows:
 -   autoescaping is enabled for all templates ending in ``.html``,
    ``.htm``, ``.xml``, ``.xhtml``, as well as ``.svg`` when using
@ -25,13 +25,13 @@ Unless customized, Jinja2 is configured by Flask as follows:
 -   a template has the ability to opt in/out autoescaping with the
    ``{% autoescape %}`` tag.
 -   Flask inserts a couple of global functions and helpers into the
-    Jinja2 context, additionally to the values that are present by
+    Jinja context, additionally to the values that are present by
    default.
 Standard Context
 ----------------
-The following global variables are available within Jinja2 templates
+The following global variables are available within Jinja templates
 by default:
 .. data:: config
@ -137,32 +137,58 @@ using in this block.
 .. _registering-filters:
-Registering Filters
+Registering Filters, Tests, and Globals
-------------------
+---------------------------------------
-If you want to register your own filters in Jinja2 you have two ways to do
+The Flask app and blueprints provide decorators and methods to register your own
-that.  You can either put them by hand into the
+filters, tests, and global functions for use in Jinja templates. They all follow
-:attr:`~flask.Flask.jinja_env` of the application or use the
+the same pattern, so the following examples only discuss filters.
 :meth:`~flask.Flask.template_filter` decorator.
-The two following examples work the same and both reverse an object::
+Decorate a function with :meth:`~.Flask.template_filter` to register it as a
 template filter.
-    @app.template_filter('reverse')
+.. code-block:: python
    def reverse_filter(s):
        return s[::-1]
-    def reverse_filter(s):
+    @app.template_filter
-        return s[::-1]
+    def reverse(s):
-    app.jinja_env.filters['reverse'] = reverse_filter
+        return reversed(s)
-In case of the decorator the argument is optional if you want to use the
+.. code-block:: jinja
 function name as name of the filter.  Once registered, you can use the filter
 in your templates in the same way as Jinja2's builtin filters, for example if
 you have a Python list in context called `mylist`::
-    {% for x in mylist | reverse %}
+    {% for item in data | reverse %}
    {% endfor %}
 By default it will use the name of the function as the name of the filter, but
 that can be changed by passing a name to the decorator.
 .. code-block:: python
    @app.template_filter("reverse")
    def reverse_filter(s):
        return reversed(s)
 A filter can be registered separately using :meth:`~.Flask.add_template_filter`.
 The name is optional and will use the function name if not given.
 .. code-block:: python
    def reverse_filter(s):
        return reversed(s)
    app.add_template_filter(reverse_filter, "reverse")
 For template tests, use the :meth:`~.Flask.template_test` decorator or
 :meth:`~.Flask.add_template_test` method. For template global functions, use the
 :meth:`~.Flask.template_global` decorator or :meth:`~.Flask.add_template_global`
 method.
 The same methods also exist on :class:`.Blueprint`, prefixed with ``app_`` to
 indicate that the registered functions will be avaialble to all templates, not
 only when rendering from within the blueprint.
 The Jinja environment is also available as :attr:`~.Flask.jinja_env`. It may be
 modified directly, as you would when using Jinja outside Flask.
 Context Processors
 ------------------
@ -211,7 +237,7 @@ strings. This can be used for streaming HTML in chunks to speed up
 initial page load, or to save memory when rendering a very large
 template.
-The Jinja2 template engine supports rendering a template piece
+The Jinja template engine supports rendering a template piece
 by piece, returning an iterator of strings. Flask provides the
 :func:`~flask.stream_template` and :func:`~flask.stream_template_string`
 functions to make this easier to use.
--- a/docs/testing.rst
+++ b/docs/testing.rst
@ -275,11 +275,10 @@ command from the command line.
 Tests that depend on an Active Context
 --------------------------------------
-You may have functions that are called from views or commands, that
+You may have functions that are called from views or commands, that expect an
-expect an active :doc:`application context </appcontext>` or
+active :doc:`app context </appcontext>` because they access :data:`.request`,
-:doc:`request context  </reqcontext>` because they access ``request``,
+:data:`.session`, :data:`.g`, or :data:`.current_app`. Rather than testing them by
-``session``, or ``current_app``. Rather than testing them by making a
+making a request or invoking the command, you can create and activate a context
 request or invoking the command, you can create and activate a context
 directly.
 Use ``with app.app_context()`` to push an application context. For
--- a/docs/tutorial/blog.rst
+++ b/docs/tutorial/blog.rst
@ -305,7 +305,7 @@ The pattern ``{{ request.form['title'] or post['title'] }}`` is used to
 choose what data appears in the form. When the form hasn't been
 submitted, the original ``post`` data appears, but if invalid form data
 was posted you want to display that so the user can fix the error, so
-``request.form`` is used instead. :data:`request` is another variable
+``request.form`` is used instead. :data:`.request` is another variable
 that's automatically available in templates.
--- a/docs/tutorial/database.rst
+++ b/docs/tutorial/database.rst
@ -60,17 +60,17 @@ response is sent.
        if db is not None:
            db.close()
-:data:`g` is a special object that is unique for each request. It is
+:data:`.g` is a special object that is unique for each request. It is
 used to store data that might be accessed by multiple functions during
 the request. The connection is stored and reused instead of creating a
 new connection if ``get_db`` is called a second time in the same
 request.
-:data:`current_app` is another special object that points to the Flask
+:data:`.current_app` is another special object that points to the Flask
 application handling the request. Since you used an application factory,
 there is no application object when writing the rest of your code.
 ``get_db`` will be called when the application has been created and is
-handling a request, so :data:`current_app` can be used.
+handling a request, so :data:`.current_app` can be used.
 :func:`sqlite3.connect` establishes a connection to the file pointed at
 by the ``DATABASE`` configuration key. This file doesn't have to exist
--- a/docs/tutorial/templates.rst
+++ b/docs/tutorial/templates.rst
@ -71,7 +71,7 @@ specific sections.
      {% block content %}{% endblock %}
    </section>
-:data:`g` is automatically available in templates. Based on if
+:data:`.g` is automatically available in templates. Based on if
 ``g.user`` is set (from ``load_logged_in_user``), either the username
 and a log out link are displayed, or links to register and log in
 are displayed. :func:`url_for` is also automatically available, and is
--- a/docs/tutorial/tests.rst
+++ b/docs/tutorial/tests.rst
@ -311,7 +311,7 @@ input and error messages without writing the same code three times.
 The tests for the ``login`` view are very similar to those for
 ``register``. Rather than testing the data in the database,
-:data:`session` should have ``user_id`` set after logging in.
+:data:`.session` should have ``user_id`` set after logging in.
 .. code-block:: python
    :caption: ``tests/test_auth.py``
@ -336,10 +336,10 @@ The tests for the ``login`` view are very similar to those for
        assert message in response.data
 Using ``client`` in a ``with`` block allows accessing context variables
-such as :data:`session` after the response is returned. Normally,
+such as :data:`.session` after the response is returned. Normally,
 accessing ``session`` outside of a request would raise an error.
-Testing ``logout`` is the opposite of ``login``. :data:`session` should
+Testing ``logout`` is the opposite of ``login``. :data:`.session` should
 not contain ``user_id`` after logging out.
 .. code-block:: python
--- a/docs/tutorial/views.rst
+++ b/docs/tutorial/views.rst
@ -208,13 +208,13 @@ There are a few differences from the ``register`` view:
    password in the same way as the stored hash and securely compares
    them. If they match, the password is valid.
-#.  :data:`session` is a :class:`dict` that stores data across requests.
+#.  :data:`.session` is a :class:`dict` that stores data across requests.
    When validation succeeds, the user's ``id`` is stored in a new
    session. The data is stored in a *cookie* that is sent to the
    browser, and the browser then sends it back with subsequent requests.
    Flask securely *signs* the data so that it can't be tampered with.
-Now that the user's ``id`` is stored in the :data:`session`, it will be
+Now that the user's ``id`` is stored in the :data:`.session`, it will be
 available on subsequent requests. At the beginning of each request, if
 a user is logged in their information should be loaded and made
 available to other views.
@ -236,7 +236,7 @@ available to other views.
 :meth:`bp.before_app_request() <Blueprint.before_app_request>` registers
 a function that runs before the view function, no matter what URL is
 requested. ``load_logged_in_user`` checks if a user id is stored in the
-:data:`session` and gets that user's data from the database, storing it
+:data:`.session` and gets that user's data from the database, storing it
 on :data:`g.user <g>`, which lasts for the length of the request. If
 there is no user id, or if the id doesn't exist, ``g.user`` will be
 ``None``.
@ -245,7 +245,7 @@ there is no user id, or if the id doesn't exist, ``g.user`` will be
 Logout
 ------
-To log out, you need to remove the user id from the :data:`session`.
+To log out, you need to remove the user id from the :data:`.session`.
 Then ``load_logged_in_user`` won't load a user on subsequent requests.
 .. code-block:: python
--- a/docs/web-security.rst
+++ b/docs/web-security.rst
@ -51,12 +51,12 @@ tags.  For more information on that have a look at the Wikipedia article
 on `Cross-Site Scripting
 <https://en.wikipedia.org/wiki/Cross-site_scripting>`_.
-Flask configures Jinja2 to automatically escape all values unless
+Flask configures Jinja to automatically escape all values unless
 explicitly told otherwise.  This should rule out all XSS problems caused
 in templates, but there are still other places where you have to be
 careful:
-   generating HTML without the help of Jinja2
+-   generating HTML without the help of Jinja
 -   calling :class:`~markupsafe.Markup` on data submitted by users
 -   sending out HTML from uploaded files, never do that, use the
    ``Content-Disposition: attachment`` header to prevent that problem.
@ -65,7 +65,7 @@ careful:
    trick a browser to execute HTML.
 Another thing that is very important are unquoted attributes.  While
-Jinja2 can protect you from XSS issues by escaping HTML, there is one
+Jinja can protect you from XSS issues by escaping HTML, there is one
 thing it cannot protect you from: XSS by attribute injection.  To counter
 this possible attack vector, be sure to always quote your attributes with
 either double or single quotes when using Jinja expressions in them:
@ -158,7 +158,7 @@ recommend reviewing each of the headers below for use in your application.
 The `Flask-Talisman`_ extension can be used to manage HTTPS and the security
 headers for you.
-.. _Flask-Talisman: https://github.com/GoogleCloudPlatform/flask-talisman
+.. _Flask-Talisman: https://github.com/wntrblm/flask-talisman
 HTTP Strict Transport Security (HSTS)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@ -269,6 +269,27 @@ values (or any values that need secure signatures).
 .. _samesite_support: https://caniuse.com/#feat=same-site-cookie-attribute
 Host Header Validation
 ----------------------
 The ``Host`` header is used by the client to indicate what host name the request
 was made to. This is used, for example, by ``url_for(..., _external=True)`` to
 generate full URLs, for use in email or other messages outside the browser
 window.
 By default the app doesn't know what host(s) it is allowed to be accessed
 through, and assumes any host is valid. Although browsers do not allow setting
 the ``Host`` header, requests made by attackers in other scenarios could set
 the ``Host`` header to a value they want.
 When deploying your application, set :data:`TRUSTED_HOSTS` to restrict what
 values the ``Host`` header may be.
 The ``Host`` header may be modified by proxies in between the client and your
 application. See :doc:`deploying/proxy_fix` to tell your app which proxy values
 to trust.
 Copy/Paste to Terminal
 ----------------------
--- a/pyproject.toml
+++ b/pyproject.toml
@ -1,6 +1,6 @@
 [project]
 name = "Flask"
-version = "3.1.1"
+version = "3.2.0.dev"
 description = "A simple framework for building complex web applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@ -19,11 +19,10 @@ classifiers = [
    "Topic :: Software Development :: Libraries :: Application Frameworks",
    "Typing :: Typed",
 ]
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 dependencies = [
    "blinker>=1.9.0",
    "click>=8.1.3",
    "importlib-metadata>=3.6.0; python_version < '3.10'",
    "itsdangerous>=2.2.0",
    "jinja2>=3.1.2",
    "markupsafe>=2.1.1",
@ -58,7 +57,7 @@ pre-commit = [
 ]
 tests = [
    "asgiref",
-    "greenlet ; python_version < '3.11'",
+    "greenlet",
    "pytest",
    "python-dotenv",
 ]
@ -126,7 +125,7 @@ exclude_also = [
 ]
 [tool.mypy]
-python_version = "3.9"
+python_version = "3.10"
 files = ["src", "tests/type_check"]
 show_error_codes = true
 pretty = true
@ -142,7 +141,7 @@ module = [
 ignore_missing_imports = true
 [tool.pyright]
-pythonVersion = "3.9"
+pythonVersion = "3.10"
 include = ["src", "tests/type_check"]
 typeCheckingMode = "basic"
@ -161,19 +160,17 @@ select = [
    "UP",  # pyupgrade
    "W",  # pycodestyle warning
 ]
 ignore = [
    "UP038",  # keep isinstance tuple
 ]
 [tool.ruff.lint.isort]
 force-single-line = true
 order-by-type = false
 [tool.gha-update]
 tag-only = [
    "slsa-framework/slsa-github-generator",
 ]
 [tool.tox]
 env_list = [
-    "py3.13", "py3.12", "py3.11", "py3.10", "py3.9",
+    "py3.13", "py3.12", "py3.11", "py3.10",
    "pypy3.11",
    "tests-min", "tests-dev",
    "style",
--- a/src/flask/init.py
+++ b/src/flask/init.py
@ -1,7 +1,3 @@
 from __future__ import annotations
 import typing as t
 from . import json as json
 from .app import Flask as Flask
 from .blueprints import Blueprint as Blueprint
@ -41,21 +37,3 @@ from .templating import stream_template as stream_template
 from .templating import stream_template_string as stream_template_string
 from .wrappers import Request as Request
 from .wrappers import Response as Response
 if not t.TYPE_CHECKING:
    def __getattr__(name: str) -> t.Any:
        if name == "__version__":
            import importlib.metadata
            import warnings
            warnings.warn(
                "The '__version__' attribute is deprecated and will be removed in"
                " Flask 3.2. Use feature detection or"
                " 'importlib.metadata.version(\"flask\")' instead.",
                DeprecationWarning,
                stacklevel=2,
            )
            return importlib.metadata.version("flask")
        raise AttributeError(name)
--- a/src/flask/app.py
+++ b/src/flask/app.py
@ -29,20 +29,15 @@ from werkzeug.wsgi import get_host
 from . import cli
 from . import typing as ft
 from .ctx import AppContext
 from .ctx import RequestContext
 from .globals import _cv_app
 from .globals import _cv_request
 from .globals import current_app
 from .globals import g
 from .globals import request
 from .globals import request_ctx
 from .globals import session
 from .helpers import get_debug_flag
 from .helpers import get_flashed_messages
 from .helpers import get_load_dotenv
 from .helpers import send_from_directory
 from .sansio.app import App
 from .sansio.scaffold import _sentinel
 from .sessions import SecureCookieSessionInterface
 from .sessions import SessionInterface
 from .signals import appcontext_tearing_down
@ -295,7 +290,7 @@ class Flask(App):
        .. versionadded:: 0.9
        """
-        value = current_app.config["SEND_FILE_MAX_AGE_DEFAULT"]
+        value = self.config["SEND_FILE_MAX_AGE_DEFAULT"]
        if value is None:
            return None
@ -517,8 +512,8 @@ class Flask(App):
        names: t.Iterable[str | None] = (None,)
        # A template may be rendered outside a request context.
-        if request:
+        if (ctx := _cv_app.get(None)) is not None and ctx.has_request:
-            names = chain(names, reversed(request.blueprints))
+            names = chain(names, reversed(ctx.request.blueprints))
        # The values passed to render_template take precedence. Keep a
        # copy to re-apply after all context functions.
@ -886,7 +881,8 @@ class Flask(App):
           This no longer does the exception handling, this code was
           moved to the new :meth:`full_dispatch_request`.
        """
-        req = request_ctx.request
+        req = _cv_app.get().request
        if req.routing_exception is not None:
            self.raise_routing_exception(req)
        rule: Rule = req.url_rule  # type: ignore[assignment]
@ -957,7 +953,7 @@ class Flask(App):
        .. versionadded:: 0.7
        """
-        adapter = request_ctx.url_adapter
+        adapter = _cv_app.get().url_adapter
        methods = adapter.allowed_methods()  # type: ignore[union-attr]
        rv = self.response_class()
        rv.allow.update(methods)
@ -1057,11 +1053,9 @@ class Flask(App):
        .. versionadded:: 2.2
            Moved from ``flask.url_for``, which calls this method.
        """
-        req_ctx = _cv_request.get(None)
+        if (ctx := _cv_app.get(None)) is not None and ctx.has_request:
-
+            url_adapter = ctx.url_adapter
-        if req_ctx is not None:
+            blueprint_name = ctx.request.blueprint
            url_adapter = req_ctx.url_adapter
            blueprint_name = req_ctx.request.blueprint
            # If the endpoint starts with "." and the request matches a
            # blueprint, the endpoint is relative to the blueprint.
@ -1076,13 +1070,11 @@ class Flask(App):
            if _external is None:
                _external = _scheme is not None
        else:
            app_ctx = _cv_app.get(None)
            # If called by helpers.url_for, an app context is active,
            # use its url_adapter. Otherwise, app.url_for was called
            # directly, build an adapter.
-            if app_ctx is not None:
+            if ctx is not None:
-                url_adapter = app_ctx.url_adapter
+                url_adapter = ctx.url_adapter
            else:
                url_adapter = self.create_url_adapter(None)
@ -1278,12 +1270,13 @@ class Flask(App):
        value is handled as if it was the return value from the view, and
        further request handling is stopped.
        """
-        names = (None, *reversed(request.blueprints))
+        req = _cv_app.get().request
        names = (None, *reversed(req.blueprints))
        for name in names:
            if name in self.url_value_preprocessors:
                for url_func in self.url_value_preprocessors[name]:
-                    url_func(request.endpoint, request.view_args)
+                    url_func(req.endpoint, req.view_args)
        for name in names:
            if name in self.before_request_funcs:
@ -1308,12 +1301,12 @@ class Flask(App):
        :return: a new response object or the same, has to be an
                 instance of :attr:`response_class`.
        """
-        ctx = request_ctx._get_current_object()  # type: ignore[attr-defined]
+        ctx = _cv_app.get()
        for func in ctx._after_request_functions:
            response = self.ensure_sync(func)(response)
-        for name in chain(request.blueprints, (None,)):
+        for name in chain(ctx.request.blueprints, (None,)):
            if name in self.after_request_funcs:
                for func in reversed(self.after_request_funcs[name]):
                    response = self.ensure_sync(func)(response)
@ -1323,77 +1316,57 @@ class Flask(App):
        return response
-    def do_teardown_request(
+    def do_teardown_request(self, exc: BaseException | None = None) -> None:
-        self,
+        """Called after the request is dispatched and the response is finalized,
-        exc: BaseException | None = _sentinel,  # type: ignore[assignment]
+        right before the request context is popped. Called by
-    ) -> None:
+        :meth:`.AppContext.pop`.
        """Called after the request is dispatched and the response is
        returned, right before the request context is popped.
-        This calls all functions decorated with
+        This calls all functions decorated with :meth:`teardown_request`, and
-        :meth:`teardown_request`, and :meth:`Blueprint.teardown_request`
+        :meth:`Blueprint.teardown_request` if a blueprint handled the request.
-        if a blueprint handled the request. Finally, the
+        Finally, the :data:`request_tearing_down` signal is sent.
        :data:`request_tearing_down` signal is sent.
-        This is called by
+        :param exc: An unhandled exception raised while dispatching the request.
-        :meth:`RequestContext.pop() <flask.ctx.RequestContext.pop>`,
+            Passed to each teardown function.
        which may be delayed during testing to maintain access to
        resources.
        :param exc: An unhandled exception raised while dispatching the
            request. Detected from the current exception information if
            not passed. Passed to each teardown function.
        .. versionchanged:: 0.9
            Added the ``exc`` argument.
        """
-        if exc is _sentinel:
+        req = _cv_app.get().request
            exc = sys.exc_info()[1]
-        for name in chain(request.blueprints, (None,)):
+        for name in chain(req.blueprints, (None,)):
            if name in self.teardown_request_funcs:
                for func in reversed(self.teardown_request_funcs[name]):
                    self.ensure_sync(func)(exc)
        request_tearing_down.send(self, _async_wrapper=self.ensure_sync, exc=exc)
-    def do_teardown_appcontext(
+    def do_teardown_appcontext(self, exc: BaseException | None = None) -> None:
-        self,
+        """Called right before the application context is popped. Called by
-        exc: BaseException | None = _sentinel,  # type: ignore[assignment]
+        :meth:`.AppContext.pop`.
    ) -> None:
        """Called right before the application context is popped.
-        When handling a request, the application context is popped
+        This calls all functions decorated with :meth:`teardown_appcontext`.
-        after the request context. See :meth:`do_teardown_request`.
+        Then the :data:`appcontext_tearing_down` signal is sent.
-        This calls all functions decorated with
+        :param exc: An unhandled exception raised while the context was active.
-        :meth:`teardown_appcontext`. Then the
+            Passed to each teardown function.
        :data:`appcontext_tearing_down` signal is sent.
        This is called by
        :meth:`AppContext.pop() <flask.ctx.AppContext.pop>`.
        .. versionadded:: 0.9
        """
        if exc is _sentinel:
            exc = sys.exc_info()[1]
        for func in reversed(self.teardown_appcontext_funcs):
            self.ensure_sync(func)(exc)
        appcontext_tearing_down.send(self, _async_wrapper=self.ensure_sync, exc=exc)
    def app_context(self) -> AppContext:
-        """Create an :class:`~flask.ctx.AppContext`. Use as a ``with``
+        """Create an :class:`.AppContext`. When the context is pushed,
-        block to push the context, which will make :data:`current_app`
+        :data:`.current_app` and :data:`.g` become available.
        point at this application.
-        An application context is automatically pushed by
+        A context is automatically pushed when handling each request, and when
-        :meth:`RequestContext.push() <flask.ctx.RequestContext.push>`
+        running any ``flask`` CLI command. Use this as a ``with`` block to
-        when handling a request, and when running a CLI command. Use
+        manually push a context outside of those situations, such as during
-        this to manually create a context outside of these situations.
+        setup or testing.
-        ::
+        .. code-block:: python
            with app.app_context():
                init_db()
@ -1404,44 +1377,37 @@ class Flask(App):
        """
        return AppContext(self)
-    def request_context(self, environ: WSGIEnvironment) -> RequestContext:
+    def request_context(self, environ: WSGIEnvironment) -> AppContext:
-        """Create a :class:`~flask.ctx.RequestContext` representing a
+        """Create an :class:`.AppContext` with request information representing
-        WSGI environment. Use a ``with`` block to push the context,
+        the given WSGI environment. A context is automatically pushed when
-        which will make :data:`request` point at this request.
+        handling each request. When the context is pushed, :data:`.request`,
        :data:`.session`, :data:`g:, and :data:`.current_app` become available.
-        See :doc:`/reqcontext`.
+        This method should not be used in your own code. Creating a valid WSGI
        environ is not trivial. Use :meth:`test_request_context` to correctly
        create a WSGI environ and request context instead.
-        Typically you should not call this from your own code. A request
+        See :doc:`/appcontext`.
        context is automatically pushed by the :meth:`wsgi_app` when
        handling a request. Use :meth:`test_request_context` to create
        an environment and context instead of this method.
-        :param environ: a WSGI environment
+        :param environ: A WSGI environment.
        """
-        return RequestContext(self, environ)
+        return AppContext.from_environ(self, environ)
-    def test_request_context(self, *args: t.Any, **kwargs: t.Any) -> RequestContext:
+    def test_request_context(self, *args: t.Any, **kwargs: t.Any) -> AppContext:
-        """Create a :class:`~flask.ctx.RequestContext` for a WSGI
+        """Create an :class:`.AppContext` with request information created from
-        environment created from the given values. This is mostly useful
+        the given arguments. When the context is pushed, :data:`.request`,
-        during testing, where you may want to run a function that uses
+        :data:`.session`, :data:`g:, and :data:`.current_app` become available.
        request data without dispatching a full request.
-        See :doc:`/reqcontext`.
+        This is useful during testing to run a function that uses request data
        without dispatching a full request. Use this as a ``with`` block to push
        a context.
-        Use a ``with`` block to push the context, which will make
+        .. code-block:: python
        :data:`request` point at the request for the created
        environment. ::
            with app.test_request_context(...):
                generate_report()
-        When using the shell, it may be easier to push and pop the
+        See :doc:`/appcontext`.
        context manually to avoid indentation. ::
            ctx = app.test_request_context(...)
            ctx.push()
            ...
            ctx.pop()
        Takes the same arguments as Werkzeug's
        :class:`~werkzeug.test.EnvironBuilder`, with some defaults from
@ -1451,20 +1417,18 @@ class Flask(App):
        :param path: URL path being requested.
        :param base_url: Base URL where the app is being served, which
            ``path`` is relative to. If not given, built from
-            :data:`PREFERRED_URL_SCHEME`, ``subdomain``,
+            :data:`PREFERRED_URL_SCHEME`, ``subdomain``, :data:`SERVER_NAME`,
-            :data:`SERVER_NAME`, and :data:`APPLICATION_ROOT`.
+            and :data:`APPLICATION_ROOT`.
-        :param subdomain: Subdomain name to append to
+        :param subdomain: Subdomain name to prepend to :data:`SERVER_NAME`.
            :data:`SERVER_NAME`.
        :param url_scheme: Scheme to use instead of
            :data:`PREFERRED_URL_SCHEME`.
-        :param data: The request body, either as a string or a dict of
+        :param data: The request body text or bytes,or a dict of form data.
            form keys and values.
        :param json: If given, this is serialized as JSON and passed as
            ``data``. Also defaults ``content_type`` to
            ``application/json``.
-        :param args: other positional arguments passed to
+        :param args: Other positional arguments passed to
            :class:`~werkzeug.test.EnvironBuilder`.
-        :param kwargs: other keyword arguments passed to
+        :param kwargs: Other keyword arguments passed to
            :class:`~werkzeug.test.EnvironBuilder`.
        """
        from .testing import EnvironBuilder
@ -1472,10 +1436,12 @@ class Flask(App):
        builder = EnvironBuilder(self, *args, **kwargs)
        try:
-            return self.request_context(builder.get_environ())
+            environ = builder.get_environ()
        finally:
            builder.close()
        return self.request_context(environ)
    def wsgi_app(
        self, environ: WSGIEnvironment, start_response: StartResponse
    ) -> cabc.Iterable[bytes]:
@ -1496,7 +1462,6 @@ class Flask(App):
            Teardown events for the request and app contexts are called
            even if an unhandled error occurs. Other events may not be
            called depending on when an error occurs during dispatch.
            See :ref:`callbacks-and-errors`.
        :param environ: A WSGI environment.
        :param start_response: A callable accepting a status code,
@ -1519,7 +1484,6 @@ class Flask(App):
        finally:
            if "werkzeug.debug.preserve_context" in environ:
                environ["werkzeug.debug.preserve_context"](_cv_app.get())
                environ["werkzeug.debug.preserve_context"](_cv_request.get())
            if error is not None and self.should_ignore_error(error):
                error = None
--- a/src/flask/cli.py
+++ b/src/flask/cli.py
@ -601,15 +601,7 @@ class FlaskGroup(AppGroup):
        if self._loaded_plugin_commands:
            return
-        if sys.version_info >= (3, 10):
+        for ep in importlib.metadata.entry_points(group="flask.commands"):
            from importlib import metadata
        else:
            # Use a backport on Python < 3.10. We technically have
            # importlib.metadata on 3.8+, but the API changed in 3.10,
            # so use the backport for consistency.
            import importlib_metadata as metadata  # pyright: ignore
        for ep in metadata.entry_points(group="flask.commands"):
            self.add_command(ep.load(), ep.name)
        self._loaded_plugin_commands = True
@ -636,7 +628,7 @@ class FlaskGroup(AppGroup):
        # Push an app context for the loaded app unless it is already
        # active somehow. This makes the context available to parameter
        # and command callbacks without needing @with_appcontext.
-        if not current_app or current_app._get_current_object() is not app:  # type: ignore[attr-defined]
+        if not current_app or current_app._get_current_object() is not app:
            ctx.with_resource(app.app_context())
        return app.cli.get_command(ctx, name)
--- a/src/flask/ctx.py
+++ b/src/flask/ctx.py
@ -1,20 +1,20 @@
 from __future__ import annotations
 import contextvars
 import sys
 import typing as t
 from functools import update_wrapper
 from types import TracebackType
 from werkzeug.exceptions import HTTPException
 from werkzeug.routing import MapAdapter
 from . import typing as ft
 from .globals import _cv_app
 from .globals import _cv_request
 from .signals import appcontext_popped
 from .signals import appcontext_pushed
-if t.TYPE_CHECKING:  # pragma: no cover
+if t.TYPE_CHECKING:
    import typing_extensions as te
    from _typeshed.wsgi import WSGIEnvironment
    from .app import Flask
@ -31,7 +31,7 @@ class _AppCtxGlobals:
    application context.
    Creating an app context automatically creates this object, which is
-    made available as the :data:`g` proxy.
+    made available as the :data:`.g` proxy.
    .. describe:: 'key' in g
@ -117,29 +117,27 @@ class _AppCtxGlobals:
 def after_this_request(
    f: ft.AfterRequestCallable[t.Any],
 ) -> ft.AfterRequestCallable[t.Any]:
-    """Executes a function after this request.  This is useful to modify
+    """Decorate a function to run after the current request. The behavior is the
-    response objects.  The function is passed the response object and has
+    same as :meth:`.Flask.after_request`, except it only applies to the current
-    to return the same or a new one.
+    request, rather than every request. Therefore, it must be used within a
    request context, rather than during setup.
-    Example::
+    .. code-block:: python
-        @app.route('/')
+        @app.route("/")
        def index():
            @after_this_request
            def add_header(response):
-                response.headers['X-Foo'] = 'Parachute'
+                response.headers["X-Foo"] = "Parachute"
                return response
            return 'Hello World!'
-    This is more useful if a function other than the view function wants to
+            return "Hello, World!"
    modify a response.  For instance think of a decorator that wants to add
    some headers without converting the return value into a response object.
    .. versionadded:: 0.9
    """
-    ctx = _cv_request.get(None)
+    ctx = _cv_app.get(None)
-    if ctx is None:
+    if ctx is None or not ctx.has_request:
        raise RuntimeError(
            "'after_this_request' can only be used when a request"
            " context is active, such as in a view function."
@ -153,13 +151,27 @@ F = t.TypeVar("F", bound=t.Callable[..., t.Any])
 def copy_current_request_context(f: F) -> F:
-    """A helper function that decorates a function to retain the current
+    """Decorate a function to run inside the current request context. This can
-    request context.  This is useful when working with greenlets.  The moment
+    be used when starting a background task, otherwise it will not see the app
-    the function is decorated a copy of the request context is created and
+    and request objects that were active in the parent.
    then pushed when the function is called.  The current session is also
    included in the copied request context.
-    Example::
+    .. warning::
        Due to the following caveats, it is often safer (and simpler) to pass
        the data you need when starting the task, rather than using this and
        relying on the context objects.
    In order to avoid execution switching partially though reading data, either
    read the request body (access ``form``, ``json``, ``data``, etc) before
    starting the task, or use a lock. This can be an issue when using threading,
    but shouldn't be an issue when using greenlet/gevent or asyncio.
    If the task will access ``session``, be sure to do so in the parent as well
    so that the ``Vary: cookie`` header will be set. Modifying ``session`` in
    the task should be avoided, as it may execute after the response cookie has
    already been written.
    .. code-block:: python
        import gevent
        from flask import copy_current_request_context
@ -176,7 +188,7 @@ def copy_current_request_context(f: F) -> F:
    .. versionadded:: 0.10
    """
-    ctx = _cv_request.get(None)
+    ctx = _cv_app.get(None)
    if ctx is None:
        raise RuntimeError(
@ -187,48 +199,57 @@ def copy_current_request_context(f: F) -> F:
    ctx = ctx.copy()
    def wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
-        with ctx:  # type: ignore[union-attr]
+        with ctx:
-            return ctx.app.ensure_sync(f)(*args, **kwargs)  # type: ignore[union-attr]
+            return ctx.app.ensure_sync(f)(*args, **kwargs)
    return update_wrapper(wrapper, f)  # type: ignore[return-value]
 def has_request_context() -> bool:
-    """If you have code that wants to test if a request context is there or
+    """Test if an app context is active and if it has request information.
    not this function can be used.  For instance, you may want to take advantage
    of request information if the request object is available, but fail
    silently if it is unavailable.
-    ::
+    .. code-block:: python
-        class User(db.Model):
+        from flask import has_request_context, request
-            def __init__(self, username, remote_addr=None):
+        if has_request_context():
-                self.username = username
+            remote_addr = request.remote_addr
                if remote_addr is None and has_request_context():
                    remote_addr = request.remote_addr
                self.remote_addr = remote_addr
-    Alternatively you can also just test any of the context bound objects
+    If a request context is active, the :data:`.request` and :data:`.session`
-    (such as :class:`request` or :class:`g`) for truthness::
+    context proxies will available and ``True``, otherwise ``False``. You can
    use that to test the data you use, rather than using this function.
-        class User(db.Model):
+    .. code-block:: python
-            def __init__(self, username, remote_addr=None):
+        from flask import request
-                self.username = username
+
-                if remote_addr is None and request:
+        if request:
-                    remote_addr = request.remote_addr
+            remote_addr = request.remote_addr
                self.remote_addr = remote_addr
    .. versionadded:: 0.7
    """
-    return _cv_request.get(None) is not None
+    return (ctx := _cv_app.get(None)) is not None and ctx.has_request
 def has_app_context() -> bool:
-    """Works like :func:`has_request_context` but for the application
+    """Test if an app context is active. Unlike :func:`has_request_context`
-    context.  You can also just do a boolean check on the
+    this can be true outside a request, such as in a CLI command.
-    :data:`current_app` object instead.
+
    .. code-block:: python
        from flask import has_app_context, g
        if has_app_context():
            g.cached_data = ...
    If an app context is active, the :data:`.g` and :data:`.current_app` context
    proxies will available and ``True``, otherwise ``False``. You can use that
    to test the data you use, rather than using this function.
        from flask import g
        if g:
            g.cached_data = ...
    .. versionadded:: 0.9
    """
@ -236,214 +257,260 @@ def has_app_context() -> bool:
 class AppContext:
-    """The app context contains application-specific information. An app
+    """An app context contains information about an app, and about the request
-    context is created and pushed at the beginning of each request if
+    when handling a request. A context is pushed at the beginning of each
-    one is not already active. An app context is also pushed when
+    request and CLI command, and popped at the end. The context is referred to
-    running CLI commands.
+    as a "request context" if it has request information, and an "app context"
-    """
+    if not.
-    def __init__(self, app: Flask) -> None:
+    Do not use this class directly. Use :meth:`.Flask.app_context` to create an
-        self.app = app
+    app context if needed during setup, and :meth:`.Flask.test_request_context`
-        self.url_adapter = app.create_url_adapter(None)
+    to create a request context if needed during tests.
        self.g: _AppCtxGlobals = app.app_ctx_globals_class()
        self._cv_tokens: list[contextvars.Token[AppContext]] = []
-    def push(self) -> None:
+    When the context is popped, it will evaluate all the teardown functions
-        """Binds the app context to the current context."""
+    registered with :meth:`~flask.Flask.teardown_request` (if handling a
-        self._cv_tokens.append(_cv_app.set(self))
+    request) then :meth:`.Flask.teardown_appcontext`.
        appcontext_pushed.send(self.app, _async_wrapper=self.app.ensure_sync)
-    def pop(self, exc: BaseException | None = _sentinel) -> None:  # type: ignore
+    When using the interactive debugger, the context will be restored so
-        """Pops the app context."""
+    ``request`` is still accessible. Similarly, the test client can preserve the
-        try:
+    context after the request ends. However, teardown functions may already have
-            if len(self._cv_tokens) == 1:
+    closed some resources such as database connections, and will run again when
-                if exc is _sentinel:
+    the restored context is popped.
                    exc = sys.exc_info()[1]
                self.app.do_teardown_appcontext(exc)
        finally:
            ctx = _cv_app.get()
            _cv_app.reset(self._cv_tokens.pop())
-        if ctx is not self:
+    :param app: The application this context represents.
-            raise AssertionError(
+    :param request: The request data this context represents.
-                f"Popped wrong app context. ({ctx!r} instead of {self!r})"
+    :param session: The session data this context represents. If not given,
-            )
+        loaded from the request on first access.
-        appcontext_popped.send(self.app, _async_wrapper=self.app.ensure_sync)
+    .. versionchanged:: 3.2
        Merged with ``RequestContext``. The ``RequestContext`` alias will be
        removed in Flask 4.0.
-    def __enter__(self) -> AppContext:
+    .. versionchanged:: 3.2
-        self.push()
+        A combined app and request context is pushed for every request and CLI
-        return self
+        command, rather than trying to detect if an app context is already
        pushed.
-    def __exit__(
+    .. versionchanged:: 3.2
-        self,
+        The session is loaded the first time it is accessed, rather than when
-        exc_type: type | None,
+        the context is pushed.
        exc_value: BaseException | None,
        tb: TracebackType | None,
    ) -> None:
        self.pop(exc_value)
 class RequestContext:
    """The request context contains per-request information. The Flask
    app creates and pushes it at the beginning of the request, then pops
    it at the end of the request. It will create the URL adapter and
    request object for the WSGI environment provided.
    Do not attempt to use this class directly, instead use
    :meth:`~flask.Flask.test_request_context` and
    :meth:`~flask.Flask.request_context` to create this object.
    When the request context is popped, it will evaluate all the
    functions registered on the application for teardown execution
    (:meth:`~flask.Flask.teardown_request`).
    The request context is automatically popped at the end of the
    request. When using the interactive debugger, the context will be
    restored so ``request`` is still accessible. Similarly, the test
    client can preserve the context after the request ends. However,
    teardown functions may already have closed some resources such as
    database connections.
    """
    def __init__(
        self,
        app: Flask,
-        environ: WSGIEnvironment,
+        *,
        request: Request | None = None,
        session: SessionMixin | None = None,
    ) -> None:
        self.app = app
-        if request is None:
+        """The application represented by this context. Accessed through
-            request = app.request_class(environ)
+        :data:`.current_app`.
-            request.json_module = app.json
+        """
-        self.request: Request = request
+
-        self.url_adapter = None
+        self.g: _AppCtxGlobals = app.app_ctx_globals_class()
-        try:
+        """The global data for this context. Accessed through :data:`.g`."""
-            self.url_adapter = app.create_url_adapter(self.request)
+
-        except HTTPException as e:
+        self.url_adapter: MapAdapter | None = None
-            self.request.routing_exception = e
+        """The URL adapter bound to the request, or the app if not in a request.
-        self.flashes: list[tuple[str, str]] | None = None
+        May be ``None`` if binding failed.
-        self.session: SessionMixin | None = session
+        """
-        # Functions that should be executed after the request on the response
+
-        # object.  These will be called before the regular "after_request"
+        self._request: Request | None = request
-        # functions.
+        self._session: SessionMixin | None = session
        self._flashes: list[tuple[str, str]] | None = None
        self._after_request_functions: list[ft.AfterRequestCallable[t.Any]] = []
-        self._cv_tokens: list[
+        try:
-            tuple[contextvars.Token[RequestContext], AppContext | None]
+            self.url_adapter = app.create_url_adapter(self._request)
-        ] = []
+        except HTTPException as e:
            if self._request is not None:
                self._request.routing_exception = e
-    def copy(self) -> RequestContext:
+        self._cv_token: contextvars.Token[AppContext] | None = None
-        """Creates a copy of this request context with the same request object.
+        """The previous state to restore when popping."""
        This can be used to move a request context to a different greenlet.
        Because the actual request object is the same this cannot be used to
        move a request context to a different thread unless access to the
        request object is locked.
-        .. versionadded:: 0.10
+        self._push_count: int = 0
        """Track nested pushes of this context. Cleanup will only run once the
        original push has been popped.
        """
    @classmethod
    def from_environ(cls, app: Flask, environ: WSGIEnvironment, /) -> te.Self:
        """Create an app context with request data from the given WSGI environ.
        :param app: The application this context represents.
        :param environ: The request data this context represents.
        """
        request = app.request_class(environ)
        request.json_module = app.json
        return cls(app, request=request)
    @property
    def has_request(self) -> bool:
        """True if this context was created with request data."""
        return self._request is not None
    def copy(self) -> te.Self:
        """Create a new context with the same data objects as this context. See
        :func:`.copy_current_request_context`.
        .. versionchanged:: 1.1
-           The current session object is used instead of reloading the original
+            The current session data is used instead of reloading the original data.
-           data. This prevents `flask.session` pointing to an out-of-date object.
+
        .. versionadded:: 0.10
        """
        return self.__class__(
            self.app,
-            environ=self.request.environ,
+            request=self._request,
-            request=self.request,
+            session=self._session,
            session=self.session,
        )
    @property
    def request(self) -> Request:
        """The request object associated with this context. Accessed through
        :data:`.request`. Only available in request contexts, otherwise raises
        :exc:`RuntimeError`.
        """
        if self._request is None:
            raise RuntimeError("There is no request in this context.")
        return self._request
    @property
    def session(self) -> SessionMixin:
        """The session object associated with this context. Accessed through
        :data:`.session`. Only available in request contexts, otherwise raises
        :exc:`RuntimeError`.
        """
        if self._request is None:
            raise RuntimeError("There is no request in this context.")
        if self._session is None:
            si = self.app.session_interface
            self._session = si.open_session(self.app, self.request)
            if self._session is None:
                self._session = si.make_null_session(self.app)
        return self._session
    def match_request(self) -> None:
-        """Can be overridden by a subclass to hook into the matching
+        """Apply routing to the current request, storing either the matched
-        of the request.
+        endpoint and args, or a routing exception.
        """
        try:
-            result = self.url_adapter.match(return_rule=True)  # type: ignore
+            result = self.url_adapter.match(return_rule=True)  # type: ignore[union-attr]
            self.request.url_rule, self.request.view_args = result  # type: ignore
        except HTTPException as e:
-            self.request.routing_exception = e
+            self._request.routing_exception = e  # type: ignore[union-attr]
        else:
            self._request.url_rule, self._request.view_args = result  # type: ignore[union-attr]
    def push(self) -> None:
-        # Before we push the request context we have to ensure that there
+        """Push this context so that it is the active context. If this is a
-        # is an application context.
+        request context, calls :meth:`match_request` to perform routing with
-        app_ctx = _cv_app.get(None)
+        the context active.
-        if app_ctx is None or app_ctx.app is not self.app:
+        Typically, this is not used directly. Instead, use a ``with`` block
-            app_ctx = self.app.app_context()
+        to manage the context.
            app_ctx.push()
        else:
            app_ctx = None
-        self._cv_tokens.append((_cv_request.set(self), app_ctx))
+        In some situations, such as streaming or testing, the context may be
        pushed multiple times. It will only trigger matching and signals if it
        is not currently pushed.
        """
        self._push_count += 1
-        # Open the session at the moment that the request context is available.
+        if self._cv_token is not None:
-        # This allows a custom open_session method to use the request context.
+            return
        # Only open a new session if this is the first time the request was
        # pushed, otherwise stream_with_context loses the session.
        if self.session is None:
            session_interface = self.app.session_interface
            self.session = session_interface.open_session(self.app, self.request)
-            if self.session is None:
+        self._cv_token = _cv_app.set(self)
-                self.session = session_interface.make_null_session(self.app)
+        appcontext_pushed.send(self.app, _async_wrapper=self.app.ensure_sync)
-        # Match the request URL after loading the session, so that the
+        if self._request is not None and self.url_adapter is not None:
        # session is available in custom URL converters.
        if self.url_adapter is not None:
            self.match_request()
-    def pop(self, exc: BaseException | None = _sentinel) -> None:  # type: ignore
+    def pop(self, exc: BaseException | None = None) -> None:
-        """Pops the request context and unbinds it by doing that.  This will
+        """Pop this context so that it is no longer the active context. Then
-        also trigger the execution of functions registered by the
+        call teardown functions and signals.
-        :meth:`~flask.Flask.teardown_request` decorator.
+
        Typically, this is not used directly. Instead, use a ``with`` block
        to manage the context.
        This context must currently be the active context, otherwise a
        :exc:`RuntimeError` is raised. In some situations, such as streaming or
        testing, the context may have been pushed multiple times. It will only
        trigger cleanup once it has been popped as many times as it was pushed.
        Until then, it will remain the active context.
        :param exc: An unhandled exception that was raised while the context was
            active. Passed to teardown functions.
        .. versionchanged:: 0.9
-           Added the `exc` argument.
+            Added the ``exc`` argument.
        """
-        clear_request = len(self._cv_tokens) == 1
+        if self._cv_token is None:
            raise RuntimeError(f"Cannot pop this context ({self!r}), it is not pushed.")
        ctx = _cv_app.get(None)
        if ctx is None or self._cv_token is None:
            raise RuntimeError(
                f"Cannot pop this context ({self!r}), there is no active context."
            )
        if ctx is not self:
            raise RuntimeError(
                f"Cannot pop this context ({self!r}), it is not the active"
                f" context ({ctx!r})."
            )
        self._push_count -= 1
        if self._push_count > 0:
            return
        try:
-            if clear_request:
+            if self._request is not None:
                if exc is _sentinel:
                    exc = sys.exc_info()[1]
                self.app.do_teardown_request(exc)
-
+                self._request.close()
                request_close = getattr(self.request, "close", None)
                if request_close is not None:
                    request_close()
        finally:
-            ctx = _cv_request.get()
+            self.app.do_teardown_appcontext(exc)
-            token, app_ctx = self._cv_tokens.pop()
+            _cv_app.reset(self._cv_token)
-            _cv_request.reset(token)
+            self._cv_token = None
            appcontext_popped.send(self.app, _async_wrapper=self.app.ensure_sync)
-            # get rid of circular dependencies at the end of the request
+    def __enter__(self) -> te.Self:
            # so that we don't require the GC to be active.
            if clear_request:
                ctx.request.environ["werkzeug.request"] = None
            if app_ctx is not None:
                app_ctx.pop(exc)
            if ctx is not self:
                raise AssertionError(
                    f"Popped wrong request context. ({ctx!r} instead of {self!r})"
                )
    def __enter__(self) -> RequestContext:
        self.push()
        return self
    def __exit__(
        self,
-        exc_type: type | None,
+        exc_type: type[BaseException] | None,
        exc_value: BaseException | None,
        tb: TracebackType | None,
    ) -> None:
        self.pop(exc_value)
    def __repr__(self) -> str:
-        return (
+        if self._request is not None:
-            f"<{type(self).__name__} {self.request.url!r}"
+            return (
-            f" [{self.request.method}] of {self.app.name}>"
+                f"<{type(self).__name__} {id(self)} of {self.app.name},"
                f" {self.request.method} {self.request.url!r}>"
            )
        return f"<{type(self).__name__} {id(self)} of {self.app.name}>"
 def __getattr__(name: str) -> t.Any:
    import warnings
    if name == "RequestContext":
        warnings.warn(
            "'RequestContext' has merged with 'AppContext', and will be removed"
            " in Flask 4.0. Use 'AppContext' instead.",
            DeprecationWarning,
            stacklevel=2,
        )
        return AppContext
    raise AttributeError(name)
--- a/src/flask/debughelpers.py
+++ b/src/flask/debughelpers.py
@ -6,7 +6,7 @@ from jinja2.loaders import BaseLoader
 from werkzeug.routing import RequestRedirect
 from .blueprints import Blueprint
-from .globals import request_ctx
+from .globals import _cv_app
 from .sansio.app import App
 if t.TYPE_CHECKING:
@ -136,8 +136,9 @@ def explain_template_loading_attempts(
    info = [f"Locating template {template!r}:"]
    total_found = 0
    blueprint = None
-    if request_ctx and request_ctx.request.blueprint is not None:
+
-        blueprint = request_ctx.request.blueprint
+    if (ctx := _cv_app.get(None)) is not None and ctx.has_request:
        blueprint = ctx.request.blueprint
    for idx, (loader, srcobj, triple) in enumerate(attempts):
        if isinstance(srcobj, App):
--- a/src/flask/globals.py
+++ b/src/flask/globals.py
@ -9,43 +9,69 @@ if t.TYPE_CHECKING:  # pragma: no cover
    from .app import Flask
    from .ctx import _AppCtxGlobals
    from .ctx import AppContext
    from .ctx import RequestContext
    from .sessions import SessionMixin
    from .wrappers import Request
    T = t.TypeVar("T", covariant=True)
    class ProxyMixin(t.Protocol[T]):
        def _get_current_object(self) -> T: ...
    # These subclasses inform type checkers that the proxy objects look like the
    # proxied type along with the _get_current_object method.
    class FlaskProxy(ProxyMixin[Flask], Flask): ...
    class AppContextProxy(ProxyMixin[AppContext], AppContext): ...
    class _AppCtxGlobalsProxy(ProxyMixin[_AppCtxGlobals], _AppCtxGlobals): ...
    class RequestProxy(ProxyMixin[Request], Request): ...
    class SessionMixinProxy(ProxyMixin[SessionMixin], SessionMixin): ...
 _no_app_msg = """\
 Working outside of application context.
-This typically means that you attempted to use functionality that needed
+Attempted to use functionality that expected a current application to be set. To
-the current application. To solve this, set up an application context
+solve this, set up an app context using 'with app.app_context()'. See the
-with app.app_context(). See the documentation for more information.\
+documentation on app context for more information.\
 """
 _cv_app: ContextVar[AppContext] = ContextVar("flask.app_ctx")
-app_ctx: AppContext = LocalProxy(  # type: ignore[assignment]
+app_ctx: AppContextProxy = LocalProxy(  # type: ignore[assignment]
    _cv_app, unbound_message=_no_app_msg
 )
-current_app: Flask = LocalProxy(  # type: ignore[assignment]
+current_app: FlaskProxy = LocalProxy(  # type: ignore[assignment]
    _cv_app, "app", unbound_message=_no_app_msg
 )
-g: _AppCtxGlobals = LocalProxy(  # type: ignore[assignment]
+g: _AppCtxGlobalsProxy = LocalProxy(  # type: ignore[assignment]
    _cv_app, "g", unbound_message=_no_app_msg
 )
 _no_req_msg = """\
 Working outside of request context.
-This typically means that you attempted to use functionality that needed
+Attempted to use functionality that expected an active HTTP request. See the
-an active HTTP request. Consult the documentation on testing for
+documentation on request context for more information.\
 information about how to avoid this problem.\
 """
-_cv_request: ContextVar[RequestContext] = ContextVar("flask.request_ctx")
+request: RequestProxy = LocalProxy(  # type: ignore[assignment]
-request_ctx: RequestContext = LocalProxy(  # type: ignore[assignment]
+    _cv_app, "request", unbound_message=_no_req_msg
    _cv_request, unbound_message=_no_req_msg
 )
-request: Request = LocalProxy(  # type: ignore[assignment]
+session: SessionMixinProxy = LocalProxy(  # type: ignore[assignment]
-    _cv_request, "request", unbound_message=_no_req_msg
+    _cv_app, "session", unbound_message=_no_req_msg
 )
 session: SessionMixin = LocalProxy(  # type: ignore[assignment]
    _cv_request, "session", unbound_message=_no_req_msg
 )
 def __getattr__(name: str) -> t.Any:
    import warnings
    if name == "request_ctx":
        warnings.warn(
            "'request_ctx' has merged with 'app_ctx', and will be removed"
            " in Flask 4.0. Use 'app_ctx' instead.",
            DeprecationWarning,
            stacklevel=2,
        )
        return app_ctx
    raise AttributeError(name)
--- a/src/flask/helpers.py
+++ b/src/flask/helpers.py
@ -13,10 +13,10 @@ from werkzeug.exceptions import abort as _wz_abort
 from werkzeug.utils import redirect as _wz_redirect
 from werkzeug.wrappers import Response as BaseResponse
-from .globals import _cv_request
+from .globals import _cv_app
 from .globals import app_ctx
 from .globals import current_app
 from .globals import request
 from .globals import request_ctx
 from .globals import session
 from .signals import message_flashed
@ -62,35 +62,40 @@ def stream_with_context(
 def stream_with_context(
    generator_or_function: t.Iterator[t.AnyStr] | t.Callable[..., t.Iterator[t.AnyStr]],
 ) -> t.Iterator[t.AnyStr] | t.Callable[[t.Iterator[t.AnyStr]], t.Iterator[t.AnyStr]]:
-    """Request contexts disappear when the response is started on the server.
+    """Wrap a response generator function so that it runs inside the current
-    This is done for efficiency reasons and to make it less likely to encounter
+    request context. This keeps :data:`.request`, :data:`.session`, and :data:`.g`
-    memory leaks with badly written WSGI middlewares.  The downside is that if
+    available, even though at the point the generator runs the request context
-    you are using streamed responses, the generator cannot access request bound
+    will typically have ended.
    information any more.
-    This function however can help you keep the context around for longer::
+    Use it as a decorator on a generator function:
    .. code-block:: python
        from flask import stream_with_context, request, Response
-        @app.route('/stream')
+        @app.get("/stream")
        def streamed_response():
            @stream_with_context
            def generate():
-                yield 'Hello '
+                yield "Hello "
-                yield request.args['name']
+                yield request.args["name"]
-                yield '!'
+                yield "!"
            return Response(generate())
-    Alternatively it can also be used around a specific generator::
+    Or use it as a wrapper around a created generator:
    .. code-block:: python
        from flask import stream_with_context, request, Response
-        @app.route('/stream')
+        @app.get("/stream")
        def streamed_response():
            def generate():
-                yield 'Hello '
+                yield "Hello "
-                yield request.args['name']
+                yield request.args["name"]
-                yield '!'
+                yield "!"
            return Response(stream_with_context(generate()))
    .. versionadded:: 0.9
@ -105,35 +110,29 @@ def stream_with_context(
        return update_wrapper(decorator, generator_or_function)  # type: ignore[arg-type]
-    def generator() -> t.Iterator[t.AnyStr | None]:
+    def generator() -> t.Iterator[t.AnyStr]:
-        ctx = _cv_request.get(None)
+        if (ctx := _cv_app.get(None)) is None:
        if ctx is None:
            raise RuntimeError(
                "'stream_with_context' can only be used when a request"
                " context is active, such as in a view function."
            )
        with ctx:
            # Dummy sentinel.  Has to be inside the context block or we're
            # not actually keeping the context around.
            yield None
-            # The try/finally is here so that if someone passes a WSGI level
+        with ctx:
-            # iterator in we're still running the cleanup logic.  Generators
+            yield None  # type: ignore[misc]
-            # don't need that because they are closed on their destruction
+
            # automatically.
            try:
                yield from gen
            finally:
                # Clean up in case the user wrapped a WSGI iterator.
                if hasattr(gen, "close"):
                    gen.close()
-    # The trick is to start the generator.  Then the code execution runs until
+    # Execute the generator to the sentinel value. This captures the current
-    # the first dummy None is yielded at which point the context was already
+    # context and pushes it to preserve it. Further iteration will yield from
-    # pushed.  This item is discarded.  Then when the iteration continues the
+    # the original iterator.
    # real generator is executed.
    wrapped_g = generator()
    next(wrapped_g)
-    return wrapped_g  # type: ignore[return-value]
+    return wrapped_g
 def make_response(*args: t.Any) -> Response:
@ -257,8 +256,8 @@ def redirect(
        Calls ``current_app.redirect`` if available instead of always
        using Werkzeug's default ``redirect``.
    """
-    if current_app:
+    if (ctx := _cv_app.get(None)) is not None:
-        return current_app.redirect(location, code=code)
+        return ctx.app.redirect(location, code=code)
    return _wz_redirect(location, code=code, Response=Response)
@ -280,8 +279,8 @@ def abort(code: int | BaseResponse, *args: t.Any, **kwargs: t.Any) -> t.NoReturn
        Calls ``current_app.aborter`` if available instead of always
        using Werkzeug's default ``abort``.
    """
-    if current_app:
+    if (ctx := _cv_app.get(None)) is not None:
-        current_app.aborter(code, *args, **kwargs)
+        ctx.app.aborter(code, *args, **kwargs)
    _wz_abort(code, *args, **kwargs)
@ -333,7 +332,7 @@ def flash(message: str, category: str = "message") -> None:
    flashes = session.get("_flashes", [])
    flashes.append((category, message))
    session["_flashes"] = flashes
-    app = current_app._get_current_object()  # type: ignore
+    app = current_app._get_current_object()
    message_flashed.send(
        app,
        _async_wrapper=app.ensure_sync,
@ -373,10 +372,10 @@ def get_flashed_messages(
    :param category_filter: filter of categories to limit return values.  Only
                            categories in the list will be returned.
    """
-    flashes = request_ctx.flashes
+    flashes = app_ctx._flashes
    if flashes is None:
        flashes = session.pop("_flashes") if "_flashes" in session else []
-        request_ctx.flashes = flashes
+        app_ctx._flashes = flashes
    if category_filter:
        flashes = list(filter(lambda f: f[0] in category_filter, flashes))
    if not with_categories:
@ -385,20 +384,22 @@ def get_flashed_messages(
 def _prepare_send_file_kwargs(**kwargs: t.Any) -> dict[str, t.Any]:
    ctx = app_ctx._get_current_object()
    if kwargs.get("max_age") is None:
-        kwargs["max_age"] = current_app.get_send_file_max_age
+        kwargs["max_age"] = ctx.app.get_send_file_max_age
    kwargs.update(
-        environ=request.environ,
+        environ=ctx.request.environ,
-        use_x_sendfile=current_app.config["USE_X_SENDFILE"],
+        use_x_sendfile=ctx.app.config["USE_X_SENDFILE"],
-        response_class=current_app.response_class,
+        response_class=ctx.app.response_class,
-        _root_path=current_app.root_path,  # type: ignore
+        _root_path=ctx.app.root_path,
    )
    return kwargs
 def send_file(
-    path_or_file: os.PathLike[t.AnyStr] | str | t.BinaryIO,
+    path_or_file: os.PathLike[t.AnyStr] | str | t.IO[bytes],
    mimetype: str | None = None,
    as_attachment: bool = False,
    download_name: str | None = None,
--- a/src/flask/json/init.py
+++ b/src/flask/json/init.py
@ -141,7 +141,7 @@ def jsonify(*args: t.Any, **kwargs: t.Any) -> Response:
    mimetype. A dict or list returned from a view will be converted to a
    JSON response automatically without needing to call this.
-    This requires an active request or application context, and calls
+    This requires an active app context, and calls
    :meth:`app.json.response() <flask.json.provider.JSONProvider.response>`.
    In debug mode, the output is formatted with indentation to make it
--- a/src/flask/json/provider.py
+++ b/src/flask/json/provider.py
@ -135,7 +135,7 @@ class DefaultJSONProvider(JSONProvider):
        method) will call the ``__html__`` method to get a string.
    """
-    default: t.Callable[[t.Any], t.Any] = staticmethod(_default)  # type: ignore[assignment]
+    default: t.Callable[[t.Any], t.Any] = staticmethod(_default)
    """Apply this function to any object that :meth:`json.dumps` does
    not know how to serialize. It should return a valid JSON type or
    raise a ``TypeError``.
--- a/src/flask/sansio/app.py
+++ b/src/flask/sansio/app.py
@ -177,11 +177,8 @@ class App(Scaffold):
    #: 3. Return None instead of AttributeError on unexpected attributes.
    #: 4. Raise exception if an unexpected attr is set, a "controlled" flask.g.
    #:
    #: In Flask 0.9 this property was called `request_globals_class` but it
    #: was changed in 0.10 to :attr:`app_ctx_globals_class` because the
    #: flask.g object is now application context scoped.
    #:
    #: .. versionadded:: 0.10
    #:     Renamed from ``request_globals_class`.
    app_ctx_globals_class = _AppCtxGlobals
    #: The class that is used for the ``config`` attribute of this app.
@ -213,7 +210,7 @@ class App(Scaffold):
    #:
    #: This attribute can also be configured from the config with the
    #: :data:`SECRET_KEY` configuration key. Defaults to ``None``.
-    secret_key = ConfigAttribute[t.Union[str, bytes, None]]("SECRET_KEY")
+    secret_key = ConfigAttribute[str | bytes | None]("SECRET_KEY")
    #: A :class:`~datetime.timedelta` which is used to set the expiration
    #: date of a permanent session.  The default is 31 days which makes a
@ -423,7 +420,7 @@ class App(Scaffold):
            )
    @cached_property
-    def name(self) -> str:  # type: ignore
+    def name(self) -> str:
        """The name of the application.  This is usually the import name
        with the difference that it's guessed from the run file if the
        import name is main.  This name is used as a display name when
@ -521,7 +518,7 @@ class App(Scaffold):
        return os.path.join(prefix, "var", f"{self.name}-instance")
    def create_global_jinja_loader(self) -> DispatchingJinjaLoader:
-        """Creates the loader for the Jinja2 environment.  Can be used to
+        """Creates the loader for the Jinja environment.  Can be used to
        override just the loader and keeping the rest unchanged.  It's
        discouraged to override this function.  Instead one should override
        the :meth:`jinja_loader` function instead.
@ -660,21 +657,34 @@ class App(Scaffold):
                )
            self.view_functions[endpoint] = view_func
-    @setupmethod
+    @t.overload
    def template_filter(self, name: T_template_filter) -> T_template_filter: ...
    @t.overload
    def template_filter(
        self, name: str | None = None
-    ) -> t.Callable[[T_template_filter], T_template_filter]:
+    ) -> t.Callable[[T_template_filter], T_template_filter]: ...
-        """A decorator that is used to register custom template filter.
+    @setupmethod
-        You can specify a name for the filter, otherwise the function
+    def template_filter(
-        name will be used. Example::
+        self, name: T_template_filter | str | None = None
    ) -> T_template_filter | t.Callable[[T_template_filter], T_template_filter]:
        """Decorate a function to register it as a custom Jinja filter. The name
        is optional. The decorator may be used without parentheses.
-          @app.template_filter()
+        .. code-block:: python
          def reverse(s):
              return s[::-1]
-        :param name: the optional name of the filter, otherwise the
+            @app.template_filter("reverse")
-                     function name will be used.
+            def reverse_filter(s):
                return reversed(s)
        The :meth:`add_template_filter` method may be used to register a
        function later rather than decorating.
        :param name: The name to register the filter as. If not given, uses the
            function's name.
        """
        if callable(name):
            self.add_template_filter(name)
            return name
        def decorator(f: T_template_filter) -> T_template_filter:
            self.add_template_filter(f, name=name)
@ -686,36 +696,52 @@ class App(Scaffold):
    def add_template_filter(
        self, f: ft.TemplateFilterCallable, name: str | None = None
    ) -> None:
-        """Register a custom template filter.  Works exactly like the
+        """Register a function to use as a custom Jinja filter.
        :meth:`template_filter` decorator.
-        :param name: the optional name of the filter, otherwise the
+        The :meth:`template_filter` decorator can be used to register a function
-                     function name will be used.
+        by decorating instead.
        :param f: The function to register.
        :param name: The name to register the filter as. If not given, uses the
            function's name.
        """
        self.jinja_env.filters[name or f.__name__] = f
-    @setupmethod
+    @t.overload
    def template_test(self, name: T_template_test) -> T_template_test: ...
    @t.overload
    def template_test(
        self, name: str | None = None
-    ) -> t.Callable[[T_template_test], T_template_test]:
+    ) -> t.Callable[[T_template_test], T_template_test]: ...
-        """A decorator that is used to register custom template test.
+    @setupmethod
-        You can specify a name for the test, otherwise the function
+    def template_test(
-        name will be used. Example::
+        self, name: T_template_test | str | None = None
    ) -> T_template_test | t.Callable[[T_template_test], T_template_test]:
        """Decorate a function to register it as a custom Jinja test. The name
        is optional. The decorator may be used without parentheses.
-          @app.template_test()
+        .. code-block:: python
-          def is_prime(n):
+
-              if n == 2:
+            @app.template_test("prime")
-                  return True
+            def is_prime_test(n):
-              for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
+                if n == 2:
-                  if n % i == 0:
+                    return True
-                      return False
+                for i in range(2, int(math.ceil(math.sqrt(n))) + 1):
                    if n % i == 0:
                        return False
              return True
-        .. versionadded:: 0.10
+        The :meth:`add_template_test` method may be used to register a function
        later rather than decorating.
-        :param name: the optional name of the test, otherwise the
+        :param name: The name to register the filter as. If not given, uses the
-                     function name will be used.
+            function's name.
        .. versionadded:: 0.10
        """
        if callable(name):
            self.add_template_test(name)
            return name
        def decorator(f: T_template_test) -> T_template_test:
            self.add_template_test(f, name=name)
@ -727,33 +753,49 @@ class App(Scaffold):
    def add_template_test(
        self, f: ft.TemplateTestCallable, name: str | None = None
    ) -> None:
-        """Register a custom template test.  Works exactly like the
+        """Register a function to use as a custom Jinja test.
-        :meth:`template_test` decorator.
+
        The :meth:`template_test` decorator can be used to register a function
        by decorating instead.
        :param f: The function to register.
        :param name: The name to register the test as. If not given, uses the
            function's name.
        .. versionadded:: 0.10
        :param name: the optional name of the test, otherwise the
                     function name will be used.
        """
        self.jinja_env.tests[name or f.__name__] = f
-    @setupmethod
+    @t.overload
    def template_global(self, name: T_template_global) -> T_template_global: ...
    @t.overload
    def template_global(
        self, name: str | None = None
-    ) -> t.Callable[[T_template_global], T_template_global]:
+    ) -> t.Callable[[T_template_global], T_template_global]: ...
-        """A decorator that is used to register a custom template global function.
+    @setupmethod
-        You can specify a name for the global function, otherwise the function
+    def template_global(
-        name will be used. Example::
+        self, name: T_template_global | str | None = None
    ) -> T_template_global | t.Callable[[T_template_global], T_template_global]:
        """Decorate a function to register it as a custom Jinja global. The name
        is optional. The decorator may be used without parentheses.
-            @app.template_global()
+        .. code-block:: python
            @app.template_global
            def double(n):
                return 2 * n
-        .. versionadded:: 0.10
+        The :meth:`add_template_global` method may be used to register a
        function later rather than decorating.
-        :param name: the optional name of the global function, otherwise the
+        :param name: The name to register the global as. If not given, uses the
-                     function name will be used.
+            function's name.
        .. versionadded:: 0.10
        """
        if callable(name):
            self.add_template_global(name)
            return name
        def decorator(f: T_template_global) -> T_template_global:
            self.add_template_global(f, name=name)
@ -765,22 +807,24 @@ class App(Scaffold):
    def add_template_global(
        self, f: ft.TemplateGlobalCallable, name: str | None = None
    ) -> None:
-        """Register a custom template global function. Works exactly like the
+        """Register a function to use as a custom Jinja global.
-        :meth:`template_global` decorator.
+
        The :meth:`template_global` decorator can be used to register a function
        by decorating instead.
        :param f: The function to register.
        :param name: The name to register the global as. If not given, uses the
            function's name.
        .. versionadded:: 0.10
        :param name: the optional name of the global function, otherwise the
                     function name will be used.
        """
        self.jinja_env.globals[name or f.__name__] = f
    @setupmethod
    def teardown_appcontext(self, f: T_teardown) -> T_teardown:
-        """Registers a function to be called when the application
+        """Registers a function to be called when the app context is popped. The
-        context is popped. The application context is typically popped
+        context is popped at the end of a request, CLI command, or manual ``with``
-        after the request context for each request, at the end of CLI
+        block.
        commands, or after a manually pushed context ends.
        .. code-block:: python
@ -789,9 +833,7 @@ class App(Scaffold):
        When the ``with`` block exits (or ``ctx.pop()`` is called), the
        teardown functions are called just before the app context is
-        made inactive. Since a request context typically also manages an
+        made inactive.
        application context it would also be called when you pop a
        request context.
        When a teardown function was called because of an unhandled
        exception it will be passed an error object. If an
--- a/src/flask/sansio/blueprints.py
+++ b/src/flask/sansio/blueprints.py
@ -440,16 +440,31 @@ class Blueprint(Scaffold):
            )
        )
-    @setupmethod
+    @t.overload
    def app_template_filter(self, name: T_template_filter) -> T_template_filter: ...
    @t.overload
    def app_template_filter(
        self, name: str | None = None
-    ) -> t.Callable[[T_template_filter], T_template_filter]:
+    ) -> t.Callable[[T_template_filter], T_template_filter]: ...
-        """Register a template filter, available in any template rendered by the
+    @setupmethod
-        application. Equivalent to :meth:`.Flask.template_filter`.
+    def app_template_filter(
        self, name: T_template_filter | str | None = None
    ) -> T_template_filter | t.Callable[[T_template_filter], T_template_filter]:
        """Decorate a function to register it as a custom Jinja filter. The name
        is optional. The decorator may be used without parentheses.
-        :param name: the optional name of the filter, otherwise the
+        The :meth:`add_app_template_filter` method may be used to register a
-                     function name will be used.
+        function later rather than decorating.
        The filter is available in all templates, not only those under this
        blueprint. Equivalent to :meth:`.Flask.template_filter`.
        :param name: The name to register the filter as. If not given, uses the
            function's name.
        """
        if callable(name):
            self.add_app_template_filter(name)
            return name
        def decorator(f: T_template_filter) -> T_template_filter:
            self.add_app_template_filter(f, name=name)
@ -461,31 +476,51 @@ class Blueprint(Scaffold):
    def add_app_template_filter(
        self, f: ft.TemplateFilterCallable, name: str | None = None
    ) -> None:
-        """Register a template filter, available in any template rendered by the
+        """Register a function to use as a custom Jinja filter.
        application. Works like the :meth:`app_template_filter` decorator. Equivalent to
        :meth:`.Flask.add_template_filter`.
-        :param name: the optional name of the filter, otherwise the
+        The :meth:`app_template_filter` decorator can be used to register a
-                     function name will be used.
+        function by decorating instead.
        The filter is available in all templates, not only those under this
        blueprint. Equivalent to :meth:`.Flask.add_template_filter`.
        :param f: The function to register.
        :param name: The name to register the filter as. If not given, uses the
            function's name.
        """
-        def register_template(state: BlueprintSetupState) -> None:
+        def register_template_filter(state: BlueprintSetupState) -> None:
-            state.app.jinja_env.filters[name or f.__name__] = f
+            state.app.add_template_filter(f, name=name)
-        self.record_once(register_template)
+        self.record_once(register_template_filter)
-    @setupmethod
+    @t.overload
    def app_template_test(self, name: T_template_test) -> T_template_test: ...
    @t.overload
    def app_template_test(
        self, name: str | None = None
-    ) -> t.Callable[[T_template_test], T_template_test]:
+    ) -> t.Callable[[T_template_test], T_template_test]: ...
-        """Register a template test, available in any template rendered by the
+    @setupmethod
-        application. Equivalent to :meth:`.Flask.template_test`.
+    def app_template_test(
        self, name: T_template_test | str | None = None
    ) -> T_template_test | t.Callable[[T_template_test], T_template_test]:
        """Decorate a function to register it as a custom Jinja test. The name
        is optional. The decorator may be used without parentheses.
        The :meth:`add_app_template_test` method may be used to register a
        function later rather than decorating.
        The test is available in all templates, not only those under this
        blueprint. Equivalent to :meth:`.Flask.template_test`.
        :param name: The name to register the filter as. If not given, uses the
            function's name.
        .. versionadded:: 0.10
        :param name: the optional name of the test, otherwise the
                     function name will be used.
        """
        if callable(name):
            self.add_app_template_test(name)
            return name
        def decorator(f: T_template_test) -> T_template_test:
            self.add_app_template_test(f, name=name)
@ -497,33 +532,53 @@ class Blueprint(Scaffold):
    def add_app_template_test(
        self, f: ft.TemplateTestCallable, name: str | None = None
    ) -> None:
-        """Register a template test, available in any template rendered by the
+        """Register a function to use as a custom Jinja test.
-        application. Works like the :meth:`app_template_test` decorator. Equivalent to
+
-        :meth:`.Flask.add_template_test`.
+        The :meth:`app_template_test` decorator can be used to register a
        function by decorating instead.
        The test is available in all templates, not only those under this
        blueprint. Equivalent to :meth:`.Flask.add_template_test`.
        :param f: The function to register.
        :param name: The name to register the test as. If not given, uses the
            function's name.
        .. versionadded:: 0.10
        :param name: the optional name of the test, otherwise the
                     function name will be used.
        """
-        def register_template(state: BlueprintSetupState) -> None:
+        def register_template_test(state: BlueprintSetupState) -> None:
-            state.app.jinja_env.tests[name or f.__name__] = f
+            state.app.add_template_test(f, name=name)
-        self.record_once(register_template)
+        self.record_once(register_template_test)
-    @setupmethod
+    @t.overload
    def app_template_global(self, name: T_template_global) -> T_template_global: ...
    @t.overload
    def app_template_global(
        self, name: str | None = None
-    ) -> t.Callable[[T_template_global], T_template_global]:
+    ) -> t.Callable[[T_template_global], T_template_global]: ...
-        """Register a template global, available in any template rendered by the
+    @setupmethod
-        application. Equivalent to :meth:`.Flask.template_global`.
+    def app_template_global(
        self, name: T_template_global | str | None = None
    ) -> T_template_global | t.Callable[[T_template_global], T_template_global]:
        """Decorate a function to register it as a custom Jinja global. The name
        is optional. The decorator may be used without parentheses.
        The :meth:`add_app_template_global` method may be used to register a
        function later rather than decorating.
        The global is available in all templates, not only those under this
        blueprint. Equivalent to :meth:`.Flask.template_global`.
        :param name: The name to register the global as. If not given, uses the
            function's name.
        .. versionadded:: 0.10
        :param name: the optional name of the global, otherwise the
                     function name will be used.
        """
        if callable(name):
            self.add_app_template_global(name)
            return name
        def decorator(f: T_template_global) -> T_template_global:
            self.add_app_template_global(f, name=name)
@ -535,20 +590,25 @@ class Blueprint(Scaffold):
    def add_app_template_global(
        self, f: ft.TemplateGlobalCallable, name: str | None = None
    ) -> None:
-        """Register a template global, available in any template rendered by the
+        """Register a function to use as a custom Jinja global.
-        application. Works like the :meth:`app_template_global` decorator. Equivalent to
+
-        :meth:`.Flask.add_template_global`.
+        The :meth:`app_template_global` decorator can be used to register a function
        by decorating instead.
        The global is available in all templates, not only those under this
        blueprint. Equivalent to :meth:`.Flask.add_template_global`.
        :param f: The function to register.
        :param name: The name to register the global as. If not given, uses the
            function's name.
        .. versionadded:: 0.10
        :param name: the optional name of the global, otherwise the
                     function name will be used.
        """
-        def register_template(state: BlueprintSetupState) -> None:
+        def register_template_global(state: BlueprintSetupState) -> None:
-            state.app.jinja_env.globals[name or f.__name__] = f
+            state.app.add_template_global(f, name=name)
-        self.record_once(register_template)
+        self.record_once(register_template_global)
    @setupmethod
    def before_app_request(self, f: T_before_request) -> T_before_request:
--- a/src/flask/sansio/scaffold.py
+++ b/src/flask/sansio/scaffold.py
@ -84,7 +84,7 @@ class Scaffold:
        #: to. Do not change this once it is set by the constructor.
        self.import_name = import_name
-        self.static_folder = static_folder  # type: ignore
+        self.static_folder = static_folder
        self.static_url_path = static_url_path
        #: The path to the templates folder, relative to
@ -507,8 +507,8 @@ class Scaffold:
    @setupmethod
    def teardown_request(self, f: T_teardown) -> T_teardown:
        """Register a function to be called when the request context is
-        popped. Typically this happens at the end of each request, but
+        popped. Typically, this happens at the end of each request, but
-        contexts may be pushed manually as well during testing.
+        contexts may be pushed manually during testing.
        .. code-block:: python
--- a/src/flask/sessions.py
+++ b/src/flask/sessions.py
@ -107,7 +107,7 @@ class NullSession(SecureCookieSession):
            "application to something unique and secret."
        )
-    __setitem__ = __delitem__ = clear = pop = popitem = update = setdefault = _fail  # type: ignore # noqa: B950
+    __setitem__ = __delitem__ = clear = pop = popitem = update = setdefault = _fail  # noqa: B950
    del _fail
--- a/src/flask/templating.py
+++ b/src/flask/templating.py
@ -8,9 +8,7 @@ from jinja2 import Template
 from jinja2 import TemplateNotFound
 from .globals import _cv_app
 from .globals import _cv_request
 from .globals import current_app
 from .globals import request
 from .helpers import stream_with_context
 from .signals import before_render_template
 from .signals import template_rendered
@ -25,19 +23,21 @@ def _default_template_ctx_processor() -> dict[str, t.Any]:
    """Default template context processor.  Injects `request`,
    `session` and `g`.
    """
-    appctx = _cv_app.get(None)
+    ctx = _cv_app.get(None)
    reqctx = _cv_request.get(None)
    rv: dict[str, t.Any] = {}
-    if appctx is not None:
+
-        rv["g"] = appctx.g
+    if ctx is not None:
-    if reqctx is not None:
+        rv["g"] = ctx.g
-        rv["request"] = reqctx.request
+
-        rv["session"] = reqctx.session
+        if ctx.has_request:
            rv["request"] = ctx.request
            rv["session"] = ctx.session
    return rv
 class Environment(BaseEnvironment):
-    """Works like a regular Jinja2 environment but has some additional
+    """Works like a regular Jinja environment but has some additional
    knowledge of how Flask's blueprint works so that it can prepend the
    name of the blueprint to referenced templates if necessary.
    """
@ -145,7 +145,7 @@ def render_template(
        a list is given, the first name to exist will be rendered.
    :param context: The variables to make available in the template.
    """
-    app = current_app._get_current_object()  # type: ignore[attr-defined]
+    app = current_app._get_current_object()
    template = app.jinja_env.get_or_select_template(template_name_or_list)
    return _render(app, template, context)
@ -157,7 +157,7 @@ def render_template_string(source: str, **context: t.Any) -> str:
    :param source: The source code of the template to render.
    :param context: The variables to make available in the template.
    """
-    app = current_app._get_current_object()  # type: ignore[attr-defined]
+    app = current_app._get_current_object()
    template = app.jinja_env.from_string(source)
    return _render(app, template, context)
@ -176,13 +176,7 @@ def _stream(
            app, _async_wrapper=app.ensure_sync, template=template, context=context
        )
-    rv = generate()
+    return stream_with_context(generate())
    # If a request context is active, keep it while generating.
    if request:
        rv = stream_with_context(rv)
    return rv
 def stream_template(
@ -199,7 +193,7 @@ def stream_template(
    .. versionadded:: 2.2
    """
-    app = current_app._get_current_object()  # type: ignore[attr-defined]
+    app = current_app._get_current_object()
    template = app.jinja_env.get_or_select_template(template_name_or_list)
    return _stream(app, template, context)
@ -214,6 +208,6 @@ def stream_template_string(source: str, **context: t.Any) -> t.Iterator[str]:
    .. versionadded:: 2.2
    """
-    app = current_app._get_current_object()  # type: ignore[attr-defined]
+    app = current_app._get_current_object()
    template = app.jinja_env.from_string(source)
    return _stream(app, template, context)
--- a/src/flask/testing.py
+++ b/src/flask/testing.py
@ -85,7 +85,7 @@ class EnvironBuilder(werkzeug.test.EnvironBuilder):
        self.app = app
        super().__init__(path, base_url, *args, **kwargs)
-    def json_dumps(self, obj: t.Any, **kwargs: t.Any) -> str:  # type: ignore
+    def json_dumps(self, obj: t.Any, **kwargs: t.Any) -> str:
        """Serialize ``obj`` to a JSON-formatted string.
        The serialization will be configured according to the config associated
@ -107,10 +107,10 @@ def _get_werkzeug_version() -> str:
 class FlaskClient(Client):
-    """Works like a regular Werkzeug test client but has knowledge about
+    """Works like a regular Werkzeug test client, with additional behavior for
-    Flask's contexts to defer the cleanup of the request context until
+    Flask. Can defer the cleanup of the request context until the end of a
-    the end of a ``with`` block. For general information about how to
+    ``with`` block. For general information about how to use this class refer to
-    use this class refer to :class:`werkzeug.test.Client`.
+    :class:`werkzeug.test.Client`.
    .. versionchanged:: 0.12
       `app.test_client()` includes preset default environment, which can be
@ -240,10 +240,10 @@ class FlaskClient(Client):
        response.json_module = self.application.json  # type: ignore[assignment]
        # Re-push contexts that were preserved during the request.
-        while self._new_contexts:
+        for cm in self._new_contexts:
            cm = self._new_contexts.pop()
            self._context_stack.enter_context(cm)
        self._new_contexts.clear()
        return response
    def __enter__(self) -> FlaskClient:
--- a/src/flask/typing.py
+++ b/src/flask/typing.py
@ -23,8 +23,7 @@ ResponseValue = t.Union[
 ]
 # the possible types for an individual HTTP header
-# This should be a Union, but mypy doesn't pass unless it's a TypeVar.
+HeaderValue = str | list[str] | tuple[str, ...]
 HeaderValue = t.Union[str, list[str], tuple[str, ...]]
 # the possible types for HTTP headers
 HeadersValue = t.Union[
@ -47,34 +46,29 @@ ResponseReturnValue = t.Union[
 # callback annotated with flask.Response fail type checking.
 ResponseClass = t.TypeVar("ResponseClass", bound="Response")
-AppOrBlueprintKey = t.Optional[str]  # The App key is None, whereas blueprints are named
+AppOrBlueprintKey = str | None  # The App key is None, whereas blueprints are named
-AfterRequestCallable = t.Union[
+AfterRequestCallable = (
-    t.Callable[[ResponseClass], ResponseClass],
+    t.Callable[[ResponseClass], ResponseClass]
-    t.Callable[[ResponseClass], t.Awaitable[ResponseClass]],
+    | t.Callable[[ResponseClass], t.Awaitable[ResponseClass]]
-]
+)
-BeforeFirstRequestCallable = t.Union[
+BeforeFirstRequestCallable = t.Callable[[], None] | t.Callable[[], t.Awaitable[None]]
-    t.Callable[[], None], t.Callable[[], t.Awaitable[None]]
+BeforeRequestCallable = (
-]
+    t.Callable[[], ResponseReturnValue | None]
-BeforeRequestCallable = t.Union[
+    | t.Callable[[], t.Awaitable[ResponseReturnValue | None]]
-    t.Callable[[], t.Optional[ResponseReturnValue]],
+)
    t.Callable[[], t.Awaitable[t.Optional[ResponseReturnValue]]],
 ]
 ShellContextProcessorCallable = t.Callable[[], dict[str, t.Any]]
-TeardownCallable = t.Union[
+TeardownCallable = (
-    t.Callable[[t.Optional[BaseException]], None],
+    t.Callable[[BaseException | None], None]
-    t.Callable[[t.Optional[BaseException]], t.Awaitable[None]],
+    | t.Callable[[BaseException | None], t.Awaitable[None]]
-]
+)
-TemplateContextProcessorCallable = t.Union[
+TemplateContextProcessorCallable = (
-    t.Callable[[], dict[str, t.Any]],
+    t.Callable[[], dict[str, t.Any]] | t.Callable[[], t.Awaitable[dict[str, t.Any]]]
-    t.Callable[[], t.Awaitable[dict[str, t.Any]]],
+)
 ]
 TemplateFilterCallable = t.Callable[..., t.Any]
 TemplateGlobalCallable = t.Callable[..., t.Any]
 TemplateTestCallable = t.Callable[..., bool]
 URLDefaultCallable = t.Callable[[str, dict[str, t.Any]], None]
-URLValuePreprocessorCallable = t.Callable[
+URLValuePreprocessorCallable = t.Callable[[str | None, dict[str, t.Any] | None], None]
    [t.Optional[str], t.Optional[dict[str, t.Any]]], None
 ]
 # This should take Exception, but that either breaks typing the argument
 # with a specific exception, or decorating multiple times with different
@ -82,12 +76,12 @@ URLValuePreprocessorCallable = t.Callable[
 # https://github.com/pallets/flask/issues/4095
 # https://github.com/pallets/flask/issues/4295
 # https://github.com/pallets/flask/issues/4297
-ErrorHandlerCallable = t.Union[
+ErrorHandlerCallable = (
-    t.Callable[[t.Any], ResponseReturnValue],
+    t.Callable[[t.Any], ResponseReturnValue]
-    t.Callable[[t.Any], t.Awaitable[ResponseReturnValue]],
+    | t.Callable[[t.Any], t.Awaitable[ResponseReturnValue]]
-]
+)
-RouteCallable = t.Union[
+RouteCallable = (
-    t.Callable[..., ResponseReturnValue],
+    t.Callable[..., ResponseReturnValue]
-    t.Callable[..., t.Awaitable[ResponseReturnValue]],
+    | t.Callable[..., t.Awaitable[ResponseReturnValue]]
-]
+)
--- a/tests/conftest.py
+++ b/tests/conftest.py
@ -5,7 +5,7 @@ import pytest
 from _pytest import monkeypatch
 from flask import Flask
-from flask.globals import request_ctx
+from flask.globals import app_ctx as _app_ctx
@pytest.fixture(scope="session", autouse=True)
@ -83,16 +83,17 @@ def test_apps(monkeypatch):
@pytest.fixture(autouse=True)
 def leak_detector():
    """Fails if any app contexts are still pushed when a test ends. Pops all
    contexts so subsequent tests are not affected.
    """
    yield
    # make sure we're not leaking a request context since we are
    # testing flask internally in debug mode in a few cases
    leaks = []
    while request_ctx:
        leaks.append(request_ctx._get_current_object())
        request_ctx.pop()
-    assert leaks == []
+    while _app_ctx:
        leaks.append(_app_ctx._get_current_object())
        _app_ctx.pop()
    assert not leaks
@pytest.fixture
--- a/tests/test_appctx.py
+++ b/tests/test_appctx.py
@ -2,7 +2,6 @@ import pytest
 import flask
 from flask.globals import app_ctx
 from flask.globals import request_ctx
 def test_basic_url_generation(app):
@ -107,7 +106,8 @@ def test_app_tearing_down_with_handled_exception_by_app_handler(app, client):
    with app.app_context():
        client.get("/")
-    assert cleanup_stuff == [None]
+    # teardown request context, and with block context
    assert cleanup_stuff == [None, None]
 def test_app_tearing_down_with_unhandled_exception(app, client):
@ -126,9 +126,11 @@ def test_app_tearing_down_with_unhandled_exception(app, client):
        with app.app_context():
            client.get("/")
-    assert len(cleanup_stuff) == 1
+    assert len(cleanup_stuff) == 2
    assert isinstance(cleanup_stuff[0], ValueError)
    assert str(cleanup_stuff[0]) == "dummy"
    # exception propagated, seen by request context and with block context
    assert cleanup_stuff[0] is cleanup_stuff[1]
 def test_app_ctx_globals_methods(app, app_ctx):
@ -178,8 +180,7 @@ def test_context_refcounts(app, client):
    @app.route("/")
    def index():
        with app_ctx:
-            with request_ctx:
+            pass
                pass
        assert flask.request.environ["werkzeug.request"] is not None
        return ""
--- a/tests/test_blueprints.py
+++ b/tests/test_blueprints.py
@ -366,11 +366,35 @@ def test_template_filter(app):
    def my_reverse(s):
        return s[::-1]
    @bp.app_template_filter
    def my_reverse_2(s):
        return s[::-1]
    @bp.app_template_filter("my_reverse_custom_name_3")
    def my_reverse_3(s):
        return s[::-1]
    @bp.app_template_filter(name="my_reverse_custom_name_4")
    def my_reverse_4(s):
        return s[::-1]
    app.register_blueprint(bp, url_prefix="/py")
    assert "my_reverse" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse"] == my_reverse
    assert app.jinja_env.filters["my_reverse"]("abcd") == "dcba"
    assert "my_reverse_2" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse_2"] == my_reverse_2
    assert app.jinja_env.filters["my_reverse_2"]("abcd") == "dcba"
    assert "my_reverse_custom_name_3" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse_custom_name_3"] == my_reverse_3
    assert app.jinja_env.filters["my_reverse_custom_name_3"]("abcd") == "dcba"
    assert "my_reverse_custom_name_4" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse_custom_name_4"] == my_reverse_4
    assert app.jinja_env.filters["my_reverse_custom_name_4"]("abcd") == "dcba"
 def test_add_template_filter(app):
    bp = flask.Blueprint("bp", __name__)
@ -502,11 +526,35 @@ def test_template_test(app):
    def is_boolean(value):
        return isinstance(value, bool)
    @bp.app_template_test
    def boolean_2(value):
        return isinstance(value, bool)
    @bp.app_template_test("my_boolean_custom_name")
    def boolean_3(value):
        return isinstance(value, bool)
    @bp.app_template_test(name="my_boolean_custom_name_2")
    def boolean_4(value):
        return isinstance(value, bool)
    app.register_blueprint(bp, url_prefix="/py")
    assert "is_boolean" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["is_boolean"] == is_boolean
    assert app.jinja_env.tests["is_boolean"](False)
    assert "boolean_2" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["boolean_2"] == boolean_2
    assert app.jinja_env.tests["boolean_2"](False)
    assert "my_boolean_custom_name" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["my_boolean_custom_name"] == boolean_3
    assert app.jinja_env.tests["my_boolean_custom_name"](False)
    assert "my_boolean_custom_name_2" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["my_boolean_custom_name_2"] == boolean_4
    assert app.jinja_env.tests["my_boolean_custom_name_2"](False)
 def test_add_template_test(app):
    bp = flask.Blueprint("bp", __name__)
@ -679,6 +727,18 @@ def test_template_global(app):
    def get_answer():
        return 42
    @bp.app_template_global
    def get_stuff_1():
        return "get_stuff_1"
    @bp.app_template_global("my_get_stuff_custom_name_2")
    def get_stuff_2():
        return "get_stuff_2"
    @bp.app_template_global(name="my_get_stuff_custom_name_3")
    def get_stuff_3():
        return "get_stuff_3"
    # Make sure the function is not in the jinja_env already
    assert "get_answer" not in app.jinja_env.globals.keys()
    app.register_blueprint(bp)
@ -688,10 +748,31 @@ def test_template_global(app):
    assert app.jinja_env.globals["get_answer"] is get_answer
    assert app.jinja_env.globals["get_answer"]() == 42
    assert "get_stuff_1" in app.jinja_env.globals.keys()
    assert app.jinja_env.globals["get_stuff_1"] == get_stuff_1
    assert app.jinja_env.globals["get_stuff_1"](), "get_stuff_1"
    assert "my_get_stuff_custom_name_2" in app.jinja_env.globals.keys()
    assert app.jinja_env.globals["my_get_stuff_custom_name_2"] == get_stuff_2
    assert app.jinja_env.globals["my_get_stuff_custom_name_2"](), "get_stuff_2"
    assert "my_get_stuff_custom_name_3" in app.jinja_env.globals.keys()
    assert app.jinja_env.globals["my_get_stuff_custom_name_3"] == get_stuff_3
    assert app.jinja_env.globals["my_get_stuff_custom_name_3"](), "get_stuff_3"
    with app.app_context():
        rv = flask.render_template_string("{{ get_answer() }}")
        assert rv == "42"
        rv = flask.render_template_string("{{ get_stuff_1() }}")
        assert rv == "get_stuff_1"
        rv = flask.render_template_string("{{ my_get_stuff_custom_name_2() }}")
        assert rv == "get_stuff_2"
        rv = flask.render_template_string("{{ my_get_stuff_custom_name_3() }}")
        assert rv == "get_stuff_3"
 def test_request_processing(app, client):
    bp = flask.Blueprint("bp", __name__)
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@ -462,7 +462,7 @@ class TestRoutes:
    def expect_order(self, order, output):
        # skip the header and match the start of each row
-        for expect, line in zip(order, output.splitlines()[2:]):
+        for expect, line in zip(order, output.splitlines()[2:], strict=False):
            # do this instead of startswith for nicer pytest output
            assert line[: len(expect)] == expect
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@ -306,6 +306,29 @@ class TestStreaming:
        rv = client.get("/")
        assert rv.data == b"flask"
    def test_async_view(self, app, client):
        @app.route("/")
        async def index():
            flask.session["test"] = "flask"
            @flask.stream_with_context
            def gen():
                yield flask.session["test"]
            return flask.Response(gen())
        # response is closed without reading stream
        client.get().close()
        # response stream is read
        assert client.get().text == "flask"
        # same as above, but with client context preservation
        with client:
            client.get().close()
        with client:
            assert client.get().text == "flask"
 class TestHelpers:
    @pytest.mark.parametrize(
--- a/tests/test_reqctx.py
+++ b/tests/test_reqctx.py
@ -3,7 +3,7 @@ import warnings
 import pytest
 import flask
-from flask.globals import request_ctx
+from flask.globals import app_ctx
 from flask.sessions import SecureCookieSessionInterface
 from flask.sessions import SessionInterface
@ -153,12 +153,12 @@ class TestGreenletContextCopying:
        @app.route("/")
        def index():
            flask.session["fizz"] = "buzz"
-            reqctx = request_ctx.copy()
+            ctx = app_ctx.copy()
            def g():
                assert not flask.request
                assert not flask.current_app
-                with reqctx:
+                with ctx:
                    assert flask.request
                    assert flask.current_app == app
                    assert flask.request.path == "/"
--- a/tests/test_session_interface.py
+++ b/tests/test_session_interface.py
@ -1,5 +1,5 @@
 import flask
-from flask.globals import request_ctx
+from flask.globals import app_ctx
 from flask.sessions import SessionInterface
@ -14,7 +14,7 @@ def test_open_session_with_endpoint():
            pass
        def open_session(self, app, request):
-            request_ctx.match_request()
+            app_ctx.match_request()
            assert request.endpoint is not None
    app = flask.Flask(__name__)
--- a/tests/test_templating.py
+++ b/tests/test_templating.py
@ -129,6 +129,30 @@ def test_template_filter(app):
    assert app.jinja_env.filters["my_reverse"] == my_reverse
    assert app.jinja_env.filters["my_reverse"]("abcd") == "dcba"
    @app.template_filter
    def my_reverse_2(s):
        return s[::-1]
    assert "my_reverse_2" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse_2"] == my_reverse_2
    assert app.jinja_env.filters["my_reverse_2"]("abcd") == "dcba"
    @app.template_filter("my_reverse_custom_name_3")
    def my_reverse_3(s):
        return s[::-1]
    assert "my_reverse_custom_name_3" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse_custom_name_3"] == my_reverse_3
    assert app.jinja_env.filters["my_reverse_custom_name_3"]("abcd") == "dcba"
    @app.template_filter(name="my_reverse_custom_name_4")
    def my_reverse_4(s):
        return s[::-1]
    assert "my_reverse_custom_name_4" in app.jinja_env.filters.keys()
    assert app.jinja_env.filters["my_reverse_custom_name_4"] == my_reverse_4
    assert app.jinja_env.filters["my_reverse_custom_name_4"]("abcd") == "dcba"
 def test_add_template_filter(app):
    def my_reverse(s):
@ -223,6 +247,30 @@ def test_template_test(app):
    assert app.jinja_env.tests["boolean"] == boolean
    assert app.jinja_env.tests["boolean"](False)
    @app.template_test
    def boolean_2(value):
        return isinstance(value, bool)
    assert "boolean_2" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["boolean_2"] == boolean_2
    assert app.jinja_env.tests["boolean_2"](False)
    @app.template_test("my_boolean_custom_name")
    def boolean_3(value):
        return isinstance(value, bool)
    assert "my_boolean_custom_name" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["my_boolean_custom_name"] == boolean_3
    assert app.jinja_env.tests["my_boolean_custom_name"](False)
    @app.template_test(name="my_boolean_custom_name_2")
    def boolean_4(value):
        return isinstance(value, bool)
    assert "my_boolean_custom_name_2" in app.jinja_env.tests.keys()
    assert app.jinja_env.tests["my_boolean_custom_name_2"] == boolean_4
    assert app.jinja_env.tests["my_boolean_custom_name_2"](False)
 def test_add_template_test(app):
    def boolean(value):
@ -320,6 +368,39 @@ def test_add_template_global(app, app_ctx):
    rv = flask.render_template_string("{{ get_stuff() }}")
    assert rv == "42"
    @app.template_global
    def get_stuff_1():
        return "get_stuff_1"
    assert "get_stuff_1" in app.jinja_env.globals.keys()
    assert app.jinja_env.globals["get_stuff_1"] == get_stuff_1
    assert app.jinja_env.globals["get_stuff_1"](), "get_stuff_1"
    rv = flask.render_template_string("{{ get_stuff_1() }}")
    assert rv == "get_stuff_1"
    @app.template_global("my_get_stuff_custom_name_2")
    def get_stuff_2():
        return "get_stuff_2"
    assert "my_get_stuff_custom_name_2" in app.jinja_env.globals.keys()
    assert app.jinja_env.globals["my_get_stuff_custom_name_2"] == get_stuff_2
    assert app.jinja_env.globals["my_get_stuff_custom_name_2"](), "get_stuff_2"
    rv = flask.render_template_string("{{ my_get_stuff_custom_name_2() }}")
    assert rv == "get_stuff_2"
    @app.template_global(name="my_get_stuff_custom_name_3")
    def get_stuff_3():
        return "get_stuff_3"
    assert "my_get_stuff_custom_name_3" in app.jinja_env.globals.keys()
    assert app.jinja_env.globals["my_get_stuff_custom_name_3"] == get_stuff_3
    assert app.jinja_env.globals["my_get_stuff_custom_name_3"](), "get_stuff_3"
    rv = flask.render_template_string("{{ my_get_stuff_custom_name_3() }}")
    assert rv == "get_stuff_3"
 def test_custom_template_loader(client):
    class MyFlask(flask.Flask):
--- a/tests/test_testing.py
+++ b/tests/test_testing.py
@ -6,7 +6,7 @@ import pytest
 import flask
 from flask import appcontext_popped
 from flask.cli import ScriptInfo
-from flask.globals import _cv_request
+from flask.globals import _cv_app
 from flask.json import jsonify
 from flask.testing import EnvironBuilder
 from flask.testing import FlaskCliRunner
@ -138,32 +138,21 @@ def test_blueprint_with_subdomain():
    assert rv.data == b"http://xxx.example.com:1234/foo/"
-def test_redirect_keep_session(app, client, app_ctx):
+def test_redirect_session(app, client, app_ctx):
-    @app.route("/", methods=["GET", "POST"])
+    @app.route("/redirect")
    def index():
-        if flask.request.method == "POST":
+        flask.session["redirect"] = True
-            return flask.redirect("/getsession")
+        return flask.redirect("/target")
        flask.session["data"] = "foo"
        return "index"
-    @app.route("/getsession")
+    @app.route("/target")
    def get_session():
-        return flask.session.get("data", "<missing>")
+        flask.session["target"] = True
        return ""
    with client:
-        rv = client.get("/getsession")
+        client.get("/redirect", follow_redirects=True)
-        assert rv.data == b"<missing>"
+        assert flask.session["redirect"] is True
-
+        assert flask.session["target"] is True
        rv = client.get("/")
        assert rv.data == b"index"
        assert flask.session.get("data") == "foo"
        rv = client.post("/", data={}, follow_redirects=True)
        assert rv.data == b"foo"
        assert flask.session.get("data") == "foo"
        rv = client.get("/getsession")
        assert rv.data == b"foo"
 def test_session_transactions(app, client):
@ -393,4 +382,4 @@ def test_client_pop_all_preserved(app, req_ctx, client):
    # close the response, releasing the context held by stream_with_context
    rv.close()
    # only req_ctx fixture should still be pushed
-    assert _cv_request.get(None) is req_ctx
+    assert _cv_app.get(None) is req_ctx
--- a/uv.lock
+++ b/uv.lock
Author	SHA1	Message	Date
David Lord	adf363679d	merge app and request context (#5812 ) pre-commit / main (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details	2025-09-19 16:45:27 -07:00
David Lord	c2705ffd9c	merge app and request context	2025-09-19 16:43:53 -07:00
David Lord	330123258e	Merge branch 'stable'	2025-08-19 14:09:56 -07:00
David Lord	85793d6c22	release version 3.1.2 (#5800 ) pre-commit / main (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.9) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details	2025-08-19 14:03:43 -07:00
David Lord	2c1b30d050	release version 3.1.2	2025-08-19 13:57:47 -07:00
David Lord	1292419ddf	Update GitHub Actions workflow for artifact handling (#5795 )	2025-08-19 13:56:49 -07:00
Grant Birkinbine	4dd52ca9c7	Update GitHub Actions workflow for artifact handling	2025-08-19 13:50:03 -07:00
David Lord	55c6255657	update dev dependencies	2025-08-19 13:41:24 -07:00
David Lord	ed1c9e953e	support call template_filter without parens (#5736 )	2025-08-19 12:36:00 -07:00
David Lord	edebd37044	rewrite docs, clean up typing for template decorators	2025-08-19 12:33:21 -07:00
kadai0308	daf1510a4b	use template_filter without parens	2025-08-19 12:33:21 -07:00
David Lord	d8259eb119	use Jinja name consistently	2025-08-19 10:43:16 -07:00
David Lord	38b4c1e19b	refactor stream_with_context for async views (#5799 )	2025-08-19 08:23:51 -07:00
David Lord	9822a03515	refactor stream_with_context for async views	2025-08-19 08:18:55 -07:00
David Lord	49b7e7bc8f	security docs for TRUSTED_HOSTS (#5798 )	2025-08-18 11:44:57 -07:00
David Lord	b228ca3d87	security docs for TRUSTED_HOSTS	2025-08-18 11:42:48 -07:00
David Lord	ff64079a51	update flask-talisman link	2025-08-18 10:51:12 -07:00
David Lord	1dfd7cd555	use IO[bytes] instead of BinaryIO for wider compatibility (#5777 )	2025-08-18 10:26:12 -07:00
Tero Vuotila	d44f1c6523	relax type hint for bytes io	2025-08-18 10:22:59 -07:00
David Lord	c56c5ec7c4	Docs: Fix escaping in HTML escaping example (#5742 )	2025-08-18 10:20:06 -07:00
Badhreesh	0f83958247	demonstrate escaping with query string slash in value would be interpreted as a path separator in the URL	2025-08-18 10:19:18 -07:00
David Lord	7fea7cf156	Update macOS UI reference to “System Settings” (#5723 )	2025-08-18 10:08:07 -07:00
David Lord	24824ff666	push preserved contexts in correct order (#5797 )	2025-08-18 09:56:39 -07:00
David Lord	53b8f08218	push preserved contexts in correct order	2025-08-18 09:45:56 -07:00
David Lord	5addaf833b	start version 3.1.2	2025-08-18 09:42:21 -07:00
David Lord	85c5d93cbd	Merge branch 'stable' pre-commit / main (push) Has been cancelled Details Lock inactive closed issues / lock (push) Has been cancelled Details	2025-06-12 13:48:07 -07:00
David Lord	85cc710464	svg logo pre-commit / main (push) Has been cancelled Details	2025-06-12 13:46:49 -07:00
David Lord	284273e3c5	Merge branch 'stable' pre-commit / main (push) Has been cancelled Details	2025-06-10 13:18:26 -07:00
David Lord	f17d986948	cleanup svg pre-commit / main (push) Has been cancelled Details	2025-06-10 13:18:15 -07:00
David Lord	d6009c0aeb	Merge branch 'stable' pre-commit / main (push) Waiting to run Details	2025-06-09 21:20:46 -07:00
David Lord	2b42a803a2	cleanup svg pre-commit / main (push) Waiting to run Details	2025-06-09 21:20:36 -07:00
David Lord	211cce038a	Merge branch 'stable' pre-commit / main (push) Waiting to run Details	2025-06-09 14:33:44 -07:00
David Lord	a7b67c99f9	svg logo (#5757 ) pre-commit / main (push) Waiting to run Details	2025-06-09 14:33:26 -07:00
David Lord	a758915893	svg logo	2025-06-09 14:31:31 -07:00
David Lord	e974128863	Merge branch 'stable' pre-commit / main (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details	2025-06-08 09:54:32 -07:00
David Lord	f04c5e6964	update dev dependencies pre-commit / main (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.9) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details	2025-06-08 09:52:11 -07:00
David Lord	c07b201ce3	Merge pull request #5754 remove slsa provenance	2025-06-08 09:47:45 -07:00
David Lord	adeea00707	remove slsa provenance PyPI trusted publishing has its own attestation support now.	2025-06-08 09:43:05 -07:00
abhiram kamini	7bf3be8dfa	Update server.rst made changes to rename system preferences to system settings according to new mac os name change	2025-06-04 17:24:45 -07:00
David Lord	a42c4d54a3	Fix global CONTRIBUTING link (#5737 ) pre-commit / main (push) Has been cancelled Details	2025-05-20 12:30:04 -04:00
AJ Jordan	184ec3c545	Fix global CONTRIBUTING link	2025-05-20 12:26:17 -04:00
David Lord	a5f9742398	drop end of life python versions (#5731 ) pre-commit / main (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details Lock inactive closed issues / lock (push) Has been cancelled Details	2025-05-13 08:35:41 -07:00
David Lord	52df9eed45	drop end of life python versions	2025-05-13 08:31:54 -07:00
David Lord	e7e5380776	Merge branch 'stable'	2025-05-13 08:10:30 -07:00
David Lord	bbaf13333f	fix syntax pre-commit / main (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.9) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details	2025-05-13 08:09:39 -07:00
David Lord	57e7286948	release version 3.1.1 (#5730 )	2025-05-13 08:01:42 -07:00
David Lord	bc143499cf	Merge branch 'stable' pre-commit / main (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.9) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.10, tests-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.13, tests-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.11, pypy3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.13) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details	2025-05-11 18:08:43 -07:00
David Lord	11c45eeba3	update dev dependencies pre-commit / main (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (3.9) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.9, py-dev) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.12) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.12, py-min) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.10, pypy310) (push) Waiting to run Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.12) (push) Waiting to run Details Tests / typing (push) Waiting to run Details	2025-05-11 05:58:48 -07:00
David Lord	b78b5a210b	Merge branch 'stable' pre-commit / main (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.10) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.11) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.13) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (3.9) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Development Versions, 3.9, py-dev) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Mac, macos-latest, 3.12) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Minimum Versions, 3.12, py-min) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (PyPy, pypy-3.10, pypy310) (push) Has been cancelled Details Tests / ${{ matrix.name \|\| matrix.python }} (Windows, windows-latest, 3.12) (push) Has been cancelled Details Tests / typing (push) Has been cancelled Details Lock inactive closed issues / lock (push) Has been cancelled Details	2025-03-30 13:17:17 -07:00
David Lord	f61172b8dd	Merge branch 'stable'	2025-01-05 09:10:00 -08:00
David Lord	60a11a730e	use global contributing guide Remove the per-project files so we don't have to keep them in sync. GitHub's UI links to everything except the contributing guide, so add a section about that to the readme.	2025-01-05 09:02:41 -08:00
David Lord	6b361ce06b	markdown formatting	2025-01-05 09:01:49 -08:00
David Lord	6b054f8f38	Merge branch 'stable'	2024-11-23 17:54:29 -08:00
David Lord	d5b7a05ab2	remove previously deprecated code (#5648 )	2024-11-23 15:59:30 -08:00
David Lord	d22bfcd4cf	remove previously deprecated code	2024-11-23 15:41:36 -08:00
David Lord	4fec712f32	start version 3.2.0	2024-11-23 15:33:38 -08:00