Merge remote-tracking branch 'upstream/master' into pin-actions-by-sha

Pin pre-commit hook by hash
Pin github actions by commit sha
2026-09-08 19:41:04 -04:00 · 2026-04-03 21:41:31 +02:00 · 2026-04-03 21:41:11 +02:00 · 2026-03-30 11:51:20 +02:00
1487 changed files with 32437 additions and 43465 deletions
@@ -0,0 +1 @@
+github: [tiangolo]
@@ -4,30 +4,13 @@ updates:
  - package-ecosystem: "github-actions"
    directory: "/"
    schedule:
-      interval: "monthly"
-    cooldown:
-      default-days: 7
+      interval: "daily"
    commit-message:
      prefix: ⬆
-    labels:
-      - "internal"
-      - "dependencies"
-      - "github_actions"
-    groups:
-      github-actions:
-        patterns:
-          - "*"
  # Python
  - package-ecosystem: "uv"
    directory: "/"
    schedule:
      interval: "monthly"
-    cooldown:
-      default-days: 7
    commit-message:
      prefix: ⬆
-    groups:
-      python-packages:
-        dependency-type: "development"
-        patterns:
-          - "*"
@@ -0,0 +1,38 @@
+docs:
+  - all:
+    - changed-files:
+      - any-glob-to-any-file:
+        - docs/en/docs/**
+        - docs_src/**
+      - all-globs-to-all-files:
+        - '!fastapi/**'
+        - '!pyproject.toml'
+        - '!docs/en/data/sponsors.yml'
+        - '!docs/en/overrides/main.html'
+
+lang-all:
+  - all:
+    - changed-files:
+      - any-glob-to-any-file:
+        - docs/*/docs/**
+      - all-globs-to-all-files:
+        - '!docs/en/docs/**'
+        - '!docs/*/**/_*.md'
+        - '!fastapi/**'
+        - '!pyproject.toml'
+
+internal:
+  - all:
+    - changed-files:
+      - any-glob-to-any-file:
+        - .github/**
+        - scripts/**
+        - .gitignore
+        - .pre-commit-config.yaml
+        - uv.lock
+        - docs/en/data/sponsors.yml
+        - docs/en/overrides/main.html
+      - all-globs-to-all-files:
+        - '!docs/*/docs/**'
+        - '!fastapi/**'
+        - '!pyproject.toml'
@@ -1,15 +0,0 @@
-auto-labels:
-  docs:
-    - docs/en/docs/**
-    - docs_src/**
-  lang-all:
-    - exclude: docs/*/**/_*.md
-    - docs/*/docs/**
-  internal:
-    - .github/**
-    - scripts/**
-    - .gitignore
-    - .pre-commit-config.yaml
-    - uv.lock
-    - docs/en/data/sponsors.yml
-    - docs/en/overrides/main.html
@@ -1,3 +0,0 @@
-workflows:
-  - .github/workflows/pre-commit.yml
-  - .github/workflows/translate.yml
@@ -1,6 +0,0 @@
-workflows:
-  - .github/workflows/bump-pre-commit-hooks.yml
-  - .github/workflows/prepare-release.yml
-  - .github/workflows/sponsors.yml
-  - .github/workflows/topic-repos.yml
-  - .github/workflows/translate.yml
@@ -1,21 +1,18 @@
 name: Add to Project

 on:
-  pull_request_target: # zizmor: ignore[dangerous-triggers]
+  pull_request_target:
  issues:
    types:
      - opened
      - reopened

-permissions: {}
-
 jobs:
  add-to-project:
    name: Add to project
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
-      - uses: actions/add-to-project@5afcf98fcd03f1c2f92c3c83f58ae24323cc57fd # v2.0.0
+      - uses: actions/add-to-project@244f685bbc3b7adfa8466e08b698b5577571133e # v1.0.2
        with:
          project-url: https://github.com/orgs/fastapi/projects/2
-          github-token: ${{ secrets.PROJECTS_TOKEN }} # zizmor: ignore[secrets-outside-env]
+          github-token: ${{ secrets.PROJECTS_TOKEN }}
@@ -4,10 +4,9 @@ on:
    branches:
      - master
  pull_request:
-permissions: {}
-
-env:
-  UV_NO_SYNC: true
+    types:
+      - opened
+      - synchronize

 jobs:
  changes:
@@ -15,16 +14,13 @@ jobs:
    # Required permissions
    permissions:
      pull-requests: read
-    timeout-minutes: 5
    # Set job outputs to values from filter step
    outputs:
      docs: ${{ steps.filter.outputs.docs }}
    steps:
-    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
    # For pull requests it's not necessary to checkout the code but for the main branch it is
-    - uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
+    - uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
      id: filter
      with:
        filters: |
@@ -34,31 +30,27 @@ jobs:
            - docs_src/**
            - pyproject.toml
            - uv.lock
+            - mkdocs.yml
+            - mkdocs.env.yml
            - .github/workflows/build-docs.yml
            - .github/workflows/deploy-docs.yml
-            - scripts/docs.py
+            - scripts/mkdocs_hooks.py
  langs:
    needs:
      - changes
-    if: ${{ needs.changes.outputs.docs == 'true' }}
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    outputs:
      langs: ${{ steps.show-langs.outputs.langs }}
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: docs
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -75,7 +67,6 @@ jobs:
      - langs
    if: ${{ needs.changes.outputs.docs == 'true' }}
    runs-on: ubuntu-latest
-    timeout-minutes: 7
    strategy:
      matrix:
        lang: ${{ fromJson(needs.langs.outputs.langs) }}
@@ -84,19 +75,15 @@ jobs:
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: docs
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -104,26 +91,22 @@ jobs:
        run: uv sync --locked --no-dev --group docs
      - name: Update Languages
        run: uv run ./scripts/docs.py update-languages
+      - uses: actions/cache@668228422ae6a00e4ad889ee87cd7109ec5666a7 # v5.0.4
+        with:
+          key: mkdocs-cards-${{ matrix.lang }}-${{ github.ref }}
+          path: docs/${{ matrix.lang }}/.cache
      - name: Build Docs
-        run: | # zizmor: ignore[template-injection] - comes from trusted source
-          uv run ./scripts/docs.py build-lang ${{ matrix.lang }}
-      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        run: uv run ./scripts/docs.py build-lang ${{ matrix.lang }}
+      - uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
        with:
          name: docs-site-${{ matrix.lang }}
-          # English owns root static assets. Translated pages reference /img, /css,
-          # and /js, so omit duplicated language-local copies from artifacts.
-          path: |
-            ./site/**
-            !./site/${{ matrix.lang }}/img/**
-            !./site/${{ matrix.lang }}/css/**
-            !./site/${{ matrix.lang }}/js/**
+          path: ./site/**
          include-hidden-files: true

  # https://github.com/marketplace/actions/alls-green#why
  docs-all-green:  # This job does nothing and is only used for the branch protection
    if: always()
    needs:
-      - langs
      - build-docs
    runs-on: ubuntu-latest
    steps:
@@ -131,4 +114,4 @@ jobs:
        uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # v1.2.2
        with:
          jobs: ${{ toJSON(needs) }}
-          allowed-skips: langs, build-docs
+          allowed-skips: build-docs
@@ -1,79 +0,0 @@
-name: Bump pre-commit hooks
-
-on:
-  schedule:
-    - cron: "0 12 1 * *"
-  workflow_dispatch:
-
-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
-jobs:
-  bump-pre-commit-hooks:
-    if: github.repository_owner == 'fastapi'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    permissions:
-      contents: read
-      id-token: write
-    steps:
-      - name: Dump GitHub context
-        env:
-          GITHUB_CONTEXT: ${{ toJson(github) }}
-        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version-file: ".python-version"
-      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-        with:
-          version: "latest-known"
-          cache-dependency-glob: |
-            pyproject.toml
-            uv.lock
-          cache-suffix: dev-all
-          # Disable saving cache as we install narrower set of dependencies than dev-all has.
-          save-cache: false
-      - name: Install dependencies
-        run: uv sync --locked --group dev
-      - name: Bump pre-commit hooks
-        run: uv run prek auto-update --freeze --cooldown-days 7
-      - name: Get PR Submit token
-        id: pr-submit
-        uses: tiangolo/pr-submit@d802fdf59bde80bc3eb8bd3259f4cbeec63de4aa # 0.0.1
-      - name: Create pull request
-        env:
-          GH_TOKEN: ${{ steps.pr-submit.outputs.token }}
-          BASE_BRANCH: ${{ github.event.repository.default_branch }}
-        run: |
-          set -euo pipefail
-          if git diff --quiet; then
-            echo "No pre-commit hook updates available"
-            exit 0
-          fi
-          git config user.name "pr-submit[bot]"
-          git config user.email "pr-submit[bot]@users.noreply.github.com"
-          branch="bump-pre-commit-hooks"
-          git switch -C "$branch"
-          git add .pre-commit-config.yaml
-          git commit -m "⬆ Bump pre-commit hooks"
-          gh auth setup-git
-          git push --force origin "$branch"
-          if [ -z "$(gh pr list --head "$branch" --state open --json number --jq '.[].number')" ]; then
-            gh pr create \
-              --base "$BASE_BRANCH" \
-              --head "$branch" \
-              --title "⬆ Bump pre-commit hooks" \
-              --body "Bump pre-commit hook versions via \`prek auto-update --freeze --cooldown-days 7\`." \
-              --label internal \
-              --label dependencies \
-              --label pre-commit
-          else
-            echo "PR for \"$branch\" already open; branch updated in place."
-          fi
@@ -0,0 +1,49 @@
+name: FastAPI People Contributors
+
+on:
+  schedule:
+    - cron: "0 3 1 * *"
+  workflow_dispatch:
+    inputs:
+      debug_enabled:
+        description: "Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)"
+        required: false
+        default: "false"
+
+jobs:
+  job:
+    if: github.repository_owner == 'fastapi'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Dump GitHub context
+        env:
+          GITHUB_CONTEXT: ${{ toJson(github) }}
+        run: echo "$GITHUB_CONTEXT"
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version-file: ".python-version"
+      - name: Setup uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+        with:
+          enable-cache: true
+          cache-dependency-glob: |
+            pyproject.toml
+            uv.lock
+      - name: Install Dependencies
+        run: uv sync --locked --no-dev --group github-actions
+      # Allow debugging with tmate
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@c0afd6f790e3a5564914980036ebf83216678101 # v3.23
+        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
+        with:
+          limit-access-to-actor: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_PR_TOKEN }}
+      - name: FastAPI People Contributors
+        run: uv run ./scripts/contributors.py
+        env:
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_PR_TOKEN }}
@@ -1,65 +0,0 @@
-name: Create Draft Release
-
-on:
-  pull_request:
-    types:
-      - closed
-
-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
-jobs:
-  create-draft-release:
-    if: github.event.pull_request.merged == true && contains(github.event.pull_request.labels.*.name, 'release')
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: write
-    env:
-      PREPARE_RELEASE_VERSION_FILE: fastapi/__init__.py
-      PREPARE_RELEASE_RELEASE_NOTES_FILE: docs/en/docs/release-notes.md
-    steps:
-      - name: Dump GitHub context
-        env:
-          GITHUB_CONTEXT: ${{ toJson(github) }}
-        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: true
-      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version-file: ".python-version"
-      - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-        with:
-          version: "latest-known"
-          cache-dependency-glob: |
-            pyproject.toml
-            uv.lock
-          cache-suffix: dev-all
-          # Disable saving cache as we install narrower set of dependencies than dev-all has.
-          save-cache: false
-      - name: Install dependencies
-        run: uv sync --locked --group dev
-      - name: Extract release details
-        id: release-details
-        run: |
-          set -euo pipefail
-          version="$(uv run python scripts/prepare_release.py current-version)"
-          uv run python scripts/prepare_release.py release-notes > draft-release-notes.md
-          echo "version=$version" >> "$GITHUB_OUTPUT"
-      - name: Create draft release
-        env:
-          GH_TOKEN: ${{ github.token }}
-          VERSION: ${{ steps.release-details.outputs.version }}
-        run: |
-          set -euo pipefail
-          gh release create "$VERSION" \
-            --draft \
-            --title "$VERSION" \
-            --notes-file draft-release-notes.md \
-            --target "$(git rev-parse HEAD)"
@@ -1,42 +1,37 @@
 name: Deploy Docs
 on:
-  workflow_run: # zizmor: ignore[dangerous-triggers]
+  workflow_run:
    workflows:
      - Build Docs
    types:
      - completed

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
+permissions:
+  deployments: write
+  issues: write
+  pull-requests: write
+  statuses: write

 jobs:
  deploy-docs:
    runs-on: ubuntu-latest
-    permissions:
-      deployments: write
-      issues: write
-      pull-requests: write
-      statuses: write
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
-          enable-cache: false
+          enable-cache: true
+          cache-dependency-glob: |
+            pyproject.toml
+            uv.lock
      - name: Install GitHub Actions dependencies
        run: uv sync --locked --no-dev --group github-actions
      - name: Deploy Docs Status Pending
@@ -64,10 +59,10 @@ jobs:
        env:
          PROJECT_NAME: fastapitiangolo
          BRANCH: ${{ ( github.event.workflow_run.head_repository.full_name == github.repository && github.event.workflow_run.head_branch == 'master' && 'main' ) || ( github.event.workflow_run.head_sha ) }}
-        uses: cloudflare/wrangler-action@ebbaa1584979971c8614a24965b4405ff95890e0 # v4.0.0
+        uses: cloudflare/wrangler-action@da0e0dfe58b7a431659754fdf3f186c529afbe65 # v3.14.1
        with:
-          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }} # zizmor: ignore[secrets-outside-env]
-          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }} # zizmor: ignore[secrets-outside-env]
+          apiToken: ${{ secrets.CLOUDFLARE_API_TOKEN }}
+          accountId: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }}
          command: pages deploy ./site --project-name=${{ env.PROJECT_NAME }} --branch=${{ env.BRANCH }}
      - name: Deploy Docs Status Error
        if: failure()
@@ -1,21 +1,18 @@
 name: "Conflict detector"
 on:
  push:
-  pull_request_target: # zizmor: ignore[dangerous-triggers]
+  pull_request_target:
    types: [synchronize]

-permissions: {}
-
 jobs:
  main:
    permissions:
      contents: read
      pull-requests: write
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
      - name: Check if PRs have merge conflicts
-        uses: eps1lon/actions-label-merge-conflict@0273be72a0bbd58fcd71d0d6c02c209b50d1e5e1 # v3.1.0
+        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
        with:
          dirtyLabel: "conflicts"
          repoToken: "${{ secrets.GITHUB_TOKEN }}"
@@ -1,53 +0,0 @@
-name: Guard Dependencies
-
-on:
-  pull_request_target: # zizmor: ignore[dangerous-triggers] -- This workflow only reads context.payload metadata, never checks out PR code
-    branches: [master]
-    paths:
-      - pyproject.toml
-      - uv.lock
-
-permissions:
-  contents: read
-  issues: write
-  pull-requests: write
-
-jobs:
-  check-author:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    steps:
-      - name: Check if author is org member or allowed bot
-        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
-        with:
-          script: |
-            const pr = context.payload.pull_request;
-            const author = pr.user.login;
-            const assoc = pr.author_association;
-
-            const botAllowlist = new Set(['dependabot[bot]']);
-            const orgAuthorAssociations = new Set(['MEMBER', 'OWNER']);
-
-            const allowed =
-              botAllowlist.has(author) ||
-              (assoc != null && orgAuthorAssociations.has(assoc));
-
-            if (!allowed) {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.pull_request.number,
-                body: `This PR modifies dependency files (\`pyproject.toml\` or \`uv.lock\`), which is restricted to members of the **${context.repo.owner}** organization on GitHub.\n\nIf you need a dependency change, please [open a discussion](https://github.com/${context.repo.owner}/${context.repo.repo}/discussions/new) describing what you need and why.\n\nClosing this PR automatically.`
-              });
-
-              await github.rest.pulls.update({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                pull_number: context.payload.pull_request.number,
-                state: 'closed'
-              });
-
-              core.setFailed('Dependency changes are restricted to organization members.');
-            } else {
-              console.log(`Author ${author} (author_association=${assoc}) is allowed to make dependency changes.`);
-            }
@@ -9,26 +9,47 @@ on:
  issues:
    types:
      - labeled
-  pull_request_target: # zizmor: ignore[dangerous-triggers]
+  pull_request_target:
    types:
      - labeled
  workflow_dispatch:

-permissions: {}
+permissions:
+  issues: write
+  pull-requests: write

 jobs:
  issue-manager:
    if: github.repository_owner == 'fastapi'
    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-      pull-requests: write
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: tiangolo/issue-manager@dc846170c36eb62fb434b3d943b36399fe240fb5 # 0.8.1
+      - uses: tiangolo/issue-manager@2fb3484ec9279485df8659e8ec73de262431737d # 0.6.0
        with:
          token: ${{ secrets.GITHUB_TOKEN }}
+          config: >
+            {
+              "answered": {
+                "delay": 864000,
+                "message": "Assuming the original need was handled, this will be automatically closed now. But feel free to add more comments or create new issues or PRs."
+              },
+              "waiting": {
+                "delay": 2628000,
+                "message": "As this PR has been waiting for the original user for a while but seems to be inactive, it's now going to be closed. But if there's anyone interested, feel free to create a new PR.",
+                "reminder": {
+                    "before": "P3D",
+                    "message": "Heads-up: this will be closed in 3 days unless there's new activity."
+                }
+              },
+              "invalid": {
+                "delay": 0,
+                "message": "This was marked as invalid and will be closed now. If this is an error, please provide additional details."
+              },
+              "maybe-ai": {
+                "delay": 0,
+                "message": "This was marked as potentially AI generated and will be closed now. If this is an error, please provide additional details, make sure to read the docs about contributing and AI."
+              }
+            }
@@ -5,36 +5,27 @@ on:
    - cron: "0 12 * * *"
  workflow_dispatch:

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
+permissions:
+  pull-requests: write

 jobs:
  label-approved:
    if: github.repository_owner == 'fastapi'
    runs-on: ubuntu-latest
-    permissions:
-      pull-requests: write
-    timeout-minutes: 7
    steps:
    - name: Dump GitHub context
      env:
        GITHUB_CONTEXT: ${{ toJson(github) }}
      run: echo "$GITHUB_CONTEXT"
-    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
    - name: Set up Python
-      uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+      uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
      with:
        python-version-file: ".python-version"
    - name: Setup uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
      with:
-        version: "latest-known"
        enable-cache: true
-        cache-suffix: github-actions
        cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -0,0 +1,33 @@
+name: Labels
+on:
+  pull_request_target:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      # For label-checker
+      - labeled
+      - unlabeled
+
+jobs:
+  labeler:
+    permissions:
+      contents: read
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/labeler@634933edcd8ababfe52f92936142cc22ac488b1b # v6.0.1
+      if: ${{ github.event.action != 'labeled' && github.event.action != 'unlabeled' }}
+    - run: echo "Done adding labels"
+  # Run this after labeler applied labels
+  check-labels:
+    needs:
+      - labeler
+    permissions:
+      pull-requests: read
+    runs-on: ubuntu-latest
+    steps:
+      - uses: agilepathway/label-checker@c3d16ad512e7cea5961df85ff2486bb774caf3c5 # v1.6.65
+        with:
+          one_of: breaking,security,feature,bug,refactor,upgrade,docs,lang-all,internal
+          repo_token: ${{ secrets.GITHUB_TOKEN }}
@@ -0,0 +1,44 @@
+name: Latest Changes
+
+on:
+  pull_request_target:
+    branches:
+      - master
+    types:
+      - closed
+  workflow_dispatch:
+    inputs:
+      number:
+        description: PR number
+        required: true
+      debug_enabled:
+        description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
+        required: false
+        default: 'false'
+
+jobs:
+  latest-changes:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Dump GitHub context
+        env:
+          GITHUB_CONTEXT: ${{ toJson(github) }}
+        run: echo "$GITHUB_CONTEXT"
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+        with:
+          # To allow latest-changes to commit to the main branch
+          token: ${{ secrets.FASTAPI_LATEST_CHANGES }}
+      # Allow debugging with tmate
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@c0afd6f790e3a5564914980036ebf83216678101 # v3.23
+        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
+        with:
+          limit-access-to-actor: true
+      - uses: tiangolo/latest-changes@c9d329cb147f0ddf4fb631214e3f838ff17ccbbd # 0.4.1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          latest_changes_file: docs/en/docs/release-notes.md
+          latest_changes_header: '## Latest Changes'
+          end_regex: '^## '
+          debug_logs: true
+          label_header_prefix: '### '
@@ -1,12 +1,10 @@
 name: Notify Translations

 on:
-  pull_request_target: # zizmor: ignore[dangerous-triggers]
+  pull_request_target:
    types:
      - labeled
      - closed
-    branches:
-      - master
  workflow_dispatch:
    inputs:
      number:
@@ -17,36 +15,25 @@ on:
        required: false
        default: 'false'

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
 jobs:
  job:
    runs-on: ubuntu-latest
    permissions:
      discussions: write
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.repository.default_branch }}
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: github-actions
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -54,7 +41,7 @@ jobs:
        run: uv sync --locked --no-dev --group github-actions
      # Allow debugging with tmate
      - name: Setup tmate session
-        uses: mxschmitt/action-tmate@35b54afac29c97fb54faba5b513f8fbd1882f113 # v3.24
+        uses: mxschmitt/action-tmate@c0afd6f790e3a5564914980036ebf83216678101 # v3.23
        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
        with:
          limit-access-to-actor: true
@@ -0,0 +1,50 @@
+name: FastAPI People
+
+on:
+  schedule:
+    - cron: "0 14 1 * *"
+  workflow_dispatch:
+    inputs:
+      debug_enabled:
+        description: Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)
+        required: false
+        default: "false"
+
+jobs:
+  job:
+    if: github.repository_owner == 'fastapi'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - name: Dump GitHub context
+        env:
+          GITHUB_CONTEXT: ${{ toJson(github) }}
+        run: echo "$GITHUB_CONTEXT"
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - name: Set up Python
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        with:
+          python-version-file: ".python-version"
+      - name: Setup uv
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
+        with:
+          enable-cache: true
+          cache-dependency-glob: |
+            pyproject.toml
+            uv.lock
+      - name: Install Dependencies
+        run: uv sync --locked --no-dev --group github-actions
+      # Allow debugging with tmate
+      - name: Setup tmate session
+        uses: mxschmitt/action-tmate@c0afd6f790e3a5564914980036ebf83216678101 # v3.23
+        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
+        with:
+          limit-access-to-actor: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_PEOPLE }}
+      - name: FastAPI People Experts
+        run: uv run ./scripts/people.py
+        env:
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_PEOPLE }}
+          SLEEP_INTERVAL: ${{ vars.PEOPLE_SLEEP_INTERVAL }}
@@ -2,52 +2,48 @@ name: pre-commit

 on:
  pull_request:
-permissions: {}
+    types:
+      - opened
+      - synchronize

 env:
-  CAN_PUSH: ${{ github.event.pull_request.head.repo.full_name == github.repository && github.actor != 'dependabot[bot]' }}
-  UV_NO_SYNC: true
+  # Forks and Dependabot don't have access to secrets
+  HAS_SECRETS: ${{ secrets.PRE_COMMIT != '' }}

 jobs:
  pre-commit:
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        name: Checkout PR for own repo
-        if: env.CAN_PUSH == 'true'
+        if: env.HAS_SECRETS == 'true'
        with:
          # To be able to commit it needs to fetch the head of the branch, not the
          # merge commit
          ref: ${{ github.head_ref }}
          # And it needs the full history to be able to compute diffs
          fetch-depth: 0
-          persist-credentials: false
+          # A token other than the default GITHUB_TOKEN is needed to be able to trigger CI
+          token: ${{ secrets.PRE_COMMIT }}
      # pre-commit lite ci needs the default checkout configs to work
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        name: Checkout PR for fork
-        if: env.CAN_PUSH == 'false'
+        if: env.HAS_SECRETS == 'false'
        with:
        # To be able to commit it needs the head branch of the PR, the remote one
          ref: ${{ github.event.pull_request.head.sha }}
          fetch-depth: 0
-          persist-credentials: false
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
-          cache-suffix: dev-all
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -55,28 +51,13 @@ jobs:
        run: uv sync --locked --extra all
      - name: Run prek - pre-commit
        id: precommit
-        run: uv run prek run --from-ref origin/${GITHUB_BASE_REF} --to-ref HEAD --show-diff-on-failure
+        run: uvx prek run --from-ref origin/${GITHUB_BASE_REF} --to-ref HEAD --show-diff-on-failure
        continue-on-error: true
-      - name: Check for changes
-        id: changes
-        run: |
-          if [[ -n "$(git status --porcelain)" ]]; then
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-          else
-            echo "changed=false" >> "$GITHUB_OUTPUT"
-          fi
-      - name: Get PR Push token
-        id: pr-push
-        if: env.CAN_PUSH == 'true' && steps.changes.outputs.changed == 'true'
-        uses: tiangolo/pr-push@ff4e51a433de4c22bbf90597e069e8247b9203d2 # 0.0.1
      - name: Commit and push changes
-        if: env.CAN_PUSH == 'true' && steps.changes.outputs.changed == 'true'
-        env:
-          GH_TOKEN: ${{ steps.pr-push.outputs.token }}
+        if: env.HAS_SECRETS == 'true'
        run: |
-          git config user.name "pr-push[bot]"
-          git config user.email "pr-push[bot]@users.noreply.github.com"
-          gh auth setup-git
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
          git add -A
          if git diff --staged --quiet; then
            echo "No changes to commit"
@@ -85,7 +66,7 @@ jobs:
            git push
          fi
      - uses: pre-commit-ci/lite-action@5d6cc0eb514c891a40562a58a8e71576c5c7fb43 # v1.1.0
-        if: env.CAN_PUSH == 'false'
+        if: env.HAS_SECRETS == 'false'
        with:
          msg: 🎨 Auto format
      - name: Error out on pre-commit errors
@@ -98,7 +79,6 @@ jobs:
    needs:
      - pre-commit
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
@@ -1,91 +0,0 @@
-name: Prepare Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      bump:
-        description: Release bump
-        required: true
-        type: choice
-        options:
-          - patch
-          - minor
-          - major
-      date:
-        description: Release date in YYYY-MM-DD format. Defaults to today.
-        required: false
-        type: string
-
-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
-jobs:
-  prepare-release:
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      contents: read
-      id-token: write
-    env:
-      PREPARE_RELEASE_VERSION_FILE: fastapi/__init__.py
-      PREPARE_RELEASE_RELEASE_NOTES_FILE: docs/en/docs/release-notes.md
-    steps:
-      - name: Dump GitHub context
-        env:
-          GITHUB_CONTEXT: ${{ toJson(github) }}
-        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version-file: ".python-version"
-      - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-        with:
-          version: "latest-known"
-          cache-dependency-glob: |
-            pyproject.toml
-            uv.lock
-          cache-suffix: dev-all
-          # Disable saving cache as we install narrower set of dependencies than dev-all has.
-          save-cache: false
-      - name: Install dependencies
-        run: uv sync --locked --group dev
-      - name: Prepare release
-        env:
-          PREPARE_RELEASE_BUMP: ${{ inputs.bump }}
-          PREPARE_RELEASE_DATE: ${{ inputs.date }}
-        run: uv run python scripts/prepare_release.py prepare
-      - name: Get release version
-        id: release-version
-        run: |
-          version="$(uv run python scripts/prepare_release.py current-version)"
-          echo "$version"
-          echo "version=$version" >> "$GITHUB_OUTPUT"
-      - name: Get PR Submit token
-        id: pr-submit
-        uses: tiangolo/pr-submit@d802fdf59bde80bc3eb8bd3259f4cbeec63de4aa # 0.0.1
-      - name: Create release pull request
-        env:
-          GH_TOKEN: ${{ steps.pr-submit.outputs.token }}
-          VERSION: ${{ steps.release-version.outputs.version }}
-        run: |
-          set -euo pipefail
-          branch="release-${VERSION}-${GITHUB_RUN_ID}-${GITHUB_RUN_ATTEMPT}"
-          git config user.name "pr-submit[bot]"
-          git config user.email "pr-submit[bot]@users.noreply.github.com"
-          git switch -c "$branch"
-          git add $PREPARE_RELEASE_VERSION_FILE $PREPARE_RELEASE_RELEASE_NOTES_FILE
-          git commit -m "🔖 Release version ${VERSION}"
-          gh auth setup-git
-          git push --set-upstream origin "$branch"
-          gh pr create \
-            --base master \
-            --head "$branch" \
-            --title "🔖 Release version ${VERSION}" \
-            --body "Prepare release ${VERSION}." \
-            --label release
@@ -3,12 +3,7 @@ name: Publish
 on:
  release:
    types:
-      - published
-
-env:
-  UV_NO_SYNC: true
-
-permissions: {}
+      - created

 jobs:
  publish:
@@ -16,24 +11,18 @@ jobs:
    permissions:
      id-token: write
      contents: read
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-        with:
-          version: "latest-known"
-          enable-cache: "false"
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
      - name: Build distribution
        run: uv build
      - name: Publish
@@ -1,38 +1,29 @@
 name: Smokeshow

 on:
-  workflow_run: # zizmor: ignore[dangerous-triggers]
+  workflow_run:
    workflows: [Test]
    types: [completed]

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
+permissions:
+  statuses: write

 jobs:
  smokeshow:
    runs-on: ubuntu-latest
-    permissions:
-      statuses: write
-    timeout-minutes: 5

    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
-          cache-suffix: github-actions
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -60,4 +51,4 @@ jobs:
          SMOKESHOW_GITHUB_CONTEXT: coverage
          SMOKESHOW_GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SMOKESHOW_GITHUB_PR_HEAD_SHA: ${{ github.event.workflow_run.head_sha }}
-          SMOKESHOW_AUTH_KEY: ${{ secrets.SMOKESHOW_AUTH_KEY }} # zizmor: ignore[secrets-outside-env]
+          SMOKESHOW_AUTH_KEY: ${{ secrets.SMOKESHOW_AUTH_KEY }}
@@ -10,37 +10,26 @@ on:
        required: false
        default: "false"

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
 jobs:
  job:
    if: github.repository_owner == 'fastapi'
    runs-on: ubuntu-latest
    permissions:
-      contents: read
-      id-token: write
-    timeout-minutes: 5
+      contents: write
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: github-actions
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -48,17 +37,12 @@ jobs:
        run: uv sync --locked --no-dev --group github-actions
      # Allow debugging with tmate
      - name: Setup tmate session
-        uses: mxschmitt/action-tmate@35b54afac29c97fb54faba5b513f8fbd1882f113 # v3.24
+        uses: mxschmitt/action-tmate@c0afd6f790e3a5564914980036ebf83216678101 # v3.23
        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
        with:
          limit-access-to-actor: true
-      - name: Get PR Submit token
-        id: pr-submit
-        uses: tiangolo/pr-submit@d802fdf59bde80bc3eb8bd3259f4cbeec63de4aa # 0.0.1
      - name: FastAPI People Sponsors
-        run: |
-          gh auth setup-git
-          uv run ./scripts/sponsors.py
+        run: uv run ./scripts/sponsors.py
        env:
-          SPONSORS_TOKEN: ${{ secrets.SPONSORS_TOKEN }} # zizmor: ignore[secrets-outside-env]
-          GITHUB_TOKEN: ${{ steps.pr-submit.outputs.token }}
+          SPONSORS_TOKEN: ${{ secrets.SPONSORS_TOKEN }}
+          PR_TOKEN: ${{ secrets.FASTAPI_PR_TOKEN }}
@@ -5,22 +5,21 @@ on:
    branches:
      - master
  pull_request:
-permissions: {}
+    types:
+      - opened
+      - synchronize

 jobs:
  test-redistribute:
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Install build dependencies
@@ -54,7 +53,6 @@ jobs:
    needs:
      - test-redistribute
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
      - name: Decide whether the needed jobs succeeded or failed
        uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # v1.2.2
@@ -5,12 +5,13 @@ on:
    branches:
      - master
  pull_request:
+    types:
+      - opened
+      - synchronize
  schedule:
    # cron every week on monday
    - cron: "0 0 * * 1"

-permissions: {}
-
 env:
  UV_NO_SYNC: true
  INLINE_SNAPSHOT_DEFAULT_FLAGS: review
@@ -22,15 +23,12 @@ jobs:
    permissions:
      pull-requests: read
    # Set job outputs to values from filter step
-    timeout-minutes: 5
    outputs:
      src: ${{ steps.filter.outputs.src }}
    steps:
-    - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-      with:
-        persist-credentials: false
+    - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
    # For pull requests it's not necessary to checkout the code but for the main branch it is
-    - uses: dorny/paths-filter@7b450fff21473bca461d4b92ce414b9d0420d706 # v4.0.2
+    - uses: dorny/paths-filter@fbd0ab8f3e69293af611ebaee6363fc25e6d187d # v4.0.1
      id: filter
      with:
        filters: |
@@ -48,12 +46,10 @@ jobs:
    needs:
      - changes
    if: needs.changes.outputs.src == 'true' || github.ref == 'refs/heads/master'
-    timeout-minutes: 10
    strategy:
      matrix:
        os: [ windows-latest, macos-latest ]
-        python-version: [ "3.14", "3.14t" ]
-        deprecated-tests: [ "no-deprecation" ]
+        python-version: [ "3.14" ]
        uv-resolution:
          - highest
        starlette-src:
@@ -64,38 +60,23 @@ jobs:
            python-version: "3.10"
            coverage: coverage
            uv-resolution: lowest-direct
-            deprecated-tests: "no-deprecation"
          - os: windows-latest
            python-version: "3.12"
            coverage: coverage
            uv-resolution: lowest-direct
-            deprecated-tests: "no-deprecation"
          - os: ubuntu-latest
            python-version: "3.13"
            coverage: coverage
            uv-resolution: highest
-            deprecated-tests: "no-deprecation"
          - os: ubuntu-latest
            python-version: "3.13"
            uv-resolution: highest
            codspeed: codspeed
-            deprecated-tests: "no-deprecation"
-          - os: ubuntu-latest
-            python-version: "3.13"
-            uv-resolution: highest
-            deprecated-tests: "no-deprecation"
-            without-httpx2: true
          - os: ubuntu-latest
            python-version: "3.14"
            coverage: coverage
            uv-resolution: highest
            starlette-src: starlette-git
-            deprecated-tests: "test-deprecation"
-          - os: ubuntu-latest
-            python-version: "3.14t"
-            coverage: coverage
-            uv-resolution: highest
-            deprecated-tests: "no-deprecation"
      fail-fast: false
    runs-on: ${{ matrix.os }}
    env:
@@ -107,19 +88,15 @@ jobs:
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version: ${{ matrix.python-version }}
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: tests-${{ matrix.uv-resolution }}
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -131,28 +108,18 @@ jobs:
      - name: Install Starlette from source
        if: matrix.starlette-src == 'starlette-git'
        run: uv pip install "git+https://github.com/Kludex/starlette@main"
-      - name: Install deprecated libraries just for testing
-        if: matrix.deprecated-tests == 'test-deprecation'
-        run: uv pip install orjson ujson
-      - name: Uninstall httpx2 to run tests with httpx
-        if: matrix.without-httpx2 == 'true'
-        run: uv pip uninstall httpx2
-      - name: Reinstall SQLAlchemy without Cython extensions
-        if: matrix.python-version == '3.14t' && matrix.os == 'ubuntu-latest'
-        run: "DISABLE_SQLALCHEMY_CEXT=1 uv pip install --force-reinstall --no-binary :all: sqlalchemy"
      - run: mkdir coverage
      - name: Test
-        run: uv run --no-sync bash scripts/test-cov.sh $PYTEST_OPTIONS
+        run: uv run --no-sync bash scripts/test-cov.sh
        env:
-          COVERAGE_FILE: coverage/.coverage.${{ runner.os }}-py${{ matrix.python-version }}-${{ matrix.deprecated-tests}}
-          CONTEXT: ${{ runner.os }}-py${{ matrix.python-version }}-${{ matrix.deprecated-tests}}
-          PYTEST_OPTIONS: ${{ (matrix.without-httpx2 == 'true') && '-W ignore::UserWarning' || '' }}
+          COVERAGE_FILE: coverage/.coverage.${{ runner.os }}-py${{ matrix.python-version }}
+          CONTEXT: ${{ runner.os }}-py${{ matrix.python-version }}
      # Do not store coverage for all possible combinations to avoid file size max errors in Smokeshow
      - name: Store coverage files
        if: matrix.coverage == 'coverage'
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
        with:
-          name: coverage-${{ runner.os }}-${{ matrix.python-version }}-${{ matrix.deprecated-tests}}-${{ hashFiles('**/coverage/.coverage.*') }}
+          name: coverage-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('**/coverage/.coverage.*') }}
          path: coverage
          include-hidden-files: true

@@ -161,7 +128,6 @@ jobs:
      - changes
    if: needs.changes.outputs.src == 'true' || github.ref == 'refs/heads/master'
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    env:
      UV_PYTHON: "3.13"
      UV_RESOLUTION: highest
@@ -170,134 +136,43 @@ jobs:
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version: "3.13"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: tests-highest
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
      - name: Install Dependencies
        run: uv sync --no-dev --group tests --extra all
      - name: CodSpeed benchmarks
-        uses: CodSpeedHQ/action@f99becdce5e5d51fd556489ebef684f4ecfd6286 # v4.18.5
+        uses: CodSpeedHQ/action@1c8ae4843586d3ba879736b7f6b7b0c990757fab # v4.12.1
        with:
          mode: simulation
          run: uv run --no-sync pytest tests/benchmarks --codspeed
-      - name: CodSpeed memory benchmark
-        uses: CodSpeedHQ/action@f99becdce5e5d51fd556489ebef684f4ecfd6286 # v4.18.5
-        with:
-          mode: memory
-          run: uv run --no-sync pytest tests/memory_benchmarks --codspeed

-  regression-test:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - name: Check out the pull request
-        if: github.event_name == 'pull_request'
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.sha }}
-          path: pr
-          persist-credentials: false
-          fetch-depth: 0
-      - name: Find changed tests
-        if: github.event_name == 'pull_request'
-        id: changed-tests
-        working-directory: pr
-        env:
-          BASE_SHA: ${{ github.event.pull_request.base.sha }}
-          HEAD_SHA: ${{ github.event.pull_request.head.sha }}
-        run: |
-          git diff --name-only --diff-filter=AM -z "$BASE_SHA" "$HEAD_SHA" -- tests \
-            | while IFS= read -r -d '' file; do
-                case "$(basename "$file")" in
-                  test_*.py) printf '%s\0' "$file" ;;
-                esac
-              done > "$RUNNER_TEMP/changed-tests"
-          if [ -s "$RUNNER_TEMP/changed-tests" ]; then
-            echo "found=true" >> "$GITHUB_OUTPUT"
-            git diff --binary "$BASE_SHA" "$HEAD_SHA" -- tests \
-              > "$RUNNER_TEMP/tests.patch"
-          else
-            echo "found=false" >> "$GITHUB_OUTPUT"
-            echo "No added or modified test files; regression proof is not applicable."
-          fi
-      - name: Check out the base revision
-        if: steps.changed-tests.outputs.found == 'true'
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          ref: ${{ github.event.pull_request.base.sha }}
-          path: base
-          persist-credentials: false
-      - name: Set up Python
-        if: steps.changed-tests.outputs.found == 'true'
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version-file: "base/.python-version"
-      - name: Setup uv
-        if: steps.changed-tests.outputs.found == 'true'
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-        with:
-          version: "latest-known"
-          enable-cache: true
-          cache-suffix: tests-highest
-          # This job checks out into `base/`, so the glob must point there.
-          cache-dependency-glob: |
-            base/pyproject.toml
-            base/uv.lock
-          # Only ever runs on pull requests, so anything it saved would be PR-scoped and useless.
-          save-cache: false
-      - name: Run the changed tests against the base code
-        if: steps.changed-tests.outputs.found == 'true'
-        working-directory: base
-        run: |
-          git apply "$RUNNER_TEMP/tests.patch"
-          uv sync --locked --no-dev --group tests --extra all
-          set +e
-          xargs -0 uv run --no-sync pytest -- < "$RUNNER_TEMP/changed-tests"
-          status=$?
-          set -e
-          if [ "$status" -eq 0 ]; then
-            echo "::warning::The changed tests already pass on the base revision. Check whether the fix is still needed."
-            echo "### Regression proof: base already passes :warning:" >> "$GITHUB_STEP_SUMMARY"
-            echo "The changed tests pass without the pull request's code changes." >> "$GITHUB_STEP_SUMMARY"
-          else
-            echo "The changed tests fail on the base revision as expected (pytest exit code $status)."
-            echo "### Regression proof: base fails as expected :white_check_mark:" >> "$GITHUB_STEP_SUMMARY"
-          fi
  coverage-combine:
    needs:
      - test
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: tests-highest
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -313,7 +188,7 @@ jobs:
      - run: uv run coverage combine coverage
      - run: uv run coverage html --title "Coverage for ${{ github.sha }}"
      - name: Store coverage HTML
-        uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
        with:
          name: coverage-html
          path: htmlcov
@@ -321,15 +196,12 @@ jobs:
      - run: uv run coverage report --fail-under=100

  # https://github.com/marketplace/actions/alls-green#why
-  test-alls-green:  # This job does nothing and is only used for the branch protection
+  check:  # This job does nothing and is only used for the branch protection
    if: always()
    needs:
-      - test
      - coverage-combine
      - benchmark
-      - regression-test
    runs-on: ubuntu-latest
-    timeout-minutes: 5
    steps:
      - name: Dump GitHub context
        env:
@@ -5,48 +5,32 @@ on:
    - cron: "0 12 1 * *"
  workflow_dispatch:

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
 jobs:
  topic-repos:
    if: github.repository_owner == 'fastapi'
    runs-on: ubuntu-latest
    permissions:
-      contents: read
-      id-token: write
-    timeout-minutes: 5
+      contents: write
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
          enable-cache: true
-          cache-suffix: github-actions
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
      - name: Install GitHub Actions dependencies
        run: uv sync --locked --no-dev --group github-actions
-      - name: Get PR Submit token
-        id: pr-submit
-        uses: tiangolo/pr-submit@d802fdf59bde80bc3eb8bd3259f4cbeec63de4aa # 0.0.1
      - name: Update Topic Repos
-        run: |
-          gh auth setup-git
-          uv run ./scripts/topic_repos.py
+        run: uv run ./scripts/topic_repos.py
        env:
-          GITHUB_TOKEN: ${{ steps.pr-submit.outputs.token }}
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_PR_TOKEN }}
@@ -13,7 +13,6 @@ on:
      command:
        description: Command to run
        type: choice
-        required: true
        options:
          - translate-page
          - translate-lang
@@ -24,23 +23,24 @@ on:
      language:
        description: Language to translate to as a letter code (e.g. "es" for Spanish)
        type: string
-        required: true
+        required: false
+        default: ""
      en_path:
        description: File path in English to translate (e.g. docs/en/docs/index.md)
        type: string
        required: false
        default: ""
+      commit_in_place:
+        description: Commit changes directly instead of making a PR
+        type: boolean
+        required: false
+        default: false
      max:
        description: Maximum number of items to translate (e.g. 10)
        type: number
        required: false
        default: 10

-permissions: {}
-
-env:
-  UV_NO_SYNC: true
-
 jobs:
  langs:
    runs-on: ubuntu-latest
@@ -48,18 +48,14 @@ jobs:
      langs: ${{ steps.show-langs.outputs.langs }}
      commands: ${{ steps.show-langs.outputs.commands }}
    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
-          cache-suffix: translations
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -78,31 +74,27 @@ jobs:
    if: github.repository_owner == 'fastapi'
    needs: langs
    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      id-token: write
    strategy:
      matrix:
        lang: ${{ fromJson(needs.langs.outputs.langs) }}
        command: ${{ fromJson(needs.langs.outputs.commands) }}
+    permissions:
+      contents: write
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
        with:
          fetch-depth: 0
-          persist-credentials: false
      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
+        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
        with:
          python-version-file: ".python-version"
      - name: Setup uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@37802adc94f370d6bfd71619e3f0bf239e1f3b78 # v7.6.0
        with:
-          version: "latest-known"
-          cache-suffix: translations
          cache-dependency-glob: |
            pyproject.toml
            uv.lock
@@ -110,44 +102,22 @@ jobs:
        run: uv sync --locked --no-dev --group github-actions --group translations
      # Allow debugging with tmate
      - name: Setup tmate session
-        uses: mxschmitt/action-tmate@35b54afac29c97fb54faba5b513f8fbd1882f113 # v3.24
+        uses: mxschmitt/action-tmate@c0afd6f790e3a5564914980036ebf83216678101 # v3.23
        if: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.debug_enabled == 'true' }}
        with:
          limit-access-to-actor: true
        env:
-          GITHUB_TOKEN: ${{ github.token }}
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} # zizmor: ignore[secrets-outside-env]
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_TRANSLATIONS }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
      - name: FastAPI Translate
-        run: uv run ./scripts/translate.py "$COMMAND"
+        run: |
+          uv run ./scripts/translate.py ${{ matrix.command }}
+          uv run ./scripts/translate.py make-pr
        env:
-          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} # zizmor: ignore[secrets-outside-env]
+          GITHUB_TOKEN: ${{ secrets.FASTAPI_TRANSLATIONS }}
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
          LANGUAGE: ${{ matrix.lang }}
          EN_PATH: ${{ github.event.inputs.en_path }}
          COMMAND: ${{ matrix.command }}
+          COMMIT_IN_PLACE: ${{ github.event.inputs.commit_in_place == 'true' && 'true' || '' }}
          MAX: ${{ github.event.inputs.max }}
-      - name: Get PR Submit token
-        if: github.event_name == 'schedule'
-        id: pr-submit
-        uses: tiangolo/pr-submit@d802fdf59bde80bc3eb8bd3259f4cbeec63de4aa # 0.0.1
-      - name: Create pull request
-        if: github.event_name == 'schedule'
-        run: |
-          gh auth setup-git
-          uv run ./scripts/translate.py make-pr
-        env:
-          GITHUB_TOKEN: ${{ steps.pr-submit.outputs.token }}
-          LANGUAGE: ${{ matrix.lang }}
-          COMMAND: ${{ matrix.command }}
-      - name: Get PR Push token
-        if: github.event_name == 'workflow_dispatch'
-        id: pr-push
-        uses: tiangolo/pr-push@f336b3817f32ea9b8273a8c15f8ecb739ac38167 # 0.0.4
-      - name: Commit and push changes
-        if: github.event_name == 'workflow_dispatch'
-        env:
-          COMMAND: ${{ matrix.command }}
-          GH_TOKEN: ${{ steps.pr-push.outputs.token }}
-          LANGUAGE: ${{ matrix.lang }}
-        run: |
-          gh auth setup-git
-          uv run ./scripts/translate.py push
@@ -1,47 +0,0 @@
-name: Warm Cache
-
-# Populates the `dev-all` uv cache at default-branch scope so that it could be used by
-# `pre-commit.yml` (it has `pull_request` trigger and can't write cache available across PRs)
-# and some others that use subset of dev dependencies.
-
-on:
-  push:
-    branches:
-      - master
-    paths:
-      - pyproject.toml
-      - uv.lock
-      - .python-version
-      - .github/workflows/warm-cache.yml
-  schedule:
-    - cron: "0 4 * * *"
-  workflow_dispatch:
-
-permissions: {}
-
-jobs:
-  warm-cache:
-    if: github.repository_owner == 'fastapi'
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Set up Python
-        uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
-        with:
-          python-version-file: ".python-version"
-      - name: Setup uv
-        id: setup-uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-        with:
-          version: "latest-known"
-          enable-cache: true
-          cache-suffix: dev-all
-          cache-dependency-glob: |
-            pyproject.toml
-            uv.lock
-      - name: Populate the cache
-        if: steps.setup-uv.outputs.cache-hit != 'true'
-        run: uv sync --locked --group dev --extra all
@@ -1,25 +0,0 @@
-name: Zizmor
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-  workflow_dispatch:
-
-permissions: {}
-
-jobs:
-  zizmor:
-    name: Run zizmor
-    runs-on: ubuntu-latest
-    timeout-minutes: 5
-    permissions:
-      security-events: write # Required for upload-sarif (used by zizmor-action) to upload SARIF files.
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Run zizmor
-        uses: zizmorcore/zizmor-action@6fc4b006235f201fdab3722e17240ab420d580e5 # v0.6.1
@@ -7,7 +7,6 @@ __pycache__
 htmlcov
 dist
 site
-site_zensical_src
 .coverage*
 coverage.xml
 .netlify
@@ -14,12 +14,6 @@ repos:
      - id: end-of-file-fixer
      - id: trailing-whitespace

-  - repo: https://github.com/crate-ci/typos
-    rev: bee27e3a4fd1ea2111cf90ab89cd076c870fce14 # frozen: v1.48.0
-    hooks:
-      - id: typos
-        args: [--force-exclude]
-
  - repo: local
    hooks:
      - id: local-ruff-check
@@ -45,7 +39,7 @@ repos:

      - id: local-ty
        name: ty check
-        entry: uv run ty check
+        entry: uv run ty check fastapi
        require_serial: true
        language: unsupported
        pass_filenames: false
@@ -65,13 +59,6 @@ repos:
        files: ^docs/en/docs/index\.md|docs/en/data/sponsors\.yml|scripts/docs\.py$
        pass_filenames: false

-      - id: render-banner-sponsors
-        language: unsupported
-        name: render sponsor banner partial
-        entry: uv run ./scripts/docs.py render-banner-sponsors
-        files: ^docs/en/data/sponsors\.yml|^docs/en/overrides/partials/banner-sponsors\.html|^scripts/docs\.py$
-        pass_filenames: false
-
      - id: update-languages
        language: unsupported
        name: update languages
@@ -98,11 +85,3 @@ repos:
        entry: uv run python scripts/add_latest_release_date.py
        files: ^docs/en/docs/release-notes\.md$
        pass_filenames: false
-
-      - id: zizmor
-        name: zizmor
-        language: python
-        entry: uv run zizmor .
-        files: ^\.github/workflows/|^uv\.lock$
-        require_serial: true
-        pass_filenames: false
@@ -0,0 +1 @@
+Please read the [Development - Contributing](https://fastapi.tiangolo.com/contributing/) guidelines in the documentation site.
@@ -49,25 +49,26 @@ The key features are:

 <a href="https://fastapicloud.com" target="_blank" title="FastAPI Cloud. By the same team behind FastAPI. You code. We Cloud."><img src="https://fastapi.tiangolo.com/img/sponsors/fastapicloud.png"></a>

-### Gold Sponsors
+### Gold and Silver Sponsors

 <a href="https://blockbee.io?ref=fastapi" target="_blank" title="BlockBee Cryptocurrency Payment Gateway"><img src="https://fastapi.tiangolo.com/img/sponsors/blockbee.png"></a>
+<a href="https://github.com/scalar/scalar/?utm_source=fastapi&utm_medium=website&utm_campaign=main-badge" target="_blank" title="Scalar: Beautiful Open-Source API References from Swagger/OpenAPI files"><img src="https://fastapi.tiangolo.com/img/sponsors/scalar.svg"></a>
 <a href="https://www.propelauth.com/?utm_source=fastapi&utm_campaign=1223&utm_medium=mainbadge" target="_blank" title="Auth, user management and more for your B2B product"><img src="https://fastapi.tiangolo.com/img/sponsors/propelauth.png"></a>
+<a href="https://zuplo.link/fastapi-gh" target="_blank" title="Zuplo: Deploy, Secure, Document, and Monetize your FastAPI"><img src="https://fastapi.tiangolo.com/img/sponsors/zuplo.png"></a>
+<a href="https://liblab.com?utm_source=fastapi" target="_blank" title="liblab - Generate SDKs from FastAPI"><img src="https://fastapi.tiangolo.com/img/sponsors/liblab.png"></a>
 <a href="https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi" target="_blank" title="Deploy & scale any full-stack web app on Render. Focus on building apps, not infra."><img src="https://fastapi.tiangolo.com/img/sponsors/render.svg"></a>
 <a href="https://www.coderabbit.ai/?utm_source=fastapi&utm_medium=badge&utm_campaign=fastapi" target="_blank" title="Cut Code Review Time & Bugs in Half with CodeRabbit"><img src="https://fastapi.tiangolo.com/img/sponsors/coderabbit.png"></a>
 <a href="https://subtotal.com/?utm_source=fastapi&utm_medium=sponsorship&utm_campaign=open-source" target="_blank" title="The Gold Standard in Retail Account Linking"><img src="https://fastapi.tiangolo.com/img/sponsors/subtotal.svg"></a>
 <a href="https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi" target="_blank" title="Deploy enterprise applications at startup speed"><img src="https://fastapi.tiangolo.com/img/sponsors/railway.png"></a>
 <a href="https://serpapi.com/?utm_source=fastapi_website" target="_blank" title="SerpApi: Web Search API"><img src="https://fastapi.tiangolo.com/img/sponsors/serpapi.png"></a>
 <a href="https://www.greptile.com/?utm_source=fastapi&utm_medium=sponsorship&utm_campaign=fastapi_sponsor_page" target="_blank" title="Greptile: The AI Code Reviewer"><img src="https://fastapi.tiangolo.com/img/sponsors/greptile.png"></a>
-
-### Silver Sponsors
-
 <a href="https://databento.com/?utm_source=fastapi&utm_medium=sponsor&utm_content=display" target="_blank" title="Pay as you go for market data"><img src="https://fastapi.tiangolo.com/img/sponsors/databento.svg"></a>
+<a href="https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship" target="_blank" title="SDKs for your API | Speakeasy"><img src="https://fastapi.tiangolo.com/img/sponsors/speakeasy.png"></a>
 <a href="https://www.svix.com/" target="_blank" title="Svix - Webhooks as a service"><img src="https://fastapi.tiangolo.com/img/sponsors/svix.svg"></a>
+<a href="https://www.stainlessapi.com/?utm_source=fastapi&utm_medium=referral" target="_blank" title="Stainless | Generate best-in-class SDKs"><img src="https://fastapi.tiangolo.com/img/sponsors/stainless.png"></a>
 <a href="https://www.permit.io/blog/implement-authorization-in-fastapi?utm_source=github&utm_medium=referral&utm_campaign=fastapi" target="_blank" title="Fine-Grained Authorization for FastAPI"><img src="https://fastapi.tiangolo.com/img/sponsors/permit.png"></a>
+<a href="https://www.interviewpal.com/?utm_source=fastapi&utm_medium=open-source&utm_campaign=dev-hiring" target="_blank" title="InterviewPal - AI Interview Coach for Engineers and Devs"><img src="https://fastapi.tiangolo.com/img/sponsors/interviewpal.png"></a>
 <a href="https://dribia.com/en/" target="_blank" title="Dribia - Data Science within your reach"><img src="https://fastapi.tiangolo.com/img/sponsors/dribia.png"></a>
-<a href="https://www.bairesdev.com/" target="_blank" title="BairesDev | Nearshore Software Development & Staff Augmentation Company"><img src="https://fastapi.tiangolo.com/img/sponsors/bairesdev.svg"></a>
-<a href="https://tutorcruncher.com/?utm_source=fastapi" target="_blank" title="TutorCruncher"><img src="https://fastapi.tiangolo.com/img/sponsors/tutorcruncher.png"></a>

 <!-- /sponsors -->

@@ -75,10 +76,6 @@ The key features are:

 ## Opinions

-
-
-<div class="only-github" markdown="1">
-
 "_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"

 <div style="text-align: right; margin-right: 10%;">Kabir Khan - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26"><small>(ref)</small></a></div>
@@ -87,7 +84,7 @@ The key features are:

 "_We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]_"

-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(ref)</small></a></div>

 ---

@@ -97,19 +94,37 @@ The key features are:

 ---

+"_I’m over the moon excited about **FastAPI**. It’s so fun!_"
+
+<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong>[Python Bytes](https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855) podcast host</strong> <a href="https://x.com/brianokken/status/1112220079972728832"><small>(ref)</small></a></div>
+
+---
+
+"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"
+
+<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong>[Hug](https://github.com/hugapi/hug) creator</strong> <a href="https://news.ycombinator.com/item?id=19455465"><small>(ref)</small></a></div>
+
+---
+
+"_If you're looking to learn one **modern framework** for building REST APIs, check out **FastAPI** [...] It's fast, easy to use and easy to learn [...]_"
+
+"_We've switched over to **FastAPI** for our **APIs** [...] I think you'll like it [...]_"
+
+<div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong>[Explosion AI](https://explosion.ai) founders - [spaCy](https://spacy.io) creators</strong> <a href="https://x.com/_inesmontani/status/1144173225322143744"><small>(ref)</small></a> - <a href="https://x.com/honnibal/status/1144031421859655680"><small>(ref)</small></a></div>
+
+---
+
 "_If anyone is looking to build a production Python API, I would highly recommend **FastAPI**. It is **beautifully designed**, **simple to use** and **highly scalable**, it has become a **key component** in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer._"

 <div style="text-align: right; margin-right: 10%;">Deon Pillsbury - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/"><small>(ref)</small></a></div>

 ---

-</div>
-
 ## FastAPI mini documentary

 There's a [FastAPI mini documentary](https://www.youtube.com/watch?v=mpR8ngthqiE) released at the end of 2025, you can watch it online:

-<a class="fastapi-feature-banner" href="https://www.youtube.com/watch?v=mpR8ngthqiE"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>
+<a href="https://www.youtube.com/watch?v=mpR8ngthqiE"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>

 ## **Typer**, the FastAPI of CLIs

@@ -123,17 +138,17 @@ If you are building a <abbr title="Command Line Interface">CLI</abbr> app to be

 FastAPI stands on the shoulders of giants:

-* [Starlette](https://starlette.dev/) for the web parts.
-* [Pydantic](https://pydantic.dev/docs/) for the data parts.
+* [Starlette](https://www.starlette.dev/) for the web parts.
+* [Pydantic](https://docs.pydantic.dev/) for the data parts.

 ## Installation

-First, [install `uv`](https://docs.astral.sh/uv/getting-started/installation/), and then add FastAPI to your project:
+Create and activate a [virtual environment](https://fastapi.tiangolo.com/virtual-environments/) and then install FastAPI:

 <div class="termy">

 ```console
-$ uv add "fastapi[standard]"
+$ pip install "fastapi[standard]"

 ---> 100%
 ```
@@ -142,8 +157,6 @@ $ uv add "fastapi[standard]"

 **Note**: Make sure you put `"fastapi[standard]"` in quotes to ensure it works in all terminals.

-If you prefer to use `pip`, install `fastapi[standard]` inside a virtual environment. See the [installation guide](tutorial/#install-fastapi) for the alternative steps.
-
 ## Example

 ### Create it
@@ -200,7 +213,7 @@ Run the server with:
 <div class="termy">

 ```console
-$ uv run fastapi dev
+$ fastapi dev

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
@@ -227,7 +240,7 @@ INFO:     Application startup complete.
 <details markdown="1">
 <summary>About the command <code>fastapi dev</code>...</summary>

-The command `fastapi dev` reads your `main.py` file automatically, detects the **FastAPI** app in it, and starts a server using [Uvicorn](https://uvicorn.dev).
+The command `fastapi dev` reads your `main.py` file automatically, detects the **FastAPI** app in it, and starts a server using [Uvicorn](https://www.uvicorn.dev).

 By default, `fastapi dev` will start with auto-reload enabled for local development.

@@ -264,7 +277,7 @@ You will see the automatic interactive API documentation (provided by [Swagger U

 And now, go to [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).

-You will see the alternative automatic documentation (provided by [ReDoc](https://github.com/Redocly/redoc)):
+You will see the alternative automatic documentation (provided by [ReDoc](https://github.com/Rebilly/ReDoc)):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -427,13 +440,13 @@ For a more complete example including more features, see the <a href="https://fa

 **Spoiler alert**: the tutorial - user guide includes:

-* Declaration of **parameters** from other different places such as: **headers**, **cookies**, **form fields** and **files**.
-* How to set **validation constraints** such as `maximum_length` or `regex`.
+* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
+* How to set **validation constraints** as `maximum_length` or `regex`.
 * A very powerful and easy to use **<dfn title="also known as components, resources, providers, services, injectables">Dependency Injection</dfn>** system.
 * Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
 * More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
 * **GraphQL** integration with [Strawberry](https://strawberry.rocks) and other libraries.
-* Many extra features (thanks to Starlette) such as:
+* Many extra features (thanks to Starlette) as:
    * **WebSockets**
    * extremely easy tests based on HTTPX and `pytest`
    * **CORS**
@@ -442,12 +455,14 @@ For a more complete example including more features, see the <a href="https://fa

 ### Deploy your app (optional)

-You can optionally deploy your FastAPI app to [FastAPI Cloud](https://fastapicloud.com) with a single command. 🚀
+You can optionally deploy your FastAPI app to [FastAPI Cloud](https://fastapicloud.com), go and join the waiting list if you haven't. 🚀
+
+If you already have a **FastAPI Cloud** account (we invited you from the waiting list 😉), you can deploy your application with one command.

 <div class="termy">

 ```console
-$ uv run fastapi deploy
+$ fastapi deploy

 Deploying to FastAPI Cloud...

@@ -458,8 +473,6 @@ Deploying to FastAPI Cloud...

 </div>

-The CLI will automatically detect your FastAPI application and deploy it to the cloud. If you are not logged in, your browser will open to complete the authentication process.
-
 That's it! Now you can access your app at that URL. ✨

 #### About FastAPI Cloud
@@ -490,7 +503,7 @@ FastAPI depends on Pydantic and Starlette.

 ### `standard` Dependencies

-When you install FastAPI with `uv add "fastapi[standard]"` it comes with the `standard` group of optional dependencies:
+When you install FastAPI with `pip install "fastapi[standard]"` it comes with the `standard` group of optional dependencies:

 Used by Pydantic:

@@ -504,17 +517,17 @@ Used by Starlette:

 Used by FastAPI:

-* [`uvicorn`](https://uvicorn.dev) - for the server that loads and serves your application. This includes `uvicorn[standard]`, which includes some dependencies (e.g. `uvloop`) needed for high performance serving.
+* [`uvicorn`](https://www.uvicorn.dev) - for the server that loads and serves your application. This includes `uvicorn[standard]`, which includes some dependencies (e.g. `uvloop`) needed for high performance serving.
 * `fastapi-cli[standard]` - to provide the `fastapi` command.
    * This includes `fastapi-cloud-cli`, which allows you to deploy your FastAPI application to [FastAPI Cloud](https://fastapicloud.com).

 ### Without `standard` Dependencies

-If you don't want to include the `standard` optional dependencies, you can install with `uv add fastapi` instead of `uv add "fastapi[standard]"`.
+If you don't want to include the `standard` optional dependencies, you can install with `pip install fastapi` instead of `pip install "fastapi[standard]"`.

 ### Without `fastapi-cloud-cli`

-If you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `uv add "fastapi[standard-no-fastapi-cloud-cli]"`.
+If you want to install FastAPI with the standard dependencies but without the `fastapi-cloud-cli`, you can install with `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.

 ### Additional Optional Dependencies

@@ -522,13 +535,13 @@ There are some additional dependencies you might want to install.

 Additional optional Pydantic dependencies:

-* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) - for settings management.
-* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) - for extra types to be used with Pydantic.
+* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) - for settings management.
+* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) - for extra types to be used with Pydantic.

 Additional optional FastAPI dependencies:

 * [`orjson`](https://github.com/ijl/orjson) - Required if you want to use `ORJSONResponse`.
-* [`ujson`](https://github.com/ultrajson/ultrajson) - Required if you want to use `UJSONResponse`.
+* [`ujson`](https://github.com/esnme/ultrajson) - Required if you want to use `UJSONResponse`.

 ## License

@@ -0,0 +1,31 @@
+# Security Policy
+
+Security is very important for FastAPI and its community. 🔒
+
+Learn more about it below. 👇
+
+## Versions
+
+The latest version of FastAPI is supported.
+
+You are encouraged to [write tests](https://fastapi.tiangolo.com/tutorial/testing/) for your application and update your FastAPI version frequently after ensuring that your tests are passing. This way you will benefit from the latest features, bug fixes, and **security fixes**.
+
+You can learn more about [FastAPI versions and how to pin and upgrade them](https://fastapi.tiangolo.com/deployment/versions/) for your project in the docs.
+
+## Reporting a Vulnerability
+
+If you think you found a vulnerability, and even if you are not sure about it, please report it right away by sending an email to: security@tiangolo.com. Please try to be as explicit as possible, describing all the steps and example code to reproduce the security issue.
+
+I (the author, [@tiangolo](https://x.com/tiangolo)) will review it thoroughly and get back to you.
+
+## Public Discussions
+
+Please restrain from publicly discussing a potential security vulnerability. 🙊
+
+It's better to discuss privately and try to find a solution first, to limit the potential impact as much as possible.
+
+---
+
+Thanks for your help!
+
+The FastAPI community and I thank you for that. 🙇
@@ -1,17 +1,17 @@
 # LLM-Testdatei { #llm-test-file }

-Dieses Dokument testet, ob das <abbr title="Large Language Model - Großes Sprachmodell">LLM</abbr>, das die Dokumentation übersetzt, den <abbr title="General Prompt - Allgemeiner Prompt">`general_prompt`</abbr> in `scripts/translate.py` und den sprachspezifischen Prompt in `docs/{language code}/llm-prompt.md` versteht. Der sprachspezifische Prompt wird an `general_prompt` angehängt.
+Dieses Dokument testet, ob das <abbr title="Large Language Model – Großes Sprachmodell">LLM</abbr>, das die Dokumentation übersetzt, den <abbr title="General Prompt – Allgemeiner Prompt">`general_prompt`</abbr> in `scripts/translate.py` und den sprachspezifischen Prompt in `docs/{language code}/llm-prompt.md` versteht. Der sprachsspezifische Prompt wird an `general_prompt` angehängt.

-Hier hinzugefügte Tests werden von allen Erstellern sprachspezifischer Prompts gesehen.
+Hier hinzugefügte Tests werden von allen Erstellern sprachsspezifischer Prompts gesehen.

 So verwenden:

-* Einen sprachspezifischen Prompt haben – `docs/{language code}/llm-prompt.md`.
+* Einen sprachsspezifischen Prompt haben – `docs/{language code}/llm-prompt.md`.
 * Eine frische Übersetzung dieses Dokuments in die gewünschte Zielsprache durchführen (siehe z. B. das Kommando `translate-page` der `translate.py`). Dadurch wird die Übersetzung unter `docs/{language code}/docs/_llm-test.md` erstellt.
 * Prüfen Sie, ob in der Übersetzung alles in Ordnung ist.
-* Verbessern Sie bei Bedarf Ihren sprachspezifischen Prompt, den allgemeinen Prompt oder das englische Dokument.
+* Verbessern Sie bei Bedarf Ihren sprachsspezifischen Prompt, den allgemeinen Prompt oder das englische Dokument.
 * Beheben Sie anschließend manuell die verbleibenden Probleme in der Übersetzung, sodass es eine gute Übersetzung ist.
-* Übersetzen Sie erneut, nachdem die gute Übersetzung vorliegt. Das ideale Ergebnis wäre, dass das LLM an der Übersetzung keine Änderungen mehr vornimmt. Das bedeutet, dass der allgemeine Prompt und Ihr sprachspezifischer Prompt so gut sind, wie sie sein können (Es wird manchmal ein paar scheinbar zufällige Änderungen machen, der Grund ist, dass [LLMs keine deterministischen Algorithmen sind](https://doublespeak.chat/#/handbook#deterministic-output)).
+* Übersetzen Sie erneut, nachdem die gute Übersetzung vorliegt. Das ideale Ergebnis wäre, dass das LLM an der Übersetzung keine Änderungen mehr vornimmt. Das bedeutet, dass der allgemeine Prompt und Ihr sprachsspezifischer Prompt so gut sind, wie sie sein können (Es wird manchmal ein paar scheinbar zufällige Änderungen machen, der Grund ist, dass [LLMs keine deterministischen Algorithmen sind](https://doublespeak.chat/#/handbook#deterministic-output)).

 Die Tests:

@@ -95,7 +95,7 @@ $ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid
 ... und noch ein Konsolen-Codebeispiel ...

 ```console
-// Ein Verzeichnis "Code" erstellen
+// Create a directory "Code"
 $ mkdir code
 // In dieses Verzeichnis wechseln
 $ cd code
@@ -124,6 +124,10 @@ Siehe Abschnitt `### Content of code blocks` im allgemeinen Prompt in `scripts/t

 //// tab | Test

+/// info | Info
+Etwas Text
+///
+
 /// note | Hinweis
 Etwas Text
 ///
@@ -132,6 +136,10 @@ Etwas Text
 Etwas Text
 ///

+/// check | Testen
+Etwas Text
+///
+
 /// tip | Tipp
 Etwas Text
 ///
@@ -189,15 +197,15 @@ Hier einige Dinge, die in HTML-„abbr“-Elemente gepackt sind (einige sind erf

 ### Das abbr gibt eine vollständige Phrase { #the-abbr-gives-a-full-phrase }

-* <abbr title="Getting Things Done - Dinge erledigt bekommen">GTD</abbr>
-* <abbr title="less than - kleiner als"><code>lt</code></abbr>
+* <abbr title="Getting Things Done – Dinge erledigt bekommen">GTD</abbr>
+* <abbr title="less than – kleiner als"><code>lt</code></abbr>
 * <abbr title="XML Web Token">XWT</abbr>
 * <abbr title="Paralleles Server-Gateway-Interface">PSGI</abbr>

 ### Das abbr gibt eine vollständige Phrase und eine Erklärung { #the-abbr-gives-a-full-phrase-and-an-explanation }

-* <abbr title="Mozilla Developer Network - Mozilla-Entwicklernetzwerk: Dokumentation für Entwickler, geschrieben von den Firefox-Leuten">MDN</abbr>
-* <abbr title="Input/Output - Eingabe/Ausgabe: Lesen oder Schreiben auf der Festplatte, Netzwerkkommunikation.">I/O</abbr>.
+* <abbr title="Mozilla Developer Network – Mozilla-Entwicklernetzwerk: Dokumentation für Entwickler, geschrieben von den Firefox-Leuten">MDN</abbr>
+* <abbr title="Input/Output – Eingabe/Ausgabe: Lesen oder Schreiben auf der Festplatte, Netzwerkkommunikation.">I/O</abbr>.

 ////

@@ -211,7 +219,7 @@ Siehe Abschnitt `### HTML abbr elements` im allgemeinen Prompt in `scripts/trans

 ////

-## HTML-„dfn“-Elemente { #html-dfn-elements }
+## HTML „dfn“-Elemente { #html-dfn-elements }

 * <dfn title="Eine Gruppe von Maschinen, die so konfiguriert sind, dass sie verbunden sind und in irgendeiner Weise zusammenarbeiten.">Cluster</dfn>
 * <dfn title="Eine Methode des Machine Learning, die künstliche neuronale Netze mit zahlreichen versteckten Schichten zwischen Eingabe- und Ausgabeschicht verwendet und so eine umfassende interne Struktur entwickelt">Deep Learning</dfn>
@@ -240,7 +248,7 @@ Die einzige strenge Regel für Überschriften ist, dass das LLM den Hash-Teil in

 Siehe Abschnitt `### Headings` im allgemeinen Prompt in `scripts/translate.py`.

-Für einige sprachspezifische Anweisungen, siehe z. B. den Abschnitt `### Headings` in `docs/de/llm-prompt.md`.
+Für einige sprachsspezifische Anweisungen, siehe z. B. den Abschnitt `### Headings` in `docs/de/llm-prompt.md`.

 ////

@@ -363,12 +371,12 @@ Für einige sprachspezifische Anweisungen, siehe z. B. den Abschnitt `### Headin
 * die Umgebungsvariable
 * die Umgebungsvariable
 * der `PATH`
-* die `PATH`-Variable
+* die `PATH`-Umgebungsvariable

 * die Authentifizierung
 * der Authentifizierungsanbieter
 * die Autorisierung
-* das Autorisierungsformular
+* das Anmeldeformular
 * der Autorisierungsanbieter
 * der Benutzer authentisiert sich
 * das System authentifiziert den Benutzer
@@ -18,7 +18,7 @@ Für diese zusätzlichen Responses müssen Sie jedoch sicherstellen, dass Sie ei

 Sie können Ihren *Pfadoperation-Dekoratoren* einen Parameter `responses` übergeben.

-Der nimmt ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> entgegen: Die Schlüssel sind Statuscodes für jede Response (wie etwa `200`), und die Werte sind andere `dict`s mit den Informationen für jede Response.
+Der nimmt ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr> entgegen, die Schlüssel sind Statuscodes für jede Response, wie etwa `200`, und die Werte sind andere `dict`s mit den Informationen für jede Response.

 Jedes dieser Response-`dict`s kann einen Schlüssel `model` haben, welcher ein Pydantic-Modell enthält, genau wie `response_model`.

@@ -34,7 +34,7 @@ Beachten Sie, dass Sie die `JSONResponse` direkt zurückgeben müssen.

 ///

-/// note | Hinweis
+/// info | Info

 Der `model`-Schlüssel ist nicht Teil von OpenAPI.

@@ -183,9 +183,9 @@ Beachten Sie, dass Sie das Bild direkt mit einer `FileResponse` zurückgeben mü

 ///

-/// note | Hinweis
+/// info | Info

-Sofern Sie in Ihrem Parameter `responses` nicht explizit einen anderen Medientyp angeben, geht FastAPI davon aus, dass die Response denselben Medientyp wie die Haupt-Response-Klasse hat (standardmäßig `application/json`).
+Sofern Sie in Ihrem Parameter `responses` nicht explizit einen anderen Medientyp angeben, geht FastAPI davon aus, dass die Response denselben Medientyp wie die Haupt-Response-Klasse hat (Standardmäßig `application/json`).

 Wenn Sie jedoch eine benutzerdefinierte Response-Klasse mit `None` als Medientyp angegeben haben, verwendet FastAPI `application/json` für jede zusätzliche Response, die über ein zugehöriges Modell verfügt.

@@ -195,7 +195,7 @@ Wenn Sie jedoch eine benutzerdefinierte Response-Klasse mit `None` als Medientyp

 Sie können auch Response-Informationen von mehreren Stellen kombinieren, einschließlich der Parameter `response_model`, `status_code` und `responses`.

-Sie können ein `response_model` deklarieren, indem Sie den Defaultstatuscode `200` (oder bei Bedarf einen benutzerdefinierten) verwenden und dann zusätzliche Informationen für dieselbe Response in `responses` direkt im OpenAPI-Schema deklarieren.
+Sie können ein `response_model` deklarieren, indem Sie den Standardstatuscode `200` (oder bei Bedarf einen benutzerdefinierten) verwenden und dann zusätzliche Informationen für dieselbe Response in `responses` direkt im OpenAPI-Schema deklarieren.

 **FastAPI** behält die zusätzlichen Informationen aus `responses` und kombiniert sie mit dem JSON-Schema aus Ihrem Modell.

@@ -243,5 +243,5 @@ Zum Beispiel:

 Um zu sehen, was genau Sie in die Responses aufnehmen können, können Sie die folgenden Abschnitte in der OpenAPI-Spezifikation überprüfen:

-* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#responses-object), enthält das `Response Object`.
-* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#response-object), Sie können alles davon direkt in jede Response innerhalb Ihres `responses`-Parameters einfügen. Einschließlich `description`, `headers`, `content` (darin deklarieren Sie verschiedene Medientypen und JSON-Schemas) und `links`.
+* [OpenAPI Responses Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object), enthält das `Response Object`.
+* [OpenAPI Response Object](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object), Sie können alles davon direkt in jede Response innerhalb Ihres `responses`-Parameter einfügen. Einschließlich `description`, `headers`, `content` (darin deklarieren Sie verschiedene Medientypen und JSON-Schemas) und `links`.
@@ -1,6 +1,5 @@
 # Zusätzliche Statuscodes { #additional-status-codes }

-
 Standardmäßig liefert **FastAPI** die <abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Responses</abbr> als `JSONResponse` zurück und fügt den Inhalt, den Sie aus Ihrer *Pfadoperation* zurückgeben, in diese `JSONResponse` ein.

 Es wird der Default-Statuscode oder derjenige verwendet, den Sie in Ihrer *Pfadoperation* festgelegt haben.
@@ -1,6 +1,5 @@
 # Fortgeschrittene Abhängigkeiten { #advanced-dependencies }

-
 ## Parametrisierte Abhängigkeiten { #parameterized-dependencies }

 Alle Abhängigkeiten, die wir bisher gesehen haben, waren festgelegte Funktionen oder Klassen.
@@ -99,7 +98,7 @@ Wenn Sie beispielsweise eine Datenbanksession in einer Abhängigkeit mit `yield`

 Dieses Verhalten wurde in 0.118.0 zurückgenommen, sodass der Exit-Code nach `yield` ausgeführt wird, nachdem die Response gesendet wurde.

-/// note | Hinweis
+/// info | Info

 Wie Sie unten sehen werden, ähnelt dies sehr dem Verhalten vor Version 0.106.0, jedoch mit mehreren Verbesserungen und Bugfixes für Sonderfälle.

@@ -45,7 +45,7 @@ Sie können Ihre Tests wie gewohnt ausführen mit:
 <div class="termy">

 ```console
-$ uv run pytest
+$ pytest

 ---> 100%
 ```
@@ -6,7 +6,7 @@ Diese Proxys könnten HTTPS-Zertifikate und andere Dinge handhaben.

 ## Proxy-<abbr title="weitergeleitete Header">Forwarded-Header</abbr> { #proxy-forwarded-headers }

-Ein **Proxy** vor Ihrer Anwendung würde normalerweise einige Header on-the-fly setzen, bevor er die Requests an Ihren **Server** sendet, um den Server wissen zu lassen, dass der Request vom Proxy **weitergeleitet** wurde, einschließlich der ursprünglichen (öffentlichen) URL, inklusive der Domain, dass HTTPS verwendet wird, usw.
+Ein **Proxy** vor Ihrer Anwendung würde normalerweise einige Header on-the-fly setzen, bevor er die Requests an den **Server** sendet, um den Server wissen zu lassen, dass der Request vom Proxy **weitergeleitet** wurde, einschließlich der ursprünglichen (öffentlichen) URL, inklusive der Domain, dass HTTPS verwendet wird, usw.

 Das **Server**-Programm (z. B. **Uvicorn** via **FastAPI CLI**) ist in der Lage, diese Header zu interpretieren und diese Information dann an Ihre Anwendung weiterzugeben.

@@ -33,7 +33,7 @@ Wenn Ihr **Server** hinter einem vertrauenswürdigen **Proxy** sitzt und nur der
 <div class="termy">

 ```console
-$ uv run fastapi run --forwarded-allow-ips="*"
+$ fastapi run --forwarded-allow-ips="*"

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -82,7 +82,7 @@ sequenceDiagram

    Note over Server: Server interpretiert die Header<br/>(wenn --forwarded-allow-ips gesetzt ist)

-    Server->>Proxy: HTTP-Response<br/>mit korrekten HTTPS-URLs
+    Server->>Proxy: HTTP-Response<br/>mit correkten HTTPS-URLs

    Proxy->>Client: HTTPS-Response
 ```
@@ -170,7 +170,7 @@ Um dies zu erreichen, können Sie die Kommandozeilenoption `--root-path` wie fol
 <div class="termy">

 ```console
-$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -200,7 +200,7 @@ Wenn Sie Uvicorn dann starten mit:
 <div class="termy">

 ```console
-$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -253,7 +253,7 @@ In einem solchen Fall (ohne ein abgetrenntes Pfadpräfix) würde der Proxy auf e

 Sie können das Experiment mit einem abgetrennten Pfadpräfix einfach lokal ausführen, indem Sie [Traefik](https://docs.traefik.io/) verwenden.

-[Laden Sie Traefik herunter](https://github.com/traefik/traefik/releases), es ist eine einzelne Binärdatei, Sie können die komprimierte Datei extrahieren und sie direkt vom Terminal aus ausführen.
+[Laden Sie Traefik herunter](https://github.com/containous/traefik/releases), es ist eine einzelne Binärdatei, Sie können die komprimierte Datei extrahieren und sie direkt vom Terminal aus ausführen.

 Dann erstellen Sie eine Datei `traefik.toml` mit:

@@ -316,12 +316,12 @@ INFO[0000] Configuration loaded from file: /home/user/awesomeapi/traefik.toml

 </div>

-Und jetzt starten Sie Ihre Anwendung, indem Sie die Option `--root-path` verwenden:
+Und jetzt starten Sie Ihre Anwendung mit Uvicorn, indem Sie die Option `--root-path` verwenden:

 <div class="termy">

 ```console
-$ uv run fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1
+$ fastapi run main.py --forwarded-allow-ips="*" --root-path /api/v1

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -461,6 +461,6 @@ Dann wird er nicht in das OpenAPI-Schema aufgenommen.

 ## Mounten einer Unteranwendung { #mounting-a-sub-application }

-Wenn Sie eine Unteranwendung mounten müssen (wie beschrieben in [Unteranwendungen – Mounts](sub-applications.md)) und dabei auch einen Proxy mit `root_path` verwenden, können Sie das normal tun, wie Sie es erwarten würden.
+Wenn Sie gleichzeitig eine Unteranwendung mounten (wie beschrieben in [Unteranwendungen – Mounts](sub-applications.md)) und einen Proxy mit `root_path` verwenden wollen, können Sie das normal tun, wie Sie es erwarten würden.

 FastAPI verwendet intern den `root_path` auf intelligente Weise, sodass es einfach funktioniert. ✨
@@ -41,7 +41,7 @@ Um eine Response mit HTML direkt von **FastAPI** zurückzugeben, verwenden Sie `

 {* ../../docs_src/custom_response/tutorial002_py310.py hl[2,7] *}

-/// note | Hinweis
+/// info | Info

 Der Parameter `response_class` wird auch verwendet, um den „Medientyp“ der Response zu definieren.

@@ -65,7 +65,7 @@ Eine `Response`, die direkt von Ihrer *Pfadoperation-Funktion* zurückgegeben wi

 ///

-/// note | Hinweis
+/// info | Info

 Natürlich stammen der eigentliche `Content-Type`-Header, der Statuscode, usw., aus dem `Response`-Objekt, das Sie zurückgegeben haben.

@@ -158,7 +158,6 @@ Sie können eine `RedirectResponse` direkt zurückgeben:

 Oder Sie können sie im Parameter `response_class` verwenden:

-
 {* ../../docs_src/custom_response/tutorial006b_py310.py hl[2,7,9] *}

 Wenn Sie das tun, können Sie die URL direkt von Ihrer *Pfadoperation*-Funktion zurückgeben.
@@ -6,7 +6,7 @@ Aber FastAPI unterstützt auf die gleiche Weise auch die Verwendung von [`datacl

 {* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}

-Das ist dank **Pydantic** ebenfalls möglich, da es [interne Unterstützung für `dataclasses`](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/#usage-of-stdlib-dataclasses-with-basemodel) bietet.
+Das ist dank **Pydantic** ebenfalls möglich, da es [„`dataclasses` intern unterstützt“](https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel).

 Auch wenn im obigen Code Pydantic nicht explizit vorkommt, verwendet FastAPI Pydantic, um diese Standard-Datenklassen in Pydantics eigene Variante von Datenklassen zu konvertieren.

@@ -18,7 +18,7 @@ Und natürlich wird das gleiche unterstützt:

 Das funktioniert genauso wie mit Pydantic-Modellen. Und tatsächlich wird es unter der Haube mittels Pydantic auf die gleiche Weise bewerkstelligt.

-/// note | Hinweis
+/// info | Info

 Bedenken Sie, dass Datenklassen nicht alles können, was Pydantic-Modelle können.

@@ -64,7 +64,7 @@ In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.da

 6. Hier geben wir ein <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> zurück, das `items` enthält, welches eine Liste von Datenklassen ist.

-    FastAPI ist weiterhin in der Lage, die Daten nach JSON zu <dfn title="die Daten in ein übertragbares Format konvertieren">serialisieren</dfn>.
+    FastAPI ist weiterhin in der Lage, die Daten nach JSON zu <dfn title="Konvertieren der Daten in ein übertragbares Format">Serialisieren</dfn>.

 7. Hier verwendet das `response_model` als Typannotation eine Liste von `Author`-Datenklassen.

@@ -74,7 +74,7 @@ In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.da

    Wie immer können Sie in FastAPI `def` und `async def` beliebig kombinieren.

-    Wenn Sie eine Auffrischung darüber benötigen, wann welche Anwendung sinnvoll ist, lesen Sie den Abschnitt _„In Eile?“_ in der Dokumentation zu [`async` und `await`](../async.md#in-a-hurry).
+    Wenn Sie eine Auffrischung darüber benötigen, wann welche Anwendung sinnvoll ist, lesen Sie den Abschnitt „In Eile?“ in der Dokumentation zu [`async` und `await`](../async.md#in-a-hurry).

 9. Diese *Pfadoperation-Funktion* gibt keine Datenklassen zurück (obwohl dies möglich wäre), sondern eine Liste von Dictionarys mit internen Daten.

@@ -82,13 +82,13 @@ In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.da

 Sie können `dataclasses` mit anderen Typannotationen auf vielfältige Weise kombinieren, um komplexe Datenstrukturen zu bilden.

-Weitere spezifische Details finden Sie in den Annotationstipps im Code oben.
+Weitere Einzelheiten finden Sie in den Bemerkungen im Quellcode oben.

 ## Mehr erfahren { #learn-more }

 Sie können `dataclasses` auch mit anderen Pydantic-Modellen kombinieren, von ihnen erben, sie in Ihre eigenen Modelle einbinden, usw.

-Weitere Informationen finden Sie in der [Pydantic-Dokumentation zu Datenklassen](https://pydantic.dev/docs/validation/latest/concepts/dataclasses/).
+Weitere Informationen finden Sie in der [Pydantic-Dokumentation zu Datenklassen](https://docs.pydantic.dev/latest/concepts/dataclasses/).

 ## Version { #version }

@@ -32,7 +32,7 @@ Wir erstellen eine asynchrone Funktion `lifespan()` mit `yield` wie folgt:

 {* ../../docs_src/events/tutorial003_py310.py hl[16,19] *}

-Hier simulieren wir den aufwendigen *Startup*-Vorgang des Ladens des Modells, indem wir die (Fake-)Modellfunktion vor dem `yield` in das <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> mit Modellen für maschinelles Lernen einfügen. Dieser Code wird ausgeführt, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**, während des *Startups*.
+Hier simulieren wir den langsamen *Startup*, das Laden des Modells, indem wir die (Fake-)Modellfunktion vor dem `yield` in das <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dictionary</abbr> mit Modellen für maschinelles Lernen einfügen. Dieser Code wird ausgeführt, **bevor** die Anwendung **beginnt, Requests entgegenzunehmen**, während des *Startups*.

 Und dann, direkt nach dem `yield`, entladen wir das Modell. Dieser Code wird ausgeführt, **nachdem** die Anwendung **die Bearbeitung von Requests abgeschlossen hat**, direkt vor dem *Shutdown*. Dadurch könnten beispielsweise Ressourcen wie Arbeitsspeicher oder eine GPU freigegeben werden.

@@ -102,7 +102,7 @@ Diese Funktionen können mit `async def` oder normalem `def` deklariert werden.

 ### `startup`-Event { #startup-event }

-Um eine Funktion hinzuzufügen, die vor dem Start der Anwendung ausgeführt werden soll, deklarieren Sie diese mit dem Event `"startup"`:
+Um eine Funktion hinzuzufügen, die vor dem Start der Anwendung ausgeführt werden soll, deklarieren Sie diese mit dem Event `startup`:

 {* ../../docs_src/events/tutorial001_py310.py hl[8] *}

@@ -114,13 +114,13 @@ Und Ihre Anwendung empfängt erst dann Requests, wenn alle `startup`-Eventhandle

 ### `shutdown`-Event { #shutdown-event }

-Um eine Funktion hinzuzufügen, die beim Shutdown der Anwendung ausgeführt werden soll, deklarieren Sie sie mit dem Event `"shutdown"`:
+Um eine Funktion hinzuzufügen, die beim Shutdown der Anwendung ausgeführt werden soll, deklarieren Sie sie mit dem Event `shutdown`:

 {* ../../docs_src/events/tutorial002_py310.py hl[6] *}

 Hier schreibt die `shutdown`-Eventhandler-Funktion eine Textzeile `"Application shutdown"` in eine Datei `log.txt`.

-/// note | Hinweis
+/// info | Info

 In der Funktion `open()` bedeutet `mode="a"` „append“ („anhängen“), sodass die Zeile nach dem, was sich in dieser Datei befindet, hinzugefügt wird, ohne den vorherigen Inhalt zu überschreiben.

@@ -140,7 +140,7 @@ Daher deklarieren wir die Eventhandler-Funktion mit Standard-`def` statt mit `as

 ### `startup` und `shutdown` zusammen { #startup-and-shutdown-together }

-Es besteht eine hohe Wahrscheinlichkeit, dass die Logik für Ihr *Startup* und *Shutdown* miteinander verknüpft ist. Vielleicht möchten Sie etwas beginnen und es dann beenden, eine Ressource belegen und sie dann freigeben usw.
+Es besteht eine hohe Wahrscheinlichkeit, dass die Logik für Ihr *Startup* und *Shutdown* miteinander verknüpft ist. Vielleicht möchten Sie etwas beginnen und es dann beenden, eine Ressource laden und sie dann freigeben usw.

 Bei getrennten Funktionen, die keine gemeinsame Logik oder Variablen haben, ist dies schwieriger, da Sie Werte in globalen Variablen speichern oder ähnliche Tricks verwenden müssen.

@@ -150,13 +150,13 @@ Aus diesem Grund wird jetzt empfohlen, stattdessen `lifespan` wie oben erläuter

 Nur ein technisches Detail für die neugierigen Nerds. 🤓

-In der technischen ASGI-Spezifikation ist dies Teil des [Lifespan-Protokolls](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) und definiert Events namens `startup` und `shutdown`.
+In der technischen ASGI-Spezifikation ist dies Teil des [Lifespan Protokolls](https://asgi.readthedocs.io/en/latest/specs/lifespan.html) und definiert Events namens `startup` und `shutdown`.

-/// note | Hinweis
+/// info | Info

-Weitere Informationen zu Starlettes `lifespan`-Handlern finden Sie in [Starlettes Lifespan-Dokumentation](https://starlette.dev/lifespan/).
+Weitere Informationen zu Starlettes `lifespan`-Handlern finden Sie in [Starlettes Lifespan-Dokumentation](https://www.starlette.dev/lifespan/).

-Einschließlich, wie Sie Lifespan-Zustand handhaben, der in anderen Bereichen Ihres Codes verwendet werden kann.
+Einschließlich, wie man Lifespan-Zustand handhabt, der in anderen Bereichen Ihres Codes verwendet werden kann.

 ///

@@ -6,13 +6,13 @@ Dies vereinfacht es, aktuelle **Dokumentation** und Client-Bibliotheken (<abbr t

 In diesem Leitfaden erfahren Sie, wie Sie ein **TypeScript-SDK** für Ihr FastAPI-Backend generieren.

-## Open-Source-SDK-Generatoren { #open-source-sdk-generators }
+## Open Source SDK-Generatoren { #open-source-sdk-generators }

 Eine vielseitige Möglichkeit ist der [OpenAPI Generator](https://openapi-generator.tech/), der **viele Programmiersprachen** unterstützt und SDKs aus Ihrer OpenAPI-Spezifikation generieren kann.

 Für **TypeScript-Clients** ist [Hey API](https://heyapi.dev/) eine speziell entwickelte Lösung, die ein optimiertes Erlebnis für das TypeScript-Ökosystem bietet.

-Weitere SDK-Generatoren finden Sie auf [OpenAPI.Tools](https://openapi.tools/categories/sdk-generators).
+Weitere SDK-Generatoren finden Sie auf [OpenAPI.Tools](https://openapi.tools/#sdk).

 /// tip | Tipp

@@ -20,6 +20,22 @@ FastAPI generiert automatisch **OpenAPI 3.1**-Spezifikationen, daher muss jedes

 ///

+## SDK-Generatoren von FastAPI-Sponsoren { #sdk-generators-from-fastapi-sponsors }
+
+Dieser Abschnitt hebt **venture-unterstützte** und **firmengestützte** Lösungen hervor, die von Unternehmen entwickelt werden, welche FastAPI sponsern. Diese Produkte bieten **zusätzliche Funktionen** und **Integrationen** zusätzlich zu hochwertig generierten SDKs.
+
+Durch das ✨ [**Sponsoring von FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ helfen diese Unternehmen sicherzustellen, dass das Framework und sein **Ökosystem** gesund und **nachhaltig** bleiben.
+
+Ihr Sponsoring zeigt auch ein starkes Engagement für die FastAPI-**Community** (Sie), was bedeutet, dass sie nicht nur einen **großartigen Service** bieten möchten, sondern auch ein **robustes und florierendes Framework**, FastAPI, unterstützen möchten. 🙇
+
+Zum Beispiel könnten Sie ausprobieren:
+
+* [Speakeasy](https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship)
+* [Stainless](https://www.stainless.com/?utm_source=fastapi&utm_medium=referral)
+* [liblab](https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi)
+
+Einige dieser Lösungen sind möglicherweise auch Open Source oder bieten kostenlose Tarife an, sodass Sie diese ohne finanzielle Verpflichtung ausprobieren können. Andere kommerzielle SDK-Generatoren sind online verfügbar und können dort gefunden werden. 🤓
+
 ## Ein TypeScript-SDK erstellen { #create-a-typescript-sdk }

 Beginnen wir mit einer einfachen FastAPI-Anwendung:
@@ -50,7 +66,7 @@ npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client

 Dies generiert ein TypeScript-SDK in `./src/client`.

-Sie können lernen, wie Sie [`@hey-api/openapi-ts` installieren](https://heyapi.dev/openapi-ts/get-started) und über die [erzeugte Ausgabe](https://heyapi.dev/openapi-ts/output) auf deren Website lesen.
+Sie können lernen, wie man [`@hey-api/openapi-ts` installiert](https://heyapi.dev/openapi-ts/get-started) und über die [erzeugte Ausgabe](https://heyapi.dev/openapi-ts/output) auf deren Website lesen.

 ### Das SDK verwenden { #using-the-sdk }

@@ -4,7 +4,7 @@ Wenn Ihre App JSON-Daten empfangen und senden muss, Sie darin aber Binärdaten e

 ## Base64 vs Dateien { #base64-vs-files }

-Prüfen Sie zunächst, ob Sie [Requestdateien](../tutorial/request-files.md) zum Hochladen von Binärdaten und [Benutzerdefinierte Response – FileResponse](./custom-response.md#fileresponse) zum Senden von Binärdaten verwenden können, anstatt sie in JSON zu kodieren.
+Prüfen Sie zunächst, ob Sie [Request Files](../tutorial/request-files.md) zum Hochladen von Binärdaten und [Benutzerdefinierte Response – FileResponse](./custom-response.md#fileresponse--fileresponse-) zum Senden von Binärdaten verwenden können, anstatt sie in JSON zu kodieren.

 JSON kann nur UTF-8-kodierte Strings enthalten, es kann daher keine rohen Bytes enthalten.

@@ -2,9 +2,9 @@

 Im Haupttutorial haben Sie gelesen, wie Sie Ihrer Anwendung [benutzerdefinierte Middleware](../tutorial/middleware.md) hinzufügen können.

-Und dann haben Sie auch gelesen, wie Sie [CORS mittels der `CORSMiddleware`](../tutorial/cors.md) handhaben.
+Und dann auch, wie man [CORS mittels der `CORSMiddleware`](../tutorial/cors.md) handhabt.

-In diesem Abschnitt werden wir sehen, wie Sie andere Middlewares verwenden.
+In diesem Abschnitt werden wir sehen, wie man andere Middlewares verwendet.

 ## ASGI-Middleware hinzufügen { #adding-asgi-middlewares }

@@ -41,7 +41,7 @@ app.add_middleware(UnicornMiddleware, some_config="rainbow")

 ## Integrierte Middleware { #integrated-middlewares }

-**FastAPI** enthält mehrere Middlewares für gängige Anwendungsfälle. Wir werden als Nächstes sehen, wie Sie sie verwenden.
+**FastAPI** enthält mehrere Middlewares für gängige Anwendungsfälle. Wir werden als Nächstes sehen, wie man sie verwendet.

 /// note | Technische Details

@@ -74,7 +74,7 @@ Wenn ein eingehender Request nicht korrekt validiert wird, wird eine `400`-<abbr

 ## `GZipMiddleware` { #gzipmiddleware }

-Verarbeitet GZip-Responses für alle Requests, die `"gzip"` im `Accept-Encoding`-Header enthalten.
+Verarbeitet GZip-Responses für alle Requests, die „gzip“ im `Accept-Encoding`-Header enthalten.

 Diese Middleware verarbeitet sowohl Standard- als auch Streaming-Responses.

@@ -91,7 +91,7 @@ Es gibt viele andere ASGI-Middlewares.

 Zum Beispiel:

-* [Uvicorns `ProxyHeadersMiddleware`](https://github.com/Kludex/uvicorn/blob/main/uvicorn/middleware/proxy_headers.py)
+* [Uvicorns `ProxyHeadersMiddleware`](https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py)
 * [MessagePack](https://github.com/florimondmanca/msgpack-asgi)

-Um mehr über weitere verfügbare Middlewares herauszufinden, besuchen Sie [Starlettes Middleware-Dokumentation](https://starlette.dev/middleware/) und die [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi).
+Um mehr über weitere verfügbare Middlewares herauszufinden, besuchen Sie [Starlettes Middleware-Dokumentation](https://www.starlette.dev/middleware/) und die [ASGI Awesome List](https://github.com/florimondmanca/awesome-asgi).
@@ -12,7 +12,7 @@ Sehen wir uns das alles anhand eines Beispiels an.

 Stellen Sie sich vor, Sie entwickeln eine Anwendung, mit der Sie Rechnungen erstellen können.

-Diese Rechnungen haben eine `id`, einen `title` (optional), einen `customer` und ein `total`.
+Diese Rechnungen haben eine `id`, einen optionalen `title`, einen `customer` (Kunde) und ein `total` (Gesamtsumme).

 Der Benutzer Ihrer API (ein externer Entwickler) erstellt mit einem POST-Request eine Rechnung in Ihrer API.

@@ -35,7 +35,7 @@ Dieser Teil ist ziemlich normal, der größte Teil des Codes ist Ihnen wahrschei

 /// tip | Tipp

-Der Query-Parameter `callback_url` verwendet einen Pydantic-[Url](https://pydantic.dev/docs/validation/latest/api/pydantic/networks/)-Typ.
+Der Query-Parameter `callback_url` verwendet einen Pydantic-[Url](https://docs.pydantic.dev/latest/api/networks/)-Typ.

 ///

@@ -106,11 +106,11 @@ Sie sollte wie eine normale FastAPI-*Pfadoperation* aussehen:
 Es gibt zwei Hauptunterschiede zu einer normalen *Pfadoperation*:

 * Es muss kein tatsächlicher Code vorhanden sein, da Ihre Anwendung diesen Code niemals aufruft. Sie wird nur zur Dokumentation der *externen API* verwendet. Die Funktion könnte also einfach `pass` enthalten.
-* Der *Pfad* kann einen [OpenAPI-3-Ausdruck](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) enthalten (mehr dazu weiter unten), wo er Variablen mit Parametern und Teilen des ursprünglichen Requests verwenden kann, der an *Ihre API* gesendet wurde.
+* Der *Pfad* kann einen [OpenAPI-3-Ausdruck](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) enthalten (mehr dazu weiter unten), wo er Variablen mit Parametern und Teilen des ursprünglichen Requests verwenden kann, der an *Ihre API* gesendet wurde.

 ### Der Callback-Pfadausdruck { #the-callback-path-expression }

-Der Callback-*Pfad* kann einen [OpenAPI-3-Ausdruck](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#key-expression) enthalten, welcher Teile des ursprünglichen Requests enthalten kann, der an *Ihre API* gesendet wurde.
+Der Callback-*Pfad* kann einen [OpenAPI-3-Ausdruck](https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression) enthalten, welcher Teile des ursprünglichen Requests enthalten kann, der an *Ihre API* gesendet wurde.

 In diesem Fall ist es der `str`:

@@ -118,13 +118,13 @@ In diesem Fall ist es der `str`:
 "{$callback_url}/invoices/{$request.body.id}"
 ```

-Wenn Ihr API-Benutzer (der externe Entwickler) also einen Request an *Ihre API* sendet, an:
+Wenn Ihr API-Benutzer (der externe Entwickler) also einen Request an *Ihre API* sendet, via:

 ```
 https://yourapi.com/invoices/?callback_url=https://www.external.org/events
 ```

-mit einem JSON-Body:
+mit einem JSON-Körper:

 ```JSON
 {
@@ -167,13 +167,13 @@ Beachten Sie, dass die verwendete Callback-URL die URL enthält, die als Query-P

 An diesem Punkt haben Sie die benötigte(n) *Callback-Pfadoperation(en)* (diejenige(n), die der *externe Entwickler* in der *externen API* implementieren sollte) im Callback-Router, den Sie oben erstellt haben.

-Verwenden Sie nun den Parameter `callbacks` im *Pfadoperation-Dekorator Ihrer API*, um das Attribut `.routes` dieses Callback-Routers zu übergeben:
+Verwenden Sie nun den Parameter `callbacks` im *Pfadoperation-Dekorator Ihrer API*, um das Attribut `.routes` (das ist eigentlich nur eine `list`e von Routen/*Pfadoperationen*) dieses Callback-Routers zu übergeben:

 {* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[33] *}

 /// tip | Tipp

-Beachten Sie, dass Sie nicht den Router selbst (`invoices_callback_router`) an `callbacks=` übergeben, sondern dessen `.routes`, wie in `invoices_callback_router.routes`. FastAPI wird diese Routen verwenden, um die Callback-OpenAPI-Dokumentation zu generieren.
+Beachten Sie, dass Sie nicht den Router selbst (`invoices_callback_router`) an `callback=` übergeben, sondern das Attribut `.routes`, wie in `invoices_callback_router.routes`.

 ///

@@ -22,7 +22,7 @@ Mit **FastAPI**, mithilfe von OpenAPI, können Sie die Namen dieser Webhooks, di

 Dies kann es Ihren Benutzern viel einfacher machen, **deren APIs zu implementieren**, um Ihre **Webhook**-Requests zu empfangen. Möglicherweise können diese sogar einen Teil ihres eigenen API-Codes automatisch generieren.

-/// note | Hinweis
+/// info | Info

 Webhooks sind in OpenAPI 3.1.0 und höher verfügbar und werden von FastAPI `0.99.0` und höher unterstützt.

@@ -36,7 +36,7 @@ Wenn Sie eine **FastAPI**-Anwendung erstellen, gibt es ein `webhooks`-Attribut,

 Die von Ihnen definierten Webhooks landen im **OpenAPI**-Schema und der automatischen **Dokumentations-Oberfläche**.

-/// note | Hinweis
+/// info | Info

 Das `app.webhooks`-Objekt ist eigentlich nur ein `APIRouter`, derselbe Typ, den Sie verwenden würden, wenn Sie Ihre App mit mehreren Dateien strukturieren.

@@ -16,11 +16,17 @@ Sie müssten sicherstellen, dass sie für jede Operation eindeutig ist.

 ### Verwendung des Namens der *Pfadoperation-Funktion* als operationId { #using-the-path-operation-function-name-as-the-operationid }

-Wenn Sie die Funktionsnamen Ihrer APIs als `operationId`s verwenden möchten, können Sie `FastAPI` eine eigene `generate_unique_id_function` übergeben.
+Wenn Sie die Funktionsnamen Ihrer API als `operationId`s verwenden möchten, können Sie über alle iterieren und die `operation_id` jeder *Pfadoperation* mit deren `APIRoute.name` überschreiben.

-Diese Funktion erhält jeweils die `APIRoute` und gibt die `operationId` zurück, die für diese Pfadoperation verwendet werden soll.
+Sie sollten dies tun, nachdem Sie alle Ihre *Pfadoperationen* hinzugefügt haben.

-{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py310.py hl[2,5:6,9] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py310.py hl[2, 12:21, 24] *}
+
+/// tip | Tipp
+
+Wenn Sie `app.openapi()` manuell aufrufen, sollten Sie vorher die `operationId`s aktualisiert haben.
+
+///

 /// warning | Achtung

@@ -1,6 +1,5 @@
 # Response – Statuscode ändern { #response-change-status-code }

-
 Sie haben wahrscheinlich schon vorher gelesen, dass Sie einen Default-[Response-Statuscode](../tutorial/response-status-code.md) festlegen können.

 In manchen Fällen müssen Sie jedoch einen anderen als den Default-Statuscode zurückgeben.
@@ -48,4 +48,4 @@ Und da die `Response` häufig zum Setzen von Headern und Cookies verwendet wird,

 ///

-Um alle verfügbaren Parameter und Optionen anzuzeigen, sehen Sie sich deren [Dokumentation in Starlette](https://starlette.dev/responses/#set-cookie) an.
+Um alle verfügbaren Parameter und Optionen anzuzeigen, sehen Sie sich deren [Dokumentation in Starlette](https://www.starlette.dev/responses/#set-cookie) an.
@@ -16,9 +16,9 @@ Normalerweise erzielen Sie eine deutlich bessere Leistung, wenn Sie ein [Respons

 ## Eine `Response` zurückgeben { #return-a-response }

-Sie können eine `Response` oder jede Unterklasse davon zurückgeben.
+Tatsächlich können Sie jede `Response` oder jede Unterklasse davon zurückgeben.

-/// note | Hinweis
+/// info | Info

 `JSONResponse` selbst ist eine Unterklasse von `Response`.

@@ -38,4 +38,4 @@ Und da die `Response` häufig zum Setzen von Headern und Cookies verwendet wird,

 Beachten Sie, dass benutzerdefinierte proprietäre Header [mit dem Präfix `X-`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers) hinzugefügt werden können.

-Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen können soll, müssen Sie diese zu Ihren CORS-Konfigurationen hinzufügen (weitere Informationen finden Sie unter [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), unter Verwendung des Parameters `expose_headers`, dokumentiert in [Starlettes CORS-Dokumentation](https://starlette.dev/middleware/#corsmiddleware).
+Wenn Sie jedoch benutzerdefinierte Header haben, die ein Client in einem Browser sehen können soll, müssen Sie diese zu Ihrer CORS-Konfiguration hinzufügen (weitere Informationen finden Sie unter [CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md)), unter Verwendung des Parameters `expose_headers`, dokumentiert in [Starlettes CORS-Dokumentation](https://www.starlette.dev/middleware/#corsmiddleware).
@@ -18,7 +18,7 @@ Sie benötigen nicht unbedingt OAuth2-Scopes, und Sie können die Authentifizier

 Aber OAuth2 mit Scopes kann bequem in Ihre API (mit OpenAPI) und deren API-Dokumentation integriert werden.

-Dennoch erzwingen Sie solche Scopes oder andere Sicherheits-/Autorisierungsanforderungen in Ihrem Code so, wie Sie es benötigen.
+Dennoch, verwenden Sie solche Scopes oder andere Sicherheits-/Autorisierungsanforderungen in Ihrem Code so wie Sie es möchten.

 In vielen Fällen kann OAuth2 mit Scopes ein Overkill sein.

@@ -46,7 +46,7 @@ Er wird normalerweise verwendet, um bestimmte Sicherheitsberechtigungen zu dekla
 * `instagram_basic` wird von Facebook / Instagram verwendet.
 * `https://www.googleapis.com/auth/drive` wird von Google verwendet.

-/// note | Hinweis
+/// info | Info

 In OAuth2 ist ein „Scope“ nur ein String, der eine bestimmte erforderliche Berechtigung deklariert.

@@ -126,7 +126,7 @@ Wir tun dies hier, um zu demonstrieren, wie **FastAPI** auf verschiedenen Ebenen

 {* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}

-/// note | Technische Details
+/// info | Technische Details

 `Security` ist tatsächlich eine Unterklasse von `Depends` und hat nur noch einen zusätzlichen Parameter, den wir später kennenlernen werden.

@@ -247,7 +247,7 @@ Das würde einer Drittanbieteranwendung passieren, die versucht, auf eine dieser

 ## Über Integrationen von Drittanbietern { #about-third-party-integrations }

-In diesem Beispiel verwenden wir den OAuth2-Flow „password“.
+In diesem Beispiel verwenden wir den OAuth2-Flow „Password“.

 Das ist angemessen, wenn wir uns bei unserer eigenen Anwendung anmelden, wahrscheinlich mit unserem eigenen Frontend.

@@ -255,9 +255,9 @@ Weil wir darauf vertrauen können, dass es den `username` und das `password` erh

 Wenn Sie jedoch eine OAuth2-Anwendung erstellen, mit der andere eine Verbindung herstellen würden (d.h. wenn Sie einen Authentifizierungsanbieter erstellen, der Facebook, Google, GitHub usw. entspricht), sollten Sie einen der anderen Flows verwenden.

-Am häufigsten ist der implicit Flow.
+Am häufigsten ist der „Implicit“-Flow.

-Am sichersten ist der code Flow, die Implementierung ist jedoch komplexer, da mehr Schritte erforderlich sind. Da er komplexer ist, schlagen viele Anbieter letztendlich den implicit Flow vor.
+Am sichersten ist der „Code“-Flow, die Implementierung ist jedoch komplexer, da mehr Schritte erforderlich sind. Da er komplexer ist, schlagen viele Anbieter letztendlich den „Implicit“-Flow vor.

 /// note | Hinweis

@@ -2,49 +2,45 @@

 In vielen Fällen benötigt Ihre Anwendung möglicherweise einige externe Einstellungen oder Konfigurationen, zum Beispiel geheime Schlüssel, Datenbank-Anmeldeinformationen, Anmeldeinformationen für E-Mail-Dienste, usw.

-Die meisten dieser Einstellungen sind variabel (können sich ändern), wie z. B. Datenbank-URLs. Und viele könnten schützenswerte, geheime Daten sein.
+Die meisten dieser Einstellungen sind variabel (können sich ändern), wie z. B. Datenbank-URLs. Und vieles könnten schützenswerte, geheime Daten sein.

 Aus diesem Grund werden diese üblicherweise in Umgebungsvariablen bereitgestellt, die von der Anwendung gelesen werden.

-Eine **Umgebungsvariable** (auch bekannt als **Env-Var**) ist ein Wert, der außerhalb des Python-Codes, im Betriebssystem, existiert und von Ihrer Anwendung und anderen Programmen gelesen werden kann.
-
-Sie können eine Umgebungsvariable für einen Befehl erstellen, wenn Sie ihn ausführen. Sie werden unten die plattformspezifischen Befehle sehen.
-
 /// tip | Tipp

-Lesen Sie den [Leitfaden zu Umgebungsvariablen](https://tiangolo.com/guides/environment-variables/) für eine detaillierte Erklärung, wie Umgebungsvariablen funktionieren.
+Um Umgebungsvariablen zu verstehen, können Sie [Umgebungsvariablen](../environment-variables.md) lesen.

 ///

 ## Typen und Validierung { #types-and-validation }

-Diese Umgebungsvariablen können nur Text-Strings verarbeiten, da sie außerhalb von Python liegen und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows und macOS) kompatibel sein müssen.
+Diese Umgebungsvariablen können nur Text-Zeichenketten verarbeiten, da sie außerhalb von Python liegen und mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen wie Linux, Windows, macOS) kompatibel sein müssen.

 Das bedeutet, dass jeder in Python aus einer Umgebungsvariablen gelesene Wert ein `str` ist und jede Konvertierung in einen anderen Typ oder jede Validierung im Code erfolgen muss.

 ## Pydantic `Settings` { #pydantic-settings }

-Glücklicherweise bietet Pydantic ein großartiges Werkzeug zur Verarbeitung dieser Einstellungen, die von Umgebungsvariablen stammen, mit [Pydantic: Settings-Verwaltung](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/).
+Glücklicherweise bietet Pydantic ein großartiges Werkzeug zur Verarbeitung dieser Einstellungen, die von Umgebungsvariablen stammen, mit [Pydantic: Settings Management](https://docs.pydantic.dev/latest/concepts/pydantic_settings/).

 ### `pydantic-settings` installieren { #install-pydantic-settings }

-Fügen Sie Ihrem Projekt das Package `pydantic-settings` hinzu:
+Stellen Sie zunächst sicher, dass Sie Ihre [virtuelle Umgebung](../virtual-environments.md) erstellt und aktiviert haben, und installieren Sie dann das Package `pydantic-settings`:

 <div class="termy">

 ```console
-$ uv add pydantic-settings
+$ pip install pydantic-settings
 ---> 100%
 ```

 </div>

-Es ist auch enthalten, wenn Sie die `all`-Extras installieren mit:
+Es ist bereits enthalten, wenn Sie die `all`-Extras installiert haben, mit:

 <div class="termy">

 ```console
-$ uv add "fastapi[all]"
+$ pip install "fastapi[all]"
 ---> 100%
 ```

@@ -80,45 +76,25 @@ Dann können Sie das neue `settings`-Objekt in Ihrer Anwendung verwenden:

 Als Nächstes würden Sie den Server ausführen und die Konfigurationen als Umgebungsvariablen übergeben. Sie könnten beispielsweise `ADMIN_EMAIL` und `APP_NAME` festlegen mit:

-//// tab | Linux, macOS, Windows Bash
-
 <div class="termy">

 ```console
-$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" uv run fastapi run main.py
+$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```

 </div>

-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-$ $Env:ADMIN_EMAIL = "deadpool@example.com"
-$ $Env:APP_NAME = "ChimichangApp"
-$ uv run fastapi run main.py
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-////
-
 /// tip | Tipp

-In Bash trennen Sie, um mehrere Umgebungsvariablen für einen einzelnen Befehl festzulegen, diese durch ein Leerzeichen und fügen sie alle vor dem Befehl ein.
+Um mehrere Umgebungsvariablen für einen einzelnen Befehl festzulegen, trennen Sie diese einfach durch ein Leerzeichen und fügen Sie alle vor dem Befehl ein.

 ///

-Und dann würde die Einstellung `admin_email` auf `"deadpool@example.com"` gesetzt.
+Und dann würde die Einstellung `admin_email` auf „deadpool@example.com“ gesetzt.

-Der `app_name` wäre `"ChimichangApp"`.
+Der `app_name` wäre „ChimichangApp“.

 Und `items_per_user` würde seinen Defaultwert von `50` behalten.

@@ -152,7 +128,7 @@ Ausgehend vom vorherigen Beispiel könnte Ihre Datei `config.py` so aussehen:

 {* ../../docs_src/settings/app02_an_py310/config.py hl[10] *}

-Beachten Sie, dass wir jetzt keine Defaultinstanz `settings = Settings()` erstellen.
+Beachten Sie, dass wir jetzt keine Standardinstanz `settings = Settings()` erstellen.

 ### Die Haupt-Anwendungsdatei { #the-main-app-file }

@@ -182,7 +158,7 @@ Bei der Abhängigkeitsüberschreibung legen wir einen neuen Wert für `admin_ema

 Dann können wir testen, ob das verwendet wird.

-## Eine `.env`-Datei lesen { #reading-a-env-file }
+## Lesen einer `.env`-Datei { #reading-a-env-file }

 Wenn Sie viele Einstellungen haben, die sich möglicherweise oft ändern, vielleicht in verschiedenen Umgebungen, kann es nützlich sein, diese in eine Datei zu schreiben und sie dann daraus zu lesen, als wären sie Umgebungsvariablen.

@@ -196,11 +172,11 @@ Aber eine dotenv-Datei muss nicht unbedingt genau diesen Dateinamen haben.

 ///

-Pydantic unterstützt das Lesen dieser Dateitypen mithilfe einer externen Bibliothek. Weitere Informationen finden Sie unter [Pydantic Settings: Dotenv (.env)-Unterstützung](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/#dotenv-env-support).
+Pydantic unterstützt das Lesen dieser Dateitypen mithilfe einer externen Bibliothek. Weitere Informationen finden Sie unter [Pydantic Settings: Dotenv (.env) support](https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support).

 /// tip | Tipp

-Damit das funktioniert, fügen Sie Ihrem Projekt `python-dotenv` mit `uv add python-dotenv` hinzu.
+Damit das funktioniert, müssen Sie `pip install python-dotenv` ausführen.

 ///

@@ -221,13 +197,13 @@ Und dann aktualisieren Sie Ihre `config.py` mit:

 /// tip | Tipp

-Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter [Pydantic: Konzepte: Konfiguration](https://pydantic.dev/docs/validation/latest/concepts/config/).
+Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet. Weitere Informationen finden Sie unter [Pydantic: Concepts: Configuration](https://docs.pydantic.dev/latest/concepts/config/).

 ///

 Hier definieren wir die Konfiguration `env_file` innerhalb Ihrer Pydantic-`Settings`-Klasse und setzen den Wert auf den Dateinamen mit der dotenv-Datei, die wir verwenden möchten.

-### Die `Settings` nur einmal mittels `lru_cache` erstellen { #creating-the-settings-only-once-with-lru-cache }
+### Die `Settings` nur einmal laden mittels `lru_cache` { #creating-the-settings-only-once-with-lru-cache }

 Das Lesen einer Datei von der Festplatte ist normalerweise ein kostspieliger (langsamer) Vorgang, daher möchten Sie ihn wahrscheinlich nur einmal ausführen und dann dasselbe Einstellungsobjekt erneut verwenden, anstatt es für jeden <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> zu lesen.

@@ -315,7 +291,7 @@ Im Fall unserer Abhängigkeit `get_settings()` akzeptiert die Funktion nicht ein

 Auf diese Weise verhält es sich fast so, als wäre es nur eine globale Variable. Da es jedoch eine Abhängigkeitsfunktion verwendet, können wir diese zu Testzwecken problemlos überschreiben.

-`@lru_cache` ist Teil von `functools`, welches Teil von Pythons Standardbibliothek ist. Weitere Informationen dazu finden Sie in der [Python-Dokumentation für `@lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).
+`@lru_cache` ist Teil von `functools`, welches Teil von Pythons Standardbibliothek ist. Weitere Informationen dazu finden Sie in der [Python Dokumentation für `@lru_cache`](https://docs.python.org/3/library/functools.html#functools.lru_cache).

 ## Zusammenfassung { #recap }

@@ -4,7 +4,7 @@ Wenn Sie Daten streamen möchten, die als JSON strukturiert werden können, soll

 Wenn Sie jedoch **reine Binärdaten** oder Strings streamen möchten, so können Sie es machen.

-/// note | Hinweis
+/// info | Info

 Hinzugefügt in FastAPI 0.134.0.

@@ -20,13 +20,13 @@ Sie könnten auf diese Weise auch **Video** oder **Audio** streamen, es könnte

 ## Eine `StreamingResponse` mit `yield` { #a-streamingresponse-with-yield }

-Wenn Sie in Ihrer *Pfadoperation-Funktion* ein `response_class=StreamingResponse` deklarieren, können Sie `yield` verwenden, um nacheinander jeden Datenchunk zu senden.
+Wenn Sie in Ihrer Pfadoperation-Funktion ein `response_class=StreamingResponse` deklarieren, können Sie `yield` verwenden, um nacheinander jeden Datenchunk zu senden.

 {* ../../docs_src/stream_data/tutorial001_py310.py ln[1:23] hl[20,23] *}

 FastAPI übergibt jeden Datenchunk unverändert an die `StreamingResponse`, es wird nicht versucht, ihn in JSON oder etwas Ähnliches zu konvertieren.

-### Nicht-async-*Pfadoperation-Funktionen* { #non-async-path-operation-functions }
+### Nicht-async-Pfadoperation-Funktionen { #non-async-path-operation-functions }

 Sie können auch reguläre `def`-Funktionen (ohne `async`) verwenden und `yield` auf die gleiche Weise einsetzen.

@@ -58,7 +58,7 @@ Zum Beispiel können Sie eine `PNGStreamingResponse` erstellen, die den `Content

 {* ../../docs_src/stream_data/tutorial002_py310.py ln[6,19:20] hl[20] *}

-Dann können Sie diese neue Klasse mit `response_class=PNGStreamingResponse` in Ihrer *Pfadoperation-Funktion* verwenden:
+Dann können Sie diese neue Klasse mit `response_class=PNGStreamingResponse` in Ihrer Pfadoperation-Funktion verwenden:

 {* ../../docs_src/stream_data/tutorial002_py310.py ln[23:27] hl[23] *}

@@ -90,7 +90,7 @@ Beispielsweise haben sie kein `await file.read()` oder `async for chunk in file`

 Und in vielen Fällen wäre das Lesen eine blockierende Operation (die die Event-Loop blockieren könnte), weil von der Festplatte oder aus dem Netzwerk gelesen wird.

-/// note | Hinweis
+/// info | Info

 Das obige Beispiel ist tatsächlich eine Ausnahme, weil sich das `io.BytesIO`-Objekt bereits im Speicher befindet, daher blockiert sein Lesen nichts.

@@ -98,7 +98,7 @@ Aber in vielen Fällen würde das Lesen einer Datei oder eines dateiähnlichen O

 ///

-Um die Event-Loop nicht zu blockieren, können Sie die *Pfadoperation-Funktion* einfach mit normalem `def` statt `async def` deklarieren, dadurch führt FastAPI sie in einem Threadpool-Worker aus, um die Haupt-Event-Loop nicht zu blockieren.
+Um die Event-Loop nicht zu blockieren, können Sie die Pfadoperation-Funktion einfach mit normalem `def` statt `async def` deklarieren, dadurch führt FastAPI sie in einem Threadpool-Worker aus, um die Haupt-Event-Loop nicht zu blockieren.

 {* ../../docs_src/stream_data/tutorial002_py310.py ln[30:34] hl[31] *}

@@ -81,7 +81,7 @@ Wenn Sie Clients unterstützen müssen, die keinen `Content-Type`-Header senden,

 Mit dieser Einstellung werden Requests ohne `Content-Type`-Header im Body als JSON geparst. Das entspricht dem Verhalten älterer FastAPI-Versionen.

-/// note | Hinweis
+/// info | Info

 Dieses Verhalten und diese Konfiguration wurden in FastAPI 0.132.0 hinzugefügt.

@@ -4,11 +4,11 @@ Wenn Sie zwei unabhängige FastAPI-Anwendungen mit deren eigenen unabhängigen O

 ## Eine **FastAPI**-Anwendung mounten { #mounting-a-fastapi-application }

-„Mounten“ bedeutet das Hinzufügen einer völlig „unabhängigen“ Anwendung an einem bestimmten Pfad, die sich dann um die Handhabung aller unter diesem Pfad liegenden _Pfadoperationen_ kümmert, welche in dieser Unteranwendung deklariert sind.
+„Mounten“ („Einhängen“) bedeutet das Hinzufügen einer völlig „unabhängigen“ Anwendung an einem bestimmten Pfad, die sich dann um die Handhabung aller unter diesem Pfad liegenden _Pfadoperationen_ kümmert, welche in dieser Unteranwendung deklariert sind.

-### Top-Level-Anwendung { #top-level-application }
+### Hauptanwendung { #top-level-application }

-Erstellen Sie zunächst die Haupt-, Top-Level-**FastAPI**-Anwendung und deren *Pfadoperationen*:
+Erstellen Sie zunächst die Hauptanwendung **FastAPI** und deren *Pfadoperationen*:

 {* ../../docs_src/sub_applications/tutorial001_py310.py hl[3, 6:8] *}

@@ -35,7 +35,7 @@ Führen Sie nun den Befehl `fastapi` aus:
 <div class="termy">

 ```console
-$ uv run fastapi dev
+$ fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -8,12 +8,12 @@ Es gibt Werkzeuge zur einfachen Konfiguration, die Sie direkt in Ihrer **FastAPI

 ## Abhängigkeiten installieren { #install-dependencies }

-Fügen Sie `jinja2` Ihrem Projekt hinzu:
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md) erstellen, sie aktivieren und `jinja2` installieren:

 <div class="termy">

 ```console
-$ uv add jinja2
+$ pip install jinja2

 ---> 100%
 ```
@@ -53,7 +53,7 @@ Sie können auch `from starlette.templating import Jinja2Templates` verwenden.

 ## Templates erstellen { #writing-templates }

-Dann können Sie unter `templates/item.html` ein Template erstellen, mit z. B.:
+Dann können Sie unter `templates/item.html` ein Template erstellen, mit z. B. folgendem Inhalt:

 ```jinja hl_lines="7"
 {!../../docs_src/templates/templates/item.html!}
@@ -123,4 +123,4 @@ Und da Sie `StaticFiles` verwenden, wird diese CSS-Datei automatisch von Ihrer *

 ## Mehr Details { #more-details }

-Weitere Informationen, einschließlich, wie man Templates testet, finden Sie in [Starlettes Dokumentation zu Templates](https://starlette.dev/templates/).
+Weitere Informationen, einschließlich, wie man Templates testet, finden Sie in [Starlettes Dokumentation zu Templates](https://www.starlette.dev/templates/).
@@ -5,7 +5,7 @@ Wenn Sie `lifespan` in Ihren Tests ausführen müssen, können Sie den `TestClie
 {* ../../docs_src/app_testing/tutorial004_py310.py hl[9:15,18,27:28,30:32,41:43] *}


-Sie können mehr Details unter [„Lifespan in Tests ausführen auf der offiziellen Starlette-Dokumentationswebsite.“](https://starlette.dev/lifespan/#running-lifespan-in-tests) nachlesen.
+Sie können mehr Details unter [„Lifespan in Tests ausführen in der offiziellen Starlette-Dokumentation.“](https://www.starlette.dev/lifespan/#running-lifespan-in-tests) nachlesen.

 Für die deprecateten Events <abbr title="Hochfahren">`startup`</abbr> und <abbr title="Herunterfahren">`shutdown`</abbr> können Sie den `TestClient` wie folgt verwenden:

@@ -8,6 +8,6 @@ Dazu verwenden Sie den `TestClient` in einer `with`-Anweisung, eine Verbindung z

 /// note | Hinweis

-Weitere Informationen finden Sie in Starlettes Dokumentation zum [Testen von WebSockets](https://starlette.dev/testclient/#testing-websocket-sessions).
+Weitere Informationen finden Sie in Starlettes Dokumentation zum [Testen von WebSockets](https://www.starlette.dev/testclient/#testing-websocket-sessions).

 ///
@@ -15,7 +15,7 @@ Es gibt jedoch Situationen, in denen Sie möglicherweise direkt auf das `Request

 ## Details zum `Request`-Objekt { #details-about-the-request-object }

-Da **FastAPI** unter der Haube eigentlich **Starlette** ist, mit einer Ebene von mehreren Tools darüber, können Sie Starlettes [`Request`](https://starlette.dev/requests/)-Objekt direkt verwenden, wenn Sie es benötigen.
+Da **FastAPI** unter der Haube eigentlich **Starlette** ist, mit einer Ebene von mehreren Tools darüber, können Sie Starlettes [`Request`](https://www.starlette.dev/requests/)-Objekt direkt verwenden, wenn Sie es benötigen.

 Das bedeutet allerdings auch, dass, wenn Sie Daten direkt vom `Request`-Objekt nehmen (z. B. dessen Body lesen), diese von FastAPI nicht validiert, konvertiert oder dokumentiert werden (mit OpenAPI, für die automatische API-Benutzeroberfläche).

@@ -45,7 +45,7 @@ Auf die gleiche Weise können Sie wie gewohnt jeden anderen Parameter deklariere

 ## `Request`-Dokumentation { #request-documentation }

-Weitere Details zum [`Request`-Objekt auf der offiziellen Starlette-Dokumentationsseite](https://starlette.dev/requests/).
+Weitere Details zum [`Request`-Objekt auf der offiziellen Starlette-Dokumentationsseite](https://www.starlette.dev/requests/).

 /// note | Technische Details

@@ -4,12 +4,12 @@ Sie können [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSoc

 ## `websockets` installieren { #install-websockets }

-Fügen Sie `websockets` (eine Python-Bibliothek, die die Verwendung des „WebSocket“-Protokolls erleichtert) zu Ihrem Projekt hinzu:
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md) erstellen, sie aktivieren und `websockets` installieren (eine Python-Bibliothek, die die Verwendung des „WebSocket“-Protokolls erleichtert):

 <div class="termy">

 ```console
-$ uv add websockets
+$ pip install websockets

 ---> 100%
 ```
@@ -69,7 +69,7 @@ Legen Sie Ihren Code in einer Datei `main.py` ab und führen Sie dann Ihre Anwen
 <div class="termy">

 ```console
-$ uv run fastapi dev
+$ fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -96,7 +96,7 @@ Sie können viele Nachrichten senden (und empfangen):

 Und alle verwenden dieselbe WebSocket-Verbindung.

-## `Depends` und andere verwenden { #using-depends-and-others }
+## Verwendung von `Depends` und anderen { #using-depends-and-others }

 In WebSocket-Endpunkten können Sie Folgendes aus `fastapi` importieren und verwenden:

@@ -111,7 +111,7 @@ Diese funktionieren auf die gleiche Weise wie für andere FastAPI-Endpunkte/*Pfa

 {* ../../docs_src/websockets_/tutorial002_an_py310.py hl[68:69,82] *}

-/// note | Hinweis
+/// info | Info

 Da es sich um einen WebSocket handelt, macht es keinen Sinn, eine `HTTPException` auszulösen, stattdessen lösen wir eine `WebSocketException` aus.

@@ -126,7 +126,7 @@ Führen Sie Ihre Anwendung aus:
 <div class="termy">

 ```console
-$ uv run fastapi dev
+$ fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -182,5 +182,5 @@ Wenn Sie etwas benötigen, das sich leicht in FastAPI integrieren lässt, aber r

 Weitere Informationen zu Optionen finden Sie in der Dokumentation von Starlette:

-* [Die `WebSocket`-Klasse](https://starlette.dev/websockets/).
-* [Klassen-basierte Handhabung von WebSockets](https://starlette.dev/endpoints/#websocketendpoint).
+* [Die `WebSocket`-Klasse](https://www.starlette.dev/websockets/).
+* [Klassen-basierte Handhabung von WebSockets](https://www.starlette.dev/endpoints/#websocketendpoint).
@@ -1,21 +1,20 @@
 # WSGI inkludieren – Flask, Django und andere { #including-wsgi-flask-django-others }

-
 Sie können WSGI-Anwendungen mounten, wie Sie es in [Unteranwendungen – Mounts](sub-applications.md), [Hinter einem Proxy](behind-a-proxy.md) gesehen haben.

 Dazu können Sie die `WSGIMiddleware` verwenden und damit Ihre WSGI-Anwendung wrappen, zum Beispiel Flask, Django usw.

 ## `WSGIMiddleware` verwenden { #using-wsgimiddleware }

-/// note | Hinweis
+/// info | Info

-Dafür muss `a2wsgi` zu Ihrem Projekt hinzugefügt werden, z. B. mit `uv add a2wsgi`.
+Dafür muss `a2wsgi` installiert sein, z. B. mit `pip install a2wsgi`.

 ///

 Sie müssen `WSGIMiddleware` aus `a2wsgi` importieren.

-Wrappen Sie dann die WSGI-App (z. B. Flask) mit der Middleware.
+Wrappen Sie dann die WSGI-Anwendung (z. B. Flask) mit der Middleware.

 Und dann mounten Sie das auf einem Pfad.

@@ -36,7 +36,7 @@ Das Django REST Framework wurde von Tom Christie erstellt. Derselbe Schöpfer vo

 ///

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Eine automatische API-Dokumentationsoberfläche zu haben.

@@ -56,7 +56,7 @@ Diese Entkopplung der Teile und die Tatsache, dass es sich um ein „Mikroframew

 Angesichts der Einfachheit von Flask schien es eine gute Ergänzung zum Erstellen von APIs zu sein. Als Nächstes musste ein „Django REST Framework“ für Flask gefunden werden.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Ein Mikroframework zu sein. Es einfach zu machen, die benötigten Tools und Teile zu kombinieren.

@@ -98,7 +98,7 @@ def read_url():

 Sehen Sie sich die Ähnlichkeiten in `requests.get(...)` und `@app.get(...)` an.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 * Über eine einfache und intuitive API zu verfügen.
 * HTTP-Methodennamen (Operationen) direkt, auf einfache und intuitive Weise zu verwenden.
@@ -118,14 +118,14 @@ Irgendwann wurde Swagger an die Linux Foundation übergeben und in OpenAPI umben

 Aus diesem Grund spricht man bei Version 2.0 häufig von „Swagger“ und ab Version 3 von „OpenAPI“.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Einen offenen Standard für API-Spezifikationen zu übernehmen und zu verwenden, anstelle eines benutzerdefinierten Schemas.

 Und Standard-basierte Tools für die Oberfläche zu integrieren:

 * [Swagger UI](https://github.com/swagger-api/swagger-ui)
-* [ReDoc](https://github.com/Redocly/redoc)
+* [ReDoc](https://github.com/Rebilly/ReDoc)

 Diese beiden wurden ausgewählt, weil sie ziemlich beliebt und stabil sind, aber bei einer schnellen Suche könnten Sie Dutzende alternativer Benutzeroberflächen für OpenAPI finden (welche Sie mit **FastAPI** verwenden können).

@@ -137,7 +137,7 @@ Es gibt mehrere Flask REST Frameworks, aber nachdem ich die Zeit und Arbeit inve

 ### [Marshmallow](https://marshmallow.readthedocs.io/en/stable/) { #marshmallow }

-Eine der von API-Systemen benötigten Hauptfunktionen ist die Daten-„<dfn title="auch genannt: Marshalling, Konvertierung">Serialisierung</dfn>“, welche Daten aus dem Code (Python) entnimmt und in etwas umwandelt, was durch das Netzwerk gesendet werden kann. Beispielsweise das Konvertieren eines Objekts, welches Daten aus einer Datenbank enthält, in ein JSON-Objekt. Konvertieren von `datetime`-Objekten in Strings, usw.
+Eine der von API-Systemen benötigten Hauptfunktionen ist die Daten-<dfn title="auch genannt: Marshalling, Konvertierung">„Serialisierung“</dfn>, welche Daten aus dem Code (Python) entnimmt und in etwas umwandelt, was durch das Netzwerk gesendet werden kann. Beispielsweise das Konvertieren eines Objekts, welches Daten aus einer Datenbank enthält, in ein JSON-Objekt. Konvertieren von `datetime`-Objekten in Strings, usw.

 Eine weitere wichtige Funktion, benötigt von APIs, ist die Datenvalidierung, welche sicherstellt, dass die Daten unter gegebenen Umständen gültig sind. Zum Beispiel, dass ein Feld ein `int` ist und kein zufälliger String. Das ist besonders nützlich für hereinkommende Daten.

@@ -147,7 +147,7 @@ Für diese Funktionen wurde Marshmallow entwickelt. Es ist eine großartige Bibl

 Aber sie wurde erstellt, bevor Typhinweise in Python existierten. Um also ein <dfn title="die Definition, wie Daten geformt sein sollen">Schema</dfn> zu definieren, müssen Sie bestimmte Werkzeuge und Klassen verwenden, die von Marshmallow bereitgestellt werden.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Code zu verwenden, um „Schemas“ zu definieren, welche Datentypen und Validierung automatisch bereitstellen.

@@ -163,13 +163,13 @@ Es verwendet unter der Haube Marshmallow, um die Datenvalidierung durchzuführen

 Es ist ein großartiges Tool und ich habe es auch oft verwendet, bevor ich **FastAPI** hatte.

-/// note | Hinweis
+/// info | Info

 Webargs wurde von denselben Marshmallow-Entwicklern erstellt.

 ///

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Eingehende Requestdaten automatisch zu validieren.

@@ -193,13 +193,13 @@ Aber dann haben wir wieder das Problem einer Mikrosyntax innerhalb eines Python-

 Der Texteditor kann dabei nicht viel helfen. Und wenn wir Parameter oder Marshmallow-Schemas ändern und vergessen, auch den YAML-Docstring zu ändern, wäre das generierte Schema veraltet.

-/// note | Hinweis
+/// info | Info

 APISpec wurde von denselben Marshmallow-Entwicklern erstellt.

 ///

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Den offenen Standard für APIs, OpenAPI, zu unterstützen.

@@ -225,19 +225,19 @@ Die Verwendung führte zur Entwicklung mehrerer Flask-Full-Stack-Generatoren. Di

 Und dieselben Full-Stack-Generatoren bildeten die Basis der [**FastAPI**-Projektgeneratoren](project-generation.md).

-/// note | Hinweis
+/// info | Info

 Flask-apispec wurde von denselben Marshmallow-Entwicklern erstellt.

 ///

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Das OpenAPI-Schema automatisch zu generieren, aus demselben Code, welcher die Serialisierung und Validierung definiert.

 ///

-### [NestJS](https://nestjs.com/) (und [Angular](https://angular.dev/)) { #nestjs-and-angular }
+### [NestJS](https://nestjs.com/) (und [Angular](https://angular.io/)) { #nestjs-and-angular }

 Dies ist nicht einmal Python, NestJS ist ein von Angular inspiriertes JavaScript (TypeScript) NodeJS Framework.

@@ -251,7 +251,7 @@ Da TypeScript-Daten jedoch nach der Kompilierung nach JavaScript nicht erhalten

 Es kann nicht sehr gut mit verschachtelten Modellen umgehen. Wenn es sich beim JSON-Body im Request also um ein JSON-Objekt mit inneren Feldern handelt, die wiederum verschachtelte JSON-Objekte sind, kann er nicht richtig dokumentiert und validiert werden.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Python-Typen zu verwenden, um eine hervorragende Editorunterstützung zu erhalten.

@@ -271,7 +271,7 @@ Hat eindeutig Uvicorn und Starlette inspiriert, welche derzeit in offenen Benchm

 ///

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Einen Weg zu finden, eine hervorragende Performanz zu haben.

@@ -283,11 +283,11 @@ Aus diesem Grund basiert **FastAPI** auf Starlette, da dieses das schnellste ver

 Falcon ist ein weiteres leistungsstarkes Python-Framework. Es ist minimalistisch konzipiert und dient als Grundlage für andere Frameworks wie Hug.

-Es ist so konzipiert, dass es über Funktionen verfügt, welche zwei Parameter empfangen, einen <abbr title="Request - Anfrage: Daten, die der Client zum Server sendet">„Request“</abbr> und eine <abbr title="Response - Antwort: Daten, die der Server zum anfragenden Client zurücksendet">„Response“</abbr>. Dann „lesen“ Sie Teile des Requests und „schreiben“ Teile der Response. Aufgrund dieses Designs ist es nicht möglich, Request-Parameter und Requestbodys mit Standard-Python-Typhinweisen als Funktionsparameter zu deklarieren.
+Es ist so konzipiert, dass es über Funktionen verfügt, welche zwei Parameter empfangen, einen <abbr title="Request - Anfrage: Daten, die der Client zum Server sendet">„Request“</abbr> und eine <abbr title="Response - Antwort: Daten, die der Server zum anfragenden Client zurücksendet">„Response“</abbr>. Dann „lesen“ Sie Teile des Requests und „schreiben“ Teile der Response. Aufgrund dieses Designs ist es nicht möglich, Request-Parameter und -Bodys mit Standard-Python-Typhinweisen als Funktionsparameter zu deklarieren.

 Daher müssen Datenvalidierung, Serialisierung und Dokumentation im Code und nicht automatisch erfolgen. Oder sie müssen als Framework oberhalb von Falcon implementiert werden, so wie Hug. Dieselbe Unterscheidung findet auch in anderen Frameworks statt, die vom Design von Falcon inspiriert sind und ein Requestobjekt und ein Responseobjekt als Parameter haben.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Wege zu finden, eine großartige Performanz zu erzielen.

@@ -313,7 +313,7 @@ Das Dependency Injection System erfordert eine Vorab-Registrierung der Abhängig

 Routen werden an einer einzigen Stelle deklariert, indem Funktionen verwendet werden, die an anderen Stellen deklariert wurden (anstatt Dekoratoren zu verwenden, welche direkt über der Funktion platziert werden können, welche den Endpunkt verarbeitet). Dies ähnelt eher der Vorgehensweise von Django als der Vorgehensweise von Flask (und Starlette). Es trennt im Code Dinge, die relativ eng miteinander gekoppelt sind.

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Zusätzliche Validierungen für Datentypen zu definieren, mithilfe des „Default“-Werts von Modellattributen. Dies verbessert die Editorunterstützung und war zuvor in Pydantic nicht verfügbar.

@@ -335,13 +335,13 @@ Es verfügt über eine interessante, ungewöhnliche Funktion: Mit demselben Fram

 Da es auf dem bisherigen Standard für synchrone Python-Webframeworks (WSGI) basiert, kann es nicht mit Websockets und anderen Dingen umgehen, verfügt aber dennoch über eine hohe Performanz.

-/// note | Hinweis
+/// info | Info

-Hug wurde von Timothy Crosley erstellt, demselben Schöpfer von [`isort`](https://github.com/PyCQA/isort), einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien.
+Hug wurde von Timothy Crosley erstellt, demselben Schöpfer von [`isort`](https://github.com/timothycrosley/isort), einem großartigen Tool zum automatischen Sortieren von Importen in Python-Dateien.

 ///

-/// tip | Ideen, die **FastAPI** inspiriert haben
+/// check | Ideen, die **FastAPI** inspiriert haben

 Hug inspirierte Teile von APIStar und war eines der Tools, die ich am vielversprechendsten fand, neben APIStar.

@@ -351,11 +351,11 @@ Hug inspirierte **FastAPI** dazu, einen `response`-Parameter in Funktionen zu de

 ///

-### [APIStar](https://github.com/encode/apistar) (<= 0.5) { #apistar-0-5 }
+### [APIStar](https://github.com/encode/apistar) (≦ 0.5) { #apistar-0-5 }

 Kurz bevor ich mich entschied, **FastAPI** zu erstellen, fand ich den **APIStar**-Server. Er hatte fast alles, was ich suchte, und ein tolles Design.

-Er war eine der ersten Implementierungen eines Frameworks, die ich je gesehen hatte (vor NestJS und Molten), das Python-Typhinweise zur Deklaration von Parametern und Requests verwendete. Ich habe ihn mehr oder weniger zeitgleich mit Hug gefunden. Aber APIStar nutzte den OpenAPI-Standard.
+Er war eine der ersten Implementierungen eines Frameworks, die ich je gesehen hatte (vor NestJS und Molten), welches Python-Typhinweise zur Deklaration von Parametern und Requests verwendeten. Ich habe ihn mehr oder weniger zeitgleich mit Hug gefunden. Aber APIStar nutzte den OpenAPI-Standard.

 Er verfügte an mehreren Stellen über automatische Datenvalidierung, Datenserialisierung und OpenAPI-Schemagenerierung, basierend auf denselben Typhinweisen.

@@ -375,7 +375,7 @@ Es handelte sich nicht länger um ein API-Webframework, da sich der Entwickler a

 Jetzt handelt es sich bei APIStar um eine Reihe von Tools zur Validierung von OpenAPI-Spezifikationen, nicht um ein Webframework.

-/// note | Hinweis
+/// info | Info

 APIStar wurde von Tom Christie erstellt. Derselbe, welcher Folgendes erstellt hat:

@@ -385,7 +385,7 @@ APIStar wurde von Tom Christie erstellt. Derselbe, welcher Folgendes erstellt ha

 ///

-/// tip | Inspirierte **FastAPI** dazu
+/// check | Inspirierte **FastAPI**

 Zu existieren.

@@ -401,7 +401,7 @@ Ich betrachte **FastAPI** als einen „spirituellen Nachfolger“ von APIStar, w

 ## Verwendet von **FastAPI** { #used-by-fastapi }

-### [Pydantic](https://pydantic.dev/docs/) { #pydantic }
+### [Pydantic](https://docs.pydantic.dev/) { #pydantic }

 Pydantic ist eine Bibliothek zum Definieren von Datenvalidierung, Serialisierung und Dokumentation (unter Verwendung von JSON Schema) basierend auf Python-Typhinweisen.

@@ -409,7 +409,7 @@ Das macht es äußerst intuitiv.

 Es ist vergleichbar mit Marshmallow. Obwohl es in Benchmarks schneller als Marshmallow ist. Und da es auf den gleichen Python-Typhinweisen basiert, ist die Editorunterstützung großartig.

-/// tip | **FastAPI** verwendet es, um
+/// check | **FastAPI** verwendet es, um

 Die gesamte Datenvalidierung, Datenserialisierung und automatische Modelldokumentation (basierend auf JSON Schema) zu erledigen.

@@ -417,7 +417,7 @@ Die gesamte Datenvalidierung, Datenserialisierung und automatische Modelldokumen

 ///

-### [Starlette](https://starlette.dev/) { #starlette }
+### [Starlette](https://www.starlette.dev/) { #starlette }

 Starlette ist ein leichtgewichtiges <dfn title="Der neue Standard für die Erstellung asynchroner Python-Webanwendungen">ASGI</dfn>-Framework/Toolkit, welches sich ideal für die Erstellung hochperformanter asynchroner Dienste eignet.

@@ -433,7 +433,7 @@ Es bietet:
 * CORS, GZip, statische Dateien, Responses streamen.
 * Session- und Cookie-Unterstützung.
 * 100 % Testabdeckung.
-* 100 % typannotierte Codebasis.
+* 100 % Typannotierte Codebasis.
 * Wenige starke Abhängigkeiten.

 Starlette ist derzeit das schnellste getestete Python-Framework. Nur übertroffen von Uvicorn, welches kein Framework, sondern ein Server ist.
@@ -448,11 +448,11 @@ Das ist eines der wichtigsten Dinge, welche **FastAPI** hinzufügt, alles basier

 ASGI ist ein neuer „Standard“, welcher von Mitgliedern des Django-Kernteams entwickelt wird. Es handelt sich immer noch nicht um einen „Python-Standard“ (ein PEP), obwohl sie gerade dabei sind, das zu tun.

-Dennoch wird es bereits von mehreren Tools als „Standard“ verwendet. Das verbessert die Interoperabilität erheblich, da Sie Uvicorn mit jedem anderen ASGI-Server (wie Daphne oder Hypercorn) tauschen oder ASGI-kompatible Tools wie `python-socketio` hinzufügen können.
+Dennoch wird es bereits von mehreren Tools als „Standard“ verwendet. Das verbessert die Interoperabilität erheblich, da Sie Uvicorn mit jeden anderen ASGI-Server (wie Daphne oder Hypercorn) tauschen oder ASGI-kompatible Tools wie `python-socketio` hinzufügen können.

 ///

-/// tip | **FastAPI** verwendet es, um
+/// check | **FastAPI** verwendet es, um

 Alle Kern-Webaspekte zu handhaben. Und fügt Funktionen obenauf.

@@ -462,7 +462,7 @@ Alles, was Sie also mit Starlette machen können, können Sie direkt mit **FastA

 ///

-### [Uvicorn](https://uvicorn.dev) { #uvicorn }
+### [Uvicorn](https://www.uvicorn.dev/) { #uvicorn }

 Uvicorn ist ein blitzschneller ASGI-Server, der auf uvloop und httptools basiert.

@@ -470,7 +470,7 @@ Es handelt sich nicht um ein Webframework, sondern um einen Server. Beispielswei

 Es ist der empfohlene Server für Starlette und **FastAPI**.

-/// tip | **FastAPI** empfiehlt es als
+/// check | **FastAPI** empfiehlt es als

 Hauptwebserver zum Ausführen von **FastAPI**-Anwendungen.

@@ -44,7 +44,7 @@ Wenn Ihre Anwendung (irgendwie) nicht mit etwas anderem kommunizieren und auf de

 ---

-Wenn Sie sich unsicher sind, verwenden Sie normales `def`.
+Wenn Sie sich unsicher sind, verwenden Sie einfach `def`.

 ---

@@ -70,7 +70,7 @@ Asynchroner Code bedeutet lediglich, dass die Sprache 💬 eine Möglichkeit hat

 Während der Zeit, die „Langsam-Datei“ 📝 benötigt, kann das System also andere Aufgaben erledigen.

-Dann kommt der Computer / das Programm 🤖 bei jeder Gelegenheit zurück, weil es entweder wieder wartet oder wann immer es 🤖 die ganze Arbeit erledigt hat, die zu diesem Zeitpunkt zu tun war. Und es 🤖 wird nachschauen, ob eine der Aufgaben, auf die es gewartet hat, bereits fertig ist, und tun, was es zu tun hatte.
+Dann kommt der Computer / das Programm 🤖 bei jeder Gelegenheit zurück, weil es entweder wieder wartet oder wann immer es 🤖 die ganze Arbeit erledigt hat, die zu diesem Zeitpunkt zu tun war. Und es 🤖 wird nachschauen, ob eine der Aufgaben, auf die es gewartet hat, fertig ist.

 Dann nimmt es 🤖 die erste erledigte Aufgabe (sagen wir, unsere „Langsam-Datei“ 📝) und bearbeitet sie weiter.

@@ -139,7 +139,7 @@ Sie und Ihr Schwarm essen die Burger und haben eine schöne Zeit. ✨

 <img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">

-/// note | Hinweis
+/// info | Info

 Die wunderschönen Illustrationen stammen von [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨

@@ -205,7 +205,7 @@ Sie essen sie und sind fertig. ⏹

 Es wurde nicht viel geredet oder geflirtet, da die meiste Zeit mit Warten 🕙 vor der Theke verbracht wurde. 😞

-/// note | Hinweis
+/// info | Info

 Die wunderschönen Illustrationen stammen von [Ketrina Thompson](https://www.instagram.com/ketrinadrawsalot). 🎨

@@ -361,7 +361,7 @@ Wenn Sie mit **FastAPI** arbeiten, müssen Sie sich darüber keine Sorgen machen

 Wenn Sie jedoch `async` / `await` ohne FastAPI verwenden möchten, können Sie dies auch tun.

-### Ihren eigenen asynchronen Code schreiben { #write-your-own-async-code }
+### Schreiben Sie Ihren eigenen asynchronen Code { #write-your-own-async-code }

 Starlette (und **FastAPI**) basieren auf [AnyIO](https://anyio.readthedocs.io/en/stable/), was bedeutet, dass es sowohl kompatibel mit der Python-Standardbibliothek [asyncio](https://docs.python.org/3/library/asyncio-task.html) als auch mit [Trio](https://trio.readthedocs.io/en/stable/) ist.

@@ -16,7 +16,7 @@ FastAPI Cloud ist der Hauptsponsor und Finanzierungsgeber für die *FastAPI and

 ## Cloudanbieter – Sponsoren { #cloud-providers-sponsors }

-Einige andere Cloudanbieter ✨ [**sponsern FastAPI**](https://github.com/sponsors/tiangolo) ✨ ebenfalls. 🙇
+Einige andere Cloudanbieter ✨ [**sponsern FastAPI**](../help-fastapi.md#sponsor-the-author) ✨ ebenfalls. 🙇

 Sie könnten diese ebenfalls in Betracht ziehen, deren Anleitungen folgen und ihre Dienste ausprobieren:

@@ -1,6 +1,6 @@
 # Deployment-Konzepte { #deployments-concepts }

-Beim Deployment einer **FastAPI**-Anwendung, oder eigentlich jeder Art von Web-API, gibt es mehrere Konzepte, die Sie wahrscheinlich interessieren, und mithilfe derer Sie die **am besten geeignete** Methode zum **Deployment Ihrer Anwendung** finden können.
+Bei dem Deployment – der Bereitstellung – einer **FastAPI**-Anwendung, oder eigentlich jeder Art von Web-API, gibt es mehrere Konzepte, die Sie wahrscheinlich interessieren, und mithilfe der Sie die **am besten geeignete** Methode zum **Deployment Ihrer Anwendung** finden können.

 Einige wichtige Konzepte sind:

@@ -59,7 +59,7 @@ Die nächsten zu berücksichtigenden Konzepte drehen sich dann um das Programm,

 Wir werden viel über den laufenden „**Prozess**“ sprechen, daher ist es nützlich, Klarheit darüber zu haben, was das bedeutet und was der Unterschied zum Wort „**Programm**“ ist.

-### Was ein Programm ist { #what-is-a-program }
+### Was ist ein Programm { #what-is-a-program }

 Das Wort **Programm** wird häufig zur Beschreibung vieler Dinge verwendet:

@@ -67,14 +67,14 @@ Das Wort **Programm** wird häufig zur Beschreibung vieler Dinge verwendet:
 * Die **Datei**, die vom Betriebssystem **ausgeführt** werden kann, zum Beispiel: `python`, `python.exe` oder `uvicorn`.
 * Ein bestimmtes Programm, während es auf dem Betriebssystem **läuft**, die CPU nutzt und Dinge im Arbeitsspeicher ablegt. Dies wird auch als **Prozess** bezeichnet.

-### Was ein Prozess ist { #what-is-a-process }
+### Was ist ein Prozess { #what-is-a-process }

 Das Wort **Prozess** wird normalerweise spezifischer verwendet und bezieht sich nur auf das, was im Betriebssystem ausgeführt wird (wie im letzten Punkt oben):

 * Ein bestimmtes Programm, während es auf dem Betriebssystem **ausgeführt** wird.
    * Dies bezieht sich weder auf die Datei noch auf den Code, sondern **speziell** auf das, was vom Betriebssystem **ausgeführt** und verwaltet wird.
-* Jedes Programm, jeder Code **kann nur dann Dinge tun**, wenn er **ausgeführt** wird. Also dann, wenn ein **Prozess läuft**.
-* Der Prozess kann von Ihnen oder vom Betriebssystem **terminiert** („beendet“, „gekillt“) werden. An diesem Punkt hört er auf zu laufen/ausgeführt zu werden und kann **keine Dinge mehr tun**.
+* Jedes Programm, jeder Code **kann nur dann Dinge tun**, wenn er **ausgeführt** wird, wenn also ein **Prozess läuft**.
+* Der Prozess kann von Ihnen oder vom Betriebssystem **terminiert** („beendet“, „gekillt“) werden. An diesem Punkt hört es auf zu laufen/ausgeführt zu werden und kann **keine Dinge mehr tun**.
 * Hinter jeder Anwendung, die Sie auf Ihrem Computer ausführen, steckt ein Prozess, jedes laufende Programm, jedes Fenster usw. Und normalerweise laufen viele Prozesse **gleichzeitig**, während ein Computer eingeschaltet ist.
 * Es können **mehrere Prozesse** desselben **Programms** gleichzeitig ausgeführt werden.

@@ -117,7 +117,7 @@ Einige Beispiele für Tools, die diese Aufgabe übernehmen können, sind:
 * Docker
 * Kubernetes
 * Docker Compose
-* Docker im Swarm-Modus
+* Docker im Schwarm-Modus
 * Systemd
 * Supervisor
 * Es wird intern von einem Cloudanbieter im Rahmen seiner Dienste verwaltet
@@ -137,7 +137,7 @@ Und wir als Entwickler verbessern den Code ständig, wenn wir diese Bugs finden

 ### Kleine Fehler automatisch handhaben { #small-errors-automatically-handled }

-Wenn beim Erstellen von Web-APIs mit FastAPI ein Fehler in unserem Code auftritt, wird FastAPI ihn normalerweise auf den einzelnen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> beschränken, der den Fehler ausgelöst hat. 🛡
+Wenn beim Erstellen von Web-APIs mit FastAPI ein Fehler in unserem Code auftritt, wird FastAPI ihn normalerweise dem einzelnen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> zurückgeben, der den Fehler ausgelöst hat. 🛡

 Der Client erhält für diesen Request einen **500 Internal Server Error**, aber die Anwendung arbeitet bei den nächsten Requests weiter, anstatt einfach komplett abzustürzen.

@@ -170,7 +170,7 @@ Dies könnte zum Beispiel erledigt werden durch:
 * Docker
 * Kubernetes
 * Docker Compose
-* Docker im Swarm-Modus
+* Docker im Schwarm-Modus
 * Systemd
 * Supervisor
 * Intern von einem Cloudanbieter im Rahmen seiner Dienste
@@ -178,7 +178,7 @@ Dies könnte zum Beispiel erledigt werden durch:

 ## Replikation – Prozesse und Arbeitsspeicher { #replication-processes-and-memory }

-Wenn Sie eine FastAPI-Anwendung verwenden und ein Serverprogramm wie den `fastapi`-Befehl, der Uvicorn ausführt, kann die Ausführung in **einem Prozess** mehrere Clients gleichzeitig versorgen.
+Wenn Sie eine FastAPI-Anwendung verwenden und ein Serverprogramm wie den `fastapi`-Befehl, der Uvicorn ausführt, kann **ein einzelner Prozess** an mehrere Clients gleichzeitig ausliefern.

 In vielen Fällen möchten Sie jedoch mehrere Workerprozesse gleichzeitig ausführen.

@@ -200,7 +200,7 @@ Um also **mehrere Prozesse** gleichzeitig zu haben, muss es einen **einzelnen Pr

 Wenn das Programm nun Dinge in den Arbeitsspeicher lädt, zum Beispiel ein Modell für maschinelles Lernen in einer Variablen oder den Inhalt einer großen Datei in einer Variablen, verbraucht das alles **einen Teil des Arbeitsspeichers (RAM – Random Access Memory)** des Servers.

-Und mehrere Prozesse **teilen sich normalerweise keinen Speicher**. Das bedeutet, dass jeder laufende Prozess seine eigenen Dinge, eigenen Variablen und eigenen Speicher hat. Und wenn Sie in Ihrem Code viel Speicher verbrauchen, verbraucht **jeder Prozess** die gleiche Menge Speicher.
+Und mehrere Prozesse teilen sich normalerweise keinen Speicher. Das bedeutet, dass jeder laufende Prozess seine eigenen Dinge, eigenen Variablen und eigenen Speicher hat. Und wenn Sie in Ihrem Code viel Speicher verbrauchen, verbraucht **jeder Prozess** die gleiche Menge Speicher.

 ### Serverspeicher { #server-memory }

@@ -36,7 +36,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]

 Container (hauptsächlich Linux-Container) sind eine sehr **leichtgewichtige** Möglichkeit, Anwendungen einschließlich aller ihrer Abhängigkeiten und erforderlichen Dateien zu verpacken und sie gleichzeitig von anderen Containern (anderen Anwendungen oder Komponenten) im selben System isoliert zu halten.

-Linux-Container werden mit demselben Linux-Kernel des Hosts (Maschine, virtueller Maschine, Cloud-Server usw.) ausgeführt. Das bedeutet einfach, dass sie sehr leichtgewichtig sind (im Vergleich zu vollständigen virtuellen Maschinen, die ein gesamtes Betriebssystem emulieren).
+Linux-Container werden mit demselben Linux-Kernel des Hosts (Maschine, virtuellen Maschine, Cloud-Servers, usw.) ausgeführt. Das bedeutet einfach, dass sie sehr leichtgewichtig sind (im Vergleich zu vollständigen virtuellen Maschinen, die ein gesamtes Betriebssystem emulieren).

 Auf diese Weise verbrauchen Container **wenig Ressourcen**, eine Menge vergleichbar mit der direkten Ausführung der Prozesse (eine virtuelle Maschine würde viel mehr verbrauchen).

@@ -46,7 +46,7 @@ Container verfügen außerdem über ihre eigenen **isoliert** laufenden Prozesse

 Ein **Container** wird von einem **Containerimage** ausgeführt.

-Ein Containerimage ist eine **statische** Version aller Dateien, Umgebungsvariablen und des Standardbefehls/-programms, die in einem Container vorhanden sein sollten. **Statisch** bedeutet hier, dass das Container-**Image** nicht läuft, nicht ausgeführt wird, sondern nur die gepackten Dateien und Metadaten enthält.
+Ein Containerimage ist eine **statische** Version aller Dateien, Umgebungsvariablen und des Standardbefehls/-programms, welche in einem Container vorhanden sein sollten. **Statisch** bedeutet hier, dass das Container-**Image** nicht läuft, nicht ausgeführt wird, sondern nur die gepackten Dateien und Metadaten enthält.

 Im Gegensatz zu einem „**Containerimage**“, bei dem es sich um den gespeicherten statischen Inhalt handelt, bezieht sich ein „**Container**“ normalerweise auf die laufende Instanz, das Ding, das **ausgeführt** wird.

@@ -89,7 +89,7 @@ Ein Container läuft, solange der **Hauptprozess** (Befehl oder Programm) läuft

 Ein Container hat normalerweise einen **einzelnen Prozess**, aber es ist auch möglich, Unterprozesse vom Hauptprozess aus zu starten, und auf diese Weise haben Sie **mehrere Prozesse** im selben Container.

-Es ist jedoch nicht möglich, einen laufenden Container ohne **mindestens einen laufenden Prozess** zu haben. Wenn der Hauptprozess stoppt, stoppt der Container.
+Es ist jedoch nicht möglich, einen laufenden Container, ohne **mindestens einen laufenden Prozess** zu haben. Wenn der Hauptprozess stoppt, stoppt der Container.

 ## Ein Docker-Image für FastAPI erstellen { #build-a-docker-image-for-fastapi }

@@ -105,32 +105,36 @@ Das ist, was Sie in **den meisten Fällen** tun möchten, zum Beispiel:

 ### Paketanforderungen { #package-requirements }

-Wenn Sie Ihr Projekt mit `uv` verwalten, werden dessen direkte Abhängigkeiten in `pyproject.toml` deklariert und die exakt aufgelösten Versionen in `uv.lock` gespeichert.
+Normalerweise befinden sich die **Paketanforderungen** für Ihre Anwendung in einer Datei.

-Sie können die Packages, die Ihre Anwendung benötigt, hinzufügen mit:
+Dies hängt hauptsächlich von dem Tool ab, mit dem Sie diese Anforderungen **installieren**.
+
+Die gebräuchlichste Methode besteht darin, eine Datei `requirements.txt` mit den Namen der Packages und deren Versionen zu erstellen, eine pro Zeile.
+
+Sie würden natürlich die gleichen Ideen verwenden, die Sie in [Über FastAPI-Versionen](versions.md) gelesen haben, um die Versionsbereiche festzulegen.
+
+Ihre `requirements.txt` könnte beispielsweise so aussehen:
+
+```
+fastapi[standard]>=0.113.0,<0.114.0
+pydantic>=2.7.0,<3.0.0
+```
+
+Und normalerweise würden Sie diese Paketabhängigkeiten mit `pip` installieren, zum Beispiel:

 <div class="termy">

 ```console
-$ uv add "fastapi[standard]" pydantic
+$ pip install -r requirements.txt
 ---> 100%
+Successfully installed fastapi pydantic
 ```

 </div>

-/// note | Hinweis
+/// info | Info

-Das Dockerfile unten verwendet `pip` innerhalb des Containers. Sie können die gelockten Abhängigkeiten aus Ihrem uv-Projekt in das erwartete Format `requirements.txt` exportieren:
-
-<div class="termy">
-
-```console
-$ uv export --format requirements-txt --no-dev --no-emit-project --output-file requirements.txt
-```
-
-</div>
-
-Die generierte `requirements.txt` ist ein Export für den Container-Build. Verwalten Sie Abhängigkeiten weiterhin mit `uv add` und generieren Sie sie neu, wenn sich `uv.lock` ändert.
+Es gibt andere Formate und Tools zum Definieren und Installieren von Paketabhängigkeiten.

 ///

@@ -180,19 +184,19 @@ COPY ./app /code/app
 CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 ```

-1. Beginnen Sie mit dem offiziellen Python-Basisimage.
+1. Beginne mit dem offiziellen Python-Basisimage.

-2. Setzen Sie das aktuelle Arbeitsverzeichnis auf `/code`.
+2. Setze das aktuelle Arbeitsverzeichnis auf `/code`.

    Hier platzieren wir die Datei `requirements.txt` und das Verzeichnis `app`.

-3. Kopieren Sie die Datei mit den Paketanforderungen in das Verzeichnis `/code`.
+3. Kopiere die Datei mit den Paketanforderungen in das Verzeichnis `/code`.

    Kopieren Sie zuerst **nur** die Datei mit den Anforderungen, nicht den Rest des Codes.

    Da sich diese Datei **nicht oft ändert**, erkennt Docker das und verwendet den **Cache** für diesen Schritt, wodurch der Cache auch für den nächsten Schritt aktiviert wird.

-4. Installieren Sie die Paketabhängigkeiten aus der Anforderungsdatei.
+4. Installiere die Paketabhängigkeiten aus der Anforderungsdatei.

    Die Option `--no-cache-dir` weist `pip` an, die heruntergeladenen Pakete nicht lokal zu speichern, da dies nur benötigt wird, sollte `pip` erneut ausgeführt werden, um dieselben Pakete zu installieren, aber das ist beim Arbeiten mit Containern nicht der Fall.

@@ -208,13 +212,13 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]

    Durch die Verwendung des Caches in diesem Schritt **sparen** Sie viel **Zeit**, wenn Sie das Image während der Entwicklung immer wieder erstellen, anstatt **jedes Mal** alle Abhängigkeiten **herunterzuladen und zu installieren**.

-5. Kopieren Sie das Verzeichnis `./app` in das Verzeichnis `/code`.
+5. Kopiere das Verzeichnis `./app` in das Verzeichnis `/code`.

    Da hier der gesamte Code enthalten ist, der sich **am häufigsten ändert**, wird der Docker-**Cache** nicht ohne weiteres für diesen oder andere **folgende Schritte** verwendet.

    Daher ist es wichtig, dies **nahe dem Ende** des `Dockerfile`s zu platzieren, um die Erstellungszeiten des Containerimages zu optimieren.

-6. Legen Sie den **Befehl** fest, um `fastapi run` zu nutzen, welches Uvicorn darunter verwendet.
+6. Lege den **Befehl** fest, um `fastapi run` zu nutzen, welches Uvicorn darunter verwendet.

    `CMD` nimmt eine Liste von Zeichenfolgen entgegen. Jede dieser Zeichenfolgen entspricht dem, was Sie durch Leerzeichen getrennt in die Befehlszeile eingeben würden.

@@ -330,7 +334,7 @@ $ docker build -t myimage .

 Beachten Sie das `.` am Ende, es entspricht `./` und teilt Docker mit, welches Verzeichnis zum Erstellen des Containerimages verwendet werden soll.

-In diesem Case handelt es sich um dasselbe aktuelle Verzeichnis (`.`).
+In diesem Fall handelt es sich um dasselbe aktuelle Verzeichnis (`.`).

 ///

@@ -368,7 +372,7 @@ Sie sehen die automatische interaktive API-Dokumentation (bereitgestellt von [Sw

 Sie können auch auf [http://192.168.99.100/redoc](http://192.168.99.100/redoc) oder [http://127.0.0.1/redoc](http://127.0.0.1/redoc) gehen (oder ähnlich, unter Verwendung Ihres Docker-Hosts).

-Sie sehen die alternative automatische Dokumentation (bereitgestellt von [ReDoc](https://github.com/Redocly/redoc)):
+Sie sehen die alternative automatische Dokumentation (bereitgestellt von [ReDoc](https://github.com/Rebilly/ReDoc)):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -401,7 +405,7 @@ COPY ./main.py /code/
 CMD ["fastapi", "run", "main.py", "--port", "80"]
 ```

-1. Kopieren Sie die Datei `main.py` direkt in das Verzeichnis `/code` (ohne ein Verzeichnis `./app`).
+1. Kopiere die Datei `main.py` direkt in das Verzeichnis `/code` (ohne ein Verzeichnis `./app`).

 2. Verwenden Sie `fastapi run`, um Ihre Anwendung in der einzelnen Datei `main.py` bereitzustellen.

@@ -436,7 +440,7 @@ Traefik verfügt über Integrationen mit Docker, Kubernetes und anderen, sodass

 ///

-Alternativ könnte HTTPS von einem Cloudanbieter als einer seiner Dienste gehandhabt werden (während die Anwendung weiterhin in einem Container ausgeführt wird).
+Alternativ könnte HTTPS von einem Cloud-Anbieter als einer seiner Dienste gehandhabt werden (während die Anwendung weiterhin in einem Container ausgeführt wird).

 ## Beim Hochfahren ausführen und Neustarts { #running-on-startup-and-restarts }

@@ -484,7 +488,7 @@ Und normalerweise wäre dieser **Load Balancer** in der Lage, Requests zu verarb

 In einem solchen Szenario möchten Sie wahrscheinlich **einen einzelnen (Uvicorn-)Prozess pro Container** haben, da Sie die Replikation bereits auf Cluster-Ebene durchführen würden.

-In diesem Fall möchten Sie also **nicht** mehrere Worker im Container haben, z. B. mit der `--workers`-Befehlszeilenoption. Sie möchten nur einen **einzelnen Uvicorn-Prozess** pro Container haben (wahrscheinlich aber mehrere Container).
+In diesem Fall möchten Sie also **nicht** mehrere Worker im Container haben, z. B. mit der `--workers` Befehlszeilenoption. Sie möchten nur einen **einzelnen Uvicorn-Prozess** pro Container haben (wahrscheinlich aber mehrere Container).

 Ein weiterer Prozessmanager im Container (wie es bei mehreren Workern der Fall wäre) würde nur **unnötige Komplexität** hinzufügen, um welche Sie sich höchstwahrscheinlich bereits mit Ihrem Clustersystem kümmern.

@@ -492,7 +496,7 @@ Ein weiterer Prozessmanager im Container (wie es bei mehreren Workern der Fall w

 Natürlich gibt es **Sonderfälle**, in denen Sie **einen Container** mit mehreren **Uvicorn-Workerprozessen** haben möchten.

-In diesen Fällen können Sie die `--workers`-Befehlszeilenoption verwenden, um die Anzahl der zu startenden Worker festzulegen:
+In diesen Fällen können Sie die `--workers` Befehlszeilenoption verwenden, um die Anzahl der zu startenden Worker festzulegen:

 ```{ .dockerfile .annotate }
 FROM python:3.14
@@ -509,7 +513,7 @@ COPY ./app /code/app
 CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
 ```

-1. Hier verwenden wir die `--workers`-Befehlszeilenoption, um die Anzahl der Worker auf 4 festzulegen.
+1. Hier verwenden wir die `--workers` Befehlszeilenoption, um die Anzahl der Worker auf 4 festzulegen.

 Hier sind einige Beispiele, wann das sinnvoll sein könnte:

@@ -552,7 +556,7 @@ Wenn Sie Container (z. B. Docker, Kubernetes) verwenden, können Sie hauptsächl

 Wenn Sie **mehrere Container** haben, von denen wahrscheinlich jeder einen **einzelnen Prozess** ausführt (z. B. in einem **Kubernetes**-Cluster), dann möchten Sie wahrscheinlich einen **separaten Container** haben, welcher die Arbeit der **Vorab-Schritte** in einem einzelnen Container, mit einem einzelnen Prozess ausführt, **bevor** die replizierten Workercontainer ausgeführt werden.

-/// note | Hinweis
+/// info | Info

 Wenn Sie Kubernetes verwenden, wäre dies wahrscheinlich ein [Init-Container](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/).

@@ -572,7 +576,7 @@ Sie sollten wahrscheinlich **nicht** dieses Basis-Docker-Image (oder ein anderes

 Wenn Sie **Kubernetes** (oder andere) verwenden und bereits **Replikation** auf Cluster-Ebene mit mehreren **Containern** eingerichtet haben. In diesen Fällen ist es besser, **ein Image von Grund auf neu zu erstellen**, wie oben beschrieben: [Ein Docker-Image für FastAPI erstellen](#build-a-docker-image-for-fastapi).

-Und wenn Sie mehrere Worker benötigen, können Sie einfach die `--workers`-Befehlszeilenoption verwenden.
+Und wenn Sie mehrere Worker benötigen, können Sie einfach die `--workers` Befehlszeilenoption verwenden.

 /// note | Technische Details

@@ -1,11 +1,31 @@
 # FastAPI Cloud { #fastapi-cloud }

-Sie können Ihre FastAPI-App in der [FastAPI Cloud](https://fastapicloud.com) mit **einem einzigen Befehl** deployen. 🚀
+Sie können Ihre FastAPI-App in der [FastAPI Cloud](https://fastapicloud.com) mit **einem einzigen Befehl** deployen – tragen Sie sich in die Warteliste ein, falls noch nicht geschehen. 🚀
+
+## Anmelden { #login }
+
+Stellen Sie sicher, dass Sie bereits ein **FastAPI-Cloud-Konto** haben (wir haben Sie von der Warteliste eingeladen 😉).
+
+Melden Sie sich dann an:

 <div class="termy">

 ```console
-$ uv run fastapi deploy
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+## Deployen { #deploy }
+
+Stellen Sie Ihre App jetzt mit **einem einzigen Befehl** bereit:
+
+<div class="termy">
+
+```console
+$ fastapi deploy

 Deploying to FastAPI Cloud...

@@ -16,8 +36,6 @@ Deploying to FastAPI Cloud...

 </div>

-Das CLI erkennt Ihre FastAPI-App automatisch und deployt sie in die Cloud. Wenn Sie nicht angemeldet sind, öffnet sich Ihr Browser, um den Authentifizierungsprozess abzuschließen.
-
 Das war’s! Jetzt können Sie Ihre App unter dieser URL aufrufen. ✨

 ## Über FastAPI Cloud { #about-fastapi-cloud }
@@ -44,4 +62,4 @@ Folgen Sie den Anleitungen Ihres Cloudanbieters, um dort FastAPI-Apps zu deploye

 ## Auf den eigenen Server deployen { #deploy-your-own-server }

-Ich werde Ihnen später in diesem **Deployment**-Leitfaden auch alle Details zeigen, sodass Sie verstehen, was passiert, was geschehen muss und wie Sie FastAPI-Apps selbst deployen können, auch auf Ihre eigenen Server. 🤓
+Ich werde Ihnen später in diesem **Deployment-Leitfaden** auch alle Details zeigen, sodass Sie verstehen, was passiert, was geschehen muss und wie Sie FastAPI-Apps selbst deployen können, auch auf Ihre eigenen Server. 🤓
@@ -21,10 +21,10 @@ Aus **Sicht des Entwicklers** sollten Sie beim Nachdenken über HTTPS Folgendes
    * Und dann müssen sie vom Dritten **erneuert**, **erneut erworben** werden.
 * Die Verschlüsselung der Verbindung erfolgt auf **TCP-Ebene**.
    * Das ist eine Schicht **unter HTTP**.
-    * Die **Zertifikats- und Verschlüsselungs**-Handhabung erfolgt also **vor HTTP**.
+    * Die Handhabung von **Zertifikaten und Verschlüsselung** erfolgt also **vor HTTP**.
 * **TCP weiß nichts über „Domains“**. Nur über IP-Adressen.
    * Die Informationen über die angeforderte **spezifische Domain** befinden sich in den **HTTP-Daten**.
-* Die **HTTPS-Zertifikate** „zertifizieren“ eine **bestimmte Domain**, aber das Protokoll und die Verschlüsselung erfolgen auf TCP-Ebene, **bevor bekannt ist**, um welche Domain es sich handelt.
+* Die **HTTPS-Zertifikate** „zertifizieren“ eine **bestimmte Domain**, aber das Protokoll und die Verschlüsselung erfolgen auf TCP-Ebene, **ohne zu wissen**, um welche Domain es sich handelt.
 * **Standardmäßig** bedeutet das, dass Sie nur **ein HTTPS-Zertifikat pro IP-Adresse** haben können.
    * Ganz gleich, wie groß Ihr Server ist oder wie klein die einzelnen Anwendungen darauf sind.
    * Hierfür gibt es jedoch eine **Lösung**.
@@ -194,7 +194,7 @@ Dieser ganze Erneuerungsprozess, während die Anwendung weiterhin bereitgestellt

 Wenn Sie einen Proxy zur Verarbeitung von HTTPS verwenden, weiß Ihr **Anwendungsserver** (z. B. Uvicorn über das FastAPI CLI) nichts über den HTTPS-Prozess, er kommuniziert per einfachem HTTP mit dem **TLS-Terminierungsproxy**.

-Dieser **Proxy** würde normalerweise unmittelbar vor dem Übermitteln des Requests an den **Anwendungsserver** einige HTTP-Header dynamisch setzen, um dem Anwendungsserver mitzuteilen, dass der Request vom Proxy **weitergeleitet** wird.
+Dieser **Proxy** würde normalerweise unmittelbar vor dem Übermitteln der Anfrage an den **Anwendungsserver** einige HTTP-Header dynamisch setzen, um dem Anwendungsserver mitzuteilen, dass der Request vom Proxy **weitergeleitet** wird.

 /// note | Technische Details

@@ -52,10 +52,11 @@ Das Wichtigste, was Sie benötigen, um eine **FastAPI**-Anwendung (oder eine and

 Es gibt mehrere Alternativen, einschließlich:

-* [Uvicorn](https://uvicorn.dev): ein hochperformanter ASGI-Server.
+* [Uvicorn](https://www.uvicorn.dev/): ein hochperformanter ASGI-Server.
 * [Hypercorn](https://hypercorn.readthedocs.io/): ein ASGI-Server, der unter anderem kompatibel mit HTTP/2 und Trio ist.
 * [Daphne](https://github.com/django/daphne): der für Django Channels entwickelte ASGI-Server.
-* [Granian](https://github.com/emmett-framework/granian): Ein Rust-HTTP-Server für Python-Anwendungen.
+* [Granian](https://github.com/emmett-framework/granian): Ein Rust HTTP-Server für Python-Anwendungen.
+* [NGINX Unit](https://unit.nginx.org/howto/fastapi/): NGINX Unit ist eine leichte und vielseitige Laufzeitumgebung für Webanwendungen.

 ## Servermaschine und Serverprogramm { #server-machine-and-server-program }

@@ -65,22 +66,22 @@ Das Wort „**Server**“ wird häufig verwendet, um sowohl den entfernten/Cloud

 Denken Sie einfach daran, dass sich „Server“ im Allgemeinen auf eines dieser beiden Dinge beziehen kann.

-Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entferntem Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen.
+Wenn man sich auf die entfernte Maschine bezieht, wird sie üblicherweise als **Server**, aber auch als **Maschine**, **VM** (virtuelle Maschine) oder **Knoten** bezeichnet. Diese Begriffe beziehen sich auf irgendeine Art von entfernten Rechner, normalerweise unter Linux, auf dem Sie Programme ausführen.

 ## Das Serverprogramm installieren { #install-the-server-program }

-Wenn Sie FastAPI installieren, wird es mit einem Produktionsserver, Uvicorn, geliefert, und Sie können ihn mit dem `fastapi run`-Befehl starten.
+Wenn Sie FastAPI installieren, wird es mit einem Produktionsserver, Uvicorn, geliefert, und Sie können ihn mit dem `fastapi run` Befehl starten.

 Aber Sie können auch ein ASGI-Serverprogramm manuell installieren.

-Fügen Sie die Serveranwendung Ihrem Projekt hinzu.
+Stellen Sie sicher, dass Sie eine [virtuelle Umgebung](../virtual-environments.md) erstellen, sie aktivieren und dann die Serveranwendung installieren.

 Zum Beispiel, um Uvicorn zu installieren:

 <div class="termy">

 ```console
-$ uv add "uvicorn[standard]"
+$ pip install "uvicorn[standard]"

 ---> 100%
 ```
@@ -95,7 +96,7 @@ Durch das Hinzufügen von `standard` installiert und verwendet Uvicorn einige em

 Dazu gehört `uvloop`, der hochperformante Drop-in-Ersatz für `asyncio`, der den großen Nebenläufigkeits-Leistungsschub bietet.

-Wenn Sie FastAPI mit etwas wie `uv add "fastapi[standard]"` hinzufügen, erhalten Sie auch bereits `uvicorn[standard]`.
+Wenn Sie FastAPI mit etwas wie `pip install "fastapi[standard]"` installieren, erhalten Sie auch `uvicorn[standard]`.

 ///

@@ -106,7 +107,7 @@ Wenn Sie einen ASGI-Server manuell installiert haben, müssen Sie normalerweise
 <div class="termy">

 ```console
-$ uv run uvicorn main:app --host 0.0.0.0 --port 80
+$ uvicorn main:app --host 0.0.0.0 --port 80

 <span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
 ```
@@ -17,7 +17,7 @@ Wie Sie im vorherigen Kapitel über [Deployment-Konzepte](concepts.md) gesehen h

 Hier zeige ich Ihnen, wie Sie **Uvicorn** mit **Workerprozessen** verwenden, indem Sie den `fastapi`-Befehl oder den `uvicorn`-Befehl direkt verwenden.

-/// note | Hinweis
+/// info | Info

 Wenn Sie Container verwenden, beispielsweise mit Docker oder Kubernetes, erzähle ich Ihnen mehr darüber im nächsten Kapitel: [FastAPI in Containern – Docker](docker.md).

@@ -86,7 +86,7 @@ Wenn Sie den `uvicorn`-Befehl direkt verwenden möchten:
 <div class="termy">

 ```console
-$ uv run uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
+$ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
 <font color="#A6E22E">INFO</font>:     Uvicorn running on <b>http://0.0.0.0:8080</b> (Press CTRL+C to quit)
 <font color="#A6E22E">INFO</font>:     Started parent process [<font color="#A1EFE4"><b>27365</b></font>]
 <font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27368</font>]
@@ -1,6 +1,6 @@
 # Editor-Unterstützung { #editor-support }

-Die offizielle [FastAPI-Erweiterung](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) verbessert Ihren FastAPI-Entwicklungsworkflow mit *Pfadoperation*-Erkennung und -Navigation sowie FastAPI-Cloud-Deployment und Live-Logstreaming.
+Die offizielle [FastAPI-Erweiterung](https://marketplace.visualstudio.com/items?itemName=FastAPILabs.fastapi-vscode) verbessert Ihren FastAPI-Entwicklungsworkflow mit Pfadoperation-Erkennung und -Navigation sowie FastAPI-Cloud-Deployment und Live-Logstreaming.

 Weitere Details zur Erweiterung finden Sie im README im [GitHub-Repository](https://github.com/fastapi/fastapi-vscode).

@@ -14,10 +14,10 @@ Standardmäßig erkennt die Erweiterung FastAPI-Anwendungen in Ihrem Workspace a

 ## Funktionen { #features }

- **Pfadoperation-Explorer** – Eine Baumansicht in der Seitenleiste aller <dfn title="Routen, Endpunkte">*Pfadoperationen*</dfn> in Ihrer Anwendung. Klicken Sie, um zu einer beliebigen Route- oder Router-Definition zu springen.
- **Routensuche** – Suchen Sie nach Pfad, Methode oder Namen mit <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd> (unter macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd>).
- **CodeLens-Navigation** – Anklickbare Links oberhalb von Testclient-Aufrufen (z. B. `client.get('/items')`), die zur passenden *Pfadoperation* springen und so eine schnelle Navigation zwischen Tests und Implementierung ermöglichen.
- **Zu FastAPI Cloud deployen** – Deployment Ihrer App mit einem Klick auf [FastAPI Cloud](https://fastapicloud.com/).
- **Anwendungslogs streamen** – Echtzeit-Logstreaming Ihrer auf FastAPI Cloud deployten Anwendung mit Loglevel-Filterung und Textsuche.
+- Pfadoperation-Explorer – Eine Baumansicht in der Seitenleiste aller <dfn title="Routen, Endpunkte">*Pfadoperationen*</dfn> in Ihrer Anwendung. Klicken Sie, um zu einer beliebigen Route- oder Router-Definition zu springen.
+- Routensuche – Suchen Sie nach Pfad, Methode oder Namen mit <kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd> (unter macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>E</kbd>).
+- CodeLens-Navigation – Anklickbare Links oberhalb von Testclient-Aufrufen (z. B. `client.get('/items')`), die zur passenden Pfadoperation springen und so eine schnelle Navigation zwischen Tests und Implementierung ermöglichen.
+- Zu FastAPI Cloud deployen – Deployment Ihrer App mit einem Klick auf [FastAPI Cloud](https://fastapicloud.com/).
+- Anwendungslogs streamen – Echtzeit-Logstreaming Ihrer auf FastAPI Cloud deployten Anwendung mit Loglevel-Filterung und Textsuche.

-Wenn Sie sich mit den Funktionen der Erweiterung vertraut machen möchten, können Sie den Erweiterungs‑Walkthrough aufrufen, indem Sie die Befehlspalette öffnen (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> oder unter macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd>) und „Welcome: Open walkthrough ...“ auswählen und anschließend den Walkthrough „Get started with FastAPI“ wählen.
+Wenn Sie sich mit den Funktionen der Erweiterung vertraut machen möchten, können Sie den Erweiterungs‑Walkthrough aufrufen, indem Sie die Befehlspalette öffnen (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> oder unter macOS: <kbd>Cmd</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd>) und „Welcome: Open walkthrough …“ auswählen und anschließend den Walkthrough „Get started with FastAPI“ wählen.
@@ -1,11 +1,298 @@
 # Umgebungsvariablen { #environment-variables }

-Eine **Umgebungsvariable** (auch bekannt als **env var**) ist ein Wert, der außerhalb Ihres Python-Codes im Betriebssystem existiert und von Ihrer Anwendung und anderen Programmen gelesen werden kann.
+/// tip | Tipp

-FastAPI-Anwendungen verwenden häufig Umgebungsvariablen für Konfigurationen wie Datenbank-URLs, E-Mail-Zugangsdaten und Secret-Keys.
+Wenn Sie bereits wissen, was „Umgebungsvariablen“ sind und wie man sie verwendet, können Sie dies überspringen.

-Sie werden lernen, wie Sie sie für Anwendungskonfigurationen verwenden, in [Einstellungen und Umgebungsvariablen](advanced/settings.md).
+///

-## Mehr erfahren { #learn-more }
+Eine Umgebungsvariable (auch bekannt als „**env var**“) ist eine Variable, die **außerhalb** des Python-Codes im **Betriebssystem** lebt und von Ihrem Python-Code (oder auch von anderen Programmen) gelesen werden kann.

-Lesen Sie den [Leitfaden zu Umgebungsvariablen](https://tiangolo.com/guides/environment-variables/) für eine detaillierte, plattformübergreifende Erklärung, einschließlich der Erstellung und des Lesens von Umgebungsvariablen und wie die `PATH`-Umgebungsvariable funktioniert.
+Umgebungsvariablen können nützlich sein, um **Einstellungen** der Anwendung zu handhaben, als Teil der **Installation** von Python usw.
+
+## Umgebungsvariablen erstellen und verwenden { #create-and-use-env-vars }
+
+Sie können Umgebungsvariablen in der **Shell (Terminal)** erstellen und verwenden, ohne Python zu benötigen:
+
+//// tab | Linux, macOS, Windows Bash
+
+<div class="termy">
+
+```console
+// Sie können eine Umgebungsvariable MY_NAME erstellen mit
+$ export MY_NAME="Wade Wilson"
+
+// Dann können Sie sie mit anderen Programmen verwenden, etwa
+$ echo "Hello $MY_NAME"
+
+Hello Wade Wilson
+```
+
+</div>
+
+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+// Erstellen Sie eine Umgebungsvariable MY_NAME
+$ $Env:MY_NAME = "Wade Wilson"
+
+// Verwenden Sie sie mit anderen Programmen, etwa
+$ echo "Hello $Env:MY_NAME"
+
+Hello Wade Wilson
+```
+
+</div>
+
+////
+
+## Umgebungsvariablen in Python lesen { #read-env-vars-in-python }
+
+Sie können auch Umgebungsvariablen **außerhalb** von Python erstellen, im Terminal (oder mit jeder anderen Methode) und sie dann **in Python** lesen.
+
+Zum Beispiel könnten Sie eine Datei `main.py` haben mit:
+
+```Python hl_lines="3"
+import os
+
+name = os.getenv("MY_NAME", "World")
+print(f"Hello {name} from Python")
+```
+
+/// tip | Tipp
+
+Das zweite Argument von [`os.getenv()`](https://docs.python.org/3.8/library/os.html#os.getenv) ist der Defaultwert, der zurückgegeben wird.
+
+Wenn er nicht angegeben wird, ist er standardmäßig `None`. Hier geben wir „World“ als den zu verwendenden Defaultwert an.
+
+///
+
+Dann könnten Sie das Python-Programm aufrufen:
+
+//// tab | Linux, macOS, Windows Bash
+
+<div class="termy">
+
+```console
+// Hier setzen wir die Umgebungsvariable noch nicht
+$ python main.py
+
+// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert
+
+Hello World from Python
+
+// Aber wenn wir zuerst eine Umgebungsvariable erstellen
+$ export MY_NAME="Wade Wilson"
+
+// Und dann das Programm erneut aufrufen
+$ python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+```
+
+</div>
+
+////
+
+//// tab | Windows PowerShell
+
+<div class="termy">
+
+```console
+// Hier setzen wir die Umgebungsvariable noch nicht
+$ python main.py
+
+// Da wir die Umgebungsvariable nicht gesetzt haben, erhalten wir den Defaultwert
+
+Hello World from Python
+
+// Aber wenn wir zuerst eine Umgebungsvariable erstellen
+$ $Env:MY_NAME = "Wade Wilson"
+
+// Und dann das Programm erneut aufrufen
+$ python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+```
+
+</div>
+
+////
+
+Da Umgebungsvariablen außerhalb des Codes gesetzt werden können, aber vom Code gelesen werden können und nicht mit den restlichen Dateien gespeichert (in `git` committet) werden müssen, werden sie häufig für Konfigurationen oder **Einstellungen** verwendet.
+
+Sie können auch eine Umgebungsvariable nur für einen **spezifischen Programmaufruf** erstellen, die nur für dieses Programm und nur für dessen Dauer verfügbar ist.
+
+Um dies zu tun, erstellen Sie sie direkt vor dem Programmaufruf, in derselben Zeile:
+
+<div class="termy">
+
+```console
+// Erstellen Sie eine Umgebungsvariable MY_NAME in der Zeile für diesen Programmaufruf
+$ MY_NAME="Wade Wilson" python main.py
+
+// Jetzt kann es die Umgebungsvariable lesen
+
+Hello Wade Wilson from Python
+
+// Die Umgebungsvariable existiert danach nicht mehr
+$ python main.py
+
+Hello World from Python
+```
+
+</div>
+
+/// tip | Tipp
+
+Sie können mehr darüber lesen auf [The Twelve-Factor App: Config](https://12factor.net/config).
+
+///
+
+## Typen und Validierung { #types-and-validation }
+
+Diese Umgebungsvariablen können nur **Textstrings** handhaben, da sie extern zu Python sind und kompatibel mit anderen Programmen und dem Rest des Systems (und sogar mit verschiedenen Betriebssystemen, wie Linux, Windows, macOS) sein müssen.
+
+Das bedeutet, dass **jeder Wert**, der in Python von einer Umgebungsvariablen gelesen wird, **ein `str` sein wird**, und jede Konvertierung in einen anderen Typ oder jede Validierung muss im Code vorgenommen werden.
+
+Sie werden mehr darüber lernen, wie man Umgebungsvariablen zur Handhabung von **Anwendungseinstellungen** verwendet, im [Handbuch für fortgeschrittene Benutzer – Einstellungen und Umgebungsvariablen](./advanced/settings.md).
+
+## `PATH`-Umgebungsvariable { #path-environment-variable }
+
+Es gibt eine **spezielle** Umgebungsvariable namens **`PATH`**, die von den Betriebssystemen (Linux, macOS, Windows) verwendet wird, um Programme zu finden, die ausgeführt werden sollen.
+
+Der Wert der Variable `PATH` ist ein langer String, der aus Verzeichnissen besteht, die auf Linux und macOS durch einen Doppelpunkt `:` und auf Windows durch ein Semikolon `;` getrennt sind.
+
+Zum Beispiel könnte die `PATH`-Umgebungsvariable so aussehen:
+
+//// tab | Linux, macOS
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
+```
+
+Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte:
+
+* `/usr/local/bin`
+* `/usr/bin`
+* `/bin`
+* `/usr/sbin`
+* `/sbin`
+
+////
+
+//// tab | Windows
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
+```
+
+Das bedeutet, dass das System nach Programmen in den Verzeichnissen suchen sollte:
+
+* `C:\Program Files\Python312\Scripts`
+* `C:\Program Files\Python312`
+* `C:\Windows\System32`
+
+////
+
+Wenn Sie einen **Befehl** im Terminal eingeben, **sucht** das Betriebssystem nach dem Programm in **jedem dieser Verzeichnisse**, die in der `PATH`-Umgebungsvariablen aufgeführt sind.
+
+Zum Beispiel, wenn Sie `python` im Terminal eingeben, sucht das Betriebssystem nach einem Programm namens `python` im **ersten Verzeichnis** in dieser Liste.
+
+Wenn es es findet, wird es **benutzt**. Andernfalls sucht es weiter in den **anderen Verzeichnissen**.
+
+### Python installieren und den `PATH` aktualisieren { #installing-python-and-updating-the-path }
+
+Wenn Sie Python installieren, könnten Sie gefragt werden, ob Sie die `PATH`-Umgebungsvariable aktualisieren möchten.
+
+//// tab | Linux, macOS
+
+Angenommen, Sie installieren Python und es landet in einem Verzeichnis `/opt/custompython/bin`.
+
+Wenn Sie erlauben, die `PATH`-Umgebungsvariable zu aktualisieren, fügt der Installer `/opt/custompython/bin` zur `PATH`-Umgebungsvariable hinzu.
+
+Das könnte so aussehen:
+
+```plaintext
+/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
+```
+
+Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `/opt/custompython/bin` (das letzte Verzeichnis) und verwendet dieses.
+
+////
+
+//// tab | Windows
+
+Angenommen, Sie installieren Python und es landet in einem Verzeichnis `C:\opt\custompython\bin`.
+
+Wenn Sie erlauben, die `PATH`-Umgebungsvariable zu aktualisieren, fügt der Installer `C:\opt\custompython\bin` zur `PATH`-Umgebungsvariable hinzu.
+
+```plaintext
+C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
+```
+
+Auf diese Weise, wenn Sie `python` im Terminal eingeben, findet das System das Python-Programm in `C:\opt\custompython\bin` (das letzte Verzeichnis) und verwendet dieses.
+
+////
+
+Also, wenn Sie tippen:
+
+<div class="termy">
+
+```console
+$ python
+```
+
+</div>
+
+//// tab | Linux, macOS
+
+Das System wird das `python` Programm in `/opt/custompython/bin` **finden** und es ausführen.
+
+Es wäre ungefähr gleichbedeutend mit der Eingabe von:
+
+<div class="termy">
+
+```console
+$ /opt/custompython/bin/python
+```
+
+</div>
+
+////
+
+//// tab | Windows
+
+Das System wird das `python` Programm in `C:\opt\custompython\bin\python` **finden** und es ausführen.
+
+Es wäre ungefähr gleichbedeutend mit der Eingabe von:
+
+<div class="termy">
+
+```console
+$ C:\opt\custompython\bin\python
+```
+
+</div>
+
+////
+
+Diese Informationen werden nützlich sein, wenn Sie über [Virtuelle Umgebungen](virtual-environments.md) lernen.
+
+## Fazit { #conclusion }
+
+Mit diesem Wissen sollten Sie ein grundlegendes Verständnis davon haben, was **Umgebungsvariablen** sind und wie man sie in Python verwendet.
+
+Sie können auch mehr darüber in der [Wikipedia zu Umgebungsvariablen](https://en.wikipedia.org/wiki/Environment_variable) lesen.
+
+In vielen Fällen ist es nicht sehr offensichtlich, wie Umgebungsvariablen nützlich und sofort anwendbar sein könnten. Aber sie tauchen immer wieder in vielen verschiedenen Szenarien auf, wenn Sie entwickeln, deshalb ist es gut, darüber Bescheid zu wissen.
+
+Zum Beispiel werden Sie diese Informationen im nächsten Abschnitt über [Virtuelle Umgebungen](virtual-environments.md) benötigen.
@@ -2,7 +2,7 @@

 **FastAPI <abbr title="command line interface - Kommandozeileninterface">CLI</abbr>** ist ein Kommandozeilenprogramm, mit dem Sie Ihre FastAPI-App bereitstellen, Ihr FastAPI-Projekt verwalten und mehr.

-Wenn Sie FastAPI zu Ihrem Projekt hinzufügen (z. B. mit `uv add "fastapi[standard]"`), erhalten Sie ein Kommandozeilenprogramm, das Sie im Terminal ausführen können.
+Wenn Sie FastAPI installieren (z. B. mit `pip install "fastapi[standard]"`), erhalten Sie ein Kommandozeilenprogramm, das Sie im Terminal ausführen können.

 Um Ihre FastAPI-App für die Entwicklung auszuführen, können Sie den Befehl `fastapi dev` verwenden:

@@ -52,7 +52,7 @@ Für die Produktion würden Sie statt `fastapi dev` `fastapi run` verwenden.

 ///

-Intern verwendet das **FastAPI CLI** [Uvicorn](https://uvicorn.dev), einen leistungsstarken, produktionsreifen, ASGI-Server. 😎
+Intern verwendet das **FastAPI CLI** [Uvicorn](https://www.uvicorn.dev), einen leistungsstarken, produktionsreifen, ASGI-Server. 😎

 Das `fastapi`-CLI versucht automatisch, die auszuführende FastAPI-App zu erkennen, und geht davon aus, dass es sich um ein Objekt namens `app` in einer Datei `main.py` handelt (oder ein paar weitere Varianten).

@@ -95,21 +95,15 @@ was gleichbedeutend wäre mit:
 from backend.main import app
 ```

-### `fastapi dev` mit Pfad oder mit der CLI-Option `--entrypoint` { #fastapi-dev-with-path-or-with-entrypoint-cli-option }
+### `fastapi dev` mit Pfad { #fastapi-dev-with-path }

 Sie können auch den Dateipfad an den Befehl `fastapi dev` übergeben, dann wird das zu verwendende FastAPI-App-Objekt erraten:

 ```console
-$ uv run fastapi dev main.py
+$ fastapi dev main.py
 ```

-Oder Sie können auch die Option `--entrypoint` an den Befehl `fastapi dev` übergeben:
-
-```console
-$ uv run fastapi dev --entrypoint main:app
-```
-
-Aber Sie müssten sich merken, bei jedem Aufruf des `fastapi`-Befehls den korrekten Pfad\entrypoint zu übergeben.
+Aber Sie müssten sich merken, bei jedem Aufruf des `fastapi`-Befehls den korrekten Pfad zu übergeben.

 Zusätzlich könnten andere Tools sie nicht finden, z. B. die [VS Code Extension](editor-support.md) oder [FastAPI Cloud](https://fastapicloud.com), daher wird empfohlen, den `entrypoint` in `pyproject.toml` zu verwenden.

@@ -119,10 +113,6 @@ Das Ausführen von `fastapi dev` startet den Entwicklermodus.

 Standardmäßig ist **Autoreload** aktiviert, das den Server automatisch neu lädt, wenn Sie Änderungen an Ihrem Code vornehmen. Dies ist ressourcenintensiv und könnte weniger stabil sein als wenn es deaktiviert ist. Sie sollten es nur für die Entwicklung verwenden. Es horcht auch auf der IP-Adresse `127.0.0.1`, die die IP für Ihre Maschine ist, um nur mit sich selbst zu kommunizieren (`localhost`).

-Vor dem Importieren Ihrer App setzt `fastapi dev` die Umgebungsvariable `FASTAPI_ENV` auf `development`. Wenn `FASTAPI_ENV` bereits gesetzt ist, bleibt der vorhandene Wert erhalten. Dadurch kann App-Startup-Code entwicklungsfreundliches Verhalten wählen, während Sie eine app-spezifische Umgebung wie `staging` bereitstellen können.
-
-Die konventionellen `FASTAPI_ENV`-Werte sind `development` und `production`. `fastapi run` lässt `FASTAPI_ENV` derzeit unverändert, setzen Sie es also explizit, wenn Ihre App den Produktionsmodus erkennen muss.
-
 ## `fastapi run` { #fastapi-run }

 Das Ausführen von `fastapi run` startet FastAPI im Produktionsmodus.
@@ -1,10 +1,10 @@
 # Merkmale { #features }

-## FastAPI-Merkmale { #fastapi-features }
+## FastAPI Merkmale { #fastapi-features }

 **FastAPI** ermöglicht Ihnen Folgendes:

-### Auf offenen Standards basieren { #based-on-open-standards }
+### Basiert auf offenen Standards { #based-on-open-standards }

 * [**OpenAPI**](https://github.com/OAI/OpenAPI-Specification) für die Erstellung von APIs, inklusive Deklarationen von <dfn title="auch bekannt als: Endpunkte, Routen">Pfad</dfn>-<dfn title="auch bekannt als HTTP-Methoden, wie POST, GET, PUT, DELETE">Operationen</dfn>, Parametern, <abbr title="Requestbody">Requestbodys</abbr>, Sicherheit, usw.
 * Automatische Dokumentation der Datenmodelle mit [**JSON Schema**](https://json-schema.org/) (da OpenAPI selbst auf JSON Schema basiert).
@@ -15,19 +15,19 @@

 Interaktive API-Dokumentation und erkundbare Web-Benutzeroberflächen. Da das Framework auf OpenAPI basiert, gibt es mehrere Optionen, zwei sind standardmäßig vorhanden.

-* [**Swagger UI**](https://github.com/swagger-api/swagger-ui), mit interaktiver Erkundung, rufen Sie Ihre API direkt vom Browser aus auf und testen Sie sie.
+* [**Swagger UI**](https://github.com/swagger-api/swagger-ui), bietet interaktive Erkundung, testen und rufen Sie Ihre API direkt im Webbrowser auf.

 ![Swagger UI Interaktion](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)

-* Alternative API-Dokumentation mit [**ReDoc**](https://github.com/Redocly/redoc).
+* Alternative API-Dokumentation mit [**ReDoc**](https://github.com/Rebilly/ReDoc).

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)

 ### Nur modernes Python { #just-modern-python }

-Alles basiert auf Standard-**Python-Typ**deklarationen (dank Pydantic). Es muss keine neue Syntax gelernt werden. Nur modernes Standard-Python.
+Alles basiert auf Standard-**Python-Typ**deklarationen (dank Pydantic). Es muss keine neue Syntax gelernt werden, nur standardisiertes modernes Python.

-Wenn Sie eine zweiminütige Auffrischung benötigen, wie man Python-Typen verwendet (auch wenn Sie FastAPI nicht benutzen), schauen Sie sich das kurze Tutorial an: [Python-Typen](python-types.md).
+Wenn Sie eine zweiminütige Auffrischung benötigen, wie man Python-Typen verwendet (auch wenn Sie FastAPI nicht benutzen), schauen Sie sich das kurze Tutorial an: [Einführung in Python-Typen](python-types.md).

 Sie schreiben Standard-Python mit Typen:

@@ -36,7 +36,7 @@ from datetime import date

 from pydantic import BaseModel

-# Deklarieren Sie eine Variable vom Typ str
+# Deklarieren Sie eine Variable als ein str
 # und bekommen Sie Editor-Unterstützung innerhalb der Funktion
 def main(user_id: str):
    return user_id
@@ -63,15 +63,15 @@ second_user_data = {
 my_second_user: User = User(**second_user_data)
 ```

-/// note | Hinweis
+/// info | Info

 `**second_user_data` bedeutet:

-Übergeben Sie die Schlüssel und Werte des `second_user_data` <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dicts</abbr> direkt als Schlüssel-Wert-Argumente, äquivalent zu: `User(id=4, name="Mary", joined="2018-11-30")`
+Nimm die Schlüssel-Wert-Paare des `second_user_data` <abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">Dicts</abbr> und übergebe sie direkt als Schlüsselwort-Argumente. Äquivalent zu: `User(id=4, name="Mary", joined="2018-11-30")`

 ///

-### Editorunterstützung { #editor-support }
+### Editor Unterstützung { #editor-support }

 Das ganze Framework wurde so entworfen, dass es einfach und intuitiv zu benutzen ist; alle Entscheidungen wurden auf mehreren Editoren getestet, sogar vor der Implementierung, um die bestmögliche Entwicklererfahrung zu gewährleisten.

@@ -85,31 +85,31 @@ So kann Ihr Editor Sie unterstützen:

 * in [Visual Studio Code](https://code.visualstudio.com/):

-![Editorunterstützung](https://fastapi.tiangolo.com/img/vscode-completion.png)
+![Editor Unterstützung](https://fastapi.tiangolo.com/img/vscode-completion.png)

 * in [PyCharm](https://www.jetbrains.com/pycharm/):

-![Editorunterstützung](https://fastapi.tiangolo.com/img/pycharm-completion.png)
+![Editor Unterstützung](https://fastapi.tiangolo.com/img/pycharm-completion.png)

-Sie bekommen sogar Autovervollständigung an Stellen, an denen Sie dies vorher nicht für möglich gehalten hätten. Zum Beispiel der `price`-Schlüssel innerhalb eines JSON-Bodys (dieser könnte auch verschachtelt sein), der aus einem Request kommt.
+Sie bekommen sogar Autovervollständigung an Stellen, an denen Sie dies vorher nicht für möglich gehalten hätten. Zum Beispiel der `price` Schlüssel in einem JSON Datensatz (dieser könnte auch verschachtelt sein), der aus einem Request kommt.

 Nie wieder falsche Schlüsselnamen tippen, Hin und Herhüpfen zwischen der Dokumentation, Hoch- und Runterscrollen, um herauszufinden, ob es `username` oder `user_name` war.

 ### Kompakt { #short }

-Es gibt für alles sinnvolle **Defaultwerte**, mit optionaler Konfiguration überall. Alle Parameter können feinjustiert werden, damit sie tun, was Sie benötigen, und die API definieren, die Sie brauchen.
+Es gibt für alles sensible **Defaultwerte**, mit optionaler Konfiguration überall. Alle Parameter können feinjustiert werden, damit sie tun, was Sie benötigen, und die API definieren, die Sie brauchen.

 Aber standardmäßig **„funktioniert einfach alles“**.

 ### Validierung { #validation }

 * Validierung für die meisten (oder alle?) Python-**Datentypen**, hierzu gehören:
-    * JSON-Objekte (`dict`).
-    * JSON-Array (`list`), das Elementtypen definiert.
-    * String-Felder (`str`) mit definierter minimaler und maximaler Länge.
+    * JSON Objekte (`dict`).
+    * JSON Listen (`list`), die den Typ ihrer Elemente definieren.
+    * Strings (`str`) mit definierter minimaler und maximaler Länge.
    * Zahlen (`int`, `float`) mit Mindest- und Maximalwerten, usw.

-* Validierung für exotischere Typen, wie:
+* Validierung für mehr exotische Typen, wie:
    * URL.
    * E-Mail.
    * UUID.
@@ -124,42 +124,42 @@ Sicherheit und Authentifizierung sind integriert. Ohne Kompromisse bei Datenbank
 Alle in OpenAPI definierten Sicherheitsschemas, inklusive:

 * HTTP Basic.
-* **OAuth2** (auch mit **JWT-Tokens**). Siehe dazu das Tutorial zu [OAuth2 mit JWT](tutorial/security/oauth2-jwt.md).
-* API-Schlüssel in:
+* **OAuth2** (auch mit **JWT Tokens**). Siehe dazu das Tutorial zu [OAuth2 mit JWT](tutorial/security/oauth2-jwt.md).
+* API Schlüssel in:
    * Headern.
    * Query-Parametern.
    * Cookies, usw.

-Zusätzlich alle Sicherheitsfunktionen von Starlette (inklusive **Session-Cookies**).
+Zusätzlich alle Sicherheitsfunktionen von Starlette (inklusive **Session Cookies**).

-Alles als wiederverwendbare Tools und Komponenten gebaut, die einfach in Ihre Systeme, Datenspeicher, relationale und NoSQL-Datenbanken, usw., integriert werden können.
+Alles als wiederverwendbare Tools und Komponenten gebaut, die einfach in Ihre Systeme, Datenspeicher, relationale und nicht-relationale Datenbanken, usw., integriert werden können.

 ### Dependency Injection { #dependency-injection }

-FastAPI enthält ein extrem einfach zu verwendendes, aber extrem mächtiges <dfn title='auch bekannt als „Komponenten“, „Ressourcen“, „Dienste“, „Anbieter“'><strong>Dependency Injection</strong></dfn>-System.
+FastAPI enthält ein extrem einfach zu verwendendes, aber extrem mächtiges <dfn title='auch bekannt als: "Komponenten", "Ressourcen", "Dienste", "Dienstanbieter"'><strong>Dependency Injection</strong></dfn> System.

 * Selbst Abhängigkeiten können Abhängigkeiten haben, woraus eine Hierarchie oder ein **„Graph“ von Abhängigkeiten** entsteht.
 * Alles **automatisch gehandhabt** durch das Framework.
-* Alle Abhängigkeiten können Daten von Requests anfordern und die Einschränkungen der **Pfadoperation** sowie die automatische Dokumentation **erweitern**.
+* Alle Abhängigkeiten können Daten von Requests anfordern und das Verhalten von **Pfadoperationen** und der automatisierten Dokumentation **modifizieren**.
 * **Automatische Validierung** selbst für solche Parameter von *Pfadoperationen*, welche in Abhängigkeiten definiert sind.
-* Unterstützung für komplexe Benutzerauthentifizierungssysteme, **Datenbankverbindungen**, usw.
+* Unterstützung für komplexe Authentifizierungssysteme, **Datenbankverbindungen**, usw.
 * **Keine Kompromisse** bei Datenbanken, Frontends, usw., sondern einfache Integration mit allen.

-### Unbegrenzte „Plug-ins“ { #unlimited-plug-ins }
+### Unbegrenzte Erweiterungen { #unlimited-plug-ins }

 Oder mit anderen Worten, sie werden nicht benötigt. Importieren und nutzen Sie den Code, den Sie brauchen.

-Jede Integration wurde so entworfen, dass sie so einfach zu nutzen ist (mit Abhängigkeiten), dass Sie ein „Plug-in“ für Ihre Anwendung mit nur 2 Zeilen Code erstellen können. Hierbei nutzen Sie die gleiche Struktur und Syntax, wie bei *Pfadoperationen*.
+Jede Integration wurde so entworfen, dass sie so einfach zu nutzen ist (mit Abhängigkeiten), dass Sie eine Erweiterung für Ihre Anwendung mit nur zwei Zeilen Code erstellen können. Hierbei nutzen Sie die gleiche Struktur und Syntax, wie bei *Pfadoperationen*.

 ### Getestet { #tested }

 * 100 % <dfn title="Der Prozentsatz an Code, der automatisch getestet wird">Testabdeckung</dfn>.
-* Zu 100 % <dfn title="Python-Typannotationen, mit denen Ihr Editor und andere externe Werkzeuge Sie besser unterstützen können">typannotierte</dfn> Codebasis.
+* 100 % <dfn title="Python-Typannotationen, mit denen Ihr Editor und andere externe Werkzeuge Sie besser unterstützen können">Typen annotiert</dfn>.
 * Verwendet in Produktionsanwendungen.

-## Starlette-Merkmale { #starlette-features }
+## Starlette Merkmale { #starlette-features }

-**FastAPI** ist vollkommen kompatibel (und basiert auf) [**Starlette**](https://starlette.dev/). Das bedeutet, wenn Sie eigenen Starlette-Quellcode haben, funktioniert dieser auch.
+**FastAPI** ist vollkommen kompatibel (und basiert auf) [**Starlette**](https://www.starlette.dev/). Das bedeutet, wenn Sie eigenen Starlette Quellcode haben, funktioniert der.

 `FastAPI` ist tatsächlich eine Unterklasse von `Starlette`. Wenn Sie also bereits Starlette kennen oder benutzen, das meiste funktioniert genau so.

@@ -173,29 +173,29 @@ Mit **FastAPI** bekommen Sie alles von **Starlette** (da FastAPI nur Starlette a
 * **CORS**, GZip, statische Dateien, Responses streamen.
 * **Sitzungs- und Cookie**-Unterstützung.
 * 100 % Testabdeckung.
-* Zu 100 % typannotierte Codebasis.
+* 100 % Typen annotierte Codebasis.

-## Pydantic-Merkmale { #pydantic-features }
+## Pydantic Merkmale { #pydantic-features }

-**FastAPI** ist vollkommen kompatibel (und basiert auf) [**Pydantic**](https://pydantic.dev/docs/). Das bedeutet, wenn Sie eigenen Pydantic-Quellcode haben, funktioniert dieser auch.
+**FastAPI** ist vollkommen kompatibel (und basiert auf) [**Pydantic**](https://docs.pydantic.dev/). Das bedeutet, wenn Sie eigenen Pydantic Quellcode haben, funktioniert der.

-Inklusive externer Bibliotheken, die auf Pydantic basieren, wie <abbr title="Object-Relational Mapper - Objektrelationaler Mapper">ORM</abbr>s und <abbr title="Object-Document Mapper - Objekt-Dokument-Mapper">ODM</abbr>s für Datenbanken.
+Inklusive externer Bibliotheken, die auf Pydantic basieren, wie <abbr title="Object-Relational Mapper - Objektrelationaler Mapper">ORM</abbr>s, <abbr title="Object-Document Mapper - Objekt-Dokument-Mapper">ODM</abbr>s für Datenbanken.

-Das bedeutet auch, dass Sie in vielen Fällen dasselbe Objekt, das Sie von einem Request erhalten, **direkt an die Datenbank** übergeben können, da alles automatisch validiert wird.
+Daher können Sie in vielen Fällen das Objekt eines Requests **direkt zur Datenbank** schicken, weil alles automatisch validiert wird.

-Das Gleiche gilt auch umgekehrt: In vielen Fällen können Sie einfach das Objekt, das Sie aus der Datenbank erhalten, **direkt an den Client** übergeben.
+Das gleiche gilt auch für die andere Richtung: Sie können in vielen Fällen das Objekt aus der Datenbank **direkt zum Client** senden.

 Mit **FastAPI** bekommen Sie alle Funktionen von **Pydantic** (da FastAPI für die gesamte Datenverarbeitung Pydantic nutzt):

 * **Kein Kopfzerbrechen**:
-    * Keine neue Schemadefinitions-Mikrosprache zu lernen.
+    * Keine neue Schemadefinition-Mikrosprache zu lernen.
    * Wenn Sie Pythons Typen kennen, wissen Sie, wie man Pydantic verwendet.
 * Gutes Zusammenspiel mit Ihrer/Ihrem **<abbr title="Integrated Development Environment - Integrierte Entwicklungsumgebung: Ähnlich einem Code-Editor">IDE</abbr>/<dfn title="Ein Programm, das Fehler im Quellcode sucht">Linter</dfn>/Gehirn**:
    * Weil Pydantics Datenstrukturen einfach nur Instanzen ihrer definierten Klassen sind; Autovervollständigung, Linting, mypy und Ihre Intuition sollten alle einwandfrei mit Ihren validierten Daten funktionieren.
 * Validierung von **komplexen Strukturen**:
-    * Benutzung von hierarchischen Pydantic-Modellen, Python-`typing`s `List` und `Dict`, usw.
-    * Die Validierer erlauben es, komplexe Datenschemas klar und einfach zu definieren, überprüft und dokumentiert als JSON Schema.
-    * Sie können tief **verschachtelte JSON**-Objekte haben, die alle validiert und annotiert sind.
+    * Benutzung von hierarchischen Pydantic-Modellen, Python-`typing`s `List` und `Dict`, etc.
+    * Die Validierer erlauben es, komplexe Datenschemen klar und einfach zu definieren, überprüft und dokumentiert als JSON Schema.
+    * Sie können tief **verschachtelte JSON** Objekte haben, die alle validiert und annotiert sind.
 * **Erweiterbar**:
-    * Pydantic erlaubt die Definition von eigenen Datentypen oder Sie können die Validierung mit Methoden in einem Modell erweitern, die mit dem Validator-Dekorator dekoriert sind.
+    * Pydantic erlaubt die Definition von eigenen Datentypen oder sie können die Validierung mit einer `validator`-dekorierten Methode im Modell erweitern.
 * 100 % Testabdeckung.
@@ -1,13 +1,18 @@
-# Helfen { #help }
+# FastAPI helfen – Hilfe erhalten { #help-fastapi-get-help }

+Mögen Sie **FastAPI**?

-Möchten Sie FastAPI helfen oder Hilfe zu FastAPI erhalten?
+Möchten Sie FastAPI, anderen Benutzern und dem Autor helfen?

-Es gibt sehr einfache Möglichkeiten, zu helfen und Hilfe zu bekommen.
+Oder möchten Sie Hilfe zu **FastAPI** erhalten?
+
+Es gibt sehr einfache Möglichkeiten zu helfen (einige erfordern nur ein oder zwei Klicks).
+
+Und es gibt auch mehrere Möglichkeiten, Hilfe zu bekommen.

 ## Newsletter abonnieren { #subscribe-to-the-newsletter }

-Sie können den (unregelmäßigen) [**FastAPI and friends**-Newsletter](newsletter.md) abonnieren, um über Folgendes informiert zu bleiben:
+Sie können den (unregelmäßigen) [**FastAPI and friends**-Newsletter](newsletter.md) abonnieren, um über folgende Themen informiert zu bleiben:

 * Neuigkeiten über FastAPI und Freunde 🚀
 * Anleitungen 📝
@@ -15,13 +20,9 @@ Sie können den (unregelmäßigen) [**FastAPI and friends**-Newsletter](newslett
 * Breaking Changes 🚨
 * Tipps und Tricks ✅

-## FastAPI online folgen { #follow-fastapi-online }
+## FastAPI auf X (Twitter) folgen { #follow-fastapi-on-x-twitter }

-Sie können **FastAPI** an mehreren Orten online folgen:
-
-* [@fastapi auf **X / Twitter**](https://x.com/fastapi)
-* [@fastapi.tiangolo.com auf **Bluesky**](https://bsky.app/profile/fastapi.tiangolo.com)
-* [FastAPI auf **LinkedIn**](https://www.linkedin.com/company/fastapi/)
+[Folgen Sie @fastapi auf **X (Twitter)**](https://x.com/fastapi), um die neuesten Nachrichten über **FastAPI** zu erhalten. 🐦

 ## **FastAPI** auf GitHub einen Stern geben { #star-fastapi-in-github }

@@ -29,37 +30,208 @@ Sie können FastAPI auf GitHub „starren“ (klicken Sie auf den Stern-Button o

 Durch das Hinzufügen eines Sterns können andere Benutzer es leichter finden und sehen, dass es für andere bereits nützlich war.

-## Das GitHub-Repository auf Releases beobachten { #watch-the-github-repository-for-releases }
+## Das GitHub-Repository auf Releases überwachen { #watch-the-github-repository-for-releases }

-Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „Watch“-Button oben rechts): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
+Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „watch“-Button oben rechts): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀

 Dort können Sie „Releases only“ auswählen.

-Auf diese Weise erhalten Sie Benachrichtigungen (per E‑Mail), wenn es ein neues Release (eine neue Version) von **FastAPI** mit Bugfixes und neuen Funktionen gibt.
+Auf diese Weise erhalten Sie Benachrichtigungen (per E-Mail), wenn es ein neues Release (eine neue Version) von **FastAPI** mit Bugfixes und neuen Funktionen gibt.

-## Dem Autor folgen { #follow-the-author }
+## Mit dem Autor vernetzen { #connect-with-the-author }

-Sie können [mir (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), dem Autor, an einigen Orten folgen, um mitzubekommen, wenn ich Neuigkeiten zu FastAPI und Freunden habe:
+Sie können sich mit [mir (Sebastián Ramírez / `tiangolo`)](https://tiangolo.com), dem Autor, vernetzen.

-* [@tiangolo auf **GitHub**](https://github.com/tiangolo).
-* [@tiangolo auf **X (Twitter)**](https://x.com/tiangolo)
-* [@tiangolo.com auf **Bluesky**](https://bsky.app/profile/tiangolo.com)
-* [@tiangolo auf **LinkedIn**](https://www.linkedin.com/in/tiangolo/).
+Sie können:
+
+* [Mir auf **GitHub** folgen](https://github.com/tiangolo).
+    * Andere Open-Source-Projekte sehen, die ich erstellt habe und die Ihnen helfen könnten.
+    * Mir folgen, um zu sehen, wenn ich ein neues Open-Source-Projekt erstelle.
+* [Mir auf **X (Twitter)** folgen](https://x.com/tiangolo) oder [Mastodon](https://fosstodon.org/@tiangolo).
+    * Mir mitteilen, wie Sie FastAPI verwenden (ich höre das gerne).
+    * Mitbekommen, wenn ich Ankündigungen mache oder neue Tools veröffentliche.
+    * Sie können auch [@fastapi auf X (Twitter) folgen](https://x.com/fastapi) (ein separates Konto).
+* [Mir auf **LinkedIn** folgen](https://www.linkedin.com/in/tiangolo/).
+    * Mitbekommen, wenn ich Ankündigungen mache oder neue Tools veröffentliche (obwohl ich X (Twitter) häufiger verwende 🤷‍♂).
+* Lesen, was ich schreibe (oder mir folgen) auf [**Dev.to**](https://dev.to/tiangolo) oder [**Medium**](https://medium.com/@tiangolo).
+    * Andere Ideen, Artikel lesen und mehr über die von mir erstellten Tools erfahren.
+    * Mir folgen, um zu lesen, wenn ich etwas Neues veröffentliche.
+
+## Über **FastAPI** tweeten { #tweet-about-fastapi }
+
+[Tweeten Sie über **FastAPI**](https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi) und teilen Sie mir und anderen mit, warum es Ihnen gefällt. 🎉
+
+Ich höre gerne, wie **FastAPI** verwendet wird, was Ihnen daran gefallen hat, in welchem Projekt/Unternehmen Sie es verwenden, usw.
+
+## Für FastAPI abstimmen { #vote-for-fastapi }
+
+* [Stimmen Sie für **FastAPI** auf Slant](https://www.slant.co/options/34241/~fastapi-review).
+* [Stimmen Sie für **FastAPI** auf AlternativeTo](https://alternativeto.net/software/fastapi/about/).
+* [Sagen Sie auf StackShare, dass Sie **FastAPI** verwenden](https://stackshare.io/pypi-fastapi).
+
+## Anderen bei Fragen auf GitHub helfen { #help-others-with-questions-in-github }
+
+Sie können versuchen, anderen bei ihren Fragen zu helfen:
+
+* [GitHub-Diskussionen](https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered)
+* [GitHub-Issues](https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+)
+
+In vielen Fällen kennen Sie möglicherweise bereits die Antwort auf diese Fragen. 🤓
+
+Wenn Sie vielen Menschen bei ihren Fragen helfen, werden Sie offizieller [FastAPI-Experte](fastapi-people.md#fastapi-experts). 🎉
+
+Denken Sie daran, der wichtigste Punkt ist: Versuchen Sie, freundlich zu sein. Die Leute bringen ihre Frustrationen mit und fragen in vielen Fällen nicht auf die beste Art und Weise, aber versuchen Sie dennoch so gut wie möglich, freundlich zu sein. 🤗
+
+Die **FastAPI**-Community soll freundlich und einladend sein. Akzeptieren Sie gleichzeitig kein Mobbing oder respektloses Verhalten gegenüber anderen. Wir müssen uns umeinander kümmern.
+
+---
+
+So helfen Sie anderen bei Fragen (in Diskussionen oder Issues):
+
+### Die Frage verstehen { #understand-the-question }
+
+* Prüfen Sie, ob Sie verstehen können, was der **Zweck** und der Anwendungsfall der fragenden Person ist.
+
+* Überprüfen Sie dann, ob die Frage (die überwiegende Mehrheit sind Fragen) **klar** ist.
+
+* In vielen Fällen handelt es sich bei der gestellten Frage um eine Lösung, die der Benutzer sich vorstellt, aber es könnte eine **bessere** Lösung geben. Wenn Sie das Problem und den Anwendungsfall besser verstehen, können Sie eine bessere **Alternativlösung** vorschlagen.
+
+* Wenn Sie die Frage nicht verstehen können, fragen Sie nach weiteren **Details**.
+
+### Das Problem reproduzieren { #reproduce-the-problem }
+
+In den meisten Fällen und bei den meisten Fragen gibt es etwas in Bezug auf den **originalen Code** der Person.
+
+In vielen Fällen wird nur ein Fragment des Codes gepostet, aber das reicht nicht aus, um **das Problem zu reproduzieren**.
+
+* Sie können die Person bitten, ein [minimales, reproduzierbares Beispiel](https://stackoverflow.com/help/minimal-reproducible-example) bereitzustellen, welches Sie **kopieren, einfügen** und lokal ausführen können, um den gleichen Fehler oder das gleiche Verhalten zu sehen, das die Person sieht, oder um ihren Anwendungsfall besser zu verstehen.
+
+* Wenn Sie in Geberlaune sind, können Sie ein solches Beispiel selbst erstellen, nur basierend auf der Beschreibung des Problems. Denken Sie jedoch daran, dass dies viel Zeit in Anspruch nehmen kann und dass es besser sein kann, zunächst um eine Klärung des Problems zu bitten.
+
+### Lösungen vorschlagen { #suggest-solutions }
+
+* Nachdem Sie die Frage verstanden haben, können Sie eine mögliche **Antwort** geben.
+
+* In vielen Fällen ist es besser, das **zugrunde liegende Problem oder den Anwendungsfall** zu verstehen, da es möglicherweise einen besseren Weg zur Lösung gibt als das, was die Person versucht.
+
+### Um Schließung bitten { #ask-to-close }
+
+Wenn die Person antwortet, besteht eine hohe Chance, dass Sie ihr Problem gelöst haben. Herzlichen Glückwunsch, **Sie sind ein Held**! 🦸
+
+* Wenn es tatsächlich das Problem gelöst hat, können Sie sie darum bitten:
+
+    * In GitHub-Diskussionen: den Kommentar als **Antwort** zu markieren.
+    * In GitHub-Issues: Das Issue zu **schließen**.
+
+## Das GitHub-Repository beobachten { #watch-the-github-repository }
+
+Sie können FastAPI auf GitHub „beobachten“ (klicken Sie auf den „watch“-Button oben rechts): [https://github.com/fastapi/fastapi](https://github.com/fastapi/fastapi). 👀
+
+Wenn Sie dann „Watching“ statt „Releases only“ auswählen, erhalten Sie Benachrichtigungen, wenn jemand ein neues Issue eröffnet oder eine neue Frage stellt. Sie können auch spezifizieren, dass Sie nur über neue Issues, Diskussionen, PRs usw. benachrichtigt werden möchten.
+
+Dann können Sie versuchen, bei der Lösung solcher Fragen zu helfen.

 ## Fragen stellen { #ask-questions }

-Sie können im GitHub-Repository [eine neue Frage erstellen](https://github.com/fastapi/fastapi/discussions/new?category=questions), zum Beispiel um:
+Sie können im GitHub-Repository [eine neue Frage erstellen](https://github.com/fastapi/fastapi/discussions/new?category=questions), zum Beispiel:

-* Eine **Frage** zu stellen oder nach einem **Problem** zu fragen.
-* Eine neue **Funktionalität** vorzuschlagen.
+* Stellen Sie eine **Frage** oder bitten Sie um Hilfe mit einem **Problem**.
+* Schlagen Sie eine neue **Funktionalität** vor.
+
+**Hinweis**: Wenn Sie das tun, bitte ich Sie, auch anderen zu helfen. 😉
+
+## Pull Requests prüfen { #review-pull-requests }
+
+Sie können mir helfen, Pull Requests von anderen zu überprüfen.
+
+Noch einmal, bitte versuchen Sie Ihr Bestes, freundlich zu sein. 🤗
+
+---
+
+Hier ist, was Sie beachten sollten und wie Sie einen Pull Request überprüfen:
+
+### Das Problem verstehen { #understand-the-problem }
+
+* Stellen Sie zunächst sicher, dass Sie **das Problem verstehen**, welches der Pull Request zu lösen versucht. Möglicherweise gibt es eine längere Diskussion dazu in einer GitHub-Diskussion oder einem GitHub-Issue.
+
+* Es besteht auch eine gute Chance, dass der Pull Request nicht wirklich benötigt wird, da das Problem auf **andere Weise** gelöst werden kann. Dann können Sie das vorschlagen oder danach fragen.
+
+### Keine Panik wegen des Stils { #dont-worry-about-style }
+
+* Machen Sie sich keine Sorgen über Dinge wie den Stil von Commit-Nachrichten. Ich werde den Commit zusammenführen und manuell anpassen.
+
+* Außerdem, keine Sorgen über Stilregeln, es gibt bereits automatisierte Tools, die das überprüfen.
+
+Und wenn es irgendeinen anderen Stil- oder Konsistenzbedarf gibt, werde ich direkt danach fragen oder zusätzliche Commits mit den erforderlichen Änderungen hinzufügen.
+
+### Den Code testen { #check-the-code }
+
+* Prüfen und lesen Sie den Code, fragen Sie sich, ob er Sinn macht, **führen Sie ihn lokal aus** und testen Sie, ob er das Problem tatsächlich löst.
+
+* Schreiben Sie dann einen **Kommentar** und berichten, dass Sie das getan haben. So weiß ich, dass Sie ihn wirklich überprüft haben.
+
+/// info | Info
+
+Leider kann ich PRs, nur weil sie von mehreren gutgeheißen wurden, nicht einfach vertrauen.
+
+Es ist mehrmals passiert, dass es PRs mit drei, fünf oder mehr Zustimmungen gibt, wahrscheinlich weil die Beschreibung ansprechend ist, aber wenn ich die PRs überprüfe, sind sie tatsächlich fehlerhaft, haben einen Bug, oder lösen das Problem nicht, welches sie behaupten, zu lösen. 😅
+
+Daher ist es wirklich wichtig, dass Sie den Code wirklich lesen und ausführen und mir in den Kommentaren mitteilen, dass Sie dies getan haben. 🤓
+
+///
+
+* Wenn der PR in irgendeiner Weise vereinfacht werden kann, können Sie danach fragen, aber es gibt keinen Grund, zu wählerisch zu sein. Es gibt viele subjektive Standpunkte (und ich habe auch meinen eigenen 🙈), also ist es besser, wenn man sich auf die grundlegenden Dinge konzentriert.
+
+### Tests { #tests }
+
+* Helfen Sie mir zu überprüfen, dass der PR **Tests** hat.
+
+* Überprüfen Sie, dass diese Tests vor dem PR **fehlschlagen**. 🚨
+
+* Überprüfen Sie dann, dass diese Tests nach dem PR **bestanden** werden. ✅
+
+* Viele PRs haben keine Tests. Sie können den Autor daran **erinnern**, Tests hinzuzufügen, oder Sie können sogar selbst einige Tests **vorschlagen**. Das ist eines der Dinge, die am meisten Zeit in Anspruch nehmen, und Sie können dabei viel helfen.
+
+* Kommentieren Sie auch hier anschließend, was Sie versucht haben, sodass ich weiß, dass Sie es überprüft haben. 🤓
+
+## Einen Pull Request erstellen { #create-a-pull-request }
+
+Sie können [zum Quellcode mit Pull Requests beitragen](contributing.md), zum Beispiel:
+
+* Um einen Tippfehler zu beheben, den Sie in der Dokumentation gefunden haben.
+* Um einen Artikel, ein Video oder einen Podcast über FastAPI zu teilen, den Sie erstellt oder gefunden haben, indem Sie [diese Datei bearbeiten](https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml).
+    * Stellen Sie sicher, dass Sie Ihren Link am Anfang des entsprechenden Abschnitts einfügen.
+* Um zu helfen, [die Dokumentation in Ihre Sprache zu übersetzen](contributing.md#translations).
+    * Sie können auch dabei helfen, die von anderen erstellten Übersetzungen zu überprüfen.
+* Um neue Dokumentationsabschnitte vorzuschlagen.
+* Um ein bestehendes Problem/Bug zu beheben.
+    * Stellen Sie sicher, dass Sie Tests hinzufügen.
+* Um eine neue Funktionalität hinzuzufügen.
+    * Stellen Sie sicher, dass Sie Tests hinzufügen.
+    * Stellen Sie sicher, dass Sie Dokumentation hinzufügen, falls das notwendig ist.
+
+## FastAPI pflegen { #help-maintain-fastapi }
+
+Helfen Sie mir, **FastAPI** zu pflegen! 🤓
+
+Es gibt viel zu tun, und das meiste davon können **SIE** tun.
+
+Die Hauptaufgaben, die Sie jetzt erledigen können, sind:
+
+* [Anderen bei Fragen auf GitHub helfen](#help-others-with-questions-in-github) (siehe Abschnitt oben).
+* [Pull Requests prüfen](#review-pull-requests) (siehe Abschnitt oben).
+
+Diese beiden Aufgaben sind die Dinge, die **am meisten Zeit verbrauchen**. Das ist die Hauptarbeit bei der Wartung von FastAPI.
+
+Wenn Sie mir dabei helfen können, **helfen Sie mir, FastAPI zu pflegen** und Sie stellen sicher, dass es weiterhin **schneller und besser voranschreitet**. 🚀

 ## Am Chat teilnehmen { #join-the-chat }

-Treten Sie dem 👥 [Discord-Chatserver](https://discord.com/invite/VQjSZaeJmf) 👥 bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community.
+Treten Sie dem 👥 [Discord-Chatserver](https://discord.gg/VQjSZaeJmf) 👥 bei und treffen Sie sich mit anderen Mitgliedern der FastAPI-Community.

 /// tip | Tipp

-Bei Fragen stellen Sie sie in GitHub-Diskussionen, dort besteht eine viel größere Chance, dass Sie Hilfe erhalten.
+Bei Fragen stellen Sie sie in [GitHub-Diskussionen](https://github.com/fastapi/fastapi/discussions/new?category=questions), dort besteht eine viel größere Chance, dass Sie Hilfe von den [FastAPI-Experten](fastapi-people.md#fastapi-experts) erhalten.

 Nutzen Sie den Chat nur für andere allgemeine Gespräche.

@@ -69,12 +241,16 @@ Nutzen Sie den Chat nur für andere allgemeine Gespräche.

 Bedenken Sie, dass Sie in Chats, die „freie Konversation“ erlauben, leicht Fragen stellen können, die zu allgemein und schwer zu beantworten sind, sodass Sie möglicherweise keine Antworten erhalten.

-Auf GitHub hilft Ihnen die Vorlage dabei, die richtige Frage zu stellen, sodass Sie leichter eine gute Antwort erhalten können, oder sogar das Problem selbst lösen, bevor Sie überhaupt fragen.
+Auf GitHub hilft Ihnen die Vorlage dabei, die richtige Frage zu stellen, sodass Sie leichter eine gute Antwort erhalten können, oder sogar das Problem selbst lösen, bevor Sie überhaupt fragen. Und auf GitHub kann ich sicherstellen, dass ich immer alles beantworte, auch wenn es einige Zeit dauert. Persönlich kann ich das mit den Chat-Systemen nicht machen. 😅

-Unterhaltungen in den Chat-Systemen sind auch nicht so leicht durchsuchbar wie auf GitHub, sie gehen verloren.
+Unterhaltungen in den Chat-Systemen sind auch nicht so leicht durchsuchbar wie auf GitHub, sodass Fragen und Antworten möglicherweise im Gespräch verloren gehen. Und nur die auf GitHub machen einen [FastAPI-Experten](fastapi-people.md#fastapi-experts), Sie werden also höchstwahrscheinlich mehr Aufmerksamkeit auf GitHub erhalten.

-## FastAPI Cloud ausprobieren { #try-fastapi-cloud }
+Auf der anderen Seite gibt es Tausende von Benutzern in den Chat-Systemen, sodass die Wahrscheinlichkeit hoch ist, dass Sie dort fast immer jemanden zum Reden finden. 😄

-Die Hauptfinanzierung für FastAPI und Freunde kommt von [**FastAPI Cloud**](https://fastapicloud.com), einer Plattform, um FastAPI-Anwendungen auf einfache und schnelle Weise zu deployen, mit einem einzigen Kommando, `fastapi deploy`.
+## Den Autor sponsern { #sponsor-the-author }

-FastAPI Cloud wird vom selben Team hinter FastAPI entwickelt. Sie können es ausprobieren und für Ihre Projekte in Betracht ziehen.
+Wenn Ihr **Produkt/Firma** auf **FastAPI** angewiesen ist oder in Zusammenhang steht und Sie seine Benutzer erreichen möchten, können Sie den Autor (mich) über [GitHub-Sponsoren](https://github.com/sponsors/tiangolo) unterstützen. Je nach Stufe können Sie einige zusätzliche Vorteile erhalten, wie z. B. ein Abzeichen in der Dokumentation. 🎁
+
+---
+
+Danke! 🚀
@@ -54,11 +54,11 @@ Alles auf eine Weise, die allen Entwicklern das beste Entwicklungserlebnis bot.

 ## Anforderungen { #requirements }

-Nachdem ich mehrere Alternativen getestet hatte, entschied ich, dass ich [**Pydantic**](https://pydantic.dev/docs/) wegen seiner Vorteile verwenden würde.
+Nachdem ich mehrere Alternativen getestet hatte, entschied ich, dass ich [**Pydantic**](https://docs.pydantic.dev/) wegen seiner Vorteile verwenden würde.

 Dann habe ich zu dessen Code beigetragen, um es vollständig mit JSON Schema kompatibel zu machen, und so verschiedene Möglichkeiten zum Definieren von einschränkenden Deklarationen (Constraints) zu unterstützen, und die Editorunterstützung (Typprüfungen, Codevervollständigung) zu verbessern, basierend auf den Tests in mehreren Editoren.

-Während der Entwicklung habe ich auch zu [**Starlette**](https://starlette.dev/) beigetragen, die andere Schlüsselanforderung.
+Während der Entwicklung habe ich auch zu [**Starlette**](https://www.starlette.dev/) beigetragen, die andere Schlüsselanforderung.

 ## Entwicklung { #development }

@@ -67,4 +67,4 @@ presets: [

 Dabei handelt es sich um **JavaScript**-Objekte, nicht um Strings, daher können Sie diese nicht direkt vom Python-Code aus übergeben.

-Wenn Sie solche Nur-JavaScript-Konfigurationen verwenden müssen, können Sie einen der früher genannten Wege verwenden. Überschreiben Sie die gesamte *Pfadoperation* der Swagger-Oberfläche und schreiben Sie manuell jedes benötigte JavaScript.
+Wenn Sie solche JavaScript-Konfigurationen verwenden müssen, können Sie einen der früher genannten Wege verwenden. Überschreiben Sie alle *Pfadoperationen* der Swagger-Oberfläche und schreiben Sie manuell jedes benötigte JavaScript.
@@ -66,7 +66,7 @@ Das `scope`-`dict` und die `receive`-Funktion sind beide Teil der ASGI-Spezifika

 Und diese beiden Dinge, `scope` und `receive`, werden benötigt, um eine neue `Request`-Instanz zu erstellen.

-Um mehr über den `Request` zu erfahren, schauen Sie sich [Starlettes Dokumentation zu Requests](https://starlette.dev/requests/) an.
+Um mehr über den `Request` zu erfahren, schauen Sie sich [Starlettes Dokumentation zu Requests](https://www.starlette.dev/requests/) an.

 ///

@@ -25,17 +25,9 @@ Diese Funktion `get_openapi()` erhält als Parameter:
 * `openapi_version`: Die Version der verwendeten OpenAPI-Spezifikation. Standardmäßig die neueste Version: `3.1.0`.
 * `summary`: Eine kurze Zusammenfassung der API.
 * `description`: Die Beschreibung Ihrer API. Dies kann Markdown enthalten und wird in der Dokumentation angezeigt.
-* `routes`: Die Routen der Anwendung, entnommen aus `app.routes`. FastAPI nutzt sie, um die registrierten *Pfadoperationen* zu sammeln, einschließlich derer aus eingebundenen Routern.
+* `routes`: Eine Liste von Routen, dies sind alle registrierten *Pfadoperationen*. Sie stammen von `app.routes`.

-/// tip | Technische Details
-
-`app.routes` ist eine Routenstruktur auf niedrigerer Ebene. Sie kann Routenkandidaten enthalten, die FastAPI intern für eingebundene Router verwendet, nicht nur endgültige `APIRoute`-Objekte.
-
-Sie können dennoch `app.routes` an `get_openapi()` übergeben. FastAPI durchläuft diesen Routenbaum, um die tatsächlich wirksamen Pfadoperationen zu sammeln.
-
-///
-
-/// note | Hinweis
+/// info | Info

 Der Parameter `summary` ist in OpenAPI 3.1.0 und höher verfügbar und wird von FastAPI 0.99.0 und höher unterstützt.

@@ -45,7 +37,7 @@ Der Parameter `summary` ist in OpenAPI 3.1.0 und höher verfügbar und wird von

 Mithilfe der oben genannten Informationen können Sie dieselbe Hilfsfunktion verwenden, um das OpenAPI-Schema zu generieren und jeden benötigten Teil zu überschreiben.

-Fügen wir beispielsweise [ReDocs OpenAPI-Erweiterung zum Einbinden eines benutzerdefinierten Logos](https://github.com/Redocly/redoc/blob/main/docs/redoc-vendor-extensions.md#x-logo) hinzu.
+Fügen wir beispielsweise [ReDocs OpenAPI-Erweiterung zum Einbinden eines benutzerdefinierten Logos](https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo) hinzu.

 ### Normales **FastAPI** { #normal-fastapi }

@@ -1,6 +1,5 @@
 # GraphQL { #graphql }

-
 Da **FastAPI** auf dem **ASGI**-Standard basiert, ist es sehr einfach, jede **GraphQL**-Bibliothek zu integrieren, die auch mit ASGI kompatibel ist.

 Sie können normale FastAPI-*Pfadoperationen* mit GraphQL in derselben Anwendung kombinieren.
@@ -22,7 +21,7 @@ Hier sind einige der **GraphQL**-Bibliotheken, die **ASGI**-Unterstützung haben
 * [Strawberry](https://strawberry.rocks/) 🍓
    * Mit [Dokumentation für FastAPI](https://strawberry.rocks/docs/integrations/fastapi)
 * [Ariadne](https://ariadnegraphql.org/)
-    * Mit [Dokumentation für FastAPI](https://ariadnegraphql.org/server/Integrations/fastapi-integration)
+    * Mit [Dokumentation für FastAPI](https://ariadnegraphql.org/docs/fastapi-integration)
 * [Tartiflette](https://tartiflette.io/)
    * Mit [Tartiflette ASGI](https://tartiflette.github.io/tartiflette-asgi/) für ASGI-Integration
 * [Graphene](https://graphene-python.org/)
@@ -8,8 +8,6 @@ FastAPI Version 0.119.0 führte eine teilweise Unterstützung für Pydantic v1 i

 FastAPI 0.126.0 entfernte die Unterstützung für Pydantic v1, während `pydantic.v1` noch eine Weile unterstützt wurde.

-FastAPI 0.128.0 entfernte ebenfalls die Unterstützung für `pydantic.v1`, daher erfordern die neuesten Versionen von FastAPI Pydantic v2.
-
 /// warning | Achtung

 Das Pydantic-Team hat die Unterstützung für Pydantic v1 in den neuesten Python-Versionen eingestellt, beginnend mit **Python 3.14**.
@@ -24,7 +22,7 @@ Wenn Sie eine ältere FastAPI-App mit Pydantic v1 haben, zeige ich Ihnen hier, w

 ## Offizieller Leitfaden { #official-guide }

-Pydantic hat einen offiziellen [Migrationsleitfaden](https://pydantic.dev/docs/validation/latest/get-started/migration/) von v1 zu v2.
+Pydantic hat einen offiziellen [Migrationsleitfaden](https://docs.pydantic.dev/latest/migration/) von v1 zu v2.

 Er enthält auch, was sich geändert hat, wie Validierungen nun korrekter und strikter sind, mögliche Stolpersteine, usw.

@@ -56,16 +54,6 @@ Das bedeutet, Sie können die neueste Version von Pydantic v2 installieren und d

 ### FastAPI-Unterstützung für Pydantic v1 in v2 { #fastapi-support-for-pydantic-v1-in-v2 }

-/// warning | Achtung
-
-Diese FastAPI-Unterstützung für `pydantic.v1`-Modelle wurde in **FastAPI 0.119.0** hinzugefügt und in **FastAPI 0.128.0** entfernt. Sie war als temporäre Hilfe für die Migration zu Pydantic v2 gedacht.
-
-In aktuellen Versionen von FastAPI löst die Verwendung eines `pydantic.v1`-Modells in Ihrer App einen Fehler aus.
-
-Der Rest dieses Abschnitts beschreibt die temporäre Unterstützung, die nur in diesen älteren Versionen verfügbar ist.
-
-///
-
 Seit FastAPI 0.119.0 gibt es außerdem eine teilweise Unterstützung für Pydantic v1 innerhalb von Pydantic v2, um die Migration auf v2 zu erleichtern.

 Sie könnten also Pydantic auf die neueste Version 2 aktualisieren und die Importe so ändern, dass das Untermodul `pydantic.v1` verwendet wird, und in vielen Fällen würde es einfach funktionieren.
@@ -134,12 +122,6 @@ Wenn Sie einige der FastAPI-spezifischen Tools für Parameter wie `Body`, `Query

 ### In Schritten migrieren { #migrate-in-steps }

-/// warning | Achtung
-
-Die unten beschriebene schrittweise Migration mit sowohl Pydantic‑v1‑ als auch Pydantic‑v2‑Modellen in derselben App funktioniert nur in **FastAPI 0.119.0 bis 0.127.x**. Sie wurde in **FastAPI 0.128.0** entfernt, die neuesten Versionen erfordern **Pydantic‑v2**-Modelle.
-
-///
-
 /// tip | Tipp

 Probieren Sie zuerst `bump-pydantic` aus. Wenn Ihre Tests erfolgreich sind und das funktioniert, sind Sie mit einem einzigen Befehl fertig. ✨
@@ -1,6 +1,5 @@
 # Separate OpenAPI-Schemas für Eingabe und Ausgabe oder nicht { #separate-openapi-schemas-for-input-and-output-or-not }

-
 Seit der Veröffentlichung von **Pydantic v2** ist die generierte OpenAPI etwas genauer und **korrekter** als zuvor. 😎

 Tatsächlich gibt es in einigen Fällen sogar **zwei JSON-Schemas** in OpenAPI für dasselbe Pydantic-Modell, für Eingabe und Ausgabe, je nachdem, ob sie **Defaultwerte** haben.
@@ -86,7 +85,7 @@ Der Hauptanwendungsfall hierfür besteht wahrscheinlich darin, dass Sie das mal

 In diesem Fall können Sie diese Funktion in **FastAPI** mit dem Parameter `separate_input_output_schemas=False` deaktivieren.

-/// note | Hinweis
+/// info | Info

 Unterstützung für `separate_input_output_schemas` wurde in FastAPI `0.102.0` hinzugefügt. 🤓

@@ -1,8 +1,3 @@
---
-include_yaml:
-  sponsors: data/sponsors.yml
---
-
 # FastAPI { #fastapi }

 <style>
@@ -59,27 +54,18 @@ Seine Schlüssel-Merkmale sind:

 ### Keystone-Sponsor { #keystone-sponsor }

-<div class="fastapi-sponsors fastapi-sponsors--keystone">
 {% for sponsor in sponsors.keystone -%}
-<a class="fastapi-sponsors__card fastapi-sponsors__card--keystone" href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img class="fastapi-sponsors__banner" src="{{ sponsor.img }}" alt="{{ sponsor.title }}"></a>
+<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
 {% endfor -%}
-</div>

-### Gold-Sponsoren { #gold-sponsors }
+### Gold- und Silber-Sponsoren { #gold-and-silver-sponsors }

-<div class="fastapi-sponsors fastapi-sponsors--gold">
 {% for sponsor in sponsors.gold -%}
-<a class="fastapi-sponsors__card fastapi-sponsors__card--gold" href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img class="fastapi-sponsors__banner" src="{{ sponsor.img }}" alt="{{ sponsor.title }}" loading="lazy"></a>
+<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
 {% endfor -%}
-</div>
-
-### Silber-Sponsoren { #silver-sponsors }
-
-<div class="fastapi-sponsors fastapi-sponsors--silver">
-{% for sponsor in sponsors.silver -%}
-<a class="fastapi-sponsors__card fastapi-sponsors__card--silver" href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img class="fastapi-sponsors__banner" src="{{ sponsor.img }}" alt="{{ sponsor.title }}" loading="lazy"></a>
+{%- for sponsor in sponsors.silver -%}
+<a href="{{ sponsor.url }}" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
 {% endfor %}
-</div>

 <!-- /sponsors -->

@@ -87,44 +73,6 @@ Seine Schlüssel-Merkmale sind:

 ## Meinungen { #opinions }

-<!-- only-mkdocs -->
-<div class="fastapi-opinions" data-fastapi-opinions>
-  <div class="fastapi-opinions__tabs" role="tablist" aria-label="Companies using FastAPI">
-    <button class="fastapi-opinions__tab" role="tab" type="button" id="fo-tab-microsoft" aria-controls="fo-panel-microsoft" aria-selected="true" tabindex="0">
-      <span class="fastapi-opinions__mark"><img src="/img/logos/microsoft.svg" alt="Microsoft" loading="lazy"></span>
-    </button>
-    <button class="fastapi-opinions__tab" role="tab" type="button" id="fo-tab-uber" aria-controls="fo-panel-uber" aria-selected="false" tabindex="-1">
-      <span class="fastapi-opinions__mark"><img src="/img/logos/uber.svg" alt="Uber" loading="lazy"></span>
-    </button>
-    <button class="fastapi-opinions__tab" role="tab" type="button" id="fo-tab-netflix" aria-controls="fo-panel-netflix" aria-selected="false" tabindex="-1">
-      <span class="fastapi-opinions__mark"><img src="/img/logos/netflix.svg" alt="Netflix" loading="lazy"></span>
-    </button>
-    <button class="fastapi-opinions__tab" role="tab" type="button" id="fo-tab-cisco" aria-controls="fo-panel-cisco" aria-selected="false" tabindex="-1">
-      <span class="fastapi-opinions__mark"><img src="/img/logos/cisco.svg" alt="Cisco" loading="lazy"></span>
-    </button>
-  </div>
-
-  <div class="fastapi-opinions__panel" id="fo-panel-microsoft" role="tabpanel" aria-labelledby="fo-tab-microsoft" tabindex="0">
-    <blockquote class="fastapi-opinions__quote">„Ich verwende <strong>FastAPI</strong> heutzutage sehr oft. Ich plane tatsächlich, es für alle <strong>ML-Services meines Teams bei Microsoft</strong> zu verwenden. Einige davon werden in das Kernprodukt <strong>Windows</strong> und einige <strong>Office</strong>-Produkte integriert.“</blockquote>
-    <div class="fastapi-opinions__attr">— Kabir Khan, <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26">(Ref.)</a></div>
-  </div>
-  <div class="fastapi-opinions__panel" id="fo-panel-uber" role="tabpanel" aria-labelledby="fo-tab-uber" tabindex="0" hidden>
-    <blockquote class="fastapi-opinions__quote">„Wir haben die <strong>FastAPI</strong>-Bibliothek übernommen, um einen <strong>REST</strong>-Server zu erstellen, der für <strong>Vorhersagen</strong> abgefragt werden kann.“ <em>[für Ludwig]</em></blockquote>
-    <div class="fastapi-opinions__attr">— Piero Molino, Yaroslav Dudin, Sai Sumanth Miryala, <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/">(Ref.)</a></div>
-  </div>
-  <div class="fastapi-opinions__panel" id="fo-panel-netflix" role="tabpanel" aria-labelledby="fo-tab-netflix" tabindex="0" hidden>
-    <blockquote class="fastapi-opinions__quote">„<strong>Netflix</strong> freut sich, die Open-Source-Veröffentlichung unseres <strong>Krisenmanagement</strong>-Orchestrierungsframeworks bekannt zu geben: <strong>Dispatch</strong>!“ <em>[erstellt mit FastAPI]</em></blockquote>
-    <div class="fastapi-opinions__attr">— Kevin Glisson, Marc Vilanova, Forest Monsen, <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072">(Ref.)</a></div>
-  </div>
-  <div class="fastapi-opinions__panel" id="fo-panel-cisco" role="tabpanel" aria-labelledby="fo-tab-cisco" tabindex="0" hidden>
-    <blockquote class="fastapi-opinions__quote">„Falls irgendjemand eine Produktions-Python-API erstellen möchte, kann ich <strong>FastAPI</strong> wärmstens empfehlen. Es ist <strong>wunderschön konzipiert</strong>, <strong>einfach zu verwenden</strong> und <strong>hoch skalierbar</strong> – es ist zu einer <strong>Schlüsselkomponente</strong> unserer API-First-Entwicklungsstrategie geworden.“</blockquote>
-    <div class="fastapi-opinions__attr">— Deon Pillsbury, <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/">(Ref.)</a></div>
-  </div>
-</div>
-<!-- /only-mkdocs -->
-
-<div class="only-github" markdown="1">
-
 „_[...] Ich verwende **FastAPI** heutzutage sehr oft. [...] Ich habe tatsächlich vor, es für alle **ML-Services meines Teams bei Microsoft** zu verwenden. Einige davon werden in das Kernprodukt **Windows** und einige **Office**-Produkte integriert._“

 <div style="text-align: right; margin-right: 10%;">Kabir Khan – <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26"><small>(Ref.)</small></a></div>
@@ -133,35 +81,53 @@ Seine Schlüssel-Merkmale sind:

 „_Wir haben die **FastAPI**-Bibliothek übernommen, um einen **REST**-Server zu erstellen, der für **Vorhersagen** abgefragt werden kann. [für Ludwig]_“

-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, und Sai Sumanth Miryala – <strong>Uber</strong> <a href="https://www.uber.com/us/en/blog/ludwig-v0-2/"><small>(Ref.)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, und Sai Sumanth Miryala – <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/"><small>(Ref.)</small></a></div>

 ---

-„_**Netflix** freut sich, die Open-Source-Veröffentlichung unseres **Krisenmanagement**-Orchestrierungsframeworks bekannt zu geben: **Dispatch**! [erstellt mit **FastAPI**]_“
+„_**Netflix** freut sich, die Open-Source-Veröffentlichung unseres **Krisenmanagement**-Orchestrierung-Frameworks bekannt zu geben: **Dispatch**! [erstellt mit **FastAPI**]_“

 <div style="text-align: right; margin-right: 10%;">Kevin Glisson, Marc Vilanova, Forest Monsen – <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072"><small>(Ref.)</small></a></div>

 ---

+„_Ich bin hellauf begeistert von **FastAPI**. Es macht so viel Spaß!_“
+
+<div style="text-align: right; margin-right: 10%;">Brian Okken – <strong>[Python Bytes](https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855) Podcast-Host</strong> <a href="https://x.com/brianokken/status/1112220079972728832"><small>(Ref.)</small></a></div>
+
+---
+
+„_Ehrlich, was Du gebaut hast, sieht super solide und poliert aus. In vielerlei Hinsicht ist es so, wie ich **Hug** haben wollte – es ist wirklich inspirierend, jemanden so etwas bauen zu sehen._“
+
+<div style="text-align: right; margin-right: 10%;">Timothy Crosley – <strong>[Hug](https://github.com/hugapi/hug)-Autor</strong> <a href="https://news.ycombinator.com/item?id=19455465"><small>(Ref.)</small></a></div>
+
+---
+
+„_Wenn Sie ein **modernes Framework** zum Erstellen von REST-APIs erlernen möchten, schauen Sie sich **FastAPI** an. [...] Es ist schnell, einfach zu verwenden und leicht zu lernen [...]_“
+
+„_Wir haben zu **FastAPI** für unsere **APIs** gewechselt [...] Ich denke, es wird Ihnen gefallen [...]_“
+
+<div style="text-align: right; margin-right: 10%;">Ines Montani – Matthew Honnibal – <strong>[Explosion AI](https://explosion.ai)-Gründer – [spaCy](https://spacy.io)-Autoren</strong> <a href="https://x.com/_inesmontani/status/1144173225322143744"><small>(Ref.)</small></a> – <a href="https://x.com/honnibal/status/1144031421859655680"><small>(Ref.)</small></a></div>
+
+---
+
 „_Falls irgendjemand eine Produktions-Python-API erstellen möchte, kann ich **FastAPI** wärmstens empfehlen. Es ist **wunderschön konzipiert**, **einfach zu verwenden** und **hoch skalierbar**; es ist zu einer **Schlüsselkomponente** unserer API-First-Entwicklungsstrategie geworden und treibt viele Automatisierungen und Services an, wie etwa unseren Virtual TAC Engineer._“

 <div style="text-align: right; margin-right: 10%;">Deon Pillsbury – <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/"><small>(Ref.)</small></a></div>

 ---

-</div>
-
 ## FastAPI Mini-Dokumentarfilm { #fastapi-mini-documentary }

 Es gibt einen [FastAPI-Mini-Dokumentarfilm](https://www.youtube.com/watch?v=mpR8ngthqiE), veröffentlicht Ende 2025, Sie können ihn online ansehen:

-<a class="fastapi-feature-banner" href="https://www.youtube.com/watch?v=mpR8ngthqiE"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini-Dokumentarfilm"></a>
+<a href="https://www.youtube.com/watch?v=mpR8ngthqiE"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini-Dokumentarfilm"></a>

 ## **Typer**, das FastAPI der CLIs { #typer-the-fastapi-of-clis }

 <a href="https://typer.tiangolo.com"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>

-Wenn Sie eine <abbr title="Command Line Interface - Kommandozeileninterface">CLI</abbr>-Anwendung für das Terminal erstellen, anstelle einer Web-API, schauen Sie sich [**Typer**](https://typer.tiangolo.com/) an.
+Wenn Sie eine <abbr title="Command Line Interface - Kommandozeilen-Schnittstelle">CLI</abbr>-Anwendung für das Terminal erstellen, anstelle einer Web-API, schauen Sie sich [**Typer**](https://typer.tiangolo.com/) an.

 **Typer** ist die kleine Schwester von FastAPI. Und es soll das **FastAPI der CLIs** sein. ⌨️ 🚀

@@ -169,17 +135,17 @@ Wenn Sie eine <abbr title="Command Line Interface - Kommandozeileninterface">CLI

 FastAPI steht auf den Schultern von Giganten:

-* [Starlette](https://starlette.dev/) für die Webanteile.
-* [Pydantic](https://pydantic.dev/docs/) für die Datenanteile.
+* [Starlette](https://www.starlette.dev/) für die Webanteile.
+* [Pydantic](https://docs.pydantic.dev/) für die Datenanteile.

 ## Installation { #installation }

-Installieren Sie zuerst [`uv`](https://docs.astral.sh/uv/getting-started/installation/) und fügen Sie dann FastAPI zu Ihrem Projekt hinzu:
+Erstellen und aktivieren Sie eine [virtuelle Umgebung](https://fastapi.tiangolo.com/de/virtual-environments/) und installieren Sie dann FastAPI:

 <div class="termy">

 ```console
-$ uv add "fastapi[standard]"
+$ pip install "fastapi[standard]"

 ---> 100%
 ```
@@ -188,11 +154,9 @@ $ uv add "fastapi[standard]"

 **Hinweis**: Stellen Sie sicher, dass Sie `"fastapi[standard]"` in Anführungszeichen setzen, damit es in allen Terminals funktioniert.

-Wenn Sie lieber `pip` verwenden, installieren Sie `fastapi[standard]` innerhalb einer virtuellen Umgebung. Siehe die [Installationsanleitung](tutorial/#install-fastapi) für die alternativen Schritte.
-
 ## Beispiel { #example }

-### Erstellen { #create-it }
+### Erstellung { #create-it }

 Erstellen Sie eine Datei `main.py` mit:

@@ -246,7 +210,7 @@ Starten Sie den Server mit:
 <div class="termy">

 ```console
-$ uv run fastapi dev
+$ fastapi dev

 ╭────────── FastAPI CLI - Development mode ───────────╮
 │                                                     │
@@ -273,7 +237,7 @@ INFO:     Application startup complete.
 <details markdown="1">
 <summary>Über den Befehl <code>fastapi dev</code> ...</summary>

-Der Befehl `fastapi dev` liest Ihre `main.py`-Datei automatisch, erkennt die **FastAPI**-App darin und startet einen Server mit [Uvicorn](https://uvicorn.dev).
+Der Befehl `fastapi dev` liest Ihre `main.py`-Datei, erkennt die **FastAPI**-App darin und startet einen Server mit [Uvicorn](https://www.uvicorn.dev).

 Standardmäßig wird `fastapi dev` mit aktiviertem Auto-Reload für die lokale Entwicklung gestartet.

@@ -310,7 +274,7 @@ Sie sehen die automatische interaktive API-Dokumentation (bereitgestellt von [Sw

 Und jetzt gehen Sie auf [http://127.0.0.1:8000/redoc](http://127.0.0.1:8000/redoc).

-Sie sehen die alternative automatische Dokumentation (bereitgestellt von [ReDoc](https://github.com/Redocly/redoc)):
+Sie sehen die alternative automatische Dokumentation (bereitgestellt von [ReDoc](https://github.com/Rebilly/ReDoc)):

 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)

@@ -488,12 +452,14 @@ Für ein vollständigeres Beispiel, mit weiteren Funktionen, siehe das <a href="

 ### Ihre App deployen (optional) { #deploy-your-app-optional }

-Optional können Sie Ihre FastAPI-App mit einem einzigen Befehl in die [FastAPI Cloud](https://fastapicloud.com) deployen. 🚀
+Optional können Sie Ihre FastAPI-App in die [FastAPI Cloud](https://fastapicloud.com) deployen, gehen Sie und treten Sie der Warteliste bei, falls noch nicht geschehen. 🚀
+
+Wenn Sie bereits ein **FastAPI Cloud**-Konto haben (wir haben Sie von der Warteliste eingeladen 😉), können Sie Ihre Anwendung mit einem einzigen Befehl deployen.

 <div class="termy">

 ```console
-$ uv run fastapi deploy
+$ fastapi deploy

 Deploying to FastAPI Cloud...

@@ -504,8 +470,6 @@ Deploying to FastAPI Cloud...

 </div>

-Das CLI erkennt Ihre FastAPI-Anwendung automatisch und deployt sie in die Cloud. Wenn Sie nicht eingeloggt sind, wird Ihr Browser geöffnet, um den Authentifizierungsprozess abzuschließen.
-
 Das war’s! Jetzt können Sie unter dieser URL auf Ihre App zugreifen. ✨

 #### Über FastAPI Cloud { #about-fastapi-cloud }
@@ -536,7 +500,7 @@ FastAPI hängt von Pydantic und Starlette ab.

 ### `standard`-Abhängigkeiten { #standard-dependencies }

-Wenn Sie FastAPI mit `uv add "fastapi[standard]"` installieren, kommt es mit der `standard`-Gruppe optionaler Abhängigkeiten:
+Wenn Sie FastAPI mit `pip install "fastapi[standard]"` installieren, kommt es mit der `standard`-Gruppe optionaler Abhängigkeiten:

 Verwendet von Pydantic:

@@ -550,17 +514,17 @@ Verwendet von Starlette:

 Verwendet von FastAPI:

-* [`uvicorn`](https://uvicorn.dev) – für den Server, der Ihre Anwendung lädt und bereitstellt. Dies umfasst `uvicorn[standard]`, das einige Abhängigkeiten (z. B. `uvloop`) beinhaltet, die für eine Bereitstellung mit hoher Performanz benötigt werden.
+* [`uvicorn`](https://www.uvicorn.dev) – für den Server, der Ihre Anwendung lädt und bereitstellt. Dies umfasst `uvicorn[standard]`, das einige Abhängigkeiten (z. B. `uvloop`) beinhaltet, die für eine Bereitstellung mit hoher Performanz benötigt werden.
 * `fastapi-cli[standard]` – um den `fastapi`-Befehl bereitzustellen.
    * Dies beinhaltet `fastapi-cloud-cli`, das es Ihnen ermöglicht, Ihre FastAPI-Anwendung auf [FastAPI Cloud](https://fastapicloud.com) bereitzustellen.

 ### Ohne `standard`-Abhängigkeiten { #without-standard-dependencies }

-Wenn Sie die `standard` optionalen Abhängigkeiten nicht einschließen möchten, können Sie mit `uv add fastapi` statt `uv add "fastapi[standard]"` installieren.
+Wenn Sie die `standard` optionalen Abhängigkeiten nicht einschließen möchten, können Sie mit `pip install fastapi` statt `pip install "fastapi[standard]"` installieren.

 ### Ohne `fastapi-cloud-cli` { #without-fastapi-cloud-cli }

-Wenn Sie FastAPI mit den Standardabhängigkeiten, aber ohne das `fastapi-cloud-cli` installieren möchten, können Sie mit `uv add "fastapi[standard-no-fastapi-cloud-cli]"` installieren.
+Wenn Sie FastAPI mit den Standardabhängigkeiten, aber ohne das `fastapi-cloud-cli` installieren möchten, können Sie mit `pip install "fastapi[standard-no-fastapi-cloud-cli]"` installieren.

 ### Zusätzliche optionale Abhängigkeiten { #additional-optional-dependencies }

@@ -568,13 +532,13 @@ Es gibt einige zusätzliche Abhängigkeiten, die Sie installieren möchten.

 Zusätzliche optionale Pydantic-Abhängigkeiten:

-* [`pydantic-settings`](https://pydantic.dev/docs/validation/latest/concepts/pydantic_settings/) – für die Verwaltung von Einstellungen.
-* [`pydantic-extra-types`](https://github.com/pydantic/pydantic-extra-types) – für zusätzliche Typen zur Verwendung mit Pydantic.
+* [`pydantic-settings`](https://docs.pydantic.dev/latest/usage/pydantic_settings/) – für die Verwaltung von Einstellungen.
+* [`pydantic-extra-types`](https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/) – für zusätzliche Typen zur Verwendung mit Pydantic.

 Zusätzliche optionale FastAPI-Abhängigkeiten:

 * [`orjson`](https://github.com/ijl/orjson) – erforderlich, wenn Sie `ORJSONResponse` verwenden möchten.
-* [`ujson`](https://github.com/ultrajson/ultrajson) – erforderlich, wenn Sie `UJSONResponse` verwenden möchten.
+* [`ujson`](https://github.com/esnme/ultrajson) – erforderlich, wenn Sie `UJSONResponse` verwenden möchten.

 ## Lizenz { #license }

@@ -4,20 +4,20 @@ Vorlagen, die normalerweise mit einem bestimmten Setup geliefert werden, sind so

 Sie können diese Vorlage verwenden, um loszulegen, da sie bereits vieles der anfänglichen Einrichtung, Sicherheit, Datenbank und einige API-Endpunkte für Sie eingerichtet hat.

-GitHub-Repository: [Full Stack FastAPI Template](https://github.com/fastapi/full-stack-fastapi-template)
+GitHub-Repository: [Full Stack FastAPI Template](https://github.com/tiangolo/full-stack-fastapi-template)

 ## Full Stack FastAPI Template – Technologiestack und Funktionen { #full-stack-fastapi-template-technology-stack-and-features }

 - ⚡ [**FastAPI**](https://fastapi.tiangolo.com/de) für die Python-Backend-API.
  - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) für die Interaktion mit der Python-SQL-Datenbank (ORM).
-  - 🔍 [Pydantic](https://pydantic.dev/docs/), verwendet von FastAPI, für die Datenvalidierung und das Einstellungsmanagement.
+  - 🔍 [Pydantic](https://docs.pydantic.dev), verwendet von FastAPI, für die Datenvalidierung und das Einstellungsmanagement.
  - 💾 [PostgreSQL](https://www.postgresql.org) als SQL-Datenbank.
 - 🚀 [React](https://react.dev) für das Frontend.
  - 💃 Verwendung von TypeScript, Hooks, Vite und anderen Teilen eines modernen Frontend-Stacks.
  - 🎨 [Tailwind CSS](https://tailwindcss.com) und [shadcn/ui](https://ui.shadcn.com) für die Frontend-Komponenten.
  - 🤖 Ein automatisch generierter Frontend-Client.
  - 🧪 [Playwright](https://playwright.dev) für End-to-End-Tests.
-  - 🦇 Dark-Mode-Unterstützung.
+  - 🦇 „Dark-Mode“-Unterstützung.
 - 🐋 [Docker Compose](https://www.docker.com) für Entwicklung und Produktion.
 - 🔒 Sicheres Passwort-Hashing standardmäßig.
 - 🔑 JWT (JSON Web Token)-Authentifizierung.
@@ -44,7 +44,7 @@ Es ist ein sehr einfaches Programm.

 Aber nun stellen Sie sich vor, Sie würden es selbst schreiben.

-Irgendwann beginnen Sie, die Funktion zu definieren, und haben die Parameter bereit ...
+Irgendwann sind die Funktions-Parameter fertig, Sie starten mit der Definition des Körpers ...

 Aber dann müssen Sie „diese Methode aufrufen, die den ersten Buchstaben in Großbuchstaben umwandelt“.

@@ -52,7 +52,7 @@ War es `upper`? War es `uppercase`? `first_uppercase`? `capitalize`?

 Dann versuchen Sie es mit dem langjährigen Freund des Programmierers, der Editor-Autovervollständigung.

-Sie geben den ersten Parameter der Funktion ein, `first_name`, dann einen Punkt (`.`) und drücken `Ctrl+Space`, um die Vervollständigung auszulösen.
+Sie geben den ersten Parameter der Funktion ein, `first_name`, dann einen Punkt (`.`) und drücken `Strg+Leertaste`, um die Vervollständigung auszulösen.

 Aber leider erhalten Sie nichts Nützliches:

@@ -62,7 +62,7 @@ Aber leider erhalten Sie nichts Nützliches:

 Lassen Sie uns eine einzelne Zeile aus der vorherigen Version ändern.

-Wir ändern genau dieses Fragment, die Parameter der Funktion, von:
+Wir ändern den folgenden Teil, die Parameter der Funktion, von:

 ```Python
    first_name, last_name
@@ -94,7 +94,7 @@ Und das Hinzufügen von Typhinweisen ändert normalerweise nichts an dem, was oh

 Aber jetzt stellen Sie sich vor, Sie sind wieder mitten in der Erstellung dieser Funktion, aber mit Typhinweisen.

-An derselben Stelle versuchen Sie, die Autovervollständigung mit `Ctrl+Space` auszulösen, und Sie sehen:
+An derselben Stelle versuchen Sie, die Autovervollständigung mit „Strg+Leertaste“ auszulösen, und Sie sehen:

 <img src="/img/python-types/image02.png">

@@ -116,7 +116,7 @@ Jetzt, da Sie wissen, dass Sie das reparieren müssen, konvertieren Sie `age` mi

 {* ../../docs_src/python_types/tutorial004_py310.py hl[2] *}

-## Typen deklarieren { #declaring-types }
+## Deklarieren von Typen { #declaring-types }

 Sie haben gerade den Haupt-Einsatzort für die Deklaration von Typhinweisen gesehen. Als Funktionsparameter.

@@ -172,7 +172,7 @@ Da die Liste ein Typ ist, welcher innere Typen enthält, werden diese von eckige

 {* ../../docs_src/python_types/tutorial006_py310.py hl[1] *}

-/// note | Hinweis
+/// info | Info

 Die inneren Typen in den eckigen Klammern werden als „Typ-Parameter“ bezeichnet.

@@ -180,7 +180,7 @@ In diesem Fall ist `str` der Typ-Parameter, der an `list` übergeben wird.

 ///

-Das bedeutet: „Die Variable `items` ist eine `list`, und jedes der Elemente in dieser Liste ist ein `str`“.
+Das bedeutet: Die Variable `items` ist eine Liste – `list` – und jedes der Elemente in dieser Liste ist ein String – `str`.

 Auf diese Weise kann Ihr Editor Sie auch bei der Bearbeitung von Einträgen aus der Liste unterstützen:

@@ -263,13 +263,13 @@ Und wiederum bekommen Sie die volle Editor-Unterstützung:

 <img src="/img/python-types/image06.png">

-Beachten Sie, dass das bedeutet: „`one_person` ist eine **Instanz** der Klasse `Person`“.
+Beachten Sie, das bedeutet: „`one_person` ist eine **Instanz** der Klasse `Person`“.

-Es bedeutet nicht: „`one_person` ist die **Klasse** namens `Person`“.
+Es bedeutet nicht: „`one_person` ist die **Klasse** genannt `Person`“.

 ## Pydantic-Modelle { #pydantic-models }

-[Pydantic](https://pydantic.dev/docs/) ist eine Python-Bibliothek für die Validierung von Daten.
+[Pydantic](https://docs.pydantic.dev/) ist eine Python-Bibliothek für die Validierung von Daten.

 Sie deklarieren die „Form“ der Daten als Klassen mit Attributen.

@@ -279,13 +279,13 @@ Dann erzeugen Sie eine Instanz dieser Klasse mit einigen Werten, und Pydantic va

 Und Sie erhalten volle Editor-Unterstützung für dieses Objekt.

-Ein Beispiel aus der offiziellen Pydantic-Dokumentation:
+Ein Beispiel aus der offiziellen Pydantic Dokumentation:

 {* ../../docs_src/python_types/tutorial011_py310.py *}

-/// note | Hinweis
+/// info | Info

-Um mehr über [Pydantic zu erfahren, schauen Sie sich dessen Dokumentation an](https://pydantic.dev/docs/).
+Um mehr über [Pydantic zu erfahren, schauen Sie sich dessen Dokumentation an](https://docs.pydantic.dev/).

 ///

@@ -301,11 +301,11 @@ Sie können `Annotated` von `typing` importieren.

 {* ../../docs_src/python_types/tutorial013_py310.py hl[1,4] *}

-Python selbst macht nichts mit diesem `Annotated`. Für Editoren und andere Tools ist der Typ immer noch `str`.
+Python selbst macht nichts mit `Annotated`. Für Editoren und andere Tools ist der Typ immer noch `str`.

-Aber Sie können diesen Platz in `Annotated` nutzen, um **FastAPI** zusätzliche Metadaten darüber bereitzustellen, wie sich Ihre Anwendung verhalten soll.
+Aber Sie können `Annotated` nutzen, um **FastAPI** mit Metadaten zu versorgen, die ihm sagen, wie sich Ihre Anwendung verhalten soll.

-Wichtig ist, dass **der erste *Typ-Parameter***, den Sie `Annotated` übergeben, der **tatsächliche Typ** ist. Der Rest sind nur Metadaten für andere Tools.
+Wichtig ist, dass **der erste *Typ-Parameter***, den Sie `Annotated` übergeben, der **tatsächliche Typ** ist. Der Rest sind Metadaten für andere Tools.

 Im Moment müssen Sie nur wissen, dass `Annotated` existiert, und dass es Standard-Python ist. 😎

@@ -335,13 +335,13 @@ Mit **FastAPI** deklarieren Sie Parameter mit Typhinweisen, und Sie erhalten:
 * **Daten zu validieren**: aus jedem Request:
    * **Automatische Fehler** generieren, die an den Client zurückgegeben werden, wenn die Daten ungültig sind.
 * Die API mit OpenAPI zu **dokumentieren**:
-    * die dann von den Benutzeroberflächen der automatisch generierten interaktiven Dokumentation verwendet wird.
+    * Die dann von den Benutzeroberflächen der automatisch generierten interaktiven Dokumentation verwendet wird.

 Das mag alles abstrakt klingen. Machen Sie sich keine Sorgen. Sie werden all das in Aktion sehen im [Tutorial – Benutzerhandbuch](tutorial/index.md).

 Das Wichtigste ist, dass **FastAPI** durch die Verwendung von Standard-Python-Typen an einer einzigen Stelle (anstatt weitere Klassen, Dekoratoren usw. hinzuzufügen) einen Großteil der Arbeit für Sie erledigt.

-/// note | Hinweis
+/// info | Info

 Wenn Sie bereits das ganze Tutorial durchgearbeitet haben und mehr über Typen erfahren wollen, dann ist eine gute Ressource [der „Cheat Sheet“ von `mypy`](https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html).

@@ -63,7 +63,7 @@ Und dann schreibt ein weiterer Hintergrundtask, der in der *Pfadoperation-Funkti

 ## Technische Details { #technical-details }

-Die Klasse `BackgroundTasks` stammt direkt von [`starlette.background`](https://starlette.dev/background/).
+Die Klasse `BackgroundTasks` stammt direkt von [`starlette.background`](https://www.starlette.dev/background/).

 Sie wird direkt in FastAPI importiert/inkludiert, sodass Sie sie von `fastapi` importieren können und vermeiden, versehentlich das alternative `BackgroundTask` (ohne das `s` am Ende) von `starlette.background` zu importieren.

@@ -71,7 +71,7 @@ Indem Sie nur `BackgroundTasks` (und nicht `BackgroundTask`) verwenden, ist es d

 Es ist immer noch möglich, `BackgroundTask` allein in FastAPI zu verwenden, aber Sie müssen das Objekt in Ihrem Code erstellen und eine Starlette-`Response` zurückgeben, die es enthält.

-Weitere Details finden Sie in [Starlettes offizieller Dokumentation für Hintergrundtasks](https://starlette.dev/background/).
+Weitere Details finden Sie in [Starlettes offizieller Dokumentation für Hintergrundtasks](https://www.starlette.dev/background/).

 ## Vorbehalt { #caveat }

@@ -4,7 +4,7 @@ Wenn Sie eine Anwendung oder eine Web-API erstellen, ist es selten der Fall, das

 **FastAPI** bietet ein praktisches Werkzeug zur Strukturierung Ihrer Anwendung bei gleichzeitiger Wahrung der Flexibilität.

-/// note | Hinweis
+/// info | Info

 Wenn Sie von Flask kommen, wäre dies das Äquivalent zu Flasks Blueprints.

@@ -17,16 +17,16 @@ Nehmen wir an, Sie haben eine Dateistruktur wie diese:
 ```
 .
 ├── app
-│   ├── __init__.py
-│   ├── main.py
-│   ├── dependencies.py
-│   └── routers
-│   │   ├── __init__.py
-│   │   ├── items.py
-│   │   └── users.py
-│   └── internal
-│       ├── __init__.py
-│       └── admin.py
+│   ├── __init__.py
+│   ├── main.py
+│   ├── dependencies.py
+│   └── routers
+│   │   ├── __init__.py
+│   │   ├── items.py
+│   │   └── users.py
+│   └── internal
+│       ├── __init__.py
+│       └── admin.py
 ```

 /// tip | Tipp
@@ -194,7 +194,7 @@ Das Endergebnis ist, dass die Pfade für diese Artikel jetzt wie folgt lauten:

 ///

-/// tip | Tipp
+/// check | Testen

 Die Parameter `prefix`, `tags`, `responses` und `dependencies` sind (wie in vielen anderen Fällen) nur ein Feature von **FastAPI**, um Ihnen dabei zu helfen, Codeverdoppelung zu vermeiden.

@@ -339,7 +339,7 @@ Wir könnten sie auch wie folgt importieren:
 from app.routers import items, users
 ```

-/// note | Hinweis
+/// info | Info

 Die erste Version ist ein „relativer Import“:

@@ -382,7 +382,7 @@ Inkludieren wir nun die `router` aus diesen Submodulen `users` und `items`:

 {* ../../docs_src/bigger_applications/app_an_py310/main.py hl[10:11] title["app/main.py"] *}

-/// note | Hinweis
+/// info | Info

 `users.router` enthält den `APIRouter` in der Datei `app/routers/users.py`.

@@ -396,17 +396,17 @@ Es wird alle Routen von diesem Router als Teil von dieser inkludieren.

 /// note | Technische Details

-FastAPI behält den ursprünglichen `APIRouter` und seine `APIRoute`s aktiv, wenn der Router in die Hauptanwendung eingebunden wird.
+Tatsächlich wird intern eine *Pfadoperation* für jede *Pfadoperation* erstellt, die im `APIRouter` deklariert wurde.

-Das bedeutet, dass benutzerdefinierte Subklassen von `APIRouter` und `APIRoute` auch nach dem Einbinden weiterhin beteiligt sein können.
+Hinter den Kulissen wird es also tatsächlich so funktionieren, als ob alles dieselbe einzige Anwendung wäre.

 ///

-/// tip | Tipp
+/// check | Testen

 Bei der Einbindung von Routern müssen Sie sich keine Gedanken über die Leistung machen.

-Dies ist so konzipiert, dass es leichtgewichtig ist und keinen Overhead pro Request hinzufügt.
+Dies dauert Mikrosekunden und geschieht nur beim Start.

 Es hat also keinen Einfluss auf die Leistung. ⚡

@@ -451,7 +451,7 @@ Hier machen wir es ... nur um zu zeigen, dass wir es können 🤷:

 und es wird korrekt funktionieren, zusammen mit allen anderen *Pfadoperationen*, die mit `app.include_router()` hinzugefügt wurden.

-/// note | Sehr technische Details
+/// info | Sehr technische Details

 **Hinweis**: Dies ist ein sehr technisches Detail, das Sie wahrscheinlich **einfach überspringen** können.

@@ -459,9 +459,9 @@ und es wird korrekt funktionieren, zusammen mit allen anderen *Pfadoperationen*,

 Die `APIRouter` sind nicht „gemountet“, sie sind nicht vom Rest der Anwendung isoliert.

-Das liegt daran, dass wir ihre *Pfadoperationen* im OpenAPI-Schema und in den Benutzeroberflächen inkludieren möchten.
+Das liegt daran, dass wir deren *Pfadoperationen* in das OpenAPI-Schema und die Benutzeroberflächen einbinden möchten.

-FastAPI behält die ursprünglichen Router und Pfadoperationen aktiv und kombiniert Router-Präfixe, Abhängigkeiten, Tags, Responses und weitere Metadaten beim Bearbeiten von Requests und beim Generieren von OpenAPI.
+Da wir sie nicht einfach isolieren und unabhängig vom Rest „mounten“ können, werden die *Pfadoperationen* „geklont“ (neu erstellt) und nicht direkt einbezogen.

 ///

@@ -487,7 +487,7 @@ Auf diese Weise weiß der `fastapi`-Befehl, wo er Ihre App findet.
 Sie könnten auch den Pfad an den Befehl übergeben, etwa:

 ```console
-$ uv run fastapi dev app/main.py
+$ fastapi dev app/main.py
 ```

 Aber dann müssten Sie sich jedes Mal, wenn Sie den `fastapi`-Befehl aufrufen, an den korrekten Pfad erinnern.
@@ -503,7 +503,7 @@ Führen Sie nun Ihre App aus:
 <div class="termy">

 ```console
-$ uv run fastapi dev
+$ fastapi dev

 <span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
@@ -532,16 +532,4 @@ Auf die gleiche Weise, wie Sie einen `APIRouter` in eine `FastAPI`-Anwendung ein
 router.include_router(other_router)
 ```

-Sie können dies vor oder nach dem Einbinden von `router` in die `FastAPI`-App tun. FastAPI inkludiert die *Pfadoperationen* von `other_router` dennoch in Routing und OpenAPI.
-
-Gleiches gilt für später zu den Routern hinzugefügte *Pfadoperationen*. Sie sind auch über die frühere Inklusion sichtbar.
-
-/// warning | Technische Details
-
-Vermeiden Sie es, `router.routes` direkt zu mutieren, nachdem ein Router inkludiert wurde. FastAPI behandelt Router-Inklusion als „live“, sodass der ursprüngliche Router und seine Routen Teil des Routings und der OpenAPI-Generierung bleiben.
-
-Verwenden Sie dokumentierte APIs wie Pfadoperation-Dekoratoren und `.include_router()`, um Routen und Router hinzuzufügen.
-
-Betrachten Sie `router.routes` als eine Low-Level-Routenstruktur, die sowohl Routendefinitionen als auch inkludierte Router enthalten kann, und verlassen Sie sich nicht darauf als flache Liste endgültiger Pfadoperationen.
-
-///
+Stellen Sie sicher, dass Sie dies tun, bevor Sie `router` in die `FastAPI`-App einbinden, damit auch die *Pfadoperationen* von `other_router` inkludiert werden.
@@ -108,7 +108,7 @@ Zum Beispiel:

 {* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}

-/// note | Hinweis
+/// info | Info

 `Body` hat die gleichen zusätzlichen Validierungs- und Metadaten-Parameter wie `Query`, `Path` und andere, die Sie später kennenlernen werden.

@@ -123,7 +123,7 @@ Standardmäßig wird **FastAPI** dann seinen Body direkt erwarten.
 Aber wenn Sie möchten, dass es einen JSON-Body mit einem Schlüssel `item` erwartet, und darin den Inhalt des Modells, so wie es das tut, wenn Sie mehrere Body-Parameter deklarieren, dann können Sie den speziellen `Body`-Parameter `embed` setzen:

 ```Python
-item: Annotated[Item, Body(embed=True)]
+item: Item = Body(embed=True)
 ```

 so wie in:
@@ -4,7 +4,7 @@ Mit **FastAPI** können Sie (dank Pydantic) beliebig tief verschachtelte Modelle

 ## Listen als Felder { #list-fields }

-Sie können ein Attribut als Kindtyp definieren. Zum Beispiel eine Python-`list`:
+Sie können ein Attribut als Kindtyp definieren, zum Beispiel eine Python-`list`.

 {* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}

@@ -12,12 +12,11 @@ Das bewirkt, dass `tags` eine Liste ist, wenngleich es nichts über den Typ der

 ## Listen mit Typ-Parametern als Felder { #list-fields-with-type-parameter }

-Aber Python hat eine spezifische Möglichkeit, Listen mit inneren Typen, auch „Typ-Parameter“ genannt, zu deklarieren:
+Aber Python erlaubt es, Listen mit inneren Typen, auch „Typ-Parameter“ genannt, zu deklarieren.

 ### Eine `list` mit einem Typ-Parameter deklarieren { #declare-a-list-with-a-type-parameter }

-Um Typen zu deklarieren, die Typ-Parameter (innere Typen) haben, wie `list`, `dict`, `tuple`,
-übergeben Sie den/die inneren Typ(en) als „Typ-Parameter“ in eckigen Klammern: `[` und `]`
+Um Typen zu deklarieren, die Typ-Parameter (innere Typen) haben, wie `list`, `dict`, `tuple`, übergeben Sie den/die inneren Typ(en) als „Typ-Parameter“ in eckigen Klammern: `[` und `]`

 ```Python
 my_list: list[str]
@@ -33,19 +32,19 @@ In unserem Beispiel können wir also bewirken, dass `tags` spezifisch eine „Li

 ## Set-Typen { #set-types }

-Aber dann denken wir darüber nach und stellen fest, dass sich die Tags nicht wiederholen sollten, sie wären wahrscheinlich eindeutige Strings.
+Aber dann denken wir darüber nach und stellen fest, dass sich die Tags nicht wiederholen sollen, es sollen eindeutige Strings sein.

-Und Python hat einen speziellen Datentyp für Mengen eindeutiger Elemente, das <abbr title="Menge">`set`</abbr>.
+Python hat einen Datentyp speziell für Mengen eindeutiger Dinge: das <abbr title="Menge">`set`</abbr>.

-Dann können wir `tags` als Set von Strings deklarieren:
+Deklarieren wir also `tags` als Set von Strings.

 {* ../../docs_src/body_nested_models/tutorial003_py310.py hl[12] *}

-Damit wird, selbst wenn Sie einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> mit duplizierten Daten erhalten, dieser zu einem Set eindeutiger Elemente konvertiert.
+Jetzt, selbst wenn Sie einen <abbr title="Request – Anfrage: Daten, die der Client zum Server sendet">Request</abbr> mit duplizierten Daten erhalten, werden diese zu einem Set eindeutiger Dinge konvertiert.

-Und wann immer Sie diese Daten ausgeben, selbst wenn die Quelle Duplikate hatte, wird es als Set von eindeutigen Elementen ausgegeben.
+Und wann immer Sie diese Daten ausgeben, selbst wenn die Quelle Duplikate hatte, wird es als Set von eindeutigen Dingen ausgegeben.

-Und es wird entsprechend annotiert / dokumentiert.
+Und es wird entsprechend annotiert/dokumentiert.

 ## Verschachtelte Modelle { #nested-models }

@@ -53,13 +52,13 @@ Jedes Attribut eines Pydantic-Modells hat einen Typ.

 Aber dieser Typ kann selbst ein anderes Pydantic-Modell sein.

-Sie können also tief verschachtelte JSON-„Objekte“ deklarieren, mit spezifischen Attributnamen, Typen und Validierungen.
+Sie können also tief verschachtelte JSON-„Objekte“ deklarieren, mit spezifischen Attributnamen, -typen, und -validierungen.

 Alles das beliebig tief verschachtelt.

 ### Ein Kindmodell definieren { #define-a-submodel }

-Zum Beispiel können wir ein `Image`-Modell definieren:
+Für ein Beispiel können wir ein `Image`-Modell definieren.

 {* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}

@@ -69,7 +68,7 @@ Und dann können wir es als Typ eines Attributes verwenden:

 {* ../../docs_src/body_nested_models/tutorial004_py310.py hl[18] *}

-Das würde bedeuten, dass **FastAPI** einen Body ähnlich dem folgenden erwartet:
+Das würde bedeuten, dass **FastAPI** einen Body wie folgt erwartet:

 ```JSON
 {
@@ -85,7 +84,7 @@ Das würde bedeuten, dass **FastAPI** einen Body ähnlich dem folgenden erwartet
 }
 ```

-Wiederum, nur mit dieser Deklaration erhalten Sie mit **FastAPI**:
+Wiederum, nur mit dieser Deklaration erhalten Sie von **FastAPI**:

 * Editor-Unterstützung (Codevervollständigung, usw.), selbst für verschachtelte Modelle
 * Datenkonvertierung
@@ -96,7 +95,7 @@ Wiederum, nur mit dieser Deklaration erhalten Sie mit **FastAPI**:

 Abgesehen von normalen einfachen Typen wie `str`, `int`, `float`, usw. können Sie komplexere einfache Typen verwenden, die von `str` erben.

-Um alle Optionen kennenzulernen, die Sie haben, schauen Sie sich [Pydantics Typübersicht](https://pydantic.dev/docs/validation/latest/concepts/types/) an. Sie werden einige Beispiele im nächsten Kapitel kennenlernen.
+Um alle Optionen kennenzulernen, die Sie haben, schauen Sie sich [Pydantics Typübersicht](https://docs.pydantic.dev/latest/concepts/types/) an. Sie werden einige Beispiele im nächsten Kapitel kennenlernen.

 Zum Beispiel, da wir im `Image`-Modell ein Feld `url` haben, können wir deklarieren, dass das eine Instanz von Pydantics `HttpUrl` sein soll, anstelle eines `str`:

@@ -106,7 +105,7 @@ Es wird getestet, ob der String eine gültige URL ist, und als solche wird er in

 ## Attribute mit Listen von Kindmodellen { #attributes-with-lists-of-submodels }

-Sie können Pydantic-Modelle auch als Kindtypen von `list`, `set`, usw. verwenden:
+Sie können Pydantic-Modelle auch als Typen innerhalb von `list`, `set`, usw. verwenden:

 {* ../../docs_src/body_nested_models/tutorial006_py310.py hl[18] *}

@@ -136,7 +135,7 @@ Das wird einen JSON-Body erwarten (konvertieren, validieren, dokumentieren, usw.
 }
 ```

-/// note | Hinweis
+/// info | Info

 Beachten Sie, dass der `images`-Schlüssel jetzt eine Liste von Bild-Objekten hat.

@@ -148,15 +147,15 @@ Sie können beliebig tief verschachtelte Modelle definieren:

 {* ../../docs_src/body_nested_models/tutorial007_py310.py hl[7,12,18,21,25] *}

-/// note | Hinweis
+/// info | Info

-Beachten Sie, wie `Offer` eine Liste von `Item`s hat, die ihrerseits eine optionale Liste von `Image`s haben
+Beachten Sie, wie `Offer` eine Liste von `Item`s hat, die ihrerseits eine optionale Liste von `Image`s haben.

 ///

 ## Bodys aus reinen Listen { #bodies-of-pure-lists }

-Wenn der Wert auf oberster Ebene des JSON-Bodys, den Sie erwarten, ein JSON-`array` (eine Python-`list`) ist, können Sie den Typ im Parameter der Funktion deklarieren, genau wie in Pydantic-Modellen:
+Wenn das äußerste Element des JSON-Bodys, das Sie erwarten, ein JSON-`array` (eine Python-`list`) ist, können Sie den Typ im Funktionsparameter deklarieren, mit der gleichen Syntax wie in Pydantic-Modellen:

 ```Python
 images: list[Image]
@@ -170,29 +169,29 @@ so wie in:

 Und Sie erhalten Editor-Unterstützung überall.

-Selbst für Elemente innerhalb von Listen:
+Selbst für Dinge in Listen:

 <img src="/img/tutorial/body-nested-models/image01.png">

-Sie würden diese Art von Editor-Unterstützung nicht erhalten, wenn Sie direkt mit `dict`, statt mit Pydantic-Modellen arbeiten würden.
+Sie würden diese Editor-Unterstützung nicht erhalten, wenn Sie direkt mit `dict`, statt mit Pydantic-Modellen arbeiten würden.

-Aber Sie müssen sich auch nicht um diese kümmern, hereinkommende Dicts werden automatisch konvertiert und Ihre Ausgabe wird ebenfalls automatisch nach JSON konvertiert.
+Aber Sie müssen sich auch nicht weiter um die Modelle kümmern, hereinkommende Dicts werden automatisch in sie konvertiert. Und was Sie zurückgeben, wird automatisch nach JSON konvertiert.

 ## Bodys mit beliebigen `dict`s { #bodies-of-arbitrary-dicts }

 Sie können einen Body auch als `dict` deklarieren, mit Schlüsseln eines Typs und Werten eines anderen Typs.

-So brauchen Sie vorher nicht zu wissen, wie die gültigen Feld-/Attributnamen lauten (wie es bei Pydantic-Modellen der Fall wäre).
+So brauchen Sie vorher nicht zu wissen, wie die Feld-/Attributnamen lauten (wie es bei Pydantic-Modellen der Fall wäre).

-Das ist nützlich, wenn Sie Schlüssel empfangen wollen, die Sie nicht bereits kennen.
+Das ist nützlich, wenn Sie Schlüssel empfangen, deren Namen Sie nicht bereits kennen.

 ---

 Ein anderer nützlicher Anwendungsfall ist, wenn Sie Schlüssel eines anderen Typs haben wollen, z. B. `int`.

-Das schauen wir uns hier an.
+Das schauen wir uns mal an.

-In diesem Fall akzeptieren Sie irgendein `dict`, solange es `int`-Schlüssel mit `float`-Werten hat:
+Im folgenden Beispiel akzeptieren Sie irgendein `dict`, solange es `int`-Schlüssel und `float`-Werte hat:

 {* ../../docs_src/body_nested_models/tutorial009_py310.py hl[7] *}

@@ -202,9 +201,9 @@ Bedenken Sie, dass JSON nur `str` als Schlüssel unterstützt.

 Aber Pydantic hat automatische Datenkonvertierung.

-Das bedeutet, dass Ihre API-Clients zwar nur Strings als Schlüssel senden können, Pydantic diese aber konvertieren und validieren wird, solange diese Strings nur Ganzzahlen enthalten.
+Das bedeutet, dass Ihre API-Clients nur Strings senden können, aber solange diese Strings nur Zahlen enthalten, wird Pydantic sie konvertieren und validieren.

-Und das `dict`, welches Sie als `weights` erhalten, wird tatsächlich `int`-Schlüssel und `float`-Werte haben.
+Und das `dict`, welches Sie als `weights` erhalten, wird `int`-Schlüssel und `float`-Werte haben.

 ///

@@ -214,8 +213,8 @@ Mit **FastAPI** haben Sie die maximale Flexibilität von Pydantic-Modellen, wäh

 Aber mit all den Vorzügen:

-* Editor-Unterstützung (Codevervollständigung überall!)
-* Datenkonvertierung (auch bekannt als Parsen / Serialisierung)
+* Editor-Unterstützung (Codevervollständigung überall)
+* Datenkonvertierung (auch bekannt als Parsen, Serialisierung)
 * Datenvalidierung
 * Schema-Dokumentation
 * Automatische Dokumentation
@@ -6,15 +6,15 @@ Ein <abbr title="Anfragekörper">**Request**body</abbr> sind Daten, die vom Clie

 Ihre API muss fast immer einen **Response**body senden. Aber Clients müssen nicht unbedingt immer **Requestbodys** senden, manchmal fordern sie nur einen Pfad an, vielleicht mit einigen Query-Parametern, aber senden keinen Body.

-Um einen **Request**body zu deklarieren, verwenden Sie [Pydantic](https://pydantic.dev/docs/)-Modelle mit all deren Fähigkeiten und Vorzügen.
+Um einen **Request**body zu deklarieren, verwenden Sie [Pydantic](https://docs.pydantic.dev/)-Modelle mit all deren Fähigkeiten und Vorzügen.

-/// note | Hinweis
+/// info | Info

 Um Daten zu senden, sollten Sie eines von: `POST` (meistverwendet), `PUT`, `DELETE` oder `PATCH` verwenden.

 Das Senden eines Bodys mit einem `GET`-Request hat ein undefiniertes Verhalten in den Spezifikationen, wird aber dennoch von FastAPI unterstützt, nur für sehr komplexe/extreme Anwendungsfälle.

-Da davon abgeraten wird, zeigt die interaktive Dokumentation mit Swagger UI die Dokumentation für den Body nicht an, wenn `GET` verwendet wird, und zwischengeschaltete Proxys unterstützen es möglicherweise nicht.
+Da davon abgeraten wird, zeigt die interaktive Dokumentation mit Swagger-Benutzeroberfläche die Dokumentation für den Body nicht an, wenn `GET` verwendet wird, und zwischengeschaltete Proxys unterstützen es möglicherweise nicht.

 ///

@@ -32,7 +32,6 @@ Verwenden Sie Standard-Python-Typen für alle Attribute:

 {* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}

-
 Wie auch bei der Deklaration von Query-Parametern gilt: Wenn ein Modellattribut einen Defaultwert hat, ist das Attribut nicht erforderlich. Andernfalls ist es erforderlich. Verwenden Sie `None`, um es einfach optional zu machen.

 Zum Beispiel deklariert das obige Modell ein JSON „`object`“ (oder Python-<abbr title="Dictionary – Zuordnungstabelle: In anderen Sprachen auch Hash, Map, Objekt, Assoziatives Array genannt">`dict`</abbr>) wie dieses:
@@ -46,7 +45,7 @@ Zum Beispiel deklariert das obige Modell ein JSON „`object`“ (oder Python-<a
 }
 ```

-... da `description` und `tax` optional sind (mit `None` als Defaultwert), wäre dieses JSON „`object`“ ebenfalls gültig:
+Da `description` und `tax` optional sind (mit `None` als Defaultwert), wäre folgendes JSON „`object`“ auch gültig:

 ```JSON
 {
@@ -110,7 +109,7 @@ Aber Sie würden die gleiche Editor-Unterstützung in [PyCharm](https://www.jetb

 /// tip | Tipp

-Wenn Sie [PyCharm](https://www.jetbrains.com/pycharm/) als Ihren Editor verwenden, können Sie das [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/) verwenden.
+Wenn Sie [PyCharm](https://www.jetbrains.com/pycharm/) als Ihren Editor verwenden, können Sie das [Pydantic PyCharm Plugin](https://github.com/koxudaxi/pydantic-pycharm-plugin/) ausprobieren.

 Es verbessert die Editor-Unterstützung für Pydantic-Modelle, mit:

@@ -128,7 +127,7 @@ Innerhalb der Funktion können Sie alle Attribute des Modellobjekts direkt verwe

 {* ../../docs_src/body/tutorial002_py310.py *}

-## Requestbody + Pfad-Parameter { #request-body-path-parameters }
+## Requestbody- + Pfad-Parameter { #request-body-path-parameters }

 Sie können Pfad-Parameter und den Requestbody gleichzeitig deklarieren.

@@ -137,7 +136,7 @@ Sie können Pfad-Parameter und den Requestbody gleichzeitig deklarieren.
 {* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}


-## Requestbody + Pfad- + Query-Parameter { #request-body-path-query-parameters }
+## Requestbody- + Pfad- + Query-Parameter { #request-body-path-query-parameters }

 Sie können auch zur gleichen Zeit **Body-**, **Pfad-** und **Query-Parameter** deklarieren.

@@ -153,7 +152,7 @@ Die Funktionsparameter werden wie folgt erkannt:

 /// note | Hinweis

-FastAPI weiß, dass der Wert von `q` nicht erforderlich ist, aufgrund des Defaultwertes `= None`.
+FastAPI weiß, dass der Wert von `q` nicht erforderlich ist, aufgrund des definierten Defaultwertes `= None`.

 Das `str | None` wird von FastAPI nicht verwendet, um zu bestimmen, dass der Wert nicht erforderlich ist. FastAPI weiß, dass er nicht erforderlich ist, weil er einen Defaultwert von `= None` hat.

@@ -32,7 +32,7 @@ Sie können die definierten Cookies in der Dokumentationsoberfläche unter `/doc
 <img src="/img/tutorial/cookie-param-models/image01.png">
 </div>

-/// note | Hinweis
+/// info | Info

 Bitte beachten Sie, dass Browser Cookies auf spezielle Weise und im Hintergrund bearbeiten, sodass sie **nicht** leicht **JavaScript** erlauben, diese zu berühren.

@@ -24,13 +24,13 @@ Aber denken Sie daran, dass, wenn Sie `Query`, `Path`, `Cookie` und andere von `

 ///

-/// note | Hinweis
+/// info | Info

 Um Cookies zu deklarieren, müssen Sie `Cookie` verwenden, da die Parameter sonst als Query-Parameter interpretiert würden.

 ///

-/// note | Hinweis
+/// info | Info

 Beachten Sie, dass **Browser Cookies auf besondere Weise und hinter den Kulissen handhaben** und **JavaScript** **nicht** ohne Weiteres erlauben, auf sie zuzugreifen.

@@ -15,7 +15,7 @@ Der Hauptzweck von `__name__ == "__main__"` ist, dass Code ausgeführt wird, wen
 <div class="termy">

 ```console
-$ uv run python myapp.py
+$ python myapp.py
 ```

 </div>
@@ -35,7 +35,7 @@ Wenn Sie sie mit folgendem Befehl ausführen:
 <div class="termy">

 ```console
-$ uv run python myapp.py
+$ python myapp.py
 ```

 </div>
@@ -72,7 +72,7 @@ Daher wird die Zeile:

 nicht ausgeführt.

-/// note | Hinweis
+/// info | Info

 Für weitere Informationen besuchen Sie bitte [die offizielle Python-Dokumentation](https://docs.python.org/3/library/__main__.html).

@@ -88,7 +88,7 @@ Zum Beispiel können Sie in Visual Studio Code:

 * Zum „Debug“-Panel gehen.
 * „Konfiguration hinzufügen ...“ auswählen.
-* „Python“ auswählen
+* „Python“ auswählen.
 * Den Debugger mit der Option „`Python: Current File (Integrated Terminal)`“ ausführen.

 Der Server wird dann mit Ihrem **FastAPI**-Code gestartet, an Ihren Haltepunkten angehalten, usw.
@@ -99,7 +99,7 @@ So könnte es aussehen:

 ---

-Wenn Sie PyCharm verwenden, können Sie:
+Wenn Sie Pycharm verwenden, können Sie:

 * Das Menü „Run“ öffnen.
 * Die Option „Debug ...“ auswählen.
@@ -28,7 +28,7 @@ Damit wird auch vermieden, neue Entwickler möglicherweise zu verwirren, die ein

 ///

-/// note | Hinweis
+/// info | Info

 In diesem Beispiel verwenden wir zwei erfundene benutzerdefinierte Header `X-Key` und `X-Token`.

@@ -2,7 +2,7 @@

 FastAPI unterstützt Abhängigkeiten, die einige <dfn title="manchmal auch genannt: „Exit Code“, „Cleanup Code“, „Teardown Code“, „Closing Code“, „Kontextmanager Exit Code“, usw.">zusätzliche Schritte nach Abschluss</dfn> ausführen.

-Verwenden Sie dazu `yield` statt `return` und schreiben Sie die zusätzlichen Schritte (Code) danach.
+Verwenden Sie dazu `yield` statt `return` und schreiben Sie die zusätzlichen Schritte / den zusätzlichen Code danach.

 /// tip | Tipp

@@ -77,7 +77,7 @@ Und wiederum benötigt `dependency_b` den Wert von `dependency_a` (hier `dep_a`

 {* ../../docs_src/dependencies/tutorial008_an_py310.py hl[18:19,26:27] *}

-Auf die gleiche Weise könnten Sie einige Abhängigkeiten mit `yield` und einige andere Abhängigkeiten mit `return` haben, und einige davon von einigen der anderen abhängen lassen.
+Auf die gleiche Weise könnten Sie einige Abhängigkeiten mit `yield` und einige andere Abhängigkeiten mit `return` haben, und alle können beliebig voneinander abhängen.

 Und Sie könnten eine einzelne Abhängigkeit haben, die auf mehreren ge`yield`eten Abhängigkeiten basiert, usw.

@@ -170,7 +170,7 @@ participant tasks as Hintergrundtasks
    end
 ```

-/// note | Hinweis
+/// info | Info

 Es wird nur **eine Response** an den Client gesendet. Es kann eine Error-Response oder die Response der *Pfadoperation* sein.

@@ -234,7 +234,6 @@ participant operation as Pfadoperation
 Abhängigkeiten mit `yield` haben sich im Laufe der Zeit weiterentwickelt, um verschiedene Anwendungsfälle abzudecken und einige Probleme zu beheben.

 Wenn Sie sehen möchten, was sich in verschiedenen Versionen von FastAPI geändert hat, lesen Sie mehr dazu im fortgeschrittenen Teil, unter [Fortgeschrittene Abhängigkeiten – Abhängigkeiten mit `yield`, `HTTPException`, `except` und Hintergrundtasks](../../advanced/advanced-dependencies.md#dependencies-with-yield-httpexception-except-and-background-tasks).
-
 ## Kontextmanager { #context-managers }

 ### Was sind „Kontextmanager“ { #what-are-context-managers }
@@ -267,19 +266,18 @@ Wenn Sie gerade erst mit **FastAPI** beginnen, möchten Sie das vielleicht vorer

 In Python können Sie Kontextmanager erstellen, indem Sie [eine Klasse mit zwei Methoden erzeugen: `__enter__()` und `__exit__()`](https://docs.python.org/3/reference/datamodel.html#context-managers).

-Sie können solche auch innerhalb von **FastAPI**-Abhängigkeiten mit `yield` verwenden, indem Sie
-`with`- oder `async with`-Anweisungen innerhalb der Abhängigkeits-Funktion verwenden:
+Sie können solche auch innerhalb von **FastAPI**-Abhängigkeiten mit `yield` verwenden, indem Sie `with`- oder `async with`-Anweisungen innerhalb der Abhängigkeits-Funktion verwenden:

 {* ../../docs_src/dependencies/tutorial010_py310.py hl[1:9,13] *}

 /// tip | Tipp

-Eine weitere Möglichkeit, einen Kontextmanager zu erstellen, ist:
+Andere Möglichkeiten, einen Kontextmanager zu erstellen, sind:

 * [`@contextlib.contextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.contextmanager) oder
 * [`@contextlib.asynccontextmanager`](https://docs.python.org/3/library/contextlib.html#contextlib.asynccontextmanager)

-indem Sie damit eine Funktion dekorieren, die ein einziges `yield` hat.
+Verwenden Sie diese, um eine Funktion zu dekorieren, die ein einziges `yield` hat.

 Das ist es auch, was **FastAPI** intern für Abhängigkeiten mit `yield` verwendet.
Author	SHA1	Message	Date
Yurii Motov	d7be7f6b05	Merge remote-tracking branch 'upstream/master' into pin-actions-by-sha	2026-04-03 21:41:31 +02:00
Yurii Motov	b269f891e8	Pin pre-commit hook by hash	2026-04-03 21:41:11 +02:00
Yurii Motov	e4b41511a3	Pin github actions by commit sha	2026-03-30 11:51:20 +02:00
				`@@ -0,0 +1 @@`
				`Please read the [Development - Contributing](https://fastapi.tiangolo.com/contributing/) guidelines in the documentation site.`