⬆ Bump actions/upload-artifact from 5 to 6

Bumps [actions/upload-artifact](https://github.com/actions/upload-artifact) from 5 to 6.
- [Release notes](https://github.com/actions/upload-artifact/releases)
- [Commits](https://github.com/actions/upload-artifact/compare/v5...v6)

---
updated-dependencies:
- dependency-name: actions/upload-artifact
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/build-docs.yml

@@ -104,7 +104,7 @@ jobs:
           path: docs/${{ matrix.lang }}/.cache
       - name: Build Docs
         run: python ./scripts/docs.py build-lang ${{ matrix.lang }}
-      - uses: actions/upload-artifact@v5
+      - uses: actions/upload-artifact@v6
         with:
           name: docs-site-${{ matrix.lang }}
           path: ./site/**

.github/workflows/smokeshow.yml

@@ -13,7 +13,6 @@ env:
 
 jobs:
   smokeshow:
-    if: ${{ github.event.workflow_run.conclusion == 'success' }}
     runs-on: ubuntu-latest
 
     steps:
@@ -24,12 +23,10 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions/setup-python@v6
         with:
-          python-version: '3.9'
+          python-version: '3.13'
       - name: Setup uv
         uses: astral-sh/setup-uv@v7
         with:
-          version: "0.4.15"
-          enable-cache: true
           cache-dependency-glob: |
             requirements**.txt
             pyproject.toml

.github/workflows/test.yml

@@ -31,35 +31,58 @@ jobs:
       - name: Setup uv
         uses: astral-sh/setup-uv@v7
         with:
-          version: "0.4.15"
-          enable-cache: true
           cache-dependency-glob: |
             requirements**.txt
             pyproject.toml
       - name: Install Dependencies
         run: uv pip install -r requirements-tests.txt
-      - name: Install Pydantic v2
-        run: uv pip install --upgrade "pydantic>=2.0.2,<3.0.0"
       - name: Lint
         run: bash scripts/lint.sh
 
   test:
-    runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version:
-          - "3.14"
-          - "3.13"
-          - "3.12"
-          - "3.11"
-          - "3.10"
-          - "3.9"
-          - "3.8"
-        pydantic-version: ["pydantic-v1", "pydantic-v2"]
-        exclude:
-          - python-version: "3.14"
-            pydantic-version: "pydantic-v1"
+        os: [ windows-latest, macos-latest ]
+        python-version: [ "3.14" ]
+        pydantic-version: [ "pydantic>=2.0.2,<3.0.0" ]
+        include:
+          - os: macos-latest
+            python-version: "3.8"
+            pydantic-version: "pydantic>=1.10.0,<2.0.0"
+          - os: windows-latest
+            python-version: "3.8"
+            pydantic-version: "pydantic>=2.0.2,<3.0.0"
+            coverage: coverage
+          - os: ubuntu-latest
+            python-version: "3.9"
+            pydantic-version: "pydantic>=1.10.0,<2.0.0"
+            coverage: coverage
+          - os: macos-latest
+            python-version: "3.10"
+            pydantic-version: "pydantic>=2.0.2,<3.0.0"
+          - os: windows-latest
+            python-version: "3.11"
+            pydantic-version: "pydantic>=1.10.0,<2.0.0"
+          - os: ubuntu-latest
+            python-version: "3.12"
+            pydantic-version: "pydantic>=2.0.2,<3.0.0"
+          - os: macos-latest
+            python-version: "3.13"
+            pydantic-version: "pydantic>=1.10.0,<2.0.0"
+          - os: windows-latest
+            python-version: "3.13"
+            pydantic-version: "pydantic>=2.0.2,<3.0.0"
+            coverage: coverage
+          # - os: ubuntu-latest
+          #   python-version: "3.13"
+          #   pydantic-version: "pydantic>=2.0.2,<2.7.0"
+          #   coverage: coverage
+          - os: ubuntu-latest
+            python-version: "3.14"
+            pydantic-version: "pydantic>=2.0.2,<3.0.0"
+            coverage: coverage
       fail-fast: false
+    runs-on: ${{ matrix.os }}
     steps:
       - name: Dump GitHub context
         env:
@@ -80,12 +103,8 @@ jobs:
             pyproject.toml
       - name: Install Dependencies
         run: uv pip install -r requirements-tests.txt
-      - name: Install Pydantic v1
-        if: matrix.pydantic-version == 'pydantic-v1'
-        run: uv pip install "pydantic>=1.10.0,<2.0.0"
-      - name: Install Pydantic v2
-        if: matrix.pydantic-version == 'pydantic-v2'
-        run: uv pip install --upgrade "pydantic>=2.0.2,<3.0.0"
+      - name: Install Pydantic
+        run: uv pip install "${{ matrix.pydantic-version }}"
       # TODO: Remove this once Python 3.8 is no longer supported
       - name: Install older AnyIO in Python 3.8
         if: matrix.python-version == '3.8'
@@ -96,10 +115,12 @@ jobs:
         env:
           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
-        uses: actions/upload-artifact@v5
+        if: matrix.coverage == 'coverage'
+        uses: actions/upload-artifact@v6
         with:
-          name: coverage-${{ matrix.python-version }}-${{ matrix.pydantic-version }}
+          name: coverage-${{ runner.os }}-${{ matrix.python-version }}-${{ hashFiles('**/coverage/.coverage.*') }}
           path: coverage
           include-hidden-files: true
 
@@ -133,14 +154,14 @@ jobs:
           merge-multiple: true
       - run: ls -la coverage
       - run: coverage combine coverage
-      - run: coverage report
       - run: coverage html --title "Coverage for ${{ github.sha }}"
       - name: Store coverage HTML
-        uses: actions/upload-artifact@v5
+        uses: actions/upload-artifact@v6
         with:
           name: coverage-html
           path: htmlcov
           include-hidden-files: true
+      - run: coverage report --fail-under=100
 
   # https://github.com/marketplace/actions/alls-green#why
   check:  # This job does nothing and is only used for the branch protection

.github/workflows/translate.yml

@@ -1,6 +1,9 @@
 name: Translate
 
 on:
+  schedule:
+    - cron: "0 5 15 * *"  # Run at 05:00 on the 15 of every month
+
   workflow_dispatch:
     inputs:
       debug_enabled:
@@ -16,7 +19,7 @@ on:
           - update-outdated
           - add-missing
           - update-and-add
-          - remove-all-removable
+          - remove-removable
       language:
         description: Language to translate to as a letter code (e.g. "es" for Spanish)
         type: string
@@ -32,16 +35,12 @@ env:
   UV_SYSTEM_PYTHON: 1
 
 jobs:
-  job:
-    if: github.repository_owner == 'fastapi'
+  langs:
     runs-on: ubuntu-latest
-    permissions:
-      contents: write
+    outputs:
+      langs: ${{ steps.show-langs.outputs.langs }}
+      commands: ${{ steps.show-langs.outputs.commands }}
     steps:
-      - name: Dump GitHub context
-        env:
-          GITHUB_CONTEXT: ${{ toJson(github) }}
-        run: echo "$GITHUB_CONTEXT"
       - uses: actions/checkout@v6
       - name: Set up Python
         uses: actions/setup-python@v6
@@ -50,8 +49,45 @@ jobs:
       - name: Setup uv
         uses: astral-sh/setup-uv@v7
         with:
-          version: "0.4.15"
-          enable-cache: true
+          cache-dependency-glob: |
+            requirements**.txt
+            pyproject.toml
+      - name: Install Dependencies
+        run: uv pip install -r requirements-github-actions.txt -r requirements-translations.txt
+      - name: Export Language Codes
+        id: show-langs
+        run: |
+          echo "langs=$(python ./scripts/translate.py llm-translatable-json)" >> $GITHUB_OUTPUT
+          echo "commands=$(python ./scripts/translate.py commands-json)" >> $GITHUB_OUTPUT
+        env:
+          LANGUAGE: ${{ github.event.inputs.language }}
+          COMMAND: ${{ github.event.inputs.command }}
+
+  translate:
+    if: github.repository_owner == 'fastapi'
+    needs: langs
+    runs-on: ubuntu-latest
+    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@v6
+        with:
+          fetch-depth: 0
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.11"
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v7
+        with:
           cache-dependency-glob: |
             requirements**.txt
             pyproject.toml
@@ -68,10 +104,11 @@ jobs:
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
       - name: FastAPI Translate
         run: |
-          python ./scripts/translate.py ${{ github.event.inputs.command }}
+          python ./scripts/translate.py ${{ matrix.command }}
           python ./scripts/translate.py make-pr
         env:
           GITHUB_TOKEN: ${{ secrets.FASTAPI_TRANSLATIONS }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
-          LANGUAGE: ${{ github.event.inputs.language }}
+          LANGUAGE: ${{ matrix.lang }}
           EN_PATH: ${{ github.event.inputs.en_path }}
+          COMMAND: ${{ matrix.command }}

docs/de/docs/advanced/additional-responses.md

@@ -175,7 +175,7 @@ Sie können denselben `responses`-Parameter verwenden, um verschiedene Medientyp
 
 Sie können beispielsweise einen zusätzlichen Medientyp `image/png` hinzufügen und damit deklarieren, dass Ihre *Pfadoperation* ein JSON-Objekt (mit dem Medientyp `application/json`) oder ein PNG-Bild zurückgeben kann:
 
-{* ../../docs_src/additional_responses/tutorial002.py hl[19:24,28] *}
+{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}
 
 /// note | Hinweis
 
@@ -237,7 +237,7 @@ Mit dieser Technik können Sie einige vordefinierte Responses in Ihren *Pfadoper
 
 Zum Beispiel:
 
-{* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
+{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
 
 ## Weitere Informationen zu OpenAPI-Responses { #more-information-about-openapi-responses }
 

docs/de/docs/advanced/dataclasses.md

@@ -4,7 +4,7 @@ FastAPI basiert auf **Pydantic**, und ich habe Ihnen gezeigt, wie Sie Pydantic-M
 
 Aber FastAPI unterstützt auf die gleiche Weise auch die Verwendung von <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a>:
 
-{* ../../docs_src/dataclasses/tutorial001.py hl[1,7:12,19:20] *}
+{* ../../docs_src/dataclasses/tutorial001_py310.py hl[1,6:11,18:19] *}
 
 Das ist dank **Pydantic** ebenfalls möglich, da es <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">`dataclasses` intern unterstützt</a>.
 
@@ -32,7 +32,7 @@ Wenn Sie jedoch eine Menge Datenklassen herumliegen haben, ist dies ein guter Tr
 
 Sie können `dataclasses` auch im Parameter `response_model` verwenden:
 
-{* ../../docs_src/dataclasses/tutorial002.py hl[1,7:13,19] *}
+{* ../../docs_src/dataclasses/tutorial002_py310.py hl[1,6:12,18] *}
 
 Die Datenklasse wird automatisch in eine Pydantic-Datenklasse konvertiert.
 
@@ -48,7 +48,7 @@ In einigen Fällen müssen Sie möglicherweise immer noch Pydantics Version von
 
 In diesem Fall können Sie einfach die Standard-`dataclasses` durch `pydantic.dataclasses` ersetzen, was einen direkten Ersatz darstellt:
 
-{* ../../docs_src/dataclasses/tutorial003.py hl[1,5,8:11,14:17,23:25,28] *}
+{* ../../docs_src/dataclasses/tutorial003_py310.py hl[1,4,7:10,13:16,22:24,27] *}
 
 1. Wir importieren `field` weiterhin von Standard-`dataclasses`.
 

docs/de/docs/advanced/openapi-callbacks.md

@@ -31,7 +31,7 @@ Sie verfügt über eine *Pfadoperation*, die einen `Invoice`-Body empfängt, und
 
 Dieser Teil ist ziemlich normal, der größte Teil des Codes ist Ihnen wahrscheinlich bereits bekannt:
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[9:13,36:53] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[7:11,34:51] *}
 
 /// tip | Tipp
 
@@ -90,7 +90,7 @@ Wenn Sie diese Sichtweise (des *externen Entwicklers*) vorübergehend übernehme
 
 Erstellen Sie zunächst einen neuen `APIRouter`, der einen oder mehrere Callbacks enthält.
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[3,25] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[1,23] *}
 
 ### Die Callback-*Pfadoperation* erstellen { #create-the-callback-path-operation }
 
@@ -101,7 +101,7 @@ Sie sollte wie eine normale FastAPI-*Pfadoperation* aussehen:
 * Sie sollte wahrscheinlich eine Deklaration des Bodys enthalten, die sie erhalten soll, z. B. `body: InvoiceEvent`.
 * Und sie könnte auch eine Deklaration der Response enthalten, die zurückgegeben werden soll, z. B. `response_model=InvoiceEventReceived`.
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[16:18,21:22,28:32] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}
 
 Es gibt zwei Hauptunterschiede zu einer normalen *Pfadoperation*:
 
@@ -169,7 +169,7 @@ An diesem Punkt haben Sie die benötigte(n) *Callback-Pfadoperation(en)* (diejen
 
 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.py hl[35] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[33] *}
 
 /// tip | Tipp
 

docs/de/docs/advanced/path-operation-advanced-configuration.md

@@ -50,7 +50,7 @@ Das Hinzufügen eines `\f` (ein maskiertes „Form Feed“-Zeichen) führt dazu,
 
 Sie wird nicht in der Dokumentation angezeigt, aber andere Tools (z. B. Sphinx) können den Rest verwenden.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
 
 ## Zusätzliche Responses { #additional-responses }
 
@@ -155,13 +155,13 @@ In der folgenden Anwendung verwenden wir beispielsweise weder die integrierte Fu
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
 
 ////
 
@@ -179,13 +179,13 @@ Und dann parsen wir in unserem Code diesen YAML-Inhalt direkt und verwenden dann
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
 
 ////
 

docs/de/docs/advanced/response-directly.md

@@ -34,7 +34,7 @@ Sie können beispielsweise kein Pydantic-Modell in eine `JSONResponse` einfügen
 
 In diesen Fällen können Sie den `jsonable_encoder` verwenden, um Ihre Daten zu konvertieren, bevor Sie sie an eine Response übergeben:
 
-{* ../../docs_src/response_directly/tutorial001.py hl[6:7,21:22] *}
+{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
 
 /// note | Technische Details
 

docs/de/docs/advanced/settings.md

@@ -148,7 +148,7 @@ Dies könnte besonders beim Testen nützlich sein, da es sehr einfach ist, eine
 
 Ausgehend vom vorherigen Beispiel könnte Ihre Datei `config.py` so aussehen:
 
-{* ../../docs_src/settings/app02/config.py hl[10] *}
+{* ../../docs_src/settings/app02_an_py39/config.py hl[10] *}
 
 Beachten Sie, dass wir jetzt keine Standardinstanz `settings = Settings()` erstellen.
 
@@ -174,7 +174,7 @@ Und dann können wir das von der *Pfadoperation-Funktion* als Abhängigkeit einf
 
 Dann wäre es sehr einfach, beim Testen ein anderes Einstellungsobjekt bereitzustellen, indem man eine Abhängigkeitsüberschreibung für `get_settings` erstellt:
 
-{* ../../docs_src/settings/app02/test_main.py hl[9:10,13,21] *}
+{* ../../docs_src/settings/app02_an_py39/test_main.py hl[9:10,13,21] *}
 
 Bei der Abhängigkeitsüberschreibung legen wir einen neuen Wert für `admin_email` fest, wenn wir das neue `Settings`-Objekt erstellen, und geben dann dieses neue Objekt zurück.
 
@@ -217,7 +217,7 @@ Und dann aktualisieren Sie Ihre `config.py` mit:
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/settings/app03_an/config.py hl[9] *}
+{* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
 
 /// tip | Tipp
 
@@ -229,7 +229,7 @@ Das Attribut `model_config` wird nur für die Pydantic-Konfiguration verwendet.
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/settings/app03_an/config_pv1.py hl[9:10] *}
+{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
 
 /// tip | Tipp
 

docs/de/docs/how-to/configure-swagger-ui.md

@@ -40,7 +40,7 @@ FastAPI enthält einige Defaultkonfigurationsparameter, die für die meisten Anw
 
 Es umfasst die folgenden Defaultkonfigurationen:
 
-{* ../../fastapi/openapi/docs.py ln[8:23] hl[17:23] *}
+{* ../../fastapi/openapi/docs.py ln[9:24] hl[18:24] *}
 
 Sie können jede davon überschreiben, indem Sie im Argument `swagger_ui_parameters` einen anderen Wert festlegen.
 

docs/de/docs/how-to/custom-request-and-route.md

@@ -42,7 +42,7 @@ Wenn der Header kein `gzip` enthält, wird nicht versucht, den Body zu dekomprim
 
 Auf diese Weise kann dieselbe Routenklasse gzip-komprimierte oder unkomprimierte Requests verarbeiten.
 
-{* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}
 
 ### Eine benutzerdefinierte `GzipRoute`-Klasse erstellen { #create-a-custom-gziproute-class }
 
@@ -54,7 +54,7 @@ Diese Methode gibt eine Funktion zurück. Und diese Funktion empfängt einen <ab
 
 Hier verwenden wir sie, um aus dem ursprünglichen Request einen `GzipRequest` zu erstellen.
 
-{* ../../docs_src/custom_request_and_route/tutorial001.py hl[18:26] *}
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[19:27] *}
 
 /// note | Technische Details
 
@@ -92,18 +92,18 @@ Wir können denselben Ansatz auch verwenden, um in einem Exceptionhandler auf de
 
 Alles, was wir tun müssen, ist, den Request innerhalb eines `try`/`except`-Blocks zu handhaben:
 
-{* ../../docs_src/custom_request_and_route/tutorial002.py hl[13,15] *}
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[14,16] *}
 
 Wenn eine Exception auftritt, befindet sich die `Request`-Instanz weiterhin im Gültigkeitsbereich, sodass wir den Requestbody lesen und bei der Fehlerbehandlung verwenden können:
 
-{* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *}
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[17:19] *}
 
 ## Benutzerdefinierte `APIRoute`-Klasse in einem Router { #custom-apiroute-class-in-a-router }
 
 Sie können auch den Parameter `route_class` eines `APIRouter` festlegen:
 
-{* ../../docs_src/custom_request_and_route/tutorial003.py hl[26] *}
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[26] *}
 
 In diesem Beispiel verwenden die *Pfadoperationen* unter dem `router` die benutzerdefinierte `TimedRoute`-Klasse und haben in der Response einen zusätzlichen `X-Response-Time`-Header mit der Zeit, die zum Generieren der Response benötigt wurde:
 
-{* ../../docs_src/custom_request_and_route/tutorial003.py hl[13:20] *}
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[13:20] *}

docs/de/docs/project-generation.md

@@ -9,18 +9,18 @@ GitHub-Repository: <a href="https://github.com/tiangolo/full-stack-fastapi-templ
 ## 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://docs.pydantic.dev), verwendet von FastAPI, für die Datenvalidierung und das Einstellungsmanagement.
-    - 💾 [PostgreSQL](https://www.postgresql.org) als SQL-Datenbank.
+  - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) für die Interaktion mit der Python-SQL-Datenbank (ORM).
+  - 🔍 [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](https://vitejs.dev) und anderen Teilen eines modernen Frontend-Stacks.
-    - 🎨 [Chakra UI](https://chakra-ui.com) für die Frontend-Komponenten.
-    - 🤖 Ein automatisch generierter Frontend-Client.
-    - 🧪 [Playwright](https://playwright.dev) für End-to-End-Tests.
-    - 🦇 Unterstützung des Dunkelmodus.
+  - 💃 Verwendung von TypeScript, Hooks, [Vite](https://vitejs.dev) 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.
 - 🐋 [Docker Compose](https://www.docker.com) für Entwicklung und Produktion.
 - 🔒 Sicheres Passwort-Hashing standardmäßig.
-- 🔑 JWT-Token-Authentifizierung.
+- 🔑 JWT (JSON Web Token)-Token-Authentifizierung.
 - 📫 E-Mail-basierte Passwortwiederherstellung.
 - ✅ Tests mit [Pytest](https://pytest.org).
 - 📞 [Traefik](https://traefik.io) als Reverse-Proxy / Load Balancer.

docs/de/docs/resources/index.md

@@ -1,3 +1,3 @@
 # Ressourcen { #resources }
 
-Zusätzliche Ressourcen, externe Links, Artikel und mehr. ✈️
+Zusätzliche Ressourcen, externe Links und mehr. ✈️

docs/de/docs/tutorial/bigger-applications.md

@@ -85,9 +85,7 @@ Sie können die *Pfadoperationen* für dieses Modul mit `APIRouter` erstellen.
 
 Sie importieren ihn und erstellen eine „Instanz“ auf die gleiche Weise wie mit der Klasse `FastAPI`:
 
-```Python hl_lines="1  3" title="app/routers/users.py"
-{!../../docs_src/bigger_applications/app/routers/users.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
 
 ### *Pfadoperationen* mit `APIRouter` { #path-operations-with-apirouter }
 
@@ -95,9 +93,7 @@ Und dann verwenden Sie ihn, um Ihre *Pfadoperationen* zu deklarieren.
 
 Verwenden Sie ihn auf die gleiche Weise wie die Klasse `FastAPI`:
 
-```Python hl_lines="6  11  16" title="app/routers/users.py"
-{!../../docs_src/bigger_applications/app/routers/users.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
 
 Sie können sich `APIRouter` als eine „Mini-`FastAPI`“-Klasse vorstellen.
 
@@ -121,35 +117,7 @@ Also fügen wir sie in ihr eigenes `dependencies`-Modul (`app/dependencies.py`)
 
 Wir werden nun eine einfache Abhängigkeit verwenden, um einen benutzerdefinierten `X-Token`-Header zu lesen:
 
-//// tab | Python 3.9+
-
-```Python hl_lines="3  6-8" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app_an_py39/dependencies.py!}
-```
-
-////
-
-//// tab | Python 3.8+
-
-```Python hl_lines="1  5-7" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app_an/dependencies.py!}
-```
-
-////
-
-//// tab | Python 3.8+ nicht annotiert
-
-/// tip | Tipp
-
-Bevorzugen Sie die `Annotated`-Version, falls möglich.
-
-///
-
-```Python hl_lines="1  4-6" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app/dependencies.py!}
-```
-
-////
+{* ../../docs_src/bigger_applications/app_an_py39/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
 
 /// tip | Tipp
 
@@ -181,9 +149,7 @@ Wir wissen, dass alle *Pfadoperationen* in diesem Modul folgendes haben:
 
 Anstatt also alles zu jeder *Pfadoperation* hinzuzufügen, können wir es dem `APIRouter` hinzufügen.
 
-```Python hl_lines="5-10  16  21" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
 
 Da der Pfad jeder *Pfadoperation* mit `/` beginnen muss, wie in:
 
@@ -242,9 +208,7 @@ Und wir müssen die Abhängigkeitsfunktion aus dem Modul `app.dependencies` impo
 
 Daher verwenden wir einen relativen Import mit `..` für die Abhängigkeiten:
 
-```Python hl_lines="3" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[3] title["app/routers/items.py"] *}
 
 #### Wie relative Importe funktionieren { #how-relative-imports-work }
 
@@ -315,9 +279,7 @@ Wir fügen weder das Präfix `/items` noch `tags=["items"]` zu jeder *Pfadoperat
 
 Aber wir können immer noch _mehr_ `tags` hinzufügen, die auf eine bestimmte *Pfadoperation* angewendet werden, sowie einige zusätzliche `responses`, die speziell für diese *Pfadoperation* gelten:
 
-```Python hl_lines="30-31" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[30:31] title["app/routers/items.py"] *}
 
 /// tip | Tipp
 
@@ -343,17 +305,13 @@ Sie importieren und erstellen wie gewohnt eine `FastAPI`-Klasse.
 
 Und wir können sogar [globale Abhängigkeiten](dependencies/global-dependencies.md){.internal-link target=_blank} deklarieren, die mit den Abhängigkeiten für jeden `APIRouter` kombiniert werden:
 
-```Python hl_lines="1  3  7" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[1,3,7] title["app/main.py"] *}
 
 ### Den `APIRouter` importieren { #import-the-apirouter }
 
 Jetzt importieren wir die anderen Submodule, die `APIRouter` haben:
 
-```Python hl_lines="4-5" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[4:5] title["app/main.py"] *}
 
 Da es sich bei den Dateien `app/routers/users.py` und `app/routers/items.py` um Submodule handelt, die Teil desselben Python-Packages `app` sind, können wir einen einzelnen Punkt `.` verwenden, um sie mit „relativen Imports“ zu importieren.
 
@@ -416,17 +374,13 @@ würde der `router` von `users` den von `items` überschreiben und wir könnten
 
 Um also beide in derselben Datei verwenden zu können, importieren wir die Submodule direkt:
 
-```Python hl_lines="5" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
 
 ### Die `APIRouter` für `users` und `items` inkludieren { #include-the-apirouters-for-users-and-items }
 
 Inkludieren wir nun die `router` aus diesen Submodulen `users` und `items`:
 
-```Python hl_lines="10-11" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[10:11] title["app/main.py"] *}
 
 /// info | Info
 
@@ -466,17 +420,13 @@ Sie enthält einen `APIRouter` mit einigen administrativen *Pfadoperationen*, di
 
 In diesem Beispiel wird es ganz einfach sein. Nehmen wir jedoch an, dass wir, da sie mit anderen Projekten in der Organisation geteilt wird, sie nicht ändern und kein `prefix`, `dependencies`, `tags`, usw. direkt zum `APIRouter` hinzufügen können:
 
-```Python hl_lines="3" title="app/internal/admin.py"
-{!../../docs_src/bigger_applications/app/internal/admin.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/internal/admin.py hl[3] title["app/internal/admin.py"] *}
 
 Aber wir möchten immer noch ein benutzerdefiniertes `prefix` festlegen, wenn wir den `APIRouter` einbinden, sodass alle seine *Pfadoperationen* mit `/admin` beginnen, wir möchten es mit den `dependencies` sichern, die wir bereits für dieses Projekt haben, und wir möchten `tags` und `responses` hinzufügen.
 
 Wir können das alles deklarieren, ohne den ursprünglichen `APIRouter` ändern zu müssen, indem wir diese Parameter an `app.include_router()` übergeben:
 
-```Python hl_lines="14-17" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[14:17] title["app/main.py"] *}
 
 Auf diese Weise bleibt der ursprüngliche `APIRouter` unverändert, sodass wir dieselbe `app/internal/admin.py`-Datei weiterhin mit anderen Projekten in der Organisation teilen können.
 
@@ -497,9 +447,7 @@ Wir können *Pfadoperationen* auch direkt zur `FastAPI`-App hinzufügen.
 
 Hier machen wir es ... nur um zu zeigen, dass wir es können 🤷:
 
-```Python hl_lines="21-23" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[21:23] title["app/main.py"] *}
 
 und es wird korrekt funktionieren, zusammen mit allen anderen *Pfadoperationen*, die mit `app.include_router()` hinzugefügt wurden.
 

docs/de/docs/tutorial/cookie-param-models.md

@@ -50,7 +50,7 @@ Ihre API hat jetzt die Macht, ihre eigene <abbr title="Das ist ein Scherz, nur f
 
 Sie können die Modellkonfiguration von Pydantic verwenden, um `extra` Felder zu verbieten (`forbid`):
 
-{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *}
+{* ../../docs_src/cookie_param_models/tutorial002_an_py310.py hl[10] *}
 
 Wenn ein Client versucht, einige **zusätzliche Cookies** zu senden, erhält er eine **Error-<abbr title="Response – Antwort: Daten, die der Server zum anfragenden Client zurücksendet">Response</abbr>**.
 

docs/de/docs/tutorial/handling-errors.md

@@ -127,7 +127,7 @@ Um diesen zu überschreiben, importieren Sie den `RequestValidationError` und ve
 
 Der Exceptionhandler erhält einen `Request` und die Exception.
 
-{* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *}
+{* ../../docs_src/handling_errors/tutorial004.py hl[2,14:19] *}
 
 Wenn Sie nun zu `/items/foo` gehen, erhalten Sie anstelle des standardmäßigen JSON-Fehlers mit:
 
@@ -149,36 +149,17 @@ Wenn Sie nun zu `/items/foo` gehen, erhalten Sie anstelle des standardmäßigen
 eine Textversion mit:
 
 ```
-1 validation error
-path -> item_id
-  value is not a valid integer (type=type_error.integer)
+Validation errors:
+Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
 ```
 
-#### `RequestValidationError` vs. `ValidationError` { #requestvalidationerror-vs-validationerror }
-
-/// warning | Achtung
-
-Dies sind technische Details, die Sie überspringen können, wenn sie für Sie jetzt nicht wichtig sind.
-
-///
-
-`RequestValidationError` ist eine Unterklasse von Pydantics <a href="https://docs.pydantic.dev/latest/concepts/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
-
-**FastAPI** verwendet diesen so, dass, wenn Sie ein Pydantic-Modell in `response_model` verwenden und Ihre Daten einen Fehler haben, Sie den Fehler in Ihrem Log sehen.
-
-Aber der Client/Benutzer wird ihn nicht sehen. Stattdessen erhält der Client einen „Internal Server Error“ mit einem HTTP-Statuscode `500`.
-
-Es sollte so sein, denn wenn Sie einen Pydantic `ValidationError` in Ihrer *Response* oder irgendwo anders in Ihrem Code haben (nicht im *Request* des Clients), ist es tatsächlich ein Fehler in Ihrem Code.
-
-Und während Sie den Fehler beheben, sollten Ihre Clients/Benutzer keinen Zugriff auf interne Informationen über den Fehler haben, da das eine Sicherheitslücke aufdecken könnte.
-
 ### Überschreiben des `HTTPException`-Fehlerhandlers { #override-the-httpexception-error-handler }
 
 Auf die gleiche Weise können Sie den `HTTPException`-Handler überschreiben.
 
 Zum Beispiel könnten Sie eine Klartext-Response statt JSON für diese Fehler zurückgeben wollen:
 
-{* ../../docs_src/handling_errors/tutorial004.py hl[3:4,9:11,22] *}
+{* ../../docs_src/handling_errors/tutorial004.py hl[3:4,9:11,25] *}
 
 /// note | Technische Details
 
@@ -188,6 +169,14 @@ Sie könnten auch `from starlette.responses import PlainTextResponse` verwenden.
 
 ///
 
+/// warning | Achtung
+
+Beachten Sie, dass der `RequestValidationError` Informationen über den Dateinamen und die Zeile enthält, in der der Validierungsfehler auftritt, sodass Sie ihn bei Bedarf mit den relevanten Informationen in Ihren Logs anzeigen können.
+
+Das bedeutet aber auch, dass, wenn Sie ihn einfach in einen String umwandeln und diese Informationen direkt zurückgeben, Sie möglicherweise ein paar Informationen über Ihr System preisgeben. Daher extrahiert und zeigt der Code hier jeden Fehler getrennt.
+
+///
+
 ### Verwenden des `RequestValidationError`-Bodys { #use-the-requestvalidationerror-body }
 
 Der `RequestValidationError` enthält den empfangenen `body` mit den ungültigen Daten.

docs/de/docs/tutorial/testing.md

@@ -122,63 +122,13 @@ Sie verfügt über eine `POST`-Operation, die mehrere Fehler zurückgeben könnt
 
 Beide *Pfadoperationen* erfordern einen `X-Token`-Header.
 
-//// tab | Python 3.10+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an_py310/main.py!}
-```
-
-////
-
-//// tab | Python 3.9+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an_py39/main.py!}
-```
-
-////
-
-//// tab | Python 3.8+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an/main.py!}
-```
-
-////
-
-//// tab | Python 3.10+ nicht annotiert
-
-/// tip | Tipp
-
-Bevorzugen Sie die `Annotated`-Version, falls möglich.
-
-///
-
-```Python
-{!> ../../docs_src/app_testing/app_b_py310/main.py!}
-```
-
-////
-
-//// tab | Python 3.8+ nicht annotiert
-
-/// tip | Tipp
-
-Bevorzugen Sie die `Annotated`-Version, falls möglich.
-
-///
-
-```Python
-{!> ../../docs_src/app_testing/app_b/main.py!}
-```
-
-////
+{* ../../docs_src/app_testing/app_b_an_py310/main.py *}
 
 ### Erweiterte Testdatei { #extended-testing-file }
 
 Anschließend könnten Sie `test_main.py` mit den erweiterten Tests aktualisieren:
 
-{* ../../docs_src/app_testing/app_b/test_main.py *}
+{* ../../docs_src/app_testing/app_b_an_py310/test_main.py *}
 
 
 Wenn Sie möchten, dass der Client Informationen im Request übergibt und Sie nicht wissen, wie das geht, können Sie suchen (googeln), wie es mit `httpx` gemacht wird, oder sogar, wie es mit `requests` gemacht wird, da das Design von HTTPX auf dem Design von Requests basiert.

docs/en/data/external_links.yml

@@ -1,430 +0,0 @@
-Articles:
-  English:
-  - author: Apitally
-    author_link: https://apitally.io
-    link: https://apitally.io/blog/getting-started-with-logging-in-fastapi
-    title: Getting started with logging in FastAPI
-  - author: Balthazar Rouberol
-    author_link: https://balthazar-rouberol.com
-    link: https://blog.balthazar-rouberol.com/how-to-profile-a-fastapi-asynchronous-request
-    title: How to profile a FastAPI asynchronous request
-  - author: Stephen Siegert - Neon
-    link: https://neon.tech/blog/deploy-a-serverless-fastapi-app-with-neon-postgres-and-aws-app-runner-at-any-scale
-    title: Deploy a Serverless FastAPI App with Neon Postgres and AWS App Runner at any scale
-  - author: Kurtis Pykes - NVIDIA
-    link: https://developer.nvidia.com/blog/building-a-machine-learning-microservice-with-fastapi/
-    title: Building a Machine Learning Microservice with FastAPI
-  - author: Ravgeet Dhillon - Twilio
-    link: https://www.twilio.com/en-us/blog/booking-appointments-twilio-notion-fastapi
-    title: Booking Appointments with Twilio, Notion, and FastAPI
-  - author: Abhinav Tripathi - Microsoft Blogs
-    link: https://devblogs.microsoft.com/cosmosdb/azure-cosmos-db-python-and-fastapi/
-    title: Write a Python data layer with Azure Cosmos DB and FastAPI
-  - author: Donny Peeters
-    author_link: https://github.com/Donnype
-    link: https://bitestreams.com/blog/fastapi-sqlalchemy/
-    title: 10 Tips for adding SQLAlchemy to FastAPI
-  - author: Jessica Temporal
-    author_link: https://jtemporal.com/socials
-    link: https://jtemporal.com/tips-on-migrating-from-flask-to-fastapi-and-vice-versa/
-    title: Tips on migrating from Flask to FastAPI and vice-versa
-  - author: Ankit Anchlia
-    author_link: https://linkedin.com/in/aanchlia21
-    link: https://hackernoon.com/explore-how-to-effectively-use-jwt-with-fastapi
-    title: Explore How to Effectively Use JWT With FastAPI
-  - author: Nicoló Lino
-    author_link: https://www.nlino.com
-    link: https://github.com/softwarebloat/python-tracing-demo
-    title: Instrument FastAPI with OpenTelemetry tracing and visualize traces in Grafana Tempo.
-  - author: Mikhail Rozhkov, Elena Samuylova
-    author_link: https://www.linkedin.com/in/mnrozhkov/
-    link: https://www.evidentlyai.com/blog/fastapi-tutorial
-    title: ML serving and monitoring with FastAPI and Evidently
-  - author: Visual Studio Code Team
-    author_link: https://code.visualstudio.com/
-    link: https://code.visualstudio.com/docs/python/tutorial-fastapi
-    title: FastAPI Tutorial in Visual Studio Code
-  - author: Apitally
-    author_link: https://apitally.io
-    link: https://blog.apitally.io/fastapi-application-monitoring-made-easy
-    title: FastAPI application monitoring made easy
-  - author: John Philip
-    author_link: https://medium.com/@amjohnphilip
-    link: https://python.plainenglish.io/building-a-restful-api-with-fastapi-secure-signup-and-login-functionality-included-45cdbcb36106
-    title: "Building a RESTful API with FastAPI: Secure Signup and Login Functionality Included"
-  - author: Keshav Malik
-    author_link: https://theinfosecguy.xyz/
-    link: https://blog.theinfosecguy.xyz/building-a-crud-api-with-fastapi-and-supabase-a-step-by-step-guide
-    title: Building a CRUD API with FastAPI and Supabase
-  - author: Adejumo Ridwan Suleiman
-    author_link: https://www.linkedin.com/in/adejumoridwan/
-    link: https://medium.com/python-in-plain-english/build-an-sms-spam-classifier-serverless-database-with-faunadb-and-fastapi-23dbb275bc5b
-    title: Build an SMS Spam Classifier Serverless Database with FaunaDB and FastAPI
-  - author: Raf Rasenberg
-    author_link: https://rafrasenberg.com/about/
-    link: https://rafrasenberg.com/fastapi-lambda/
-    title: 'FastAPI lambda container: serverless simplified'
-  - author: Teresa N. Fontanella De Santis
-    author_link: https://dev.to/
-    link: https://dev.to/teresafds/authorization-on-fastapi-with-casbin-41og
-    title: Authorization on FastAPI with Casbin
-  - author: New Relic
-    author_link: https://newrelic.com
-    link: https://newrelic.com/instant-observability/fastapi/e559ec64-f765-4470-a15f-1901fcebb468
-    title: How to monitor FastAPI application performance using Python agent
-  - author: Jean-Baptiste Rocher
-    author_link: https://hashnode.com/@jibrocher
-    link: https://dev.indooroutdoor.io/series/fastapi-react-poll-app
-    title: Building the Poll App From Django Tutorial With FastAPI And React
-  - author: Silvan Melchior
-    author_link: https://github.com/silvanmelchior
-    link: https://blog.devgenius.io/seamless-fastapi-configuration-with-confz-90949c14ea12
-    title: Seamless FastAPI Configuration with ConfZ
-  - author: Kaustubh Gupta
-    author_link: https://medium.com/@kaustubhgupta1828/
-    link: https://levelup.gitconnected.com/5-advance-features-of-fastapi-you-should-try-7c0ac7eebb3e
-    title: 5 Advanced Features of FastAPI You Should Try
-  - author: Kaustubh Gupta
-    author_link: https://medium.com/@kaustubhgupta1828/
-    link: https://www.analyticsvidhya.com/blog/2021/06/deploying-ml-models-as-api-using-fastapi-and-heroku/
-    title: Deploying ML Models as API Using FastAPI and Heroku
-  - link: https://jarmos.netlify.app/posts/using-github-actions-to-deploy-a-fastapi-project-to-heroku/
-    title: Using GitHub Actions to Deploy a FastAPI Project to Heroku
-    author_link: https://jarmos.netlify.app/
-    author: Somraj Saha
-  - author: "@pystar"
-    author_link: https://pystar.substack.com/
-    link: https://pystar.substack.com/p/how-to-create-a-fake-certificate
-    title: How to Create A Fake Certificate Authority And Generate TLS Certs for FastAPI
-  - author: Ben Gamble
-    author_link: https://uk.linkedin.com/in/bengamble7
-    link: https://ably.com/blog/realtime-ticket-booking-solution-kafka-fastapi-ably
-    title: Building a realtime ticket booking solution with Kafka, FastAPI, and Ably
-  - author: Shahriyar(Shako) Rzayev
-    author_link: https://www.linkedin.com/in/shahriyar-rzayev/
-    link: https://www.azepug.az/posts/fastapi/#building-simple-e-commerce-with-nuxtjs-and-fastapi-series
-    title: Building simple E-Commerce with NuxtJS and FastAPI
-  - author: Rodrigo Arenas
-    author_link: https://rodrigo-arenas.medium.com/
-    link: https://medium.com/analytics-vidhya/serve-a-machine-learning-model-using-sklearn-fastapi-and-docker-85aabf96729b
-    title: "Serve a machine learning model using Sklearn, FastAPI and Docker"
-  - author: Yashasvi Singh
-    author_link: https://hashnode.com/@aUnicornDev
-    link: https://aunicorndev.hashnode.dev/series/supafast-api
-    title: "Building an API with FastAPI and Supabase and Deploying on Deta"
-  - author: Navule Pavan Kumar Rao
-    author_link: https://www.linkedin.com/in/navule/
-    link: https://www.tutlinks.com/deploy-fastapi-on-ubuntu-gunicorn-caddy-2/
-    title: Deploy FastAPI on Ubuntu and Serve using Caddy 2 Web Server
-  - author: Patrick Ladon
-    author_link: https://dev.to/factorlive
-    link: https://dev.to/factorlive/python-facebook-messenger-webhook-with-fastapi-on-glitch-4n90
-    title: Python Facebook messenger webhook with FastAPI on Glitch
-  - author: Valon Januzaj
-    author_link: https://www.linkedin.com/in/valon-januzaj-b02692187/
-    link: https://valonjanuzaj.medium.com/deploy-a-dockerized-fastapi-application-to-aws-cc757830ba1b
-    title: Deploy a dockerized FastAPI application to AWS
-  - author: Amit Chaudhary
-    author_link: https://x.com/amitness
-    link: https://amitness.com/2020/06/fastapi-vs-flask/
-    title: FastAPI for Flask Users
-  - author: Louis Guitton
-    author_link: https://x.com/louis_guitton
-    link: https://guitton.co/posts/fastapi-monitoring/
-    title: How to monitor your FastAPI service
-  - author: Precious Ndubueze
-    author_link: https://medium.com/@gabbyprecious2000
-    link: https://medium.com/@gabbyprecious2000/creating-a-crud-app-with-fastapi-part-one-7c049292ad37
-    title: Creating a CRUD App with FastAPI (Part one)
-  - author: Farhad Malik
-    author_link: https://medium.com/@farhadmalik
-    link: https://towardsdatascience.com/build-and-host-fast-data-science-applications-using-fastapi-823be8a1d6a0
-    title: Build And Host Fast Data Science Applications Using FastAPI
-  - author: Navule Pavan Kumar Rao
-    author_link: https://www.linkedin.com/in/navule/
-    link: https://www.tutlinks.com/deploy-fastapi-on-azure/
-    title: Deploy FastAPI on Azure App Service
-  - author: Davide Fiocco
-    author_link: https://github.com/davidefiocco
-    link: https://davidefiocco.github.io/streamlit-fastapi-ml-serving/
-    title: Machine learning model serving in Python using FastAPI and streamlit
-  - author: Netflix
-    author_link: https://netflixtechblog.com/
-    link: https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072
-    title: Introducing Dispatch
-  - author: Stavros Korokithakis
-    author_link: https://x.com/Stavros
-    link: https://www.stavros.io/posts/fastapi-with-django/
-    title: Using FastAPI with Django
-  - author: Twilio
-    author_link: https://www.twilio.com
-    link: https://www.twilio.com/blog/build-secure-twilio-webhook-python-fastapi
-    title: Build a Secure Twilio Webhook with Python and FastAPI
-  - author: Sebastián Ramírez (tiangolo)
-    author_link: https://x.com/tiangolo
-    link: https://dev.to/tiangolo/build-a-web-api-from-scratch-with-fastapi-the-workshop-2ehe
-    title: Build a web API from scratch with FastAPI - the workshop
-  - author: Paul Sec
-    author_link: https://x.com/PaulWebSec
-    link: https://paulsec.github.io/posts/fastapi_plus_zeit_serverless_fu/
-    title: FastAPI + Zeit.co = 🚀
-  - author: cuongld2
-    author_link: https://dev.to/cuongld2
-    link: https://dev.to/cuongld2/build-simple-api-service-with-python-fastapi-part-1-581o
-    title: Build simple API service with Python FastAPI — Part 1
-  - author: Paurakh Sharma Humagain
-    author_link: https://x.com/PaurakhSharma
-    link: https://dev.to/paurakhsharma/microservice-in-python-using-fastapi-24cc
-    title: Microservice in Python using FastAPI
-  - author: Guillermo Cruz
-    author_link: https://wuilly.com/
-    link: https://wuilly.com/2019/10/real-time-notifications-with-python-and-postgres/
-    title: Real-time Notifications with Python and Postgres
-  - author: Navule Pavan Kumar Rao
-    author_link: https://www.linkedin.com/in/navule/
-    link: https://www.tutlinks.com/create-and-deploy-fastapi-app-to-heroku/
-    title: Create and Deploy FastAPI app to Heroku without using Docker
-  - author: Arthur Henrique
-    author_link: https://x.com/arthurheinrique
-    link: https://medium.com/@arthur393/another-boilerplate-to-fastapi-azure-pipeline-ci-pytest-3c8d9a4be0bb
-    title: 'Another Boilerplate to FastAPI: Azure Pipeline CI + Pytest'
-  - author: Shane Soh
-    author_link: https://medium.com/@shane.soh
-    link: https://medium.com/analytics-vidhya/deploy-machine-learning-models-with-keras-fastapi-redis-and-docker-4940df614ece
-    title: Deploy Machine Learning Models with Keras, FastAPI, Redis and Docker
-  - author: Mandy Gu
-    author_link: https://towardsdatascience.com/@mandygu
-    link: https://towardsdatascience.com/deploying-iris-classifications-with-fastapi-and-docker-7c9b83fdec3a
-    title: 'Towards Data Science: Deploying Iris Classifications with FastAPI and Docker'
-  - author: Michael Herman
-    author_link: https://testdriven.io/authors/herman
-    link: https://testdriven.io/blog/fastapi-crud/
-    title: 'TestDriven.io: Developing and Testing an Asynchronous API with FastAPI and Pytest'
-  - author: Bernard Brenyah
-    author_link: https://medium.com/@bbrenyah
-    link: https://medium.com/python-data/how-to-deploy-tensorflow-2-0-models-as-an-api-service-with-fastapi-docker-128b177e81f3
-    title: How To Deploy Tensorflow 2.0 Models As An API Service With FastAPI & Docker
-  - author: Dylan Anthony
-    author_link: https://dev.to/dbanty
-    link: https://dev.to/dbanty/why-i-m-leaving-flask-3ki6
-    title: Why I'm Leaving Flask
-  - author: Mike Moritz
-    author_link: https://medium.com/@mike.p.moritz
-    link: https://medium.com/@mike.p.moritz/using-docker-compose-to-deploy-a-lightweight-python-rest-api-with-a-job-queue-37e6072a209b
-    title: Using Docker Compose to deploy a lightweight Python REST API with a job queue
-  - author: '@euri10'
-    author_link: https://gitlab.com/euri10
-    link: https://gitlab.com/euri10/fastapi_cheatsheet
-    title: A FastAPI and Swagger UI visual cheatsheet
-  - author: Uber Engineering
-    author_link: https://eng.uber.com
-    link: https://eng.uber.com/ludwig-v0-2/
-    title: 'Uber: Ludwig v0.2 Adds New Features and Other Improvements to its Deep Learning Toolbox [including a FastAPI server]'
-  - author: Maarten Grootendorst
-    author_link: https://www.linkedin.com/in/mgrootendorst/
-    link: https://towardsdatascience.com/how-to-deploy-a-machine-learning-model-dc51200fe8cf
-    title: How to Deploy a Machine Learning Model
-  - author: Johannes Gontrum
-    author_link: https://x.com/gntrm
-    link: https://medium.com/@gntrm/jwt-authentication-with-fastapi-and-aws-cognito-1333f7f2729e
-    title: JWT Authentication with FastAPI and AWS Cognito
-  - author: Ankush Thakur
-    author_link: https://geekflare.com/author/ankush/
-    link: https://geekflare.com/python-asynchronous-web-frameworks/
-    title: Top 5 Asynchronous Web Frameworks for Python
-  - author: Nico Axtmann
-    author_link: https://www.linkedin.com/in/nico-axtmann
-    link: https://medium.com/@nico.axtmann95/deploying-a-scikit-learn-model-with-onnx-und-fastapi-1af398268915
-    title: Deploying a scikit-learn model with ONNX and FastAPI
-  - author: Nils de Bruin
-    author_link: https://medium.com/@nilsdebruin
-    link: https://medium.com/data-rebels/fastapi-authentication-revisited-enabling-api-key-authentication-122dc5975680
-    title: 'FastAPI authentication revisited: Enabling API key authentication'
-  - author: Nick Cortale
-    author_link: https://nickc1.github.io/
-    link: https://nickc1.github.io/api,/scikit-learn/2019/01/10/scikit-fastapi.html
-    title: 'FastAPI and Scikit-Learn: Easily Deploy Models'
-  - author: Errieta Kostala
-    author_link: https://dev.to/errietta
-    link: https://dev.to/errietta/introduction-to-the-fastapi-python-framework-2n10
-    title: Introduction to the fastapi python framework
-  - author: Nils de Bruin
-    author_link: https://medium.com/@nilsdebruin
-    link: https://medium.com/data-rebels/fastapi-how-to-add-basic-and-cookie-authentication-a45c85ef47d3
-    title: FastAPI — How to add basic and cookie authentication
-  - author: Nils de Bruin
-    author_link: https://medium.com/@nilsdebruin
-    link: https://medium.com/data-rebels/fastapi-google-as-an-external-authentication-provider-3a527672cf33
-    title: FastAPI — Google as an external authentication provider
-  - author: William Hayes
-    author_link: https://medium.com/@williamhayes
-    link: https://medium.com/@williamhayes/fastapi-starlette-debug-vs-prod-5f7561db3a59
-    title: FastAPI/Starlette debug vs prod
-  - author: Mukul Mantosh
-    author_link: https://x.com/MantoshMukul
-    link: https://www.jetbrains.com/pycharm/guide/tutorials/fastapi-aws-kubernetes/
-    title: Developing FastAPI Application using K8s & AWS
-  - author: KrishNa
-    author_link: https://medium.com/@krishnardt365
-    link: https://medium.com/@krishnardt365/fastapi-docker-and-postgres-91943e71be92
-    title: Fastapi, Docker(Docker compose) and Postgres
-  - author: Devon Ray
-    author_link: https://devonray.com
-    link: https://devonray.com/blog/deploying-a-fastapi-project-using-aws-lambda-aurora-cdk
-    title: Deployment using Docker, Lambda, Aurora, CDK & GH Actions
-  - author: Shubhendra Kushwaha
-    author_link: https://www.linkedin.com/in/theshubhendra/
-    link: https://theshubhendra.medium.com/mastering-soft-delete-advanced-sqlalchemy-techniques-4678f4738947
-    title: 'Mastering Soft Delete: Advanced SQLAlchemy Techniques'
-  - author: Shubhendra Kushwaha
-    author_link: https://www.linkedin.com/in/theshubhendra/
-    link: https://theshubhendra.medium.com/role-based-row-filtering-advanced-sqlalchemy-techniques-733e6b1328f6
-    title: 'Role based row filtering: Advanced SQLAlchemy Techniques'
-  German:
-  - author: Marcel Sander (actidoo)
-    author_link: https://www.actidoo.com
-    link: https://www.actidoo.com/de/blog/python-fastapi-domain-driven-design
-    title: Domain-driven Design mit Python und FastAPI
-  - author: Nico Axtmann
-    author_link: https://x.com/_nicoax
-    link: https://blog.codecentric.de/2019/08/inbetriebnahme-eines-scikit-learn-modells-mit-onnx-und-fastapi/
-    title: Inbetriebnahme eines scikit-learn-Modells mit ONNX und FastAPI
-  - author: Felix Schürmeyer
-    author_link: https://hellocoding.de/autor/felix-schuermeyer/
-    link: https://hellocoding.de/blog/coding-language/python/fastapi
-    title: REST-API Programmieren mittels Python und dem FastAPI Modul
-  Japanese:
-  - author: '@bee2'
-    author_link: https://qiita.com/bee2
-    link: https://qiita.com/bee2/items/75d9c0d7ba20e7a4a0e9
-    title: '[FastAPI] Python製のASGI Web フレームワーク FastAPIに入門する'
-  - author: '@bee2'
-    author_link: https://qiita.com/bee2
-    link: https://qiita.com/bee2/items/0ad260ab9835a2087dae
-    title: PythonのWeb frameworkのパフォーマンス比較 (Django, Flask, responder, FastAPI, japronto)
-  - author: ライトコードメディア編集部
-    author_link: https://rightcode.co.jp/author/jun
-    link: https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-admin-page-improvement
-    title: '【第4回】FastAPIチュートリアル: toDoアプリを作ってみよう【管理者ページ改良編】'
-  - author: ライトコードメディア編集部
-    author_link: https://rightcode.co.jp/author/jun
-    link: https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-authentication-user-registration
-    title: '【第3回】FastAPIチュートリアル: toDoアプリを作ってみよう【認証・ユーザ登録編】'
-  - author: ライトコードメディア編集部
-    author_link: https://rightcode.co.jp/author/jun
-    link: https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-model-building
-    title: '【第2回】FastAPIチュートリアル: ToDoアプリを作ってみよう【モデル構築編】'
-  - author: ライトコードメディア編集部
-    author_link: https://rightcode.co.jp/author/jun
-    link: https://rightcode.co.jp/blog/information-technology/fastapi-tutorial-todo-apps-environment
-    title: '【第1回】FastAPIチュートリアル: ToDoアプリを作ってみよう【環境構築編】'
-  - author: Hikaru Takahashi
-    author_link: https://qiita.com/hikarut
-    link: https://qiita.com/hikarut/items/b178af2e2440c67c6ac4
-    title: フロントエンド開発者向けのDockerによるPython開発環境構築
-  - author: '@angel_katayoku'
-    author_link: https://qiita.com/angel_katayoku
-    link: https://qiita.com/angel_katayoku/items/8a458a8952f50b73f420
-    title: FastAPIでPOSTされたJSONのレスポンスbodyを受け取る
-  - author: '@angel_katayoku'
-    author_link: https://qiita.com/angel_katayoku
-    link: https://qiita.com/angel_katayoku/items/4fbc1a4e2b33fa2237d2
-    title: FastAPIをMySQLと接続してDockerで管理してみる
-  - author: '@angel_katayoku'
-    author_link: https://qiita.com/angel_katayoku
-    link: https://qiita.com/angel_katayoku/items/0e1f5dbbe62efc612a78
-    title: FastAPIでCORSを回避
-  - author: '@ryoryomaru'
-    author_link: https://qiita.com/ryoryomaru
-    link: https://qiita.com/ryoryomaru/items/59958ed385b3571d50de
-    title: python製の最新APIフレームワーク FastAPI を触ってみた
-  - author: '@mtitg'
-    author_link: https://qiita.com/mtitg
-    link: https://qiita.com/mtitg/items/47770e9a562dd150631d
-    title: FastAPI｜DB接続してCRUDするPython製APIサーバーを構築
-  Portuguese:
-  - author: Eduardo Mendes
-    author_link: https://bolha.us/@dunossauro
-    link: https://fastapidozero.dunossauro.com/
-    title: FastAPI do ZERO
-  - author: Jessica Temporal
-    author_link: https://jtemporal.com/socials
-    link: https://jtemporal.com/dicas-para-migrar-de-flask-para-fastapi-e-vice-versa/
-    title: Dicas para migrar uma aplicação de Flask para FastAPI e vice-versa
-  Russian:
-  - author: Troy Köhler
-    author_link: https://www.linkedin.com/in/trkohler/
-    link: https://trkohler.com/fast-api-introduction-to-framework
-    title: 'FastAPI: знакомимся с фреймворком'
-  - author: prostomarkeloff
-    author_link: https://github.com/prostomarkeloff
-    link: https://habr.com/ru/post/478620/
-    title: Почему Вы должны попробовать FastAPI?
-  - author: Andrey Korchak
-    author_link: https://habr.com/ru/users/57uff3r/
-    link: https://habr.com/ru/post/454440/
-    title: 'Мелкая питонячая радость #2: Starlette - Солидная примочка – FastAPI'
-  Vietnamese:
-  - author: Nguyễn Nhân
-    author_link: https://fullstackstation.com/author/figonking/
-    link: https://fullstackstation.com/fastapi-trien-khai-bang-docker/
-    title: 'FASTAPI: TRIỂN KHAI BẰNG DOCKER'
-  Taiwanese:
-  - author: Leon
-    author_link: http://editor.leonh.space/
-    link: https://editor.leonh.space/2022/tortoise/
-    title: 'Tortoise ORM / FastAPI 整合快速筆記'
-  Spanish:
-  - author: Eduardo Zepeda
-    author_link: https://coffeebytes.dev/en/authors/eduardo-zepeda/
-    link: https://coffeebytes.dev/es/python-fastapi-el-mejor-framework-de-python/
-    title: 'Tutorial de FastAPI, ¿el mejor framework de Python?'
-Podcasts:
-  English:
-  - author: Behind the Commit
-    author_link: https://www.youtube.com/@BehindtheCommit
-    link: https://youtu.be/iaDRYUQ0OMM
-    title: Why FastAPI Became Python’s Fastest‑Growing Framework – Chat with Sebastián Ramírez
-  - author: Real Python
-    author_link: https://realpython.com/
-    link: https://realpython.com/podcasts/rpp/72/
-    title: Starting With FastAPI and Examining Python's Import System - Episode 72
-  - author: Python Bytes FM
-    author_link: https://pythonbytes.fm/
-    link: https://www.pythonpodcast.com/fastapi-web-application-framework-episode-259/
-    title: 'Do you dare to press "."? - Episode 247 - Dan #6: SQLModel - use the same models for SQL and FastAPI'
-  - author: Podcast.`__init__`
-    author_link: https://www.pythonpodcast.com/
-    link: https://www.pythonpodcast.com/fastapi-web-application-framework-episode-259/
-    title: Build The Next Generation Of Python Web Applications With FastAPI - Episode 259 - interview to Sebastían Ramírez (tiangolo)
-  - author: Python Bytes FM
-    author_link: https://pythonbytes.fm/
-    link: https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855
-    title: FastAPI on PythonBytes
-Talks:
-  English:
-  - author: Sebastián Ramírez (tiangolo)
-    author_link: https://x.com/tiangolo
-    link: https://www.youtube.com/watch?v=mwvmfl8nN_U
-    title: 'Keynote: Behind the scenes of FastAPI and friends for developers and builders — Sebastián Ramírez'
-  - author: Jeny Sadadia
-    author_link: https://github.com/JenySadadia
-    link: https://www.youtube.com/watch?v=uZdTe8_Z6BQ
-    title: 'PyCon AU 2023: Testing asynchronous applications with FastAPI and pytest'
-  - author: Sebastián Ramírez (tiangolo)
-    author_link: https://x.com/tiangolo
-    link: https://www.youtube.com/watch?v=PnpTY1f4k2U
-    title: '[VIRTUAL] Py.Amsterdam''s flying Software Circus: Intro to FastAPI'
-  - author: Sebastián Ramírez (tiangolo)
-    author_link: https://x.com/tiangolo
-    link: https://www.youtube.com/watch?v=z9K5pwb0rt8
-    title: 'PyConBY 2020: Serve ML models easily with FastAPI'
-  - author: Chris Withers
-    author_link: https://x.com/chriswithers13
-    link: https://www.youtube.com/watch?v=3DLwPcrE5mA
-    title: 'PyCon UK 2019: FastAPI from the ground up'
-  Taiwanese:
-  - author: Blueswen
-    author_link: https://github.com/blueswen
-    link: https://www.youtube.com/watch?v=y3sumuoDq4w
-    title: 'PyCon TW 2024: 全方位強化 Python 服務可觀測性：以 FastAPI 和 Grafana Stack 為例'

docs/en/docs/_llm-test.md

@@ -15,7 +15,7 @@ Use as follows:
 
 The tests:
 
-## Code snippets { #code-snippets}
+## Code snippets { #code-snippets }
 
 //// tab | Test
 
@@ -53,7 +53,7 @@ See for example section `### Quotes` in `docs/de/llm-prompt.md`.
 
 ////
 
-## Quotes in code snippets { #quotes-in-code-snippets}
+## Quotes in code snippets { #quotes-in-code-snippets }
 
 //// tab | Test
 

docs/en/docs/advanced/additional-responses.md

@@ -175,7 +175,7 @@ You can use this same `responses` parameter to add different media types for the
 
 For example, you can add an additional media type of `image/png`, declaring that your *path operation* can return a JSON object (with media type `application/json`) or a PNG image:
 
-{* ../../docs_src/additional_responses/tutorial002.py hl[19:24,28] *}
+{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}
 
 /// note
 
@@ -237,7 +237,7 @@ You can use that technique to reuse some predefined responses in your *path oper
 
 For example:
 
-{* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
+{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
 
 ## More information about OpenAPI responses { #more-information-about-openapi-responses }
 

docs/en/docs/advanced/dataclasses.md

@@ -4,7 +4,7 @@ FastAPI is built on top of **Pydantic**, and I have been showing you how to use
 
 But FastAPI also supports using <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a> the same way:
 
-{* ../../docs_src/dataclasses/tutorial001.py hl[1,7:12,19:20] *}
+{* ../../docs_src/dataclasses/tutorial001_py310.py hl[1,6:11,18:19] *}
 
 This is still supported thanks to **Pydantic**, as it has <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">internal support for `dataclasses`</a>.
 
@@ -32,7 +32,7 @@ But if you have a bunch of dataclasses laying around, this is a nice trick to us
 
 You can also use `dataclasses` in the `response_model` parameter:
 
-{* ../../docs_src/dataclasses/tutorial002.py hl[1,7:13,19] *}
+{* ../../docs_src/dataclasses/tutorial002_py310.py hl[1,6:12,18] *}
 
 The dataclass will be automatically converted to a Pydantic dataclass.
 
@@ -48,7 +48,7 @@ In some cases, you might still have to use Pydantic's version of `dataclasses`.
 
 In that case, you can simply swap the standard `dataclasses` with `pydantic.dataclasses`, which is a drop-in replacement:
 
-{* ../../docs_src/dataclasses/tutorial003.py hl[1,5,8:11,14:17,23:25,28] *}
+{* ../../docs_src/dataclasses/tutorial003_py310.py hl[1,4,7:10,13:16,22:24,27] *}
 
 1. We still import `field` from standard `dataclasses`.
 

docs/en/docs/advanced/openapi-callbacks.md

@@ -31,7 +31,7 @@ It will have a *path operation* that will receive an `Invoice` body, and a query
 
 This part is pretty normal, most of the code is probably already familiar to you:
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[9:13,36:53] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[7:11,34:51] *}
 
 /// tip
 
@@ -90,7 +90,7 @@ Temporarily adopting this point of view (of the *external developer*) can help y
 
 First create a new `APIRouter` that will contain one or more callbacks.
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[3,25] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[1,23] *}
 
 ### Create the callback *path operation* { #create-the-callback-path-operation }
 
@@ -101,7 +101,7 @@ It should look just like a normal FastAPI *path operation*:
 * It should probably have a declaration of the body it should receive, e.g. `body: InvoiceEvent`.
 * And it could also have a declaration of the response it should return, e.g. `response_model=InvoiceEventReceived`.
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[16:18,21:22,28:32] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}
 
 There are 2 main differences from a normal *path operation*:
 
@@ -169,7 +169,7 @@ At this point you have the *callback path operation(s)* needed (the one(s) that
 
 Now use the parameter `callbacks` in *your API's path operation decorator* to pass the attribute `.routes` (that's actually just a `list` of routes/*path operations*) from that callback router:
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[35] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[33] *}
 
 /// tip
 

docs/en/docs/advanced/path-operation-advanced-configuration.md

@@ -50,7 +50,7 @@ Adding an `\f` (an escaped "form feed" character) causes **FastAPI** to truncate
 
 It won't show up in the documentation, but other tools (such as Sphinx) will be able to use the rest.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
 
 ## Additional Responses { #additional-responses }
 
@@ -155,13 +155,13 @@ For example, in this application we don't use FastAPI's integrated functionality
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
 
 ////
 
@@ -179,13 +179,13 @@ And then in our code, we parse that YAML content directly, and then we are again
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
 
 ////
 

docs/en/docs/advanced/response-directly.md

@@ -34,7 +34,7 @@ For example, you cannot put a Pydantic model in a `JSONResponse` without first c
 
 For those cases, you can use the `jsonable_encoder` to convert your data before passing it to a response:
 
-{* ../../docs_src/response_directly/tutorial001.py hl[6:7,21:22] *}
+{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
 
 /// note | Technical Details
 

docs/en/docs/advanced/settings.md

@@ -148,7 +148,7 @@ This could be especially useful during testing, as it's very easy to override a
 
 Coming from the previous example, your `config.py` file could look like:
 
-{* ../../docs_src/settings/app02/config.py hl[10] *}
+{* ../../docs_src/settings/app02_an_py39/config.py hl[10] *}
 
 Notice that now we don't create a default instance `settings = Settings()`.
 
@@ -174,7 +174,7 @@ And then we can require it from the *path operation function* as a dependency an
 
 Then it would be very easy to provide a different settings object during testing by creating a dependency override for `get_settings`:
 
-{* ../../docs_src/settings/app02/test_main.py hl[9:10,13,21] *}
+{* ../../docs_src/settings/app02_an_py39/test_main.py hl[9:10,13,21] *}
 
 In the dependency override we set a new value for the `admin_email` when creating the new `Settings` object, and then we return that new object.
 
@@ -217,7 +217,7 @@ And then update your `config.py` with:
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/settings/app03_an/config.py hl[9] *}
+{* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
 
 /// tip
 
@@ -229,7 +229,7 @@ The `model_config` attribute is used just for Pydantic configuration. You can re
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/settings/app03_an/config_pv1.py hl[9:10] *}
+{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
 
 /// tip
 

docs/en/docs/external-links.md

@@ -1,36 +1,22 @@
-# External Links and Articles
+# External Links
 
 **FastAPI** has a great community constantly growing.
 
 There are many posts, articles, tools, and projects, related to **FastAPI**.
 
-Here's an incomplete list of some of them.
+You could easily use a search engine or video platform to find many resources related to FastAPI.
 
-/// tip
+/// info
 
-If you have an article, project, tool, or anything related to **FastAPI** that is not yet listed here, create a <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">Pull Request adding it</a>.
+Before, this page used to list links to external articles.
+
+But now that FastAPI is the backend framework with the most GitHub stars across languages, and the most starred and used framework in Python, it no longer makes sense to attempt to list all articles written about it.
 
 ///
 
-{% for section_name, section_content in external_links.items() %}
-
-## {{ section_name }}
-
-{% for lang_name, lang_content in section_content.items() %}
-
-### {{ lang_name }}
-
-{% for item in lang_content %}
-
-* <a href="{{ item.link }}" class="external-link" target="_blank">{{ item.title }}</a> by <a href="{{ item.author_link }}" class="external-link" target="_blank">{{ item.author }}</a>.
-
-{% endfor %}
-{% endfor %}
-{% endfor %}
-
 ## GitHub Repositories
 
-Most starred GitHub repositories with the topic `fastapi`:
+Most starred <a href="https://github.com/topics/fastapi" class="external-link" target="_blank">GitHub repositories with the topic `fastapi`</a>:
 
 {% for repo in topic_repos %}
 

docs/en/docs/how-to/configure-swagger-ui.md

@@ -40,7 +40,7 @@ FastAPI includes some default configuration parameters appropriate for most of t
 
 It includes these default configurations:
 
-{* ../../fastapi/openapi/docs.py ln[8:23] hl[17:23] *}
+{* ../../fastapi/openapi/docs.py ln[9:24] hl[18:24] *}
 
 You can override any of them by setting a different value in the argument `swagger_ui_parameters`.
 

docs/en/docs/how-to/custom-request-and-route.md

@@ -42,7 +42,7 @@ If there's no `gzip` in the header, it will not try to decompress the body.
 
 That way, the same route class can handle gzip compressed or uncompressed requests.
 
-{* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}
 
 ### Create a custom `GzipRoute` class { #create-a-custom-gziproute-class }
 
@@ -54,7 +54,7 @@ This method returns a function. And that function is what will receive a request
 
 Here we use it to create a `GzipRequest` from the original request.
 
-{* ../../docs_src/custom_request_and_route/tutorial001.py hl[18:26] *}
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[19:27] *}
 
 /// note | Technical Details
 
@@ -92,18 +92,18 @@ We can also use this same approach to access the request body in an exception ha
 
 All we need to do is handle the request inside a `try`/`except` block:
 
-{* ../../docs_src/custom_request_and_route/tutorial002.py hl[13,15] *}
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[14,16] *}
 
 If an exception occurs, the`Request` instance will still be in scope, so we can read and make use of the request body when handling the error:
 
-{* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *}
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[17:19] *}
 
 ## Custom `APIRoute` class in a router { #custom-apiroute-class-in-a-router }
 
 You can also set the `route_class` parameter of an `APIRouter`:
 
-{* ../../docs_src/custom_request_and_route/tutorial003.py hl[26] *}
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[26] *}
 
 In this example, the *path operations* under the `router` will use the custom `TimedRoute` class, and will have an extra `X-Response-Time` header in the response with the time it took to generate the response:
 
-{* ../../docs_src/custom_request_and_route/tutorial003.py hl[13:20] *}
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[13:20] *}

docs/en/docs/index.md

@@ -52,13 +52,13 @@ The key features are:
 
 <!-- sponsors -->
 
-### Keystone Sponsor
+### Keystone Sponsor { #keystone-sponsor }
 
 {% for sponsor in sponsors.keystone -%}
 <a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
 {% endfor -%}
 
-### Gold and Silver Sponsors
+### Gold and Silver Sponsors { #gold-and-silver-sponsors }
 
 {% for sponsor in sponsors.gold -%}
 <a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>

docs/en/docs/project-generation.md

@@ -9,18 +9,18 @@ GitHub Repository: <a href="https://github.com/tiangolo/full-stack-fastapi-templ
 ## Full Stack FastAPI Template - Technology Stack and Features { #full-stack-fastapi-template-technology-stack-and-features }
 
 - ⚡ [**FastAPI**](https://fastapi.tiangolo.com) for the Python backend API.
-    - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) for the Python SQL database interactions (ORM).
-    - 🔍 [Pydantic](https://docs.pydantic.dev), used by FastAPI, for the data validation and settings management.
-    - 💾 [PostgreSQL](https://www.postgresql.org) as the SQL database.
+  - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) for the Python SQL database interactions (ORM).
+  - 🔍 [Pydantic](https://docs.pydantic.dev), used by FastAPI, for the data validation and settings management.
+  - 💾 [PostgreSQL](https://www.postgresql.org) as the SQL database.
 - 🚀 [React](https://react.dev) for the frontend.
-    - 💃 Using TypeScript, hooks, [Vite](https://vitejs.dev), and other parts of a modern frontend stack.
-    - 🎨 [Chakra UI](https://chakra-ui.com) for the frontend components.
-    - 🤖 An automatically generated frontend client.
-    - 🧪 [Playwright](https://playwright.dev) for End-to-End testing.
-    - 🦇 Dark mode support.
+  - 💃 Using TypeScript, hooks, Vite, and other parts of a modern frontend stack.
+  - 🎨 [Tailwind CSS](https://tailwindcss.com) and [shadcn/ui](https://ui.shadcn.com) for the frontend components.
+  - 🤖 An automatically generated frontend client.
+  - 🧪 [Playwright](https://playwright.dev) for End-to-End testing.
+  - 🦇 Dark mode support.
 - 🐋 [Docker Compose](https://www.docker.com) for development and production.
 - 🔒 Secure password hashing by default.
-- 🔑 JWT token authentication.
+- 🔑 JWT (JSON Web Token) authentication.
 - 📫 Email based password recovery.
 - ✅ Tests with [Pytest](https://pytest.org).
 - 📞 [Traefik](https://traefik.io) as a reverse proxy / load balancer.

docs/en/docs/release-notes.md

@@ -7,6 +7,99 @@ hide:
 
 ## Latest Changes
 
+### Translations
+
+* 🌐 Update translations for es (update-outdated). PR [#14532](https://github.com/fastapi/fastapi/pull/14532) by [@tiangolo](https://github.com/tiangolo).
+* 🌐 Update translations for es (add-missing). PR [#14533](https://github.com/fastapi/fastapi/pull/14533) by [@tiangolo](https://github.com/tiangolo).
+* 🌐 Remove translations for removed docs. PR [#14516](https://github.com/fastapi/fastapi/pull/14516) by [@tiangolo](https://github.com/tiangolo).
+
+### Internal
+
+* 👷 Configure coverage, error on main tests, don't wait for Smokeshow. PR [#14536](https://github.com/fastapi/fastapi/pull/14536) by [@tiangolo](https://github.com/tiangolo).
+* 👷 Run Smokeshow always, even on test failures. PR [#14538](https://github.com/fastapi/fastapi/pull/14538) by [@tiangolo](https://github.com/tiangolo).
+* 👷 Make Pydantic versions customizable in CI. PR [#14535](https://github.com/fastapi/fastapi/pull/14535) by [@tiangolo](https://github.com/tiangolo).
+* 👷 Fix checkout GitHub Action fetch-depth for LLM translations, enable cron monthly. PR [#14531](https://github.com/fastapi/fastapi/pull/14531) by [@tiangolo](https://github.com/tiangolo).
+* 👷 Fix Typer command for CI LLM translations. PR [#14530](https://github.com/fastapi/fastapi/pull/14530) by [@tiangolo](https://github.com/tiangolo).
+* 👷 Update LLM translation CI, add language matrix and extra commands, prepare for scheduled run. PR [#14529](https://github.com/fastapi/fastapi/pull/14529) by [@tiangolo](https://github.com/tiangolo).
+* 👷 Update github-actions user for GitHub Actions workflows. PR [#14528](https://github.com/fastapi/fastapi/pull/14528) by [@tiangolo](https://github.com/tiangolo).
+* ➕ Add requirements for translations. PR [#14515](https://github.com/fastapi/fastapi/pull/14515) by [@tiangolo](https://github.com/tiangolo).
+
+## 0.124.4
+
+### Fixes
+
+* 🐛 Fix parameter aliases. PR [#14371](https://github.com/fastapi/fastapi/pull/14371) by [@YuriiMotov](https://github.com/YuriiMotov).
+
+## 0.124.3
+
+### Fixes
+
+* 🐛 Fix support for tagged union with discriminator inside of `Annotated` with `Body()`. PR [#14512](https://github.com/fastapi/fastapi/pull/14512) by [@tiangolo](https://github.com/tiangolo).
+
+### Refactors
+
+* ✅ Add set of tests for request parameters and alias. PR [#14358](https://github.com/fastapi/fastapi/pull/14358) by [@YuriiMotov](https://github.com/YuriiMotov).
+
+### Docs
+
+* 📝 Tweak links format. PR [#14505](https://github.com/fastapi/fastapi/pull/14505) by [@tiangolo](https://github.com/tiangolo).
+* 📝 Update docs about re-raising validation errors, do not include string as is to not leak information. PR [#14487](https://github.com/fastapi/fastapi/pull/14487) by [@tiangolo](https://github.com/tiangolo).
+* 🔥 Remove external links section. PR [#14486](https://github.com/fastapi/fastapi/pull/14486) by [@tiangolo](https://github.com/tiangolo).
+
+### Translations
+
+* 🌐 Sync Russian docs. PR [#14509](https://github.com/fastapi/fastapi/pull/14509) by [@YuriiMotov](https://github.com/YuriiMotov).
+* 🌐 Sync German docs. PR [#14488](https://github.com/fastapi/fastapi/pull/14488) by [@nilslindemann](https://github.com/nilslindemann).
+
+### Internal
+
+* 👷 Tweak coverage to not pass Smokeshow max file size limit. PR [#14507](https://github.com/fastapi/fastapi/pull/14507) by [@tiangolo](https://github.com/tiangolo).
+* ✅ Expand test matrix to include Windows and MacOS. PR [#14171](https://github.com/fastapi/fastapi/pull/14171) by [@svlandeg](https://github.com/svlandeg).
+
+## 0.124.2
+
+### Fixes
+
+* 🐛 Fix support for `if TYPE_CHECKING`,  non-evaluated stringified annotations. PR [#14485](https://github.com/fastapi/fastapi/pull/14485) by [@tiangolo](https://github.com/tiangolo).
+
+## 0.124.1
+
+### Fixes
+
+* 🐛 Fix handling arbitrary types when using `arbitrary_types_allowed=True`. PR [#14482](https://github.com/fastapi/fastapi/pull/14482) by [@tiangolo](https://github.com/tiangolo).
+
+### Docs
+
+* 📝 Add variants for code examples in "Advanced User Guide". PR [#14413](https://github.com/fastapi/fastapi/pull/14413) by [@YuriiMotov](https://github.com/YuriiMotov).
+* 📝 Update tech stack in project generation docs. PR [#14472](https://github.com/fastapi/fastapi/pull/14472) by [@alejsdev](https://github.com/alejsdev).
+
+### Internal
+
+* ✅ Add test for Pydantic v2, dataclasses, UUID, and `__annotations__`. PR [#14477](https://github.com/fastapi/fastapi/pull/14477) by [@tiangolo](https://github.com/tiangolo).
+
+## 0.124.0
+
+### Features
+
+* 🚸  Improve tracebacks by adding endpoint metadata. PR [#14306](https://github.com/fastapi/fastapi/pull/14306) by [@savannahostrowski](https://github.com/savannahostrowski).
+
+### Internal
+
+* ✏️ Fix typo in `scripts/mkdocs_hooks.py`. PR [#14457](https://github.com/fastapi/fastapi/pull/14457) by [@yujiteshima](https://github.com/yujiteshima).
+
+## 0.123.10
+
+### Fixes
+
+* 🐛 Fix using class (not instance) dependency that has `__call__` method. PR [#14458](https://github.com/fastapi/fastapi/pull/14458) by [@YuriiMotov](https://github.com/YuriiMotov).
+* 🐛 Fix `separate_input_output_schemas=False` with `computed_field`. PR [#14453](https://github.com/fastapi/fastapi/pull/14453) by [@YuriiMotov](https://github.com/YuriiMotov).
+
+## 0.123.9
+
+### Fixes
+
+* 🐛 Fix OAuth2 scopes in OpenAPI in extra corner cases, parent dependency with scopes, sub-dependency security scheme without scopes. PR [#14459](https://github.com/fastapi/fastapi/pull/14459) by [@tiangolo](https://github.com/tiangolo).
+
 ## 0.123.8
 
 ### Fixes

docs/en/docs/resources/index.md

@@ -1,3 +1,3 @@
 # Resources { #resources }
 
-Additional resources, external links, articles and more. ✈️
+Additional resources, external links, and more. ✈️

docs/en/docs/tutorial/bigger-applications.md

@@ -85,9 +85,7 @@ You can create the *path operations* for that module using `APIRouter`.
 
 You import it and create an "instance" the same way you would with the class `FastAPI`:
 
-```Python hl_lines="1  3" title="app/routers/users.py"
-{!../../docs_src/bigger_applications/app/routers/users.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
 
 ### *Path operations* with `APIRouter` { #path-operations-with-apirouter }
 
@@ -95,9 +93,7 @@ And then you use it to declare your *path operations*.
 
 Use it the same way you would use the `FastAPI` class:
 
-```Python hl_lines="6  11  16" title="app/routers/users.py"
-{!../../docs_src/bigger_applications/app/routers/users.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
 
 You can think of `APIRouter` as a "mini `FastAPI`" class.
 
@@ -121,35 +117,7 @@ So we put them in their own `dependencies` module (`app/dependencies.py`).
 
 We will now use a simple dependency to read a custom `X-Token` header:
 
-//// tab | Python 3.9+
-
-```Python hl_lines="3  6-8" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app_an_py39/dependencies.py!}
-```
-
-////
-
-//// tab | Python 3.8+
-
-```Python hl_lines="1  5-7" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app_an/dependencies.py!}
-```
-
-////
-
-//// tab | Python 3.8+ non-Annotated
-
-/// tip
-
-Prefer to use the `Annotated` version if possible.
-
-///
-
-```Python hl_lines="1  4-6" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app/dependencies.py!}
-```
-
-////
+{* ../../docs_src/bigger_applications/app_an_py39/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
 
 /// tip
 
@@ -181,9 +149,7 @@ We know all the *path operations* in this module have the same:
 
 So, instead of adding all that to each *path operation*, we can add it to the `APIRouter`.
 
-```Python hl_lines="5-10  16  21" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
 
 As the path of each *path operation* has to start with `/`, like in:
 
@@ -242,9 +208,7 @@ And we need to get the dependency function from the module `app.dependencies`, t
 
 So we use a relative import with `..` for the dependencies:
 
-```Python hl_lines="3" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[3] title["app/routers/items.py"] *}
 
 #### How relative imports work { #how-relative-imports-work }
 
@@ -315,9 +279,7 @@ We are not adding the prefix `/items` nor the `tags=["items"]` to each *path ope
 
 But we can still add _more_ `tags` that will be applied to a specific *path operation*, and also some extra `responses` specific to that *path operation*:
 
-```Python hl_lines="30-31" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[30:31] title["app/routers/items.py"] *}
 
 /// tip
 
@@ -343,17 +305,13 @@ You import and create a `FastAPI` class as normally.
 
 And we can even declare [global dependencies](dependencies/global-dependencies.md){.internal-link target=_blank} that will be combined with the dependencies for each `APIRouter`:
 
-```Python hl_lines="1  3  7" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[1,3,7] title["app/main.py"] *}
 
 ### Import the `APIRouter` { #import-the-apirouter }
 
 Now we import the other submodules that have `APIRouter`s:
 
-```Python hl_lines="4-5" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[4:5] title["app/main.py"] *}
 
 As the files `app/routers/users.py` and `app/routers/items.py` are submodules that are part of the same Python package `app`, we can use a single dot `.` to import them using "relative imports".
 
@@ -416,17 +374,13 @@ the `router` from `users` would overwrite the one from `items` and we wouldn't b
 
 So, to be able to use both of them in the same file, we import the submodules directly:
 
-```Python hl_lines="5" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
 
 ### Include the `APIRouter`s for `users` and `items` { #include-the-apirouters-for-users-and-items }
 
 Now, let's include the `router`s from the submodules `users` and `items`:
 
-```Python hl_lines="10-11" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[10:11] title["app/main.py"] *}
 
 /// info
 
@@ -466,17 +420,13 @@ It contains an `APIRouter` with some admin *path operations* that your organizat
 
 For this example it will be super simple. But let's say that because it is shared with other projects in the organization, we cannot modify it and add a `prefix`, `dependencies`, `tags`, etc. directly to the `APIRouter`:
 
-```Python hl_lines="3" title="app/internal/admin.py"
-{!../../docs_src/bigger_applications/app/internal/admin.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/internal/admin.py hl[3] title["app/internal/admin.py"] *}
 
 But we still want to set a custom `prefix` when including the `APIRouter` so that all its *path operations* start with `/admin`, we want to secure it with the `dependencies` we already have for this project, and we want to include `tags` and `responses`.
 
 We can declare all that without having to modify the original `APIRouter` by passing those parameters to `app.include_router()`:
 
-```Python hl_lines="14-17" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[14:17] title["app/main.py"] *}
 
 That way, the original `APIRouter` will stay unmodified, so we can still share that same `app/internal/admin.py` file with other projects in the organization.
 
@@ -497,9 +447,7 @@ We can also add *path operations* directly to the `FastAPI` app.
 
 Here we do it... just to show that we can 🤷:
 
-```Python hl_lines="21-23" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[21:23] title["app/main.py"] *}
 
 and it will work correctly, together with all the other *path operations* added with `app.include_router()`.
 

docs/en/docs/tutorial/cookie-param-models.md

@@ -50,7 +50,7 @@ Your API now has the power to control its own <abbr title="This is a joke, just
 
 You can use Pydantic's model configuration to `forbid` any `extra` fields:
 
-{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *}
+{* ../../docs_src/cookie_param_models/tutorial002_an_py310.py hl[10] *}
 
 If a client tries to send some **extra cookies**, they will receive an **error** response.
 

docs/en/docs/tutorial/handling-errors.md

@@ -127,7 +127,7 @@ To override it, import the `RequestValidationError` and use it with `@app.except
 
 The exception handler will receive a `Request` and the exception.
 
-{* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *}
+{* ../../docs_src/handling_errors/tutorial004.py hl[2,14:19] *}
 
 Now, if you go to `/items/foo`, instead of getting the default JSON error with:
 
@@ -149,36 +149,17 @@ Now, if you go to `/items/foo`, instead of getting the default JSON error with:
 you will get a text version, with:
 
 ```
-1 validation error
-path -> item_id
-  value is not a valid integer (type=type_error.integer)
+Validation errors:
+Field: ('path', 'item_id'), Error: Input should be a valid integer, unable to parse string as an integer
 ```
 
-#### `RequestValidationError` vs `ValidationError` { #requestvalidationerror-vs-validationerror }
-
-/// warning
-
-These are technical details that you might skip if it's not important for you now.
-
-///
-
-`RequestValidationError` is a sub-class of Pydantic's <a href="https://docs.pydantic.dev/latest/concepts/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a>.
-
-**FastAPI** uses it so that, if you use a Pydantic model in `response_model`, and your data has an error, you will see the error in your log.
-
-But the client/user will not see it. Instead, the client will receive an "Internal Server Error" with an HTTP status code `500`.
-
-It should be this way because if you have a Pydantic `ValidationError` in your *response* or anywhere in your code (not in the client's *request*), it's actually a bug in your code.
-
-And while you fix it, your clients/users shouldn't have access to internal information about the error, as that could expose a security vulnerability.
-
 ### Override the `HTTPException` error handler { #override-the-httpexception-error-handler }
 
 The same way, you can override the `HTTPException` handler.
 
 For example, you could want to return a plain text response instead of JSON for these errors:
 
-{* ../../docs_src/handling_errors/tutorial004.py hl[3:4,9:11,22] *}
+{* ../../docs_src/handling_errors/tutorial004.py hl[3:4,9:11,25] *}
 
 /// note | Technical Details
 
@@ -188,6 +169,14 @@ You could also use `from starlette.responses import PlainTextResponse`.
 
 ///
 
+/// warning
+
+Have in mind that the `RequestValidationError` contains the information of the file name and line where the validation error happens so that you can show it in your logs with the relevant information if you want to.
+
+But that means that if you just convert it to a string and return that information directly, you could be leaking a bit of information about your system, that's why here the code extracts and shows each error independently.
+
+///
+
 ### Use the `RequestValidationError` body { #use-the-requestvalidationerror-body }
 
 The `RequestValidationError` contains the `body` it received with invalid data.

docs/en/docs/tutorial/testing.md

@@ -121,63 +121,13 @@ It has a `POST` operation that could return several errors.
 
 Both *path operations* require an `X-Token` header.
 
-//// tab | Python 3.10+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an_py310/main.py!}
-```
-
-////
-
-//// tab | Python 3.9+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an_py39/main.py!}
-```
-
-////
-
-//// tab | Python 3.8+
-
-```Python
-{!> ../../docs_src/app_testing/app_b_an/main.py!}
-```
-
-////
-
-//// tab | Python 3.10+ non-Annotated
-
-/// tip
-
-Prefer to use the `Annotated` version if possible.
-
-///
-
-```Python
-{!> ../../docs_src/app_testing/app_b_py310/main.py!}
-```
-
-////
-
-//// tab | Python 3.8+ non-Annotated
-
-/// tip
-
-Prefer to use the `Annotated` version if possible.
-
-///
-
-```Python
-{!> ../../docs_src/app_testing/app_b/main.py!}
-```
-
-////
+{* ../../docs_src/app_testing/app_b_an_py310/main.py *}
 
 ### Extended testing file { #extended-testing-file }
 
 You could then update `test_main.py` with the extended tests:
 
-{* ../../docs_src/app_testing/app_b/test_main.py *}
+{* ../../docs_src/app_testing/app_b_an_py310/test_main.py *}
 
 
 Whenever you need the client to pass information in the request and you don't know how to, you can search (Google) how to do it in `httpx`, or even how to do it with `requests`, as HTTPX's design is based on Requests' design.

docs/en/mkdocs.yml

@@ -59,7 +59,6 @@ plugins:
   search: null
   macros:
     include_yaml:
-    - external_links: ../en/data/external_links.yml
     - github_sponsors: ../en/data/github_sponsors.yml
     - people: ../en/data/people.yml
     - contributors: ../en/data/contributors.yml

docs/es/docs/_llm-test.md

@@ -0,0 +1,503 @@
+# Archivo de prueba de LLM { #llm-test-file }
+
+Este documento prueba si el <abbr title="Large Language Model – Modelo de lenguaje grande">LLM</abbr>, que traduce la documentación, entiende el `general_prompt` en `scripts/translate.py` y el prompt específico del idioma en `docs/{language code}/llm-prompt.md`. El prompt específico del idioma se agrega al final de `general_prompt`.
+
+Las pruebas añadidas aquí serán vistas por todas las personas que diseñan prompts específicos del idioma.
+
+Úsalo de la siguiente manera:
+
+* Ten un prompt específico del idioma – `docs/{language code}/llm-prompt.md`.
+* Haz una traducción fresca de este documento a tu idioma destino (mira, por ejemplo, el comando `translate-page` de `translate.py`). Esto creará la traducción en `docs/{language code}/docs/_llm-test.md`.
+* Comprueba si todo está bien en la traducción.
+* Si es necesario, mejora tu prompt específico del idioma, el prompt general, o el documento en inglés.
+* Luego corrige manualmente los problemas restantes en la traducción para que sea una buena traducción.
+* Vuelve a traducir, teniendo la buena traducción en su lugar. El resultado ideal sería que el LLM ya no hiciera cambios a la traducción. Eso significa que el prompt general y tu prompt específico del idioma están tan bien como pueden estar (a veces hará algunos cambios aparentemente aleatorios; la razón es que <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">los LLMs no son algoritmos deterministas</a>).
+
+Las pruebas:
+
+## Fragmentos de código { #code-snippets }
+
+//// tab | Prueba
+
+Este es un fragmento de código: `foo`. Y este es otro fragmento de código: `bar`. Y otro más: `baz quux`.
+
+////
+
+//// tab | Información
+
+El contenido de los fragmentos de código debe dejarse tal cual.
+
+Consulta la sección `### Content of code snippets` en el prompt general en `scripts/translate.py`.
+
+////
+
+## Comillas { #quotes }
+
+//// tab | Prueba
+
+Ayer, mi amigo escribió: "Si escribes 'incorrectly' correctamente, lo habrás escrito incorrectamente". A lo que respondí: "Correcto, pero 'incorrectly' está incorrecto, no '"incorrectly"'".
+
+/// note | Nota
+
+El LLM probablemente traducirá esto mal. Lo interesante es si mantiene la traducción corregida al volver a traducir.
+
+///
+
+////
+
+//// tab | Información
+
+La persona que diseña el prompt puede elegir si quiere convertir comillas neutras a comillas tipográficas. También está bien dejarlas como están.
+
+Consulta por ejemplo la sección `### Quotes` en `docs/de/llm-prompt.md`.
+
+////
+
+## Comillas en fragmentos de código { #quotes-in-code-snippets }
+
+//// tab | Prueba
+
+`pip install "foo[bar]"`
+
+Ejemplos de literales de string en fragmentos de código: `"this"`, `'that'`.
+
+Un ejemplo difícil de literales de string en fragmentos de código: `f"I like {'oranges' if orange else "apples"}"`
+
+Hardcore: `Yesterday, my friend wrote: "If you spell incorrectly correctly, you have spelled it incorrectly". To which I answered: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'"`
+
+////
+
+//// tab | Información
+
+... Sin embargo, las comillas dentro de fragmentos de código deben quedarse tal cual.
+
+////
+
+## bloques de código { #code-blocks }
+
+//// tab | Prueba
+
+Un ejemplo de código Bash...
+
+```bash
+# Imprime un saludo al universo
+echo "Hello universe"
+```
+
+...y un ejemplo de código de consola...
+
+```console
+$ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid">main.py</u>
+<span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting server
+        Searching for package file structure
+```
+
+...y otro ejemplo de código de consola...
+
+```console
+// Crea un directorio "Code"
+$ mkdir code
+// Cambia a ese directorio
+$ cd code
+```
+
+...y un ejemplo de código Python...
+
+```Python
+wont_work()  # Esto no va a funcionar 😱
+works(foo="bar")  # Esto funciona 🎉
+```
+
+...y eso es todo.
+
+////
+
+//// tab | Información
+
+El código en bloques de código no debe modificarse, con la excepción de los comentarios.
+
+Consulta la sección `### Content of code blocks` en el prompt general en `scripts/translate.py`.
+
+////
+
+## Pestañas y cajas coloreadas { #tabs-and-colored-boxes }
+
+//// tab | Prueba
+
+/// info | Información
+Algo de texto
+///
+
+/// note | Nota
+Algo de texto
+///
+
+/// note | Detalles técnicos
+Algo de texto
+///
+
+/// check | Revisa
+Algo de texto
+///
+
+/// tip | Consejo
+Algo de texto
+///
+
+/// warning | Advertencia
+Algo de texto
+///
+
+/// danger | Peligro
+Algo de texto
+///
+
+////
+
+//// tab | Información
+
+Las pestañas y los bloques `Info`/`Note`/`Warning`/etc. deben tener la traducción de su título añadida después de una barra vertical (`|`).
+
+Consulta las secciones `### Special blocks` y `### Tab blocks` en el prompt general en `scripts/translate.py`.
+
+////
+
+## Enlaces web e internos { #web-and-internal-links }
+
+//// tab | Prueba
+
+El texto del enlace debe traducirse, la dirección del enlace debe permanecer sin cambios:
+
+* [Enlace al encabezado de arriba](#code-snippets)
+* [Enlace interno](index.md#installation){.internal-link target=_blank}
+* <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">Enlace externo</a>
+* <a href="https://fastapi.tiangolo.com/css/styles.css" class="external-link" target="_blank">Enlace a un estilo</a>
+* <a href="https://fastapi.tiangolo.com/js/logic.js" class="external-link" target="_blank">Enlace a un script</a>
+* <a href="https://fastapi.tiangolo.com/img/foo.jpg" class="external-link" target="_blank">Enlace a una imagen</a>
+
+El texto del enlace debe traducirse, la dirección del enlace debe apuntar a la traducción:
+
+* <a href="https://fastapi.tiangolo.com/es/" class="external-link" target="_blank">Enlace a FastAPI</a>
+
+////
+
+//// tab | Información
+
+Los enlaces deben traducirse, pero su dirección debe permanecer sin cambios. Una excepción son los enlaces absolutos a páginas de la documentación de FastAPI. En ese caso deben enlazar a la traducción.
+
+Consulta la sección `### Links` en el prompt general en `scripts/translate.py`.
+
+////
+
+## Elementos HTML "abbr" { #html-abbr-elements }
+
+//// tab | Prueba
+
+Aquí algunas cosas envueltas en elementos HTML "abbr" (algunas son inventadas):
+
+### El abbr da una frase completa { #the-abbr-gives-a-full-phrase }
+
+* <abbr title="Getting Things Done – Hacer las cosas">GTD</abbr>
+* <abbr title="less than – menor que"><code>lt</code></abbr>
+* <abbr title="XML Web Token – Token web XML">XWT</abbr>
+* <abbr title="Parallel Server Gateway Interface – Interfaz de pasarela de servidor paralela">PSGI</abbr>
+
+### El abbr da una explicación { #the-abbr-gives-an-explanation }
+
+* <abbr title="Un grupo de máquinas configuradas para estar conectadas y trabajar juntas de alguna manera.">clúster</abbr>
+* <abbr title="Un método de machine learning que usa redes neuronales artificiales con numerosas capas ocultas entre las capas de entrada y salida, desarrollando así una estructura interna completa">Deep Learning</abbr>
+
+### El abbr da una frase completa y una explicación { #the-abbr-gives-a-full-phrase-and-an-explanation }
+
+* <abbr title="Mozilla Developer Network – Red de Desarrolladores de Mozilla: documentación para desarrolladores, escrita por la gente de Firefox">MDN</abbr>
+* <abbr title="Input/Output – Entrada/Salida: lectura o escritura de disco, comunicaciones de red.">I/O</abbr>.
+
+////
+
+//// tab | Información
+
+Los atributos "title" de los elementos "abbr" se traducen siguiendo instrucciones específicas.
+
+Las traducciones pueden añadir sus propios elementos "abbr" que el LLM no debe eliminar. P. ej., para explicar palabras en inglés.
+
+Consulta la sección `### HTML abbr elements` en el prompt general en `scripts/translate.py`.
+
+////
+
+## Encabezados { #headings }
+
+//// tab | Prueba
+
+### Desarrolla una webapp - un tutorial { #develop-a-webapp-a-tutorial }
+
+Hola.
+
+### Anotaciones de tipos y -anotaciones { #type-hints-and-annotations }
+
+Hola de nuevo.
+
+### Superclases y subclases { #super-and-subclasses }
+
+Hola de nuevo.
+
+////
+
+//// tab | Información
+
+La única regla estricta para los encabezados es que el LLM deje la parte del hash dentro de llaves sin cambios, lo que asegura que los enlaces no se rompan.
+
+Consulta la sección `### Headings` en el prompt general en `scripts/translate.py`.
+
+Para instrucciones específicas del idioma, mira p. ej. la sección `### Headings` en `docs/de/llm-prompt.md`.
+
+////
+
+## Términos usados en la documentación { #terms-used-in-the-docs }
+
+//// tab | Prueba
+
+* tú
+* tu
+
+* p. ej.
+* etc.
+
+* `foo` como un `int`
+* `bar` como un `str`
+* `baz` como una `list`
+
+* el Tutorial - Guía de usuario
+* la Guía de usuario avanzada
+* la documentación de SQLModel
+* la documentación de la API
+* la documentación automática
+
+* Ciencia de datos
+* Deep Learning
+* Machine Learning
+* Inyección de dependencias
+* autenticación HTTP Basic
+* HTTP Digest
+* formato ISO
+* el estándar JSON Schema
+* el JSON Schema
+* la definición del esquema
+* Flujo de contraseña
+* Móvil
+
+* obsoleto
+* diseñado
+* inválido
+* sobre la marcha
+* estándar
+* por defecto
+* sensible a mayúsculas/minúsculas
+* insensible a mayúsculas/minúsculas
+
+* servir la aplicación
+* servir la página
+
+* la app
+* la aplicación
+
+* la request
+* la response
+* la response de error
+
+* la path operation
+* el decorador de path operation
+* la path operation function
+
+* el body
+* el request body
+* el response body
+* el body JSON
+* el body del formulario
+* el body de archivo
+* el cuerpo de la función
+
+* el parámetro
+* el parámetro del body
+* el parámetro del path
+* el parámetro de query
+* el parámetro de cookie
+* el parámetro de header
+* el parámetro del formulario
+* el parámetro de la función
+
+* el evento
+* el evento de inicio
+* el inicio del servidor
+* el evento de apagado
+* el evento de lifespan
+
+* el manejador
+* el manejador de eventos
+* el manejador de excepciones
+* manejar
+
+* el modelo
+* el modelo de Pydantic
+* el modelo de datos
+* el modelo de base de datos
+* el modelo de formulario
+* el objeto del modelo
+
+* la clase
+* la clase base
+* la clase padre
+* la subclase
+* la clase hija
+* la clase hermana
+* el método de clase
+
+* el header
+* los headers
+* el header de autorización
+* el header `Authorization`
+* el header Forwarded
+
+* el sistema de inyección de dependencias
+* la dependencia
+* el dependable
+* el dependiente
+
+* limitado por I/O
+* limitado por CPU
+* concurrencia
+* paralelismo
+* multiprocesamiento
+
+* la variable de entorno
+* la variable de entorno
+* el `PATH`
+* la variable `PATH`
+
+* la autenticación
+* el proveedor de autenticación
+* la autorización
+* el formulario de autorización
+* el proveedor de autorización
+* el usuario se autentica
+* el sistema autentica al usuario
+
+* la CLI
+* la interfaz de línea de comandos
+
+* el servidor
+* el cliente
+
+* el proveedor en la nube
+* el servicio en la nube
+
+* el desarrollo
+* las etapas de desarrollo
+
+* el dict
+* el diccionario
+* la enumeración
+* el enum
+* el miembro del enum
+
+* el codificador
+* el decodificador
+* codificar
+* decodificar
+
+* la excepción
+* lanzar
+
+* la expresión
+* el statement
+
+* el frontend
+* el backend
+
+* la discusión de GitHub
+* el issue de GitHub
+
+* el rendimiento
+* la optimización de rendimiento
+
+* el tipo de retorno
+* el valor de retorno
+
+* la seguridad
+* el esquema de seguridad
+
+* la tarea
+* la tarea en segundo plano
+* la función de tarea
+
+* la plantilla
+* el motor de plantillas
+
+* la anotación de tipos
+* la anotación de tipos
+
+* el worker del servidor
+* el worker de Uvicorn
+* el Gunicorn Worker
+* el worker process
+* la worker class
+* la carga de trabajo
+
+* el despliegue
+* desplegar
+
+* el SDK
+* el kit de desarrollo de software
+
+* el `APIRouter`
+* el `requirements.txt`
+* el Bearer Token
+* el cambio incompatible
+* el bug
+* el botón
+* el invocable
+* el código
+* el commit
+* el context manager
+* la corrutina
+* la sesión de base de datos
+* el disco
+* el dominio
+* el motor
+* el X falso
+* el método HTTP GET
+* el ítem
+* el paquete
+* el lifespan
+* el bloqueo
+* el middleware
+* la aplicación móvil
+* el módulo
+* el montaje
+* la red
+* el origen
+* el override
+* el payload
+* el procesador
+* la propiedad
+* el proxy
+* el pull request
+* la query
+* la RAM
+* la máquina remota
+* el código de estado
+* el string
+* la etiqueta
+* el framework web
+* el comodín
+* devolver
+* validar
+
+////
+
+//// tab | Información
+
+Esta es una lista no completa y no normativa de términos (mayormente) técnicos vistos en la documentación. Puede ayudar a la persona que diseña el prompt a identificar para qué términos el LLM necesita una mano. Por ejemplo cuando sigue revirtiendo una buena traducción a una traducción subóptima. O cuando tiene problemas conjugando/declinando un término en tu idioma.
+
+Mira p. ej. la sección `### List of English terms and their preferred German translations` en `docs/de/llm-prompt.md`.
+
+////

docs/es/docs/about/index.md

@@ -1,3 +1,3 @@
-# Acerca de
+# Acerca de { #about }
 
 Acerca de FastAPI, su diseño, inspiración y más. 🤓

docs/es/docs/advanced/additional-responses.md

@@ -1,4 +1,4 @@
-# Responses Adicionales en OpenAPI
+# Responses Adicionales en OpenAPI { #additional-responses-in-openapi }
 
 /// warning | Advertencia
 
@@ -14,7 +14,7 @@ Esos responses adicionales se incluirán en el esquema de OpenAPI, por lo que ta
 
 Pero para esos responses adicionales tienes que asegurarte de devolver un `Response` como `JSONResponse` directamente, con tu código de estado y contenido.
 
-## Response Adicional con `model`
+## Response Adicional con `model` { #additional-response-with-model }
 
 Puedes pasar a tus *decoradores de path operation* un parámetro `responses`.
 
@@ -169,13 +169,13 @@ Los esquemas se referencian a otro lugar dentro del esquema de OpenAPI:
 }
 ```
 
-## Media types adicionales para el response principal
+## Media types adicionales para el response principal { #additional-media-types-for-the-main-response }
 
 Puedes usar este mismo parámetro `responses` para agregar diferentes media type para el mismo response principal.
 
 Por ejemplo, puedes agregar un media type adicional de `image/png`, declarando que tu *path operation* puede devolver un objeto JSON (con media type `application/json`) o una imagen PNG:
 
-{* ../../docs_src/additional_responses/tutorial002.py hl[19:24,28] *}
+{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}
 
 /// note | Nota
 
@@ -191,13 +191,13 @@ Pero si has especificado una clase de response personalizada con `None` como su
 
 ///
 
-## Combinando información
+## Combinando información { #combining-information }
 
 También puedes combinar información de response de múltiples lugares, incluyendo los parámetros `response_model`, `status_code`, y `responses`.
 
-Puedes declarar un `response_model`, usando el código de estado predeterminado `200` (o uno personalizado si lo necesitas), y luego declarar información adicional para ese mismo response en `responses`, directamente en el esquema de OpenAPI.
+Puedes declarar un `response_model`, usando el código de estado por defecto `200` (o uno personalizado si lo necesitas), y luego declarar información adicional para ese mismo response en `responses`, directamente en el esquema de OpenAPI.
 
-**FastAPI** manterá la información adicional de `responses` y la combinará con el JSON Schema de tu modelo.
+**FastAPI** mantendrá la información adicional de `responses` y la combinará con el JSON Schema de tu modelo.
 
 Por ejemplo, puedes declarar un response con un código de estado `404` que usa un modelo Pydantic y tiene una `description` personalizada.
 
@@ -209,7 +209,7 @@ Todo se combinará e incluirá en tu OpenAPI, y se mostrará en la documentació
 
 <img src="/img/tutorial/additional-responses/image01.png">
 
-## Combina responses predefinidos y personalizados
+## Combina responses predefinidos y personalizados { #combine-predefined-responses-and-custom-ones }
 
 Es posible que desees tener algunos responses predefinidos que se apliquen a muchas *path operations*, pero que quieras combinarlos con responses personalizados necesarios por cada *path operation*.
 
@@ -237,9 +237,9 @@ Puedes usar esa técnica para reutilizar algunos responses predefinidos en tus *
 
 Por ejemplo:
 
-{* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
+{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
 
-## Más información sobre responses OpenAPI
+## Más información sobre responses OpenAPI { #more-information-about-openapi-responses }
 
 Para ver exactamente qué puedes incluir en los responses, puedes revisar estas secciones en la especificación OpenAPI:
 

docs/es/docs/advanced/additional-status-codes.md

@@ -1,10 +1,10 @@
-# Códigos de Estado Adicionales
+# Códigos de Estado Adicionales { #additional-status-codes }
 
 Por defecto, **FastAPI** devolverá los responses usando un `JSONResponse`, colocando el contenido que devuelves desde tu *path operation* dentro de ese `JSONResponse`.
 
 Usará el código de estado por defecto o el que configures en tu *path operation*.
 
-## Códigos de estado adicionales
+## Códigos de estado adicionales { #additional-status-codes_1 }
 
 Si quieres devolver códigos de estado adicionales aparte del principal, puedes hacerlo devolviendo un `Response` directamente, como un `JSONResponse`, y configurando el código de estado adicional directamente.
 
@@ -34,7 +34,7 @@ También podrías usar `from starlette.responses import JSONResponse`.
 
 ///
 
-## OpenAPI y documentación de API
+## OpenAPI y documentación de API { #openapi-and-api-docs }
 
 Si devuelves códigos de estado adicionales y responses directamente, no se incluirán en el esquema de OpenAPI (la documentación de la API), porque FastAPI no tiene una forma de saber de antemano qué vas a devolver.
 

docs/es/docs/advanced/advanced-dependencies.md

@@ -1,6 +1,6 @@
-# Dependencias Avanzadas
+# Dependencias Avanzadas { #advanced-dependencies }
 
-## Dependencias con parámetros
+## Dependencias con parámetros { #parameterized-dependencies }
 
 Todas las dependencias que hemos visto son una función o clase fija.
 
@@ -10,7 +10,7 @@ Imaginemos que queremos tener una dependencia que revise si el parámetro de que
 
 Pero queremos poder parametrizar ese contenido fijo.
 
-## Una *instance* "callable"
+## Una *instance* "callable" { #a-callable-instance }
 
 En Python hay una forma de hacer que una instance de una clase sea un "callable".
 
@@ -22,7 +22,7 @@ Para hacer eso, declaramos un método `__call__`:
 
 En este caso, este `__call__` es lo que **FastAPI** usará para comprobar parámetros adicionales y sub-dependencias, y es lo que llamará para pasar un valor al parámetro en tu *path operation function* más adelante.
 
-## Parametrizar la instance
+## Parametrizar la instance { #parameterize-the-instance }
 
 Y ahora, podemos usar `__init__` para declarar los parámetros de la instance que podemos usar para "parametrizar" la dependencia:
 
@@ -30,7 +30,7 @@ Y ahora, podemos usar `__init__` para declarar los parámetros de la instance qu
 
 En este caso, **FastAPI** nunca tocará ni se preocupará por `__init__`, lo usaremos directamente en nuestro código.
 
-## Crear una instance
+## Crear una instance { #create-an-instance }
 
 Podríamos crear una instance de esta clase con:
 
@@ -38,7 +38,7 @@ Podríamos crear una instance de esta clase con:
 
 Y de esa manera podemos "parametrizar" nuestra dependencia, que ahora tiene `"bar"` dentro de ella, como el atributo `checker.fixed_content`.
 
-## Usar la instance como una dependencia
+## Usar la instance como una dependencia { #use-the-instance-as-a-dependency }
 
 Luego, podríamos usar este `checker` en un `Depends(checker)`, en lugar de `Depends(FixedContentQueryChecker)`, porque la dependencia es la instance, `checker`, no la clase en sí.
 
@@ -63,3 +63,101 @@ En los capítulos sobre seguridad, hay funciones utilitarias que se implementan
 Si entendiste todo esto, ya sabes cómo funcionan por debajo esas herramientas de utilidad para seguridad.
 
 ///
+
+## Dependencias con `yield`, `HTTPException`, `except` y Tareas en segundo plano { #dependencies-with-yield-httpexception-except-and-background-tasks }
+
+/// warning | Advertencia
+
+Muy probablemente no necesites estos detalles técnicos.
+
+Estos detalles son útiles principalmente si tenías una aplicación de FastAPI anterior a la 0.121.0 y estás enfrentando problemas con dependencias con `yield`.
+
+///
+
+Las dependencias con `yield` han evolucionado con el tiempo para cubrir diferentes casos de uso y arreglar algunos problemas; aquí tienes un resumen de lo que ha cambiado.
+
+### Dependencias con `yield` y `scope` { #dependencies-with-yield-and-scope }
+
+En la versión 0.121.0, FastAPI agregó soporte para `Depends(scope="function")` para dependencias con `yield`.
+
+Usando `Depends(scope="function")`, el código de salida después de `yield` se ejecuta justo después de que la *path operation function* termina, antes de que la response se envíe de vuelta al cliente.
+
+Y al usar `Depends(scope="request")` (el valor por defecto), el código de salida después de `yield` se ejecuta después de que la response es enviada.
+
+Puedes leer más al respecto en la documentación de [Dependencias con `yield` - Salida temprana y `scope`](../tutorial/dependencies/dependencies-with-yield.md#early-exit-and-scope).
+
+### Dependencias con `yield` y `StreamingResponse`, detalles técnicos { #dependencies-with-yield-and-streamingresponse-technical-details }
+
+Antes de FastAPI 0.118.0, si usabas una dependencia con `yield`, ejecutaba el código de salida después de que la *path operation function* retornaba pero justo antes de enviar la response.
+
+La intención era evitar retener recursos por más tiempo del necesario, esperando a que la response viajara por la red.
+
+Este cambio también significaba que si retornabas un `StreamingResponse`, el código de salida de la dependencia con `yield` ya se habría ejecutado.
+
+Por ejemplo, si tenías una sesión de base de datos en una dependencia con `yield`, el `StreamingResponse` no podría usar esa sesión mientras hace streaming de datos porque la sesión ya se habría cerrado en el código de salida después de `yield`.
+
+Este comportamiento se revirtió en la 0.118.0, para hacer que el código de salida después de `yield` se ejecute después de que la response sea enviada.
+
+/// info | Información
+
+Como verás abajo, esto es muy similar al comportamiento anterior a la versión 0.106.0, pero con varias mejoras y arreglos de bugs para casos límite.
+
+///
+
+#### Casos de uso con salida temprana del código { #use-cases-with-early-exit-code }
+
+Hay algunos casos de uso con condiciones específicas que podrían beneficiarse del comportamiento antiguo de ejecutar el código de salida de dependencias con `yield` antes de enviar la response.
+
+Por ejemplo, imagina que tienes código que usa una sesión de base de datos en una dependencia con `yield` solo para verificar un usuario, pero la sesión de base de datos no se vuelve a usar en la *path operation function*, solo en la dependencia, y la response tarda mucho en enviarse, como un `StreamingResponse` que envía datos lentamente, pero que por alguna razón no usa la base de datos.
+
+En este caso, la sesión de base de datos se mantendría hasta que la response termine de enviarse, pero si no la usas, entonces no sería necesario mantenerla.
+
+Así es como se vería:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py *}
+
+El código de salida, el cierre automático de la `Session` en:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}
+
+...se ejecutaría después de que la response termine de enviar los datos lentos:
+
+{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}
+
+Pero como `generate_stream()` no usa la sesión de base de datos, no es realmente necesario mantener la sesión abierta mientras se envía la response.
+
+Si tienes este caso de uso específico usando SQLModel (o SQLAlchemy), podrías cerrar explícitamente la sesión después de que ya no la necesites:
+
+{* ../../docs_src/dependencies/tutorial014_an_py310.py ln[24:28] hl[28] *}
+
+De esa manera la sesión liberaría la conexión a la base de datos, para que otras requests puedan usarla.
+
+Si tienes un caso de uso diferente que necesite salir temprano desde una dependencia con `yield`, por favor crea una <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">Pregunta de Discusión en GitHub</a> con tu caso de uso específico y por qué te beneficiaría tener cierre temprano para dependencias con `yield`.
+
+Si hay casos de uso convincentes para el cierre temprano en dependencias con `yield`, consideraría agregar una nueva forma de optar por el cierre temprano.
+
+### Dependencias con `yield` y `except`, detalles técnicos { #dependencies-with-yield-and-except-technical-details }
+
+Antes de FastAPI 0.110.0, si usabas una dependencia con `yield`, y luego capturabas una excepción con `except` en esa dependencia, y no volvías a elevar la excepción, la excepción se elevaría/remitiría automáticamente a cualquier manejador de excepciones o al manejador de error interno del servidor.
+
+Esto cambió en la versión 0.110.0 para arreglar consumo de memoria no manejado por excepciones reenviadas sin un manejador (errores internos del servidor), y para hacerlo consistente con el comportamiento del código Python normal.
+
+### Tareas en segundo plano y dependencias con `yield`, detalles técnicos { #background-tasks-and-dependencies-with-yield-technical-details }
+
+Antes de FastAPI 0.106.0, elevar excepciones después de `yield` no era posible, el código de salida en dependencias con `yield` se ejecutaba después de que la response era enviada, por lo que [Manejadores de Excepciones](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} ya habrían corrido.
+
+Esto se diseñó así principalmente para permitir usar los mismos objetos devueltos con `yield` por las dependencias dentro de tareas en segundo plano, porque el código de salida se ejecutaría después de que las tareas en segundo plano terminaran.
+
+Esto cambió en FastAPI 0.106.0 con la intención de no retener recursos mientras se espera a que la response viaje por la red.
+
+/// tip | Consejo
+
+Adicionalmente, una tarea en segundo plano normalmente es un conjunto independiente de lógica que debería manejarse por separado, con sus propios recursos (por ejemplo, su propia conexión a la base de datos).
+
+Así, probablemente tendrás un código más limpio.
+
+///
+
+Si solías depender de este comportamiento, ahora deberías crear los recursos para las tareas en segundo plano dentro de la propia tarea en segundo plano, y usar internamente solo datos que no dependan de los recursos de dependencias con `yield`.
+
+Por ejemplo, en lugar de usar la misma sesión de base de datos, crearías una nueva sesión de base de datos dentro de la tarea en segundo plano, y obtendrías los objetos de la base de datos usando esta nueva sesión. Y entonces, en lugar de pasar el objeto de la base de datos como parámetro a la función de la tarea en segundo plano, pasarías el ID de ese objeto y luego obtendrías el objeto de nuevo dentro de la función de la tarea en segundo plano.

docs/es/docs/advanced/async-tests.md

@@ -1,4 +1,4 @@
-# Tests Asíncronos
+# Tests Asíncronos { #async-tests }
 
 Ya has visto cómo probar tus aplicaciones de **FastAPI** usando el `TestClient` proporcionado. Hasta ahora, solo has visto cómo escribir tests sincrónicos, sin usar funciones `async`.
 
@@ -6,11 +6,11 @@ Poder usar funciones asíncronas en tus tests puede ser útil, por ejemplo, cuan
 
 Veamos cómo podemos hacer que esto funcione.
 
-## pytest.mark.anyio
+## pytest.mark.anyio { #pytest-mark-anyio }
 
 Si queremos llamar funciones asíncronas en nuestros tests, nuestras funciones de test tienen que ser asíncronas. AnyIO proporciona un plugin útil para esto, que nos permite especificar que algunas funciones de test deben ser llamadas de manera asíncrona.
 
-## HTTPX
+## HTTPX { #httpx }
 
 Incluso si tu aplicación de **FastAPI** usa funciones `def` normales en lugar de `async def`, sigue siendo una aplicación `async` por debajo.
 
@@ -18,7 +18,7 @@ El `TestClient` hace algo de magia interna para llamar a la aplicación FastAPI
 
 El `TestClient` está basado en <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a>, y afortunadamente, podemos usarlo directamente para probar la API.
 
-## Ejemplo
+## Ejemplo { #example }
 
 Para un ejemplo simple, consideremos una estructura de archivos similar a la descrita en [Aplicaciones Más Grandes](../tutorial/bigger-applications.md){.internal-link target=_blank} y [Testing](../tutorial/testing.md){.internal-link target=_blank}:
 
@@ -38,7 +38,7 @@ El archivo `test_main.py` tendría los tests para `main.py`, podría verse así
 
 {* ../../docs_src/async_tests/test_main.py *}
 
-## Ejecútalo
+## Ejecútalo { #run-it }
 
 Puedes ejecutar tus tests como de costumbre vía:
 
@@ -52,7 +52,7 @@ $ pytest
 
 </div>
 
-## En Detalle
+## En Detalle { #in-detail }
 
 El marcador `@pytest.mark.anyio` le dice a pytest que esta función de test debe ser llamada asíncronamente:
 
@@ -60,7 +60,7 @@ El marcador `@pytest.mark.anyio` le dice a pytest que esta función de test debe
 
 /// tip | Consejo
 
-Note que la función de test ahora es `async def` en lugar de solo `def` como antes al usar el `TestClient`.
+Nota que la función de test ahora es `async def` en lugar de solo `def` como antes al usar el `TestClient`.
 
 ///
 
@@ -88,12 +88,12 @@ Si tu aplicación depende de eventos de lifespan, el `AsyncClient` no activará
 
 ///
 
-## Otras Llamadas a Funciones Asíncronas
+## Otras Llamadas a Funciones Asíncronas { #other-asynchronous-function-calls }
 
 Al ser la función de test asíncrona, ahora también puedes llamar (y `await`) otras funciones `async` además de enviar requests a tu aplicación FastAPI en tus tests, exactamente como las llamarías en cualquier otro lugar de tu código.
 
 /// tip | Consejo
 
-Si encuentras un `RuntimeError: Task attached to a different loop` al integrar llamadas a funciones asíncronas en tus tests (por ejemplo, cuando usas <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MotorClient de MongoDB</a>), recuerda crear instances de objetos que necesiten un loop de eventos solo dentro de funciones async, por ejemplo, en un callback `'@app.on_event("startup")`.
+Si encuentras un `RuntimeError: Task attached to a different loop` al integrar llamadas a funciones asíncronas en tus tests (por ejemplo, cuando usas <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MotorClient de MongoDB</a>), recuerda crear instances de objetos que necesiten un loop de eventos solo dentro de funciones async, por ejemplo, en un callback `@app.on_event("startup")`.
 
 ///

docs/es/docs/advanced/behind-a-proxy.md

@@ -1,6 +1,105 @@
-# Detrás de un Proxy
+# Detrás de un Proxy { #behind-a-proxy }
 
-En algunas situaciones, podrías necesitar usar un **proxy** como Traefik o Nginx con una configuración que añade un prefijo de path extra que no es visto por tu aplicación.
+En muchas situaciones, usarías un **proxy** como Traefik o Nginx delante de tu app de FastAPI.
+
+Estos proxies podrían manejar certificados HTTPS y otras cosas.
+
+## Headers reenviados por el Proxy { #proxy-forwarded-headers }
+
+Un **proxy** delante de tu aplicación normalmente establecería algunos headers sobre la marcha antes de enviar los requests a tu **server** para que el servidor sepa que el request fue **reenviado** por el proxy, informándole la URL original (pública), incluyendo el dominio, que está usando HTTPS, etc.
+
+El programa **server** (por ejemplo **Uvicorn** a través de **FastAPI CLI**) es capaz de interpretar esos headers, y luego pasar esa información a tu aplicación.
+
+Pero por seguridad, como el server no sabe que está detrás de un proxy confiable, no interpretará esos headers.
+
+/// note | Detalles Técnicos
+
+Los headers del proxy son:
+
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For" class="external-link" target="_blank">X-Forwarded-For</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto" class="external-link" target="_blank">X-Forwarded-Proto</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>
+
+///
+
+### Habilitar headers reenviados por el Proxy { #enable-proxy-forwarded-headers }
+
+Puedes iniciar FastAPI CLI con la *Opción de CLI* `--forwarded-allow-ips` y pasar las direcciones IP que deberían ser confiables para leer esos headers reenviados.
+
+Si lo estableces a `--forwarded-allow-ips="*"`, confiaría en todas las IPs entrantes.
+
+Si tu **server** está detrás de un **proxy** confiable y solo el proxy le habla, esto haría que acepte cualquiera que sea la IP de ese **proxy**.
+
+<div class="termy">
+
+```console
+$ 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)
+```
+
+</div>
+
+### Redirecciones con HTTPS { #redirects-with-https }
+
+Por ejemplo, digamos que defines una *path operation* `/items/`:
+
+{* ../../docs_src/behind_a_proxy/tutorial001_01.py hl[6] *}
+
+Si el cliente intenta ir a `/items`, por defecto, sería redirigido a `/items/`.
+
+Pero antes de configurar la *Opción de CLI* `--forwarded-allow-ips` podría redirigir a `http://localhost:8000/items/`.
+
+Pero quizá tu aplicación está alojada en `https://mysuperapp.com`, y la redirección debería ser a `https://mysuperapp.com/items/`.
+
+Al configurar `--proxy-headers` ahora FastAPI podrá redirigir a la ubicación correcta. 😎
+
+```
+https://mysuperapp.com/items/
+```
+
+/// tip | Consejo
+
+Si quieres aprender más sobre HTTPS, revisa la guía [Acerca de HTTPS](../deployment/https.md){.internal-link target=_blank}.
+
+///
+
+### Cómo funcionan los headers reenviados por el Proxy { #how-proxy-forwarded-headers-work }
+
+Aquí tienes una representación visual de cómo el **proxy** añade headers reenviados entre el cliente y el **application server**:
+
+```mermaid
+sequenceDiagram
+    participant Client as Cliente
+    participant Proxy as Proxy/Load Balancer
+    participant Server as Servidor de FastAPI
+
+    Client->>Proxy: HTTPS Request<br/>Host: mysuperapp.com<br/>Path: /items
+
+    Note over Proxy: El proxy añade headers reenviados
+
+    Proxy->>Server: HTTP Request<br/>X-Forwarded-For: [client IP]<br/>X-Forwarded-Proto: https<br/>X-Forwarded-Host: mysuperapp.com<br/>Path: /items
+
+    Note over Server: El servidor interpreta los headers<br/>(si --forwarded-allow-ips está configurado)
+
+    Server->>Proxy: HTTP Response<br/>con URLs HTTPS correctas
+
+    Proxy->>Client: HTTPS Response
+```
+
+El **proxy** intercepta el request original del cliente y añade los *headers* especiales de reenvío (`X-Forwarded-*`) antes de pasar el request al **application server**.
+
+Estos headers preservan información sobre el request original que de otro modo se perdería:
+
+* **X-Forwarded-For**: La IP original del cliente
+* **X-Forwarded-Proto**: El protocolo original (`https`)
+* **X-Forwarded-Host**: El host original (`mysuperapp.com`)
+
+Cuando **FastAPI CLI** está configurado con `--forwarded-allow-ips`, confía en estos headers y los usa, por ejemplo para generar las URLs correctas en redirecciones.
+
+## Proxy con un prefijo de path eliminado { #proxy-with-a-stripped-path-prefix }
+
+Podrías tener un proxy que añada un prefijo de path a tu aplicación.
 
 En estos casos, puedes usar `root_path` para configurar tu aplicación.
 
@@ -10,8 +109,6 @@ El `root_path` se usa para manejar estos casos específicos.
 
 Y también se usa internamente al montar subaplicaciones.
 
-## Proxy con un prefijo de path eliminado
-
 Tener un proxy con un prefijo de path eliminado, en este caso, significa que podrías declarar un path en `/app` en tu código, pero luego añades una capa encima (el proxy) que situaría tu aplicación **FastAPI** bajo un path como `/api/v1`.
 
 En este caso, el path original `/app` realmente sería servido en `/api/v1/app`.
@@ -66,14 +163,14 @@ La UI de los docs también necesitaría el esquema de OpenAPI para declarar que
 
 En este ejemplo, el "Proxy" podría ser algo como **Traefik**. Y el servidor sería algo como FastAPI CLI con **Uvicorn**, ejecutando tu aplicación de FastAPI.
 
-### Proporcionando el `root_path`
+### Proporcionando el `root_path` { #providing-the-root-path }
 
 Para lograr esto, puedes usar la opción de línea de comandos `--root-path` como:
 
 <div class="termy">
 
 ```console
-$ fastapi run main.py --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)
 ```
@@ -90,7 +187,7 @@ Y la opción de línea de comandos `--root-path` proporciona ese `root_path`.
 
 ///
 
-### Revisar el `root_path` actual
+### Revisar el `root_path` actual { #checking-the-current-root-path }
 
 Puedes obtener el `root_path` actual utilizado por tu aplicación para cada request, es parte del diccionario `scope` (que es parte de la especificación ASGI).
 
@@ -103,7 +200,7 @@ Luego, si inicias Uvicorn con:
 <div class="termy">
 
 ```console
-$ fastapi run main.py --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)
 ```
@@ -119,7 +216,7 @@ El response sería algo como:
 }
 ```
 
-### Configurar el `root_path` en la app de FastAPI
+### Configurar el `root_path` en la app de FastAPI { #setting-the-root-path-in-the-fastapi-app }
 
 Alternativamente, si no tienes una forma de proporcionar una opción de línea de comandos como `--root-path` o su equivalente, puedes configurar el parámetro `root_path` al crear tu app de FastAPI:
 
@@ -127,11 +224,11 @@ Alternativamente, si no tienes una forma de proporcionar una opción de línea d
 
 Pasar el `root_path` a `FastAPI` sería el equivalente a pasar la opción de línea de comandos `--root-path` a Uvicorn o Hypercorn.
 
-### Acerca de `root_path`
+### Acerca de `root_path` { #about-root-path }
 
 Ten en cuenta que el servidor (Uvicorn) no usará ese `root_path` para nada, a excepción de pasárselo a la app.
 
-Pero si vas con tu navegador a <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000/app</a> verás el response normal:
+Pero si vas con tu navegador a <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a> verás el response normal:
 
 ```JSON
 {
@@ -144,15 +241,15 @@ Así que no se esperará que sea accedido en `http://127.0.0.1:8000/api/v1/app`.
 
 Uvicorn esperará que el proxy acceda a Uvicorn en `http://127.0.0.1:8000/app`, y luego será responsabilidad del proxy añadir el prefijo extra `/api/v1` encima.
 
-## Sobre proxies con un prefijo de path eliminado
+## Sobre proxies con un prefijo de path eliminado { #about-proxies-with-a-stripped-path-prefix }
 
 Ten en cuenta que un proxy con prefijo de path eliminado es solo una de las formas de configurarlo.
 
-Probablemente en muchos casos, el valor predeterminado será que el proxy no tenga un prefijo de path eliminado.
+Probablemente en muchos casos, el valor por defecto será que el proxy no tenga un prefijo de path eliminado.
 
 En un caso así (sin un prefijo de path eliminado), el proxy escucharía algo como `https://myawesomeapp.com`, y luego si el navegador va a `https://myawesomeapp.com/api/v1/app` y tu servidor (por ejemplo, Uvicorn) escucha en `http://127.0.0.1:8000`, el proxy (sin un prefijo de path eliminado) accedería a Uvicorn en el mismo path: `http://127.0.0.1:8000/api/v1/app`.
 
-## Probando localmente con Traefik
+## Probando localmente con Traefik { #testing-locally-with-traefik }
 
 Puedes ejecutar fácilmente el experimento localmente con un prefijo de path eliminado usando <a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a>.
 
@@ -224,14 +321,14 @@ Y ahora inicia tu app, utilizando la opción `--root-path`:
 <div class="termy">
 
 ```console
-$ fastapi run main.py --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)
 ```
 
 </div>
 
-### Revisa los responses
+### Revisa los responses { #check-the-responses }
 
 Ahora, si vas a la URL con el puerto para Uvicorn: <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, verás el response normal:
 
@@ -267,7 +364,7 @@ Y la versión sin el prefijo de path (`http://127.0.0.1:8000/app`), proporcionad
 
 Eso demuestra cómo el Proxy (Traefik) usa el prefijo de path y cómo el servidor (Uvicorn) usa el `root_path` de la opción `--root-path`.
 
-### Revisa la UI de los docs
+### Revisa la UI de los docs { #check-the-docs-ui }
 
 Pero aquí está la parte divertida. ✨
 
@@ -287,7 +384,7 @@ Justo como queríamos. ✔️
 
 Esto es porque FastAPI usa este `root_path` para crear el `server` por defecto en OpenAPI con la URL proporcionada por `root_path`.
 
-## Servidores adicionales
+## Servidores adicionales { #additional-servers }
 
 /// warning | Advertencia
 
@@ -346,7 +443,15 @@ La UI de los docs interactuará con el server que selecciones.
 
 ///
 
-### Desactivar el server automático de `root_path`
+/// note | Detalles Técnicos
+
+La propiedad `servers` en la especificación de OpenAPI es opcional.
+
+Si no especificas el parámetro `servers` y `root_path` es igual a `/`, la propiedad `servers` en el esquema de OpenAPI generado se omitirá por completo por defecto, lo cual es equivalente a un único server con un valor `url` de `/`.
+
+///
+
+### Desactivar el server automático de `root_path` { #disable-automatic-server-from-root-path }
 
 Si no quieres que **FastAPI** incluya un server automático usando el `root_path`, puedes usar el parámetro `root_path_in_servers=False`:
 
@@ -354,7 +459,7 @@ Si no quieres que **FastAPI** incluya un server automático usando el `root_path
 
 y entonces no lo incluirá en el esquema de OpenAPI.
 
-## Montando una sub-aplicación
+## Montando una sub-aplicación { #mounting-a-sub-application }
 
 Si necesitas montar una sub-aplicación (como se describe en [Aplicaciones secundarias - Monturas](sub-applications.md){.internal-link target=_blank}) mientras usas un proxy con `root_path`, puedes hacerlo normalmente, como esperarías.
 

docs/es/docs/advanced/custom-response.md

@@ -1,4 +1,4 @@
-# Response Personalizado - HTML, Stream, Archivo, otros
+# Response Personalizado - HTML, Stream, Archivo, otros { #custom-response-html-stream-file-others }
 
 Por defecto, **FastAPI** devolverá los responses usando `JSONResponse`.
 
@@ -18,7 +18,7 @@ Si usas una clase de response sin media type, FastAPI esperará que tu response
 
 ///
 
-## Usa `ORJSONResponse`
+## Usa `ORJSONResponse` { #use-orjsonresponse }
 
 Por ejemplo, si estás exprimendo el rendimiento, puedes instalar y usar <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> y establecer el response como `ORJSONResponse`.
 
@@ -48,7 +48,7 @@ El `ORJSONResponse` solo está disponible en FastAPI, no en Starlette.
 
 ///
 
-## Response HTML
+## Response HTML { #html-response }
 
 Para devolver un response con HTML directamente desde **FastAPI**, usa `HTMLResponse`.
 
@@ -67,7 +67,7 @@ Y se documentará así en OpenAPI.
 
 ///
 
-### Devuelve una `Response`
+### Devuelve una `Response` { #return-a-response }
 
 Como se ve en [Devolver una Response directamente](response-directly.md){.internal-link target=_blank}, también puedes sobrescribir el response directamente en tu *path operation*, devolviéndolo.
 
@@ -87,13 +87,13 @@ Por supuesto, el `Content-Type` header real, el código de estado, etc., provend
 
 ///
 
-### Documenta en OpenAPI y sobrescribe `Response`
+### Documenta en OpenAPI y sobrescribe `Response` { #document-in-openapi-and-override-response }
 
 Si quieres sobrescribir el response desde dentro de la función pero al mismo tiempo documentar el "media type" en OpenAPI, puedes usar el parámetro `response_class` Y devolver un objeto `Response`.
 
 El `response_class` solo se usará para documentar el OpenAPI *path operation*, pero tu `Response` se usará tal cual.
 
-#### Devuelve un `HTMLResponse` directamente
+#### Devuelve un `HTMLResponse` directamente { #return-an-htmlresponse-directly }
 
 Por ejemplo, podría ser algo así:
 
@@ -101,13 +101,13 @@ Por ejemplo, podría ser algo así:
 
 En este ejemplo, la función `generate_html_response()` ya genera y devuelve una `Response` en lugar de devolver el HTML en un `str`.
 
-Al devolver el resultado de llamar a `generate_html_response()`, ya estás devolviendo una `Response` que sobrescribirá el comportamiento predeterminado de **FastAPI**.
+Al devolver el resultado de llamar a `generate_html_response()`, ya estás devolviendo una `Response` que sobrescribirá el comportamiento por defecto de **FastAPI**.
 
 Pero como pasaste `HTMLResponse` en el `response_class` también, **FastAPI** sabrá cómo documentarlo en OpenAPI y la documentación interactiva como HTML con `text/html`:
 
 <img src="/img/tutorial/custom-response/image01.png">
 
-## Responses disponibles
+## Responses disponibles { #available-responses }
 
 Aquí hay algunos de los responses disponibles.
 
@@ -121,7 +121,7 @@ También podrías usar `from starlette.responses import HTMLResponse`.
 
 ///
 
-### `Response`
+### `Response` { #response }
 
 La clase principal `Response`, todos los otros responses heredan de ella.
 
@@ -138,23 +138,23 @@ FastAPI (de hecho Starlette) incluirá automáticamente un header Content-Length
 
 {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-### `HTMLResponse`
+### `HTMLResponse` { #htmlresponse }
 
 Toma algún texto o bytes y devuelve un response HTML, como leíste arriba.
 
-### `PlainTextResponse`
+### `PlainTextResponse` { #plaintextresponse }
 
 Toma algún texto o bytes y devuelve un response de texto plano.
 
 {* ../../docs_src/custom_response/tutorial005.py hl[2,7,9] *}
 
-### `JSONResponse`
+### `JSONResponse` { #jsonresponse }
 
 Toma algunos datos y devuelve un response codificado como `application/json`.
 
-Este es el response predeterminado usado en **FastAPI**, como leíste arriba.
+Este es el response usado por defecto en **FastAPI**, como leíste arriba.
 
-### `ORJSONResponse`
+### `ORJSONResponse` { #orjsonresponse }
 
 Un response JSON rápido alternativo usando <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a>, como leíste arriba.
 
@@ -164,7 +164,7 @@ Esto requiere instalar `orjson`, por ejemplo, con `pip install orjson`.
 
 ///
 
-### `UJSONResponse`
+### `UJSONResponse` { #ujsonresponse }
 
 Un response JSON alternativo usando <a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a>.
 
@@ -188,7 +188,7 @@ Es posible que `ORJSONResponse` sea una alternativa más rápida.
 
 ///
 
-### `RedirectResponse`
+### `RedirectResponse` { #redirectresponse }
 
 Devuelve una redirección HTTP. Usa un código de estado 307 (Redirección Temporal) por defecto.
 
@@ -204,7 +204,7 @@ O puedes usarlo en el parámetro `response_class`:
 
 Si haces eso, entonces puedes devolver la URL directamente desde tu *path operation function*.
 
-En este caso, el `status_code` utilizado será el predeterminado para `RedirectResponse`, que es `307`.
+En este caso, el `status_code` utilizado será el por defecto para `RedirectResponse`, que es `307`.
 
 ---
 
@@ -212,13 +212,13 @@ También puedes usar el parámetro `status_code` combinado con el parámetro `re
 
 {* ../../docs_src/custom_response/tutorial006c.py hl[2,7,9] *}
 
-### `StreamingResponse`
+### `StreamingResponse` { #streamingresponse }
 
 Toma un generador `async` o un generador/iterador normal y transmite el cuerpo del response.
 
 {* ../../docs_src/custom_response/tutorial007.py hl[2,14] *}
 
-#### Usando `StreamingResponse` con objetos similares a archivos
+#### Usando `StreamingResponse` con objetos similares a archivos { #using-streamingresponse-with-file-like-objects }
 
 Si tienes un objeto similar a un archivo (por ejemplo, el objeto devuelto por `open()`), puedes crear una función generadora para iterar sobre ese objeto similar a un archivo.
 
@@ -242,7 +242,7 @@ Nota que aquí como estamos usando `open()` estándar que no admite `async` y `a
 
 ///
 
-### `FileResponse`
+### `FileResponse` { #fileresponse }
 
 Transmite un archivo asincrónicamente como response.
 
@@ -263,7 +263,7 @@ También puedes usar el parámetro `response_class`:
 
 En este caso, puedes devolver la path del archivo directamente desde tu *path operation* function.
 
-## Clase de response personalizada
+## Clase de response personalizada { #custom-response-class }
 
 Puedes crear tu propia clase de response personalizada, heredando de `Response` y usándola.
 
@@ -291,7 +291,7 @@ Ahora en lugar de devolver:
 
 Por supuesto, probablemente encontrarás formas mucho mejores de aprovechar esto que formatear JSON. 😉
 
-## Clase de response predeterminada
+## Clase de response por defecto { #default-response-class }
 
 Al crear una instance de la clase **FastAPI** o un `APIRouter`, puedes especificar qué clase de response usar por defecto.
 
@@ -307,6 +307,6 @@ Todavía puedes sobrescribir `response_class` en *path operations* como antes.
 
 ///
 
-## Documentación adicional
+## Documentación adicional { #additional-documentation }
 
 También puedes declarar el media type y muchos otros detalles en OpenAPI usando `responses`: [Responses Adicionales en OpenAPI](additional-responses.md){.internal-link target=_blank}.

docs/es/docs/advanced/dataclasses.md

@@ -1,10 +1,10 @@
-# Usando Dataclasses
+# Usando Dataclasses { #using-dataclasses }
 
 FastAPI está construido sobre **Pydantic**, y te he estado mostrando cómo usar modelos de Pydantic para declarar requests y responses.
 
 Pero FastAPI también soporta el uso de <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a> de la misma manera:
 
-{* ../../docs_src/dataclasses/tutorial001.py hl[1,7:12,19:20] *}
+{* ../../docs_src/dataclasses/tutorial001_py310.py hl[1,6:11,18:19] *}
 
 Esto sigue siendo soportado gracias a **Pydantic**, ya que tiene <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">soporte interno para `dataclasses`</a>.
 
@@ -28,11 +28,11 @@ Pero si tienes un montón de dataclasses por ahí, este es un buen truco para us
 
 ///
 
-## Dataclasses en `response_model`
+## Dataclasses en `response_model` { #dataclasses-in-response-model }
 
 También puedes usar `dataclasses` en el parámetro `response_model`:
 
-{* ../../docs_src/dataclasses/tutorial002.py hl[1,7:13,19] *}
+{* ../../docs_src/dataclasses/tutorial002_py310.py hl[1,6:12,18] *}
 
 El dataclass será automáticamente convertido a un dataclass de Pydantic.
 
@@ -40,7 +40,7 @@ De esta manera, su esquema aparecerá en la interfaz de usuario de la documentac
 
 <img src="/img/tutorial/dataclasses/image01.png">
 
-## Dataclasses en Estructuras de Datos Anidadas
+## Dataclasses en Estructuras de Datos Anidadas { #dataclasses-in-nested-data-structures }
 
 También puedes combinar `dataclasses` con otras anotaciones de tipos para crear estructuras de datos anidadas.
 
@@ -48,7 +48,7 @@ En algunos casos, todavía podrías tener que usar la versión de `dataclasses`
 
 En ese caso, simplemente puedes intercambiar los `dataclasses` estándar con `pydantic.dataclasses`, que es un reemplazo directo:
 
-{* ../../docs_src/dataclasses/tutorial003.py hl[1,5,8:11,14:17,23:25,28] *}
+{* ../../docs_src/dataclasses/tutorial003_py310.py hl[1,4,7:10,13:16,22:24,27] *}
 
 1. Todavía importamos `field` de los `dataclasses` estándar.
 
@@ -64,7 +64,7 @@ En ese caso, simplemente puedes intercambiar los `dataclasses` estándar con `py
 
 6. Aquí estamos regresando un diccionario que contiene `items`, que es una lista de dataclasses.
 
-    FastAPI todavía es capaz de <abbr title="converting the data to a format that can be transmitted">serializar</abbr> los datos a JSON.
+    FastAPI todavía es capaz de <abbr title="convertir los datos a un formato que pueda transmitirse">serializar</abbr> los datos a JSON.
 
 7. Aquí el `response_model` está usando una anotación de tipo de una lista de dataclasses `Author`.
 
@@ -84,12 +84,12 @@ Puedes combinar `dataclasses` con otras anotaciones de tipos en muchas combinaci
 
 Revisa las anotaciones en el código arriba para ver más detalles específicos.
 
-## Aprende Más
+## Aprende Más { #learn-more }
 
 También puedes combinar `dataclasses` con otros modelos de Pydantic, heredar de ellos, incluirlos en tus propios modelos, etc.
 
 Para saber más, revisa la <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/" class="external-link" target="_blank">documentación de Pydantic sobre dataclasses</a>.
 
-## Versión
+## Versión { #version }
 
 Esto está disponible desde la versión `0.67.0` de FastAPI. 🔖

docs/es/docs/advanced/generate-clients.md

@@ -1,115 +1,76 @@
-# Genera Clientes
+# Generando SDKs { #generating-sdks }
 
-Como **FastAPI** está basado en la especificación OpenAPI, obtienes compatibilidad automática con muchas herramientas, incluyendo la documentación automática de la API (proporcionada por Swagger UI).
+Como **FastAPI** está basado en la especificación **OpenAPI**, sus APIs se pueden describir en un formato estándar que muchas herramientas entienden.
 
-Una ventaja particular que no es necesariamente obvia es que puedes **generar clientes** (a veces llamados <abbr title="Software Development Kits">**SDKs**</abbr> ) para tu API, para muchos **lenguajes de programación** diferentes.
+Esto facilita generar **documentación** actualizada, paquetes de cliente (<abbr title="Software Development Kits – Kits de Desarrollo de Software">**SDKs**</abbr>) en múltiples lenguajes y **escribir pruebas** o **flujos de automatización** que se mantengan sincronizados con tu código.
 
-## Generadores de Clientes OpenAPI
+En esta guía, aprenderás a generar un **SDK de TypeScript** para tu backend con FastAPI.
 
-Hay muchas herramientas para generar clientes desde **OpenAPI**.
+## Generadores de SDKs de código abierto { #open-source-sdk-generators }
 
-Una herramienta común es <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>.
+Una opción versátil es el <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>, que soporta **muchos lenguajes de programación** y puede generar SDKs a partir de tu especificación OpenAPI.
 
-Si estás construyendo un **frontend**, una alternativa muy interesante es <a href="https://github.com/hey-api/openapi-ts" class="external-link" target="_blank">openapi-ts</a>.
+Para **clientes de TypeScript**, <a href="https://heyapi.dev/" class="external-link" target="_blank">Hey API</a> es una solución diseñada específicamente, que ofrece una experiencia optimizada para el ecosistema de TypeScript.
 
-## Generadores de Clientes y SDKs - Sponsor
+Puedes descubrir más generadores de SDK en <a href="https://openapi.tools/#sdk" class="external-link" target="_blank">OpenAPI.Tools</a>.
 
-También hay algunos generadores de Clientes y SDKs **respaldados por empresas** basados en OpenAPI (FastAPI), en algunos casos pueden ofrecerte **funcionalidades adicionales** además de SDKs/clientes generados de alta calidad.
+/// tip | Consejo
 
-Algunos de ellos también ✨ [**sponsorean FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, esto asegura el **desarrollo** continuo y saludable de FastAPI y su **ecosistema**.
+FastAPI genera automáticamente especificaciones **OpenAPI 3.1**, así que cualquier herramienta que uses debe soportar esta versión.
 
-Y muestra su verdadero compromiso con FastAPI y su **comunidad** (tú), ya que no solo quieren proporcionarte un **buen servicio** sino también asegurarse de que tengas un **buen y saludable framework**, FastAPI. 🙇
+///
+
+## Generadores de SDKs de sponsors de FastAPI { #sdk-generators-from-fastapi-sponsors }
+
+Esta sección destaca soluciones **respaldadas por empresas** y **venture-backed** de compañías que sponsorean FastAPI. Estos productos ofrecen **funcionalidades adicionales** e **integraciones** además de SDKs generados de alta calidad.
+
+Al ✨ [**sponsorear FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, estas compañías ayudan a asegurar que el framework y su **ecosistema** se mantengan saludables y **sustentables**.
+
+Su sponsorship también demuestra un fuerte compromiso con la **comunidad** de FastAPI (tú), mostrando que no solo les importa ofrecer un **gran servicio**, sino también apoyar un **framework robusto y próspero**, FastAPI. 🙇
 
 Por ejemplo, podrías querer probar:
 
 * <a href="https://speakeasy.com/editor?utm_source=fastapi+repo&utm_medium=github+sponsorship" class="external-link" target="_blank">Speakeasy</a>
-* <a href="https://www.stainlessapi.com/?utm_source=fastapi&utm_medium=referral" class="external-link" target="_blank">Stainless</a>
-* <a href="https://developers.liblab.com/tutorials/sdk-for-fastapi/?utm_source=fastapi" class="external-link" target="_blank">liblab</a>
+* <a href="https://www.stainless.com/?utm_source=fastapi&utm_medium=referral" class="external-link" target="_blank">Stainless</a>
+* <a href="https://developers.liblab.com/tutorials/sdk-for-fastapi?utm_source=fastapi" class="external-link" target="_blank">liblab</a>
 
-También hay varias otras empresas que ofrecen servicios similares que puedes buscar y encontrar en línea. 🤓
+Algunas de estas soluciones también pueden ser open source u ofrecer niveles gratuitos, así que puedes probarlas sin un compromiso financiero. Hay otros generadores de SDK comerciales disponibles y se pueden encontrar en línea. 🤓
 
-## Genera un Cliente Frontend en TypeScript
+## Crea un SDK de TypeScript { #create-a-typescript-sdk }
 
 Empecemos con una aplicación simple de FastAPI:
 
 {* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *}
 
-Nota que las *path operations* definen los modelos que usan para el payload de la petición y el payload del response, usando los modelos `Item` y `ResponseMessage`.
+Nota que las *path operations* definen los modelos que usan para el payload del request y el payload del response, usando los modelos `Item` y `ResponseMessage`.
 
-### Documentación de la API
+### Documentación de la API { #api-docs }
 
-Si vas a la documentación de la API, verás que tiene los **esquemas** para los datos que se enviarán en las peticiones y se recibirán en los responses:
+Si vas a `/docs`, verás que tiene los **esquemas** para los datos a enviar en requests y recibir en responses:
 
 <img src="/img/tutorial/generate-clients/image01.png">
 
-Puedes ver esos esquemas porque fueron declarados con los modelos en la aplicación.
+Puedes ver esos esquemas porque fueron declarados con los modelos en la app.
 
-Esa información está disponible en el **JSON Schema** de OpenAPI de la aplicación, y luego se muestra en la documentación de la API (por Swagger UI).
+Esa información está disponible en el **OpenAPI schema** de la app, y luego se muestra en la documentación de la API.
 
 Y esa misma información de los modelos que está incluida en OpenAPI es lo que puede usarse para **generar el código del cliente**.
 
-### Genera un Cliente en TypeScript
+### Hey API { #hey-api }
 
-Ahora que tenemos la aplicación con los modelos, podemos generar el código del cliente para el frontend.
+Una vez que tenemos una app de FastAPI con los modelos, podemos usar Hey API para generar un cliente de TypeScript. La forma más rápida de hacerlo es con npx.
 
-#### Instalar `openapi-ts`
-
-Puedes instalar `openapi-ts` en tu código de frontend con:
-
-<div class="termy">
-
-```console
-$ npm install @hey-api/openapi-ts --save-dev
-
----> 100%
+```sh
+npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
 ```
 
-</div>
+Esto generará un SDK de TypeScript en `./src/client`.
 
-#### Generar el Código del Cliente
+Puedes aprender cómo <a href="https://heyapi.dev/openapi-ts/get-started" class="external-link" target="_blank">instalar `@hey-api/openapi-ts`</a> y leer sobre el <a href="https://heyapi.dev/openapi-ts/output" class="external-link" target="_blank">output generado</a> en su sitio web.
 
-Para generar el código del cliente puedes usar la aplicación de línea de comandos `openapi-ts` que ahora estaría instalada.
+### Usar el SDK { #using-the-sdk }
 
-Como está instalada en el proyecto local, probablemente no podrías llamar a ese comando directamente, pero podrías ponerlo en tu archivo `package.json`.
-
-Podría verse como esto:
-
-```JSON  hl_lines="7"
-{
-  "name": "frontend-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "generate-client": "openapi-ts --input http://localhost:8000/openapi.json --output ./src/client --client axios"
-  },
-  "author": "",
-  "license": "",
-  "devDependencies": {
-    "@hey-api/openapi-ts": "^0.27.38",
-    "typescript": "^4.6.2"
-  }
-}
-```
-
-Después de tener ese script de NPM `generate-client` allí, puedes ejecutarlo con:
-
-<div class="termy">
-
-```console
-$ npm run generate-client
-
-frontend-app@1.0.0 generate-client /home/user/code/frontend-app
-> openapi-ts --input http://localhost:8000/openapi.json --output ./src/client --client axios
-```
-
-</div>
-
-Ese comando generará código en `./src/client` y usará `axios` (el paquete HTTP de frontend) internamente.
-
-### Prueba el Código del Cliente
-
-Ahora puedes importar y usar el código del cliente, podría verse así, nota que tienes autocompletado para los métodos:
+Ahora puedes importar y usar el código del cliente. Podría verse así, nota que tienes autocompletado para los métodos:
 
 <img src="/img/tutorial/generate-clients/image02.png">
 
@@ -131,17 +92,17 @@ El objeto de response también tendrá autocompletado:
 
 <img src="/img/tutorial/generate-clients/image05.png">
 
-## App de FastAPI con Tags
+## App de FastAPI con tags { #fastapi-app-with-tags }
 
-En muchos casos tu aplicación de FastAPI será más grande, y probablemente usarás tags para separar diferentes grupos de *path operations*.
+En muchos casos tu app de FastAPI será más grande, y probablemente usarás tags para separar diferentes grupos de *path operations*.
 
-Por ejemplo, podrías tener una sección para **items** y otra sección para **usuarios**, y podrían estar separadas por tags:
+Por ejemplo, podrías tener una sección para **items** y otra sección para **users**, y podrían estar separadas por tags:
 
 {* ../../docs_src/generate_clients/tutorial002_py39.py hl[21,26,34] *}
 
-### Genera un Cliente TypeScript con Tags
+### Genera un Cliente TypeScript con tags { #generate-a-typescript-client-with-tags }
 
-Si generas un cliente para una aplicación de FastAPI usando tags, normalmente también separará el código del cliente basándose en los tags.
+Si generas un cliente para una app de FastAPI usando tags, normalmente también separará el código del cliente basándose en los tags.
 
 De esta manera podrás tener las cosas ordenadas y agrupadas correctamente para el código del cliente:
 
@@ -152,7 +113,7 @@ En este caso tienes:
 * `ItemsService`
 * `UsersService`
 
-### Nombres de los Métodos del Cliente
+### Nombres de los métodos del cliente { #client-method-names }
 
 Ahora mismo los nombres de los métodos generados como `createItemItemsPost` no se ven muy limpios:
 
@@ -166,15 +127,15 @@ OpenAPI requiere que cada operation ID sea único a través de todas las *path o
 
 Pero te mostraré cómo mejorar eso a continuación. 🤓
 
-## Operation IDs Personalizados y Mejores Nombres de Métodos
+## Operation IDs personalizados y mejores nombres de métodos { #custom-operation-ids-and-better-method-names }
 
 Puedes **modificar** la forma en que estos operation IDs son **generados** para hacerlos más simples y tener **nombres de métodos más simples** en los clientes.
 
 En este caso tendrás que asegurarte de que cada operation ID sea **único** de alguna otra manera.
 
-Por ejemplo, podrías asegurarte de que cada *path operation* tenga un tag, y luego generar el operation ID basado en el **tag** y el nombre de la *path operation* **name** (el nombre de la función).
+Por ejemplo, podrías asegurarte de que cada *path operation* tenga un tag, y luego generar el operation ID basado en el **tag** y el **name** de la *path operation* (el nombre de la función).
 
-### Función Personalizada para Generar ID Único
+### Función personalizada para generar ID único { #custom-generate-unique-id-function }
 
 FastAPI usa un **ID único** para cada *path operation*, se usa para el **operation ID** y también para los nombres de cualquier modelo personalizado necesario, para requests o responses.
 
@@ -186,15 +147,15 @@ Puedes entonces pasar esa función personalizada a **FastAPI** como el parámetr
 
 {* ../../docs_src/generate_clients/tutorial003_py39.py hl[6:7,10] *}
 
-### Generar un Cliente TypeScript con Operation IDs Personalizados
+### Genera un Cliente TypeScript con operation IDs personalizados { #generate-a-typescript-client-with-custom-operation-ids }
 
-Ahora si generas el cliente de nuevo, verás que tiene los nombres de métodos mejorados:
+Ahora, si generas el cliente de nuevo, verás que tiene los nombres de métodos mejorados:
 
 <img src="/img/tutorial/generate-clients/image07.png">
 
 Como ves, los nombres de métodos ahora tienen el tag y luego el nombre de la función, ahora no incluyen información del path de la URL y la operación HTTP.
 
-### Preprocesa la Especificación OpenAPI para el Generador de Clientes
+### Preprocesa la especificación OpenAPI para el generador de clientes { #preprocess-the-openapi-specification-for-the-client-generator }
 
 El código generado aún tiene algo de **información duplicada**.
 
@@ -218,44 +179,30 @@ Podríamos descargar el JSON de OpenAPI a un archivo `openapi.json` y luego podr
 
 Con eso, los operation IDs serían renombrados de cosas como `items-get_items` a solo `get_items`, de esa manera el generador del cliente puede generar nombres de métodos más simples.
 
-### Generar un Cliente TypeScript con el OpenAPI Preprocesado
+### Genera un Cliente TypeScript con el OpenAPI preprocesado { #generate-a-typescript-client-with-the-preprocessed-openapi }
 
-Ahora como el resultado final está en un archivo `openapi.json`, modificarías el `package.json` para usar ese archivo local, por ejemplo:
+Como el resultado final ahora está en un archivo `openapi.json`, necesitas actualizar la ubicación de la entrada:
 
-```JSON  hl_lines="7"
-{
-  "name": "frontend-app",
-  "version": "1.0.0",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "generate-client": "openapi-ts --input ./openapi.json --output ./src/client --client axios"
-  },
-  "author": "",
-  "license": "",
-  "devDependencies": {
-    "@hey-api/openapi-ts": "^0.27.38",
-    "typescript": "^4.6.2"
-  }
-}
+```sh
+npx @hey-api/openapi-ts -i ./openapi.json -o src/client
 ```
 
 Después de generar el nuevo cliente, ahora tendrías nombres de métodos **limpios**, con todo el **autocompletado**, **errores en línea**, etc:
 
 <img src="/img/tutorial/generate-clients/image08.png">
 
-## Beneficios
+## Beneficios { #benefits }
 
-Cuando usas los clientes generados automáticamente obtendrás **autocompletado** para:
+Cuando uses los clientes generados automáticamente obtendrás **autocompletado** para:
 
 * Métodos.
-* Payloads de peticiones en el cuerpo, parámetros de query, etc.
-* Payloads de responses.
+* Payloads de request en el body, parámetros de query, etc.
+* Payloads de response.
 
 También tendrás **errores en línea** para todo.
 
 Y cada vez que actualices el código del backend, y **regeneres** el frontend, tendrás las nuevas *path operations* disponibles como métodos, las antiguas eliminadas, y cualquier otro cambio se reflejará en el código generado. 🤓
 
-Esto también significa que si algo cambió será **reflejado** automáticamente en el código del cliente. Y si haces **build** del cliente, te dará error si tienes algún **desajuste** en los datos utilizados.
+Esto también significa que si algo cambió será **reflejado** automáticamente en el código del cliente. Y si haces **build** del cliente, dará error si tienes algún **desajuste** en los datos utilizados.
 
 Así que, **detectarás muchos errores** muy temprano en el ciclo de desarrollo en lugar de tener que esperar a que los errores se muestren a tus usuarios finales en producción para luego intentar depurar dónde está el problema. ✨

docs/es/docs/advanced/index.md

@@ -1,6 +1,6 @@
-# Guía avanzada del usuario
+# Guía avanzada del usuario { #advanced-user-guide }
 
-## Funcionalidades adicionales
+## Funcionalidades adicionales { #additional-features }
 
 El [Tutorial - Guía del usuario](../tutorial/index.md){.internal-link target=_blank} principal debería ser suficiente para darte un recorrido por todas las funcionalidades principales de **FastAPI**.
 
@@ -14,23 +14,8 @@ Y es posible que para tu caso de uso, la solución esté en una de ellas.
 
 ///
 
-## Lee primero el Tutorial
+## Lee primero el Tutorial { #read-the-tutorial-first }
 
 Aún podrías usar la mayoría de las funcionalidades en **FastAPI** con el conocimiento del [Tutorial - Guía del usuario](../tutorial/index.md){.internal-link target=_blank} principal.
 
 Y las siguientes secciones asumen que ya lo leíste y que conoces esas ideas principales.
-
-## Cursos externos
-
-Aunque el [Tutorial - Guía del usuario](../tutorial/index.md){.internal-link target=_blank} y esta **Guía avanzada del usuario** están escritos como un tutorial guiado (como un libro) y deberían ser suficientes para que **aprendas FastAPI**, podrías querer complementarlo con cursos adicionales.
-
-O podría ser que simplemente prefieras tomar otros cursos porque se adaptan mejor a tu estilo de aprendizaje.
-
-Algunos proveedores de cursos ✨ [**sponsorean FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, esto asegura el desarrollo continuo y saludable de FastAPI y su **ecosistema**.
-
-Y muestra su verdadero compromiso con FastAPI y su **comunidad** (tú), ya que no solo quieren brindarte una **buena experiencia de aprendizaje** sino que también quieren asegurarse de que tengas un **buen y saludable framework**, FastAPI. 🙇
-
-Podrías querer probar sus cursos:
-
-* <a href="https://training.talkpython.fm/fastapi-courses" class="external-link" target="_blank">Talk Python Training</a>
-* <a href="https://testdriven.io/courses/tdd-fastapi/" class="external-link" target="_blank">Desarrollo guiado por pruebas</a>

docs/es/docs/advanced/openapi-callbacks.md

@@ -1,18 +1,18 @@
-# OpenAPI Callbacks
+# Callbacks de OpenAPI { #openapi-callbacks }
 
 Podrías crear una API con una *path operation* que podría desencadenar un request a una *API externa* creada por alguien más (probablemente el mismo desarrollador que estaría *usando* tu API).
 
-El proceso que ocurre cuando tu aplicación API llama a la *API externa* se llama un "callback". Porque el software que escribió el desarrollador externo envía un request a tu API y luego tu API *responde*, enviando un request a una *API externa* (que probablemente fue creada por el mismo desarrollador).
+El proceso que ocurre cuando tu aplicación API llama a la *API externa* se llama un "callback". Porque el software que escribió el desarrollador externo envía un request a tu API y luego tu API hace un *callback*, enviando un request a una *API externa* (que probablemente fue creada por el mismo desarrollador).
 
 En este caso, podrías querer documentar cómo esa API externa *debería* verse. Qué *path operation* debería tener, qué cuerpo debería esperar, qué response debería devolver, etc.
 
-## Una aplicación con callbacks
+## Una aplicación con callbacks { #an-app-with-callbacks }
 
 Veamos todo esto con un ejemplo.
 
 Imagina que desarrollas una aplicación que permite crear facturas.
 
-Estas facturas tendrán un `id`, `title` (opcional), `customer`, y `total`.
+Estas facturas tendrán un `id`, `title` (opcional), `customer` y `total`.
 
 El usuario de tu API (un desarrollador externo) creará una factura en tu API con un request POST.
 
@@ -23,15 +23,15 @@ Luego tu API (imaginemos):
 * Enviará una notificación de vuelta al usuario de la API (el desarrollador externo).
     * Esto se hará enviando un request POST (desde *tu API*) a alguna *API externa* proporcionada por ese desarrollador externo (este es el "callback").
 
-## La aplicación normal de **FastAPI**
+## La aplicación normal de **FastAPI** { #the-normal-fastapi-app }
 
-Primero veamos cómo sería la aplicación API normal antes de agregar el callback.
+Primero veamos cómo se vería la aplicación API normal antes de agregar el callback.
 
 Tendrá una *path operation* que recibirá un cuerpo `Invoice`, y un parámetro de query `callback_url` que contendrá la URL para el callback.
 
 Esta parte es bastante normal, probablemente ya estés familiarizado con la mayor parte del código:
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[9:13,36:53] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[7:11,34:51] *}
 
 /// tip | Consejo
 
@@ -39,9 +39,9 @@ El parámetro de query `callback_url` utiliza un tipo <a href="https://docs.pyda
 
 ///
 
-Lo único nuevo es el `callbacks=invoices_callback_router.routes` como un argumento para el *decorador de path operation*. Veremos qué es eso a continuación.
+Lo único nuevo es `callbacks=invoices_callback_router.routes` como un argumento para el *decorador de path operation*. Veremos qué es eso a continuación.
 
-## Documentar el callback
+## Documentar el callback { #documenting-the-callback }
 
 El código real del callback dependerá mucho de tu propia aplicación API.
 
@@ -56,7 +56,7 @@ httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
 
 Pero posiblemente la parte más importante del callback es asegurarse de que el usuario de tu API (el desarrollador externo) implemente la *API externa* correctamente, de acuerdo con los datos que *tu API* va a enviar en el request body del callback, etc.
 
-Entonces, lo que haremos a continuación es agregar el código para documentar cómo debería verse esa *API externa* para recibir el callback de *tu API*.
+Así que, lo que haremos a continuación es agregar el código para documentar cómo debería verse esa *API externa* para recibir el callback de *tu API*.
 
 Esa documentación aparecerá en la Swagger UI en `/docs` en tu API, y permitirá a los desarrolladores externos saber cómo construir la *API externa*.
 
@@ -70,11 +70,11 @@ Cuando implementes el callback tú mismo, podrías usar algo como <a href="https
 
 ///
 
-## Escribir el código de documentación del callback
+## Escribe el código de documentación del callback { #write-the-callback-documentation-code }
 
 Este código no se ejecutará en tu aplicación, solo lo necesitamos para *documentar* cómo debería verse esa *API externa*.
 
-Pero, ya sabes cómo crear fácilmente documentación automática para una API con **FastAPI**.
+Pero ya sabes cómo crear fácilmente documentación automática para una API con **FastAPI**.
 
 Así que vamos a usar ese mismo conocimiento para documentar cómo debería verse la *API externa*... creando la(s) *path operation(s)* que la API externa debería implementar (las que tu API va a llamar).
 
@@ -86,29 +86,29 @@ Adoptar temporalmente este punto de vista (del *desarrollador externo*) puede ay
 
 ///
 
-### Crear un `APIRouter` de callback
+### Crea un `APIRouter` de callback { #create-a-callback-apirouter }
 
 Primero crea un nuevo `APIRouter` que contendrá uno o más callbacks.
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[3,25] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[1,23] *}
 
-### Crear la *path operation* del callback
+### Crea la *path operation* del callback { #create-the-callback-path-operation }
 
-Para crear la *path operation* del callback utiliza el mismo `APIRouter` que creaste anteriormente.
+Para crear la *path operation* del callback usa el mismo `APIRouter` que creaste arriba.
 
 Debería verse como una *path operation* normal de FastAPI:
 
 * Probablemente debería tener una declaración del body que debería recibir, por ejemplo `body: InvoiceEvent`.
 * Y también podría tener una declaración del response que debería devolver, por ejemplo `response_model=InvoiceEventReceived`.
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[16:18,21:22,28:32] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}
 
 Hay 2 diferencias principales respecto a una *path operation* normal:
 
 * No necesita tener ningún código real, porque tu aplicación nunca llamará a este código. Solo se usa para documentar la *API externa*. Así que, la función podría simplemente tener `pass`.
 * El *path* puede contener una <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expresión OpenAPI 3</a> (ver más abajo) donde puede usar variables con parámetros y partes del request original enviado a *tu API*.
 
-### La expresión del path del callback
+### La expresión del path del callback { #the-callback-path-expression }
 
 El *path* del callback puede tener una <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">expresión OpenAPI 3</a> que puede contener partes del request original enviado a *tu API*.
 
@@ -134,7 +134,7 @@ con un JSON body de:
 }
 ```
 
-luego *tu API* procesará la factura, y en algún momento después, enviará un request de callback al `callback_url` (la *API externa*):
+luego *tu API* procesará la factura y, en algún momento después, enviará un request de callback al `callback_url` (la *API externa*):
 
 ```
 https://www.external.org/events/invoices/2expen51ve
@@ -163,13 +163,13 @@ Observa cómo la URL del callback utilizada contiene la URL recibida como parám
 
 ///
 
-### Agregar el router de callback
+### Agrega el router de callback { #add-the-callback-router }
 
-En este punto tienes las *path operation(s)* del callback necesarias (las que el *desarrollador externo* debería implementar en la *API externa*) en el router de callback que creaste antes.
+En este punto tienes las *path operation(s)* del callback necesarias (las que el *desarrollador externo* debería implementar en la *API externa*) en el router de callback que creaste arriba.
 
 Ahora usa el parámetro `callbacks` en el *decorador de path operation de tu API* para pasar el atributo `.routes` (que en realidad es solo un `list` de rutas/*path operations*) de ese router de callback:
 
-{* ../../docs_src/openapi_callbacks/tutorial001.py hl[35] *}
+{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[33] *}
 
 /// tip | Consejo
 
@@ -177,7 +177,7 @@ Observa que no estás pasando el router en sí (`invoices_callback_router`) a `c
 
 ///
 
-### Revisa la documentación
+### Revisa la documentación { #check-the-docs }
 
 Ahora puedes iniciar tu aplicación e ir a <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 

docs/es/docs/advanced/openapi-webhooks.md

@@ -1,4 +1,4 @@
-# Webhooks de OpenAPI
+# Webhooks de OpenAPI { #openapi-webhooks }
 
 Hay casos donde quieres decirle a los **usuarios** de tu API que tu aplicación podría llamar a *su* aplicación (enviando una request) con algunos datos, normalmente para **notificar** de algún tipo de **evento**.
 
@@ -6,7 +6,7 @@ Esto significa que en lugar del proceso normal de tus usuarios enviando requests
 
 Esto normalmente se llama un **webhook**.
 
-## Pasos de los webhooks
+## Pasos de los webhooks { #webhooks-steps }
 
 El proceso normalmente es que **tú defines** en tu código cuál es el mensaje que enviarás, el **body de la request**.
 
@@ -16,7 +16,7 @@ Y **tus usuarios** definen de alguna manera (por ejemplo en un panel web en alg
 
 Toda la **lógica** sobre cómo registrar los URLs para webhooks y el código para realmente enviar esas requests depende de ti. Lo escribes como quieras en **tu propio código**.
 
-## Documentando webhooks con **FastAPI** y OpenAPI
+## Documentando webhooks con **FastAPI** y OpenAPI { #documenting-webhooks-with-fastapi-and-openapi }
 
 Con **FastAPI**, usando OpenAPI, puedes definir los nombres de estos webhooks, los tipos de operaciones HTTP que tu aplicación puede enviar (por ejemplo, `POST`, `PUT`, etc.) y los **bodies** de las requests que tu aplicación enviaría.
 
@@ -28,7 +28,7 @@ Los webhooks están disponibles en OpenAPI 3.1.0 y superiores, soportados por Fa
 
 ///
 
-## Una aplicación con webhooks
+## Una aplicación con webhooks { #an-app-with-webhooks }
 
 Cuando creas una aplicación de **FastAPI**, hay un atributo `webhooks` que puedes usar para definir *webhooks*, de la misma manera que definirías *path operations*, por ejemplo con `@app.webhooks.post()`.
 
@@ -46,7 +46,7 @@ Nota que con los webhooks en realidad no estás declarando un *path* (como `/ite
 
 Esto es porque se espera que **tus usuarios** definan el actual **URL path** donde quieren recibir la request del webhook de alguna otra manera (por ejemplo, un panel web).
 
-### Revisa la documentación
+### Revisa la documentación { #check-the-docs }
 
 Ahora puedes iniciar tu app e ir a <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 

docs/es/docs/advanced/path-operation-advanced-configuration.md

@@ -1,6 +1,6 @@
-# Configuración Avanzada de Path Operation
+# Configuración Avanzada de Path Operation { #path-operation-advanced-configuration }
 
-## operationId de OpenAPI
+## operationId de OpenAPI { #openapi-operationid }
 
 /// warning | Advertencia
 
@@ -14,7 +14,7 @@ Tienes que asegurarte de que sea único para cada operación.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *}
 
-### Usar el nombre de la *función de path operation* como el operationId
+### Usar el nombre de la *path operation function* como el operationId { #using-the-path-operation-function-name-as-the-operationid }
 
 Si quieres usar los nombres de las funciones de tus APIs como `operationId`s, puedes iterar sobre todas ellas y sobrescribir el `operation_id` de cada *path operation* usando su `APIRoute.name`.
 
@@ -30,29 +30,29 @@ Si llamas manualmente a `app.openapi()`, deberías actualizar los `operationId`s
 
 /// warning | Advertencia
 
-Si haces esto, tienes que asegurarte de que cada una de tus *funciones de path operation* tenga un nombre único.
+Si haces esto, tienes que asegurarte de que cada una de tus *path operation functions* tenga un nombre único.
 
 Incluso si están en diferentes módulos (archivos de Python).
 
 ///
 
-## Excluir de OpenAPI
+## Excluir de OpenAPI { #exclude-from-openapi }
 
 Para excluir una *path operation* del esquema OpenAPI generado (y por lo tanto, de los sistemas de documentación automática), utiliza el parámetro `include_in_schema` y configúralo en `False`:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial003.py hl[6] *}
 
-## Descripción avanzada desde el docstring
+## Descripción avanzada desde el docstring { #advanced-description-from-docstring }
 
-Puedes limitar las líneas usadas del docstring de una *función de path operation* para OpenAPI.
+Puedes limitar las líneas usadas del docstring de una *path operation function* para OpenAPI.
 
 Añadir un `\f` (un carácter de separación de página escapado) hace que **FastAPI** trunque la salida usada para OpenAPI en este punto.
 
 No aparecerá en la documentación, pero otras herramientas (como Sphinx) podrán usar el resto.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
 
-## Responses Adicionales
+## Responses Adicionales { #additional-responses }
 
 Probablemente has visto cómo declarar el `response_model` y el `status_code` para una *path operation*.
 
@@ -62,11 +62,11 @@ También puedes declarar responses adicionales con sus modelos, códigos de esta
 
 Hay un capítulo entero en la documentación sobre ello, puedes leerlo en [Responses Adicionales en OpenAPI](additional-responses.md){.internal-link target=_blank}.
 
-## OpenAPI Extra
+## OpenAPI Extra { #openapi-extra }
 
 Cuando declaras una *path operation* en tu aplicación, **FastAPI** genera automáticamente los metadatos relevantes sobre esa *path operation* para incluirlos en el esquema de OpenAPI.
 
-/// note | Nota
+/// note | Detalles técnicos
 
 En la especificación de OpenAPI se llama el <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">Objeto de Operación</a>.
 
@@ -88,7 +88,7 @@ Si solo necesitas declarar responses adicionales, una forma más conveniente de
 
 Puedes extender el esquema de OpenAPI para una *path operation* usando el parámetro `openapi_extra`.
 
-### Extensiones de OpenAPI
+### Extensiones de OpenAPI { #openapi-extensions }
 
 Este `openapi_extra` puede ser útil, por ejemplo, para declarar [Extensiones de OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions):
 
@@ -129,7 +129,7 @@ Y si ves el OpenAPI resultante (en `/openapi.json` en tu API), verás tu extensi
 }
 ```
 
-### Esquema de *path operation* personalizada de OpenAPI
+### Esquema de *path operation* personalizada de OpenAPI { #custom-openapi-path-operation-schema }
 
 El diccionario en `openapi_extra` se combinará profundamente con el esquema de OpenAPI generado automáticamente para la *path operation*.
 
@@ -141,37 +141,37 @@ Podrías hacer eso con `openapi_extra`:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[19:36, 39:40] *}
 
-En este ejemplo, no declaramos ningún modelo Pydantic. De hecho, el cuerpo del request ni siquiera se <abbr title="converted from some plain format, like bytes, into Python objects">parse</abbr> como JSON, se lee directamente como `bytes`, y la función `magic_data_reader()` sería la encargada de parsearlo de alguna manera.
+En este ejemplo, no declaramos ningún modelo Pydantic. De hecho, el cuerpo del request ni siquiera se <abbr title="convertido de algún formato plano, como bytes, a objetos de Python">parse</abbr> como JSON, se lee directamente como `bytes`, y la función `magic_data_reader()` sería la encargada de parsearlo de alguna manera.
 
 Sin embargo, podemos declarar el esquema esperado para el cuerpo del request.
 
-### Tipo de contenido personalizado de OpenAPI
+### Tipo de contenido personalizado de OpenAPI { #custom-openapi-content-type }
 
-Usando este mismo truco, podrías usar un modelo Pydantic para definir el esquema JSON que luego se incluye en la sección personalizada del esquema OpenAPI para la *path operation*.
+Usando este mismo truco, podrías usar un modelo Pydantic para definir el JSON Schema que luego se incluye en la sección personalizada del esquema OpenAPI para la *path operation*.
 
 Y podrías hacer esto incluso si el tipo de datos en el request no es JSON.
 
-Por ejemplo, en esta aplicación no usamos la funcionalidad integrada de FastAPI para extraer el esquema JSON de los modelos Pydantic ni la validación automática para JSON. De hecho, estamos declarando el tipo de contenido del request como YAML, no JSON:
+Por ejemplo, en esta aplicación no usamos la funcionalidad integrada de FastAPI para extraer el JSON Schema de los modelos Pydantic ni la validación automática para JSON. De hecho, estamos declarando el tipo de contenido del request como YAML, no JSON:
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[17:22, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
 
 ////
 
 /// info | Información
 
-En la versión 1 de Pydantic el método para obtener el esquema JSON para un modelo se llamaba `Item.schema()`, en la versión 2 de Pydantic, el método se llama `Item.model_json_schema()`.
+En la versión 1 de Pydantic el método para obtener el JSON Schema para un modelo se llamaba `Item.schema()`, en la versión 2 de Pydantic, el método se llama `Item.model_json_schema()`.
 
 ///
 
-Sin embargo, aunque no estamos usando la funcionalidad integrada por defecto, aún estamos usando un modelo Pydantic para generar manualmente el esquema JSON para los datos que queremos recibir en YAML.
+Sin embargo, aunque no estamos usando la funcionalidad integrada por defecto, aún estamos usando un modelo Pydantic para generar manualmente el JSON Schema para los datos que queremos recibir en YAML.
 
 Luego usamos el request directamente, y extraemos el cuerpo como `bytes`. Esto significa que FastAPI ni siquiera intentará parsear la carga útil del request como JSON.
 
@@ -179,13 +179,13 @@ Y luego en nuestro código, parseamos ese contenido YAML directamente, y nuevame
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
 
 ////
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1.py hl[26:33] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
 
 ////
 

docs/es/docs/advanced/response-change-status-code.md

@@ -1,10 +1,10 @@
-# Response - Cambiar Código de Estado
+# Response - Cambiar Código de Estado { #response-change-status-code }
 
 Probablemente leíste antes que puedes establecer un [Código de Estado de Response](../tutorial/response-status-code.md){.internal-link target=_blank} por defecto.
 
 Pero en algunos casos necesitas devolver un código de estado diferente al predeterminado.
 
-## Caso de uso
+## Caso de uso { #use-case }
 
 Por ejemplo, imagina que quieres devolver un código de estado HTTP de "OK" `200` por defecto.
 
@@ -14,9 +14,9 @@ Pero todavía quieres poder filtrar y convertir los datos que devuelves con un `
 
 Para esos casos, puedes usar un parámetro `Response`.
 
-## Usa un parámetro `Response`
+## Usa un parámetro `Response` { #use-a-response-parameter }
 
-Puedes declarar un parámetro de tipo `Response` en tu *función de path operation* (como puedes hacer para cookies y headers).
+Puedes declarar un parámetro de tipo `Response` en tu *path operation function* (como puedes hacer para cookies y headers).
 
 Y luego puedes establecer el `status_code` en ese objeto de response *temporal*.
 

docs/es/docs/advanced/response-directly.md

@@ -1,4 +1,4 @@
-# Devolver una Response Directamente
+# Devolver una Response Directamente { #return-a-response-directly }
 
 Cuando creas una *path operation* en **FastAPI**, normalmente puedes devolver cualquier dato desde ella: un `dict`, una `list`, un modelo de Pydantic, un modelo de base de datos, etc.
 
@@ -10,7 +10,7 @@ Pero puedes devolver un `JSONResponse` directamente desde tus *path operations*.
 
 Esto podría ser útil, por ejemplo, para devolver headers o cookies personalizados.
 
-## Devolver una `Response`
+## Devolver una `Response` { #return-a-response }
 
 De hecho, puedes devolver cualquier `Response` o cualquier subclase de ella.
 
@@ -26,7 +26,7 @@ No hará ninguna conversión de datos con los modelos de Pydantic, no convertir
 
 Esto te da mucha flexibilidad. Puedes devolver cualquier tipo de datos, sobrescribir cualquier declaración o validación de datos, etc.
 
-## Usar el `jsonable_encoder` en una `Response`
+## Usar el `jsonable_encoder` en una `Response` { #using-the-jsonable-encoder-in-a-response }
 
 Como **FastAPI** no realiza cambios en una `Response` que devuelves, tienes que asegurarte de que sus contenidos estén listos para ello.
 
@@ -34,9 +34,9 @@ Por ejemplo, no puedes poner un modelo de Pydantic en un `JSONResponse` sin prim
 
 Para esos casos, puedes usar el `jsonable_encoder` para convertir tus datos antes de pasarlos a un response:
 
-{* ../../docs_src/response_directly/tutorial001.py hl[6:7,21:22] *}
+{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
 
-/// note | Nota
+/// note | Detalles técnicos
 
 También podrías usar `from starlette.responses import JSONResponse`.
 
@@ -44,7 +44,7 @@ También podrías usar `from starlette.responses import JSONResponse`.
 
 ///
 
-## Devolver una `Response` personalizada
+## Devolver una `Response` personalizada { #returning-a-custom-response }
 
 El ejemplo anterior muestra todas las partes que necesitas, pero aún no es muy útil, ya que podrías haber devuelto el `item` directamente, y **FastAPI** lo colocaría en un `JSONResponse` por ti, convirtiéndolo a un `dict`, etc. Todo eso por defecto.
 
@@ -56,7 +56,7 @@ Podrías poner tu contenido XML en un string, poner eso en un `Response`, y devo
 
 {* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-## Notas
+## Notas { #notes }
 
 Cuando devuelves una `Response` directamente, sus datos no son validados, convertidos (serializados), ni documentados automáticamente.
 

docs/es/docs/advanced/security/http-basic-auth.md

@@ -1,4 +1,4 @@
-# HTTP Basic Auth
+# HTTP Basic Auth { #http-basic-auth }
 
 Para los casos más simples, puedes usar HTTP Basic Auth.
 
@@ -12,7 +12,7 @@ Eso le dice al navegador que muestre el prompt integrado para un nombre de usuar
 
 Luego, cuando escribes ese nombre de usuario y contraseña, el navegador los envía automáticamente en el header.
 
-## Simple HTTP Basic Auth
+## Simple HTTP Basic Auth { #simple-http-basic-auth }
 
 * Importa `HTTPBasic` y `HTTPBasicCredentials`.
 * Crea un "esquema de `security`" usando `HTTPBasic`.
@@ -26,7 +26,7 @@ Cuando intentas abrir la URL por primera vez (o haces clic en el botón "Execute
 
 <img src="/img/tutorial/security/image12.png">
 
-## Revisa el nombre de usuario
+## Revisa el nombre de usuario { #check-the-username }
 
 Aquí hay un ejemplo más completo.
 
@@ -46,13 +46,13 @@ Esto sería similar a:
 
 ```Python
 if not (credentials.username == "stanleyjobson") or not (credentials.password == "swordfish"):
-    # Return some error
+    # Devuelve algún error
     ...
 ```
 
 Pero al usar `secrets.compare_digest()` será seguro contra un tipo de ataques llamados "timing attacks".
 
-### Timing Attacks
+### Timing attacks { #timing-attacks }
 
 ¿Pero qué es un "timing attack"?
 
@@ -80,19 +80,19 @@ if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
 
 Python tendrá que comparar todo `stanleyjobso` en ambos `stanleyjobsox` y `stanleyjobson` antes de darse cuenta de que ambas strings no son las mismas. Así que tomará algunos microsegundos extra para responder "Nombre de usuario o contraseña incorrectos".
 
-#### El tiempo de respuesta ayuda a los atacantes
+#### El tiempo de respuesta ayuda a los atacantes { #the-time-to-answer-helps-the-attackers }
 
 En ese punto, al notar que el servidor tardó algunos microsegundos más en enviar el response "Nombre de usuario o contraseña incorrectos", los atacantes sabrán que acertaron en _algo_, algunas de las letras iniciales eran correctas.
 
 Y luego pueden intentar de nuevo sabiendo que probablemente es algo más similar a `stanleyjobsox` que a `johndoe`.
 
-#### Un ataque "profesional"
+#### Un ataque "profesional" { #a-professional-attack }
 
 Por supuesto, los atacantes no intentarían todo esto a mano, escribirían un programa para hacerlo, posiblemente con miles o millones de pruebas por segundo. Y obtendrían solo una letra correcta adicional a la vez.
 
 Pero haciendo eso, en algunos minutos u horas, los atacantes habrían adivinado el nombre de usuario y la contraseña correctos, con la "ayuda" de nuestra aplicación, solo usando el tiempo tomado para responder.
 
-#### Arréglalo con `secrets.compare_digest()`
+#### Arréglalo con `secrets.compare_digest()` { #fix-it-with-secrets-compare-digest }
 
 Pero en nuestro código estamos usando realmente `secrets.compare_digest()`.
 
@@ -100,7 +100,7 @@ En resumen, tomará el mismo tiempo comparar `stanleyjobsox` con `stanleyjobson`
 
 De esa manera, usando `secrets.compare_digest()` en el código de tu aplicación, será seguro contra todo este rango de ataques de seguridad.
 
-### Devuelve el error
+### Devuelve el error { #return-the-error }
 
 Después de detectar que las credenciales son incorrectas, regresa un `HTTPException` con un código de estado 401 (el mismo que se devuelve cuando no se proporcionan credenciales) y agrega el header `WWW-Authenticate` para que el navegador muestre el prompt de inicio de sesión nuevamente:
 

docs/es/docs/advanced/security/index.md

@@ -1,6 +1,6 @@
-# Seguridad Avanzada
+# Seguridad Avanzada { #advanced-security }
 
-## Funcionalidades Adicionales
+## Funcionalidades Adicionales { #additional-features }
 
 Hay algunas funcionalidades extra para manejar la seguridad aparte de las cubiertas en el [Tutorial - Guía del Usuario: Seguridad](../../tutorial/security/index.md){.internal-link target=_blank}.
 
@@ -12,8 +12,8 @@ Y es posible que para tu caso de uso, la solución esté en una de ellas.
 
 ///
 
-## Lee primero el Tutorial
+## Lee primero el Tutorial { #read-the-tutorial-first }
 
-Las siguientes secciones asumen que ya leíste el [Tutorial - Guía del Usuario: Seguridad](../../tutorial/security/index.md){.internal-link target=_blank}.
+Las siguientes secciones asumen que ya leíste el [Tutorial - Guía del Usuario: Seguridad](../../tutorial/security/index.md){.internal-link target=_blank} principal.
 
 Todas están basadas en los mismos conceptos, pero permiten algunas funcionalidades adicionales.

docs/es/docs/advanced/settings.md

@@ -1,4 +1,4 @@
-# Configuraciones y Variables de Entorno
+# Configuraciones y Variables de Entorno { #settings-and-environment-variables }
 
 En muchos casos, tu aplicación podría necesitar algunas configuraciones o ajustes externos, por ejemplo, claves secretas, credenciales de base de datos, credenciales para servicios de correo electrónico, etc.
 
@@ -12,17 +12,17 @@ Para entender las variables de entorno, puedes leer [Variables de Entorno](../en
 
 ///
 
-## Tipos y validación
+## Tipos y validación { #types-and-validation }
 
 Estas variables de entorno solo pueden manejar strings de texto, ya que son externas a Python y tienen que ser compatibles con otros programas y el resto del sistema (e incluso con diferentes sistemas operativos, como Linux, Windows, macOS).
 
 Eso significa que cualquier valor leído en Python desde una variable de entorno será un `str`, y cualquier conversión a un tipo diferente o cualquier validación tiene que hacerse en código.
 
-## Pydantic `Settings`
+## Pydantic `Settings` { #pydantic-settings }
 
 Afortunadamente, Pydantic proporciona una gran utilidad para manejar estas configuraciones provenientes de variables de entorno con <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/" class="external-link" target="_blank">Pydantic: Settings management</a>.
 
-### Instalar `pydantic-settings`
+### Instalar `pydantic-settings` { #install-pydantic-settings }
 
 Primero, asegúrate de crear tu [entorno virtual](../virtual-environments.md){.internal-link target=_blank}, actívalo y luego instala el paquete `pydantic-settings`:
 
@@ -52,7 +52,7 @@ En Pydantic v1 venía incluido con el paquete principal. Ahora se distribuye com
 
 ///
 
-### Crear el objeto `Settings`
+### Crear el objeto `Settings` { #create-the-settings-object }
 
 Importa `BaseSettings` de Pydantic y crea una sub-clase, muy similar a un modelo de Pydantic.
 
@@ -88,13 +88,13 @@ Luego, cuando creas una instance de esa clase `Settings` (en este caso, en el ob
 
 Luego convertirá y validará los datos. Así que, cuando uses ese objeto `settings`, tendrás datos de los tipos que declaraste (por ejemplo, `items_per_user` será un `int`).
 
-### Usar el `settings`
+### Usar el `settings` { #use-the-settings }
 
 Luego puedes usar el nuevo objeto `settings` en tu aplicación:
 
 {* ../../docs_src/settings/tutorial001.py hl[18:20] *}
 
-### Ejecutar el servidor
+### Ejecutar el servidor { #run-the-server }
 
 Luego, ejecutarías el servidor pasando las configuraciones como variables de entorno, por ejemplo, podrías establecer un `ADMIN_EMAIL` y `APP_NAME` con:
 
@@ -120,7 +120,7 @@ El `app_name` sería `"ChimichangApp"`.
 
 Y el `items_per_user` mantendría su valor por defecto de `50`.
 
-## Configuraciones en otro módulo
+## Configuraciones en otro módulo { #settings-in-another-module }
 
 Podrías poner esas configuraciones en otro archivo de módulo como viste en [Aplicaciones Más Grandes - Múltiples Archivos](../tutorial/bigger-applications.md){.internal-link target=_blank}.
 
@@ -138,21 +138,21 @@ También necesitarías un archivo `__init__.py` como viste en [Aplicaciones Más
 
 ///
 
-## Configuraciones en una dependencia
+## Configuraciones en una dependencia { #settings-in-a-dependency }
 
 En algunas ocasiones podría ser útil proporcionar las configuraciones desde una dependencia, en lugar de tener un objeto global con `settings` que se use en todas partes.
 
 Esto podría ser especialmente útil durante las pruebas, ya que es muy fácil sobrescribir una dependencia con tus propias configuraciones personalizadas.
 
-### El archivo de configuración
+### El archivo de configuración { #the-config-file }
 
 Proveniente del ejemplo anterior, tu archivo `config.py` podría verse como:
 
-{* ../../docs_src/settings/app02/config.py hl[10] *}
+{* ../../docs_src/settings/app02_an_py39/config.py hl[10] *}
 
 Nota que ahora no creamos una instance por defecto `settings = Settings()`.
 
-### El archivo principal de la app
+### El archivo principal de la app { #the-main-app-file }
 
 Ahora creamos una dependencia que devuelve un nuevo `config.Settings()`.
 
@@ -170,17 +170,17 @@ Y luego podemos requerirlo desde la *path operation function* como una dependenc
 
 {* ../../docs_src/settings/app02_an_py39/main.py hl[17,19:21] *}
 
-### Configuraciones y pruebas
+### Configuraciones y pruebas { #settings-and-testing }
 
 Luego sería muy fácil proporcionar un objeto de configuraciones diferente durante las pruebas al sobrescribir una dependencia para `get_settings`:
 
-{* ../../docs_src/settings/app02/test_main.py hl[9:10,13,21] *}
+{* ../../docs_src/settings/app02_an_py39/test_main.py hl[9:10,13,21] *}
 
 En la dependencia sobreescrita establecemos un nuevo valor para el `admin_email` al crear el nuevo objeto `Settings`, y luego devolvemos ese nuevo objeto.
 
 Luego podemos probar que se está usando.
 
-## Leer un archivo `.env`
+## Leer un archivo `.env` { #reading-a-env-file }
 
 Si tienes muchas configuraciones que posiblemente cambien mucho, tal vez en diferentes entornos, podría ser útil ponerlos en un archivo y luego leerlos desde allí como si fueran variables de entorno.
 
@@ -202,7 +202,7 @@ Para que esto funcione, necesitas `pip install python-dotenv`.
 
 ///
 
-### El archivo `.env`
+### El archivo `.env` { #the-env-file }
 
 Podrías tener un archivo `.env` con:
 
@@ -211,13 +211,13 @@ ADMIN_EMAIL="deadpool@example.com"
 APP_NAME="ChimichangApp"
 ```
 
-### Leer configuraciones desde `.env`
+### Leer configuraciones desde `.env` { #read-settings-from-env }
 
 Y luego actualizar tu `config.py` con:
 
 //// tab | Pydantic v2
 
-{* ../../docs_src/settings/app03_an/config.py hl[9] *}
+{* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
 
 /// tip | Consejo
 
@@ -229,7 +229,7 @@ El atributo `model_config` se usa solo para configuración de Pydantic. Puedes l
 
 //// tab | Pydantic v1
 
-{* ../../docs_src/settings/app03_an/config_pv1.py hl[9:10] *}
+{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
 
 /// tip | Consejo
 
@@ -247,7 +247,7 @@ En la versión 1 de Pydantic la configuración se hacía en una clase interna `C
 
 Aquí definimos la configuración `env_file` dentro de tu clase Pydantic `Settings`, y establecemos el valor en el nombre del archivo con el archivo dotenv que queremos usar.
 
-### Creando el `Settings` solo una vez con `lru_cache`
+### Creando el `Settings` solo una vez con `lru_cache` { #creating-the-settings-only-once-with-lru-cache }
 
 Leer un archivo desde el disco es normalmente una operación costosa (lenta), por lo que probablemente quieras hacerlo solo una vez y luego reutilizar el mismo objeto de configuraciones, en lugar de leerlo para cada request.
 
@@ -274,7 +274,7 @@ Pero como estamos usando el decorador `@lru_cache` encima, el objeto `Settings`
 
 Entonces, para cualquier llamada subsiguiente de `get_settings()` en las dependencias de los próximos requests, en lugar de ejecutar el código interno de `get_settings()` y crear un nuevo objeto `Settings`, devolverá el mismo objeto que fue devuelto en la primera llamada, una y otra vez.
 
-#### Detalles Técnicos de `lru_cache`
+#### Detalles Técnicos de `lru_cache` { #lru-cache-technical-details }
 
 `@lru_cache` modifica la función que decora para devolver el mismo valor que se devolvió la primera vez, en lugar de calcularlo nuevamente, ejecutando el código de la función cada vez.
 
@@ -335,9 +335,9 @@ En el caso de nuestra dependencia `get_settings()`, la función ni siquiera toma
 
 De esa manera, se comporta casi como si fuera solo una variable global. Pero como usa una función de dependencia, entonces podemos sobrescribirla fácilmente para las pruebas.
 
-`@lru_cache` es parte de `functools`, que es parte del library estándar de Python, puedes leer más sobre él en las <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">docs de Python para `@lru_cache`</a>.
+`@lru_cache` es parte de `functools`, que es parte del paquete estándar de Python, puedes leer más sobre él en las <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">docs de Python para `@lru_cache`</a>.
 
-## Resumen
+## Resumen { #recap }
 
 Puedes usar Pydantic Settings para manejar las configuraciones o ajustes de tu aplicación, con todo el poder de los modelos de Pydantic.
 

docs/es/docs/advanced/sub-applications.md

@@ -1,18 +1,18 @@
-# Sub Aplicaciones - Mounts
+# Sub Aplicaciones - Mounts { #sub-applications-mounts }
 
 Si necesitas tener dos aplicaciones de **FastAPI** independientes, cada una con su propio OpenAPI independiente y su propia interfaz de docs, puedes tener una aplicación principal y "montar" una (o más) sub-aplicación(es).
 
-## Montar una aplicación **FastAPI**
+## Montar una aplicación **FastAPI** { #mounting-a-fastapi-application }
 
 "Montar" significa añadir una aplicación completamente "independiente" en un path específico, que luego se encarga de manejar todo bajo ese path, con las _path operations_ declaradas en esa sub-aplicación.
 
-### Aplicación de nivel superior
+### Aplicación de nivel superior { #top-level-application }
 
 Primero, crea la aplicación principal de nivel superior de **FastAPI**, y sus *path operations*:
 
 {* ../../docs_src/sub_applications/tutorial001.py hl[3, 6:8] *}
 
-### Sub-aplicación
+### Sub-aplicación { #sub-application }
 
 Luego, crea tu sub-aplicación, y sus *path operations*.
 
@@ -20,7 +20,7 @@ Esta sub-aplicación es solo otra aplicación estándar de FastAPI, pero es la q
 
 {* ../../docs_src/sub_applications/tutorial001.py hl[11, 14:16] *}
 
-### Montar la sub-aplicación
+### Montar la sub-aplicación { #mount-the-sub-application }
 
 En tu aplicación de nivel superior, `app`, monta la sub-aplicación, `subapi`.
 
@@ -28,7 +28,7 @@ En este caso, se montará en el path `/subapi`:
 
 {* ../../docs_src/sub_applications/tutorial001.py hl[11, 19] *}
 
-### Revisa la documentación automática de la API
+### Revisa la documentación automática de la API { #check-the-automatic-api-docs }
 
 Ahora, ejecuta el comando `fastapi` con tu archivo:
 
@@ -56,7 +56,7 @@ Verás la documentación automática de la API para la sub-aplicación, incluyen
 
 Si intentas interactuar con cualquiera de las dos interfaces de usuario, funcionarán correctamente, porque el navegador podrá comunicarse con cada aplicación o sub-aplicación específica.
 
-### Detalles Técnicos: `root_path`
+### Detalles Técnicos: `root_path` { #technical-details-root-path }
 
 Cuando montas una sub-aplicación como se describe arriba, FastAPI se encargará de comunicar el path de montaje para la sub-aplicación usando un mecanismo de la especificación ASGI llamado `root_path`.
 

docs/es/docs/advanced/testing-dependencies.md

@@ -1,6 +1,6 @@
-# Probando Dependencias con Overrides
+# Probando Dependencias con Overrides { #testing-dependencies-with-overrides }
 
-## Sobrescribir dependencias durante las pruebas
+## Sobrescribir dependencias durante las pruebas { #overriding-dependencies-during-testing }
 
 Hay algunos escenarios donde podrías querer sobrescribir una dependencia durante las pruebas.
 
@@ -8,7 +8,7 @@ No quieres que la dependencia original se ejecute (ni ninguna de las sub-depende
 
 En cambio, quieres proporcionar una dependencia diferente que se usará solo durante las pruebas (posiblemente solo algunas pruebas específicas), y que proporcionará un valor que pueda ser usado donde se usó el valor de la dependencia original.
 
-### Casos de uso: servicio externo
+### Casos de uso: servicio externo { #use-cases-external-service }
 
 Un ejemplo podría ser que tienes un proveedor de autenticación externo al que necesitas llamar.
 
@@ -20,7 +20,7 @@ Probablemente quieras probar el proveedor externo una vez, pero no necesariament
 
 En este caso, puedes sobrescribir la dependencia que llama a ese proveedor y usar una dependencia personalizada que devuelva un usuario de prueba, solo para tus tests.
 
-### Usa el atributo `app.dependency_overrides`
+### Usa el atributo `app.dependency_overrides` { #use-the-app-dependency-overrides-attribute }
 
 Para estos casos, tu aplicación **FastAPI** tiene un atributo `app.dependency_overrides`, es un simple `dict`.
 

docs/es/docs/advanced/testing-events.md

@@ -1,5 +1,12 @@
-# Testing Events: startup - shutdown
+# Eventos de testing: lifespan y startup - shutdown { #testing-events-lifespan-and-startup-shutdown }
 
-Cuando necesitas que tus manejadores de eventos (`startup` y `shutdown`) se ejecuten en tus tests, puedes usar el `TestClient` con un statement `with`:
+Cuando necesitas que `lifespan` se ejecute en tus tests, puedes usar el `TestClient` con un statement `with`:
+
+{* ../../docs_src/app_testing/tutorial004.py hl[9:15,18,27:28,30:32,41:43] *}
+
+
+Puedes leer más detalles sobre ["Ejecutar lifespan en tests en el sitio oficial de documentación de Starlette."](https://www.starlette.dev/lifespan/#running-lifespan-in-tests)
+
+Para los eventos obsoletos `startup` y `shutdown`, puedes usar el `TestClient` así:
 
 {* ../../docs_src/app_testing/tutorial003.py hl[9:12,20:24] *}

docs/es/docs/advanced/wsgi.md

@@ -1,10 +1,10 @@
-# Incluyendo WSGI - Flask, Django, otros
+# Incluyendo WSGI - Flask, Django, otros { #including-wsgi-flask-django-others }
 
 Puedes montar aplicaciones WSGI como viste con [Sub Aplicaciones - Mounts](sub-applications.md){.internal-link target=_blank}, [Detrás de un Proxy](behind-a-proxy.md){.internal-link target=_blank}.
 
 Para eso, puedes usar `WSGIMiddleware` y usarlo para envolver tu aplicación WSGI, por ejemplo, Flask, Django, etc.
 
-## Usando `WSGIMiddleware`
+## Usando `WSGIMiddleware` { #using-wsgimiddleware }
 
 Necesitas importar `WSGIMiddleware`.
 
@@ -14,7 +14,7 @@ Y luego móntala bajo un path.
 
 {* ../../docs_src/wsgi/tutorial001.py hl[2:3,3] *}
 
-## Revisa
+## Revisa { #check-it }
 
 Ahora, cada request bajo el path `/v1/` será manejado por la aplicación Flask.
 

docs/es/docs/benchmarks.md

@@ -1,10 +1,10 @@
-# Benchmarks
+# Benchmarks { #benchmarks }
 
 Los benchmarks independientes de TechEmpower muestran aplicaciones de **FastAPI** ejecutándose bajo Uvicorn como <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">uno de los frameworks de Python más rápidos disponibles</a>, solo por debajo de Starlette y Uvicorn en sí mismos (utilizados internamente por FastAPI).
 
 Pero al revisar benchmarks y comparaciones, debes tener en cuenta lo siguiente.
 
-## Benchmarks y velocidad
+## Benchmarks y velocidad { #benchmarks-and-speed }
 
 Cuando ves los benchmarks, es común ver varias herramientas de diferentes tipos comparadas como equivalentes.
 

docs/es/docs/deployment/cloud.md

@@ -1,15 +1,24 @@
-# Despliega FastAPI en Proveedores de Nube
+# Despliega FastAPI en Proveedores de Nube { #deploy-fastapi-on-cloud-providers }
 
 Puedes usar prácticamente **cualquier proveedor de nube** para desplegar tu aplicación FastAPI.
 
 En la mayoría de los casos, los principales proveedores de nube tienen guías para desplegar FastAPI con ellos.
 
-## Proveedores de Nube - Sponsors
+## FastAPI Cloud { #fastapi-cloud }
 
-Algunos proveedores de nube ✨ [**son sponsors de FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, esto asegura el desarrollo **continuado** y **saludable** de FastAPI y su **ecosistema**.
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** está construido por el mismo autor y equipo detrás de **FastAPI**.
 
-Y muestra su verdadero compromiso con FastAPI y su **comunidad** (tú), ya que no solo quieren proporcionarte un **buen servicio**, sino también asegurarse de que tengas un **framework bueno y saludable**, FastAPI. 🙇
+Simplifica el proceso de **construir**, **desplegar** y **acceder** a una API con un esfuerzo mínimo.
 
-Podrías querer probar sus servicios y seguir sus guías:
+Trae la misma experiencia de desarrollador de construir aplicaciones con FastAPI a desplegarlas en la nube. 🎉
+
+FastAPI Cloud es el sponsor principal y proveedor de financiamiento de los proyectos open source *FastAPI and friends*. ✨
+
+## Proveedores de Nube - Sponsors { #cloud-providers-sponsors }
+
+Otros proveedores de nube ✨ [**son sponsors de FastAPI**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ también. 🙇
+
+También podrías considerarlos para seguir sus guías y probar sus servicios:
 
 * <a href="https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi" class="external-link" target="_blank">Render</a>
+* <a href="https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi" class="external-link" target="_blank">Railway</a>

docs/es/docs/deployment/concepts.md

@@ -1,4 +1,4 @@
-# Conceptos de Implementación
+# Conceptos de Implementación { #deployments-concepts }
 
 Cuando implementas una aplicación **FastAPI**, o en realidad, cualquier tipo de API web, hay varios conceptos que probablemente te importen, y al entenderlos, puedes encontrar la **forma más adecuada** de **implementar tu aplicación**.
 
@@ -23,7 +23,7 @@ En los próximos capítulos, te daré más **recetas concretas** para implementa
 
 Pero por ahora, revisemos estas importantes **ideas conceptuales**. Estos conceptos también se aplican a cualquier otro tipo de API web. 💡
 
-## Seguridad - HTTPS
+## Seguridad - HTTPS { #security-https }
 
 En el [capítulo anterior sobre HTTPS](https.md){.internal-link target=_blank} aprendimos sobre cómo HTTPS proporciona cifrado para tu API.
 
@@ -31,7 +31,7 @@ También vimos que HTTPS es normalmente proporcionado por un componente **extern
 
 Y debe haber algo encargado de **renovar los certificados HTTPS**, podría ser el mismo componente o algo diferente.
 
-### Herramientas de Ejemplo para HTTPS
+### Herramientas de Ejemplo para HTTPS { #example-tools-for-https }
 
 Algunas de las herramientas que podrías usar como Proxy de Terminación TLS son:
 
@@ -55,11 +55,11 @@ Te mostraré algunos ejemplos concretos en los próximos capítulos.
 
 Luego, los siguientes conceptos a considerar son todos acerca del programa que ejecuta tu API real (por ejemplo, Uvicorn).
 
-## Programa y Proceso
+## Programa y Proceso { #program-and-process }
 
 Hablaremos mucho sobre el "**proceso**" en ejecución, así que es útil tener claridad sobre lo que significa y cuál es la diferencia con la palabra "**programa**".
 
-### Qué es un Programa
+### Qué es un Programa { #what-is-a-program }
 
 La palabra **programa** se usa comúnmente para describir muchas cosas:
 
@@ -67,7 +67,7 @@ La palabra **programa** se usa comúnmente para describir muchas cosas:
 * El **archivo** que puede ser **ejecutado** por el sistema operativo, por ejemplo: `python`, `python.exe` o `uvicorn`.
 * Un programa específico mientras está siendo **ejecutado** en el sistema operativo, usando la CPU y almacenando cosas en la memoria. Esto también se llama **proceso**.
 
-### Qué es un Proceso
+### Qué es un Proceso { #what-is-a-process }
 
 La palabra **proceso** se usa normalmente de una manera más específica, refiriéndose solo a lo que está ejecutándose en el sistema operativo (como en el último punto anterior):
 
@@ -88,11 +88,11 @@ Y, por ejemplo, probablemente verás que hay múltiples procesos ejecutando el m
 
 Ahora que conocemos la diferencia entre los términos **proceso** y **programa**, sigamos hablando sobre implementaciones.
 
-## Ejecución al Iniciar
+## Ejecución al Iniciar { #running-on-startup }
 
 En la mayoría de los casos, cuando creas una API web, quieres que esté **siempre en ejecución**, ininterrumpida, para que tus clientes puedan acceder a ella en cualquier momento. Esto, por supuesto, a menos que tengas una razón específica para que se ejecute solo en ciertas situaciones, pero la mayoría de las veces quieres que esté constantemente en ejecución y **disponible**.
 
-### En un Servidor Remoto
+### En un Servidor Remoto { #in-a-remote-server }
 
 Cuando configuras un servidor remoto (un servidor en la nube, una máquina virtual, etc.) lo más sencillo que puedes hacer es usar `fastapi run` (que utiliza Uvicorn) o algo similar, manualmente, de la misma manera que lo haces al desarrollar localmente.
 
@@ -102,15 +102,15 @@ Pero si pierdes la conexión con el servidor, el **proceso en ejecución** proba
 
 Y si el servidor se reinicia (por ejemplo, después de actualizaciones o migraciones del proveedor de la nube) probablemente **no lo notarás**. Y debido a eso, ni siquiera sabrás que tienes que reiniciar el proceso manualmente. Así, tu API simplemente quedará muerta. 😱
 
-### Ejecutar Automáticamente al Iniciar
+### Ejecutar Automáticamente al Iniciar { #run-automatically-on-startup }
 
 En general, probablemente querrás que el programa del servidor (por ejemplo, Uvicorn) se inicie automáticamente al arrancar el servidor, y sin necesidad de ninguna **intervención humana**, para tener siempre un proceso en ejecución con tu API (por ejemplo, Uvicorn ejecutando tu aplicación FastAPI).
 
-### Programa Separado
+### Programa Separado { #separate-program }
 
 Para lograr esto, normalmente tendrás un **programa separado** que se asegurará de que tu aplicación se ejecute al iniciarse. Y en muchos casos, también se asegurará de que otros componentes o aplicaciones se ejecuten, por ejemplo, una base de datos.
 
-### Herramientas de Ejemplo para Ejecutar al Iniciar
+### Herramientas de Ejemplo para Ejecutar al Iniciar { #example-tools-to-run-at-startup }
 
 Algunos ejemplos de las herramientas que pueden hacer este trabajo son:
 
@@ -125,29 +125,29 @@ Algunos ejemplos de las herramientas que pueden hacer este trabajo son:
 
 Te daré más ejemplos concretos en los próximos capítulos.
 
-## Reinicios
+## Reinicios { #restarts }
 
 De manera similar a asegurarte de que tu aplicación se ejecute al iniciar, probablemente también quieras asegurarte de que se **reinicie** después de fallos.
 
-### Cometemos Errores
+### Cometemos Errores { #we-make-mistakes }
 
 Nosotros, como humanos, cometemos **errores**, todo el tiempo. El software casi *siempre* tiene **bugs** ocultos en diferentes lugares. 🐛
 
 Y nosotros, como desarrolladores, seguimos mejorando el código a medida que encontramos esos bugs y a medida que implementamos nuevas funcionalidades (posiblemente agregando nuevos bugs también 😅).
 
-### Errores Pequeños Manejados Automáticamente
+### Errores Pequeños Manejados Automáticamente { #small-errors-automatically-handled }
 
-Al construir APIs web con FastAPI, si hay un error en nuestro código, FastAPI normalmente lo contiene a la solicitud única que desencadenó el error. 🛡
+Al construir APIs web con FastAPI, si hay un error en nuestro código, FastAPI normalmente lo contiene al request único que desencadenó el error. 🛡
 
-El cliente obtendrá un **500 Internal Server Error** para esa solicitud, pero la aplicación continuará funcionando para las siguientes solicitudes en lugar de simplemente colapsar por completo.
+El cliente obtendrá un **500 Internal Server Error** para ese request, pero la aplicación continuará funcionando para los siguientes requests en lugar de simplemente colapsar por completo.
 
-### Errores Mayores - Colapsos
+### Errores Mayores - Colapsos { #bigger-errors-crashes }
 
 Sin embargo, puede haber casos en los que escribamos algún código que **colapse toda la aplicación** haciendo que Uvicorn y Python colapsen. 💥
 
 Y aún así, probablemente no querrías que la aplicación quede muerta porque hubo un error en un lugar, probablemente querrás que **siga ejecutándose** al menos para las *path operations* que no estén rotas.
 
-### Reiniciar Después del Colapso
+### Reiniciar Después del Colapso { #restart-after-crash }
 
 Pero en esos casos con errores realmente malos que colapsan el **proceso en ejecución**, querrías un componente externo encargado de **reiniciar** el proceso, al menos un par de veces...
 
@@ -161,7 +161,7 @@ Así que enfoquémonos en los casos principales, donde podría colapsar por comp
 
 Probablemente querrías que la cosa encargada de reiniciar tu aplicación sea un **componente externo**, porque para ese punto, la misma aplicación con Uvicorn y Python ya colapsó, así que no hay nada en el mismo código de la misma aplicación que pueda hacer algo al respecto.
 
-### Herramientas de Ejemplo para Reiniciar Automáticamente
+### Herramientas de Ejemplo para Reiniciar Automáticamente { #example-tools-to-restart-automatically }
 
 En la mayoría de los casos, la misma herramienta que se utiliza para **ejecutar el programa al iniciar** también se utiliza para manejar reinicios automáticos.
 
@@ -176,19 +176,19 @@ Por ejemplo, esto podría ser manejado por:
 * Manejado internamente por un proveedor de nube como parte de sus servicios
 * Otros...
 
-## Replicación - Procesos y Memoria
+## Replicación - Procesos y Memoria { #replication-processes-and-memory }
 
 Con una aplicación FastAPI, usando un programa servidor como el comando `fastapi` que ejecuta Uvicorn, ejecutarlo una vez en **un proceso** puede servir a múltiples clientes concurrentemente.
 
 Pero en muchos casos, querrás ejecutar varios worker processes al mismo tiempo.
 
-### Múltiples Procesos - Workers
+### Múltiples Procesos - Workers { #multiple-processes-workers }
 
 Si tienes más clientes de los que un solo proceso puede manejar (por ejemplo, si la máquina virtual no es muy grande) y tienes **múltiples núcleos** en la CPU del servidor, entonces podrías tener **múltiples procesos** ejecutando la misma aplicación al mismo tiempo, y distribuir todas las requests entre ellos.
 
 Cuando ejecutas **múltiples procesos** del mismo programa de API, comúnmente se les llama **workers**.
 
-### Worker Processes y Puertos
+### Worker Processes y Puertos { #worker-processes-and-ports }
 
 Recuerda de la documentación [Sobre HTTPS](https.md){.internal-link target=_blank} que solo un proceso puede estar escuchando en una combinación de puerto y dirección IP en un servidor.
 
@@ -196,19 +196,19 @@ Esto sigue siendo cierto.
 
 Así que, para poder tener **múltiples procesos** al mismo tiempo, tiene que haber un **solo proceso escuchando en un puerto** que luego transmita la comunicación a cada worker process de alguna forma.
 
-### Memoria por Proceso
+### Memoria por Proceso { #memory-per-process }
 
-Ahora, cuando el programa carga cosas en memoria, por ejemplo, un modelo de machine learning en una variable, o el contenido de un archivo grande en una variable, todo eso **consume un poco de la memoria (RAM)** del servidor.
+Ahora, cuando el programa carga cosas en memoria, por ejemplo, un modelo de Machine Learning en una variable, o el contenido de un archivo grande en una variable, todo eso **consume un poco de la memoria (RAM)** del servidor.
 
 Y múltiples procesos normalmente **no comparten ninguna memoria**. Esto significa que cada proceso en ejecución tiene sus propias cosas, variables y memoria. Y si estás consumiendo una gran cantidad de memoria en tu código, **cada proceso** consumirá una cantidad equivalente de memoria.
 
-### Memoria del Servidor
+### Memoria del Servidor { #server-memory }
 
 Por ejemplo, si tu código carga un modelo de Machine Learning con **1 GB de tamaño**, cuando ejecutas un proceso con tu API, consumirá al menos 1 GB de RAM. Y si inicias **4 procesos** (4 workers), cada uno consumirá 1 GB de RAM. Así que, en total, tu API consumirá **4 GB de RAM**.
 
 Y si tu servidor remoto o máquina virtual solo tiene 3 GB de RAM, intentar cargar más de 4 GB de RAM causará problemas. 🚨
 
-### Múltiples Procesos - Un Ejemplo
+### Múltiples Procesos - Un Ejemplo { #multiple-processes-an-example }
 
 En este ejemplo, hay un **Proceso Administrador** que inicia y controla dos **Worker Processes**.
 
@@ -224,7 +224,7 @@ Un detalle interesante es que el porcentaje de **CPU utilizado** por cada proces
 
 Si tienes una API que hace una cantidad comparable de cálculos cada vez y tienes muchos clientes, entonces la **utilización de CPU** probablemente *también sea estable* (en lugar de constantemente subir y bajar rápidamente).
 
-### Ejemplos de Herramientas y Estrategias de Replicación
+### Ejemplos de Herramientas y Estrategias de Replicación { #examples-of-replication-tools-and-strategies }
 
 Puede haber varios enfoques para lograr esto, y te contaré más sobre estrategias específicas en los próximos capítulos, por ejemplo, al hablar sobre Docker y contenedores.
 
@@ -247,7 +247,7 @@ Te contaré más sobre imágenes de contenedores, Docker, Kubernetes, etc. en un
 
 ///
 
-## Pasos Previos Antes de Iniciar
+## Pasos Previos Antes de Iniciar { #previous-steps-before-starting }
 
 Hay muchos casos en los que quieres realizar algunos pasos **antes de iniciar** tu aplicación.
 
@@ -269,7 +269,7 @@ En ese caso, no tendrías que preocuparte por nada de esto. 🤷
 
 ///
 
-### Ejemplos de Estrategias para Pasos Previos
+### Ejemplos de Estrategias para Pasos Previos { #examples-of-previous-steps-strategies }
 
 Esto **dependerá mucho** de la forma en que **implementarás tu sistema**, y probablemente estará conectado con la forma en que inicias programas, manejas reinicios, etc.
 
@@ -285,7 +285,7 @@ Te daré más ejemplos concretos para hacer esto con contenedores en un capítul
 
 ///
 
-## Utilización de Recursos
+## Utilización de Recursos { #resource-utilization }
 
 Tu(s) servidor(es) es(son) un **recurso** que puedes consumir o **utilizar**, con tus programas, el tiempo de cómputo en las CPUs y la memoria RAM disponible.
 
@@ -305,7 +305,7 @@ Podrías establecer un **número arbitrario** para alcanzar, por ejemplo, algo *
 
 Puedes usar herramientas simples como `htop` para ver la CPU y RAM utilizadas en tu servidor o la cantidad utilizada por cada proceso. O puedes usar herramientas de monitoreo más complejas, que pueden estar distribuidas a través de servidores, etc.
 
-## Resumen
+## Resumen { #recap }
 
 Has estado leyendo aquí algunos de los conceptos principales que probablemente necesitarás tener en mente al decidir cómo implementar tu aplicación:
 

docs/es/docs/deployment/docker.md

@@ -1,4 +1,4 @@
-# FastAPI en Contenedores - Docker
+# FastAPI en Contenedores - Docker { #fastapi-in-containers-docker }
 
 Al desplegar aplicaciones de FastAPI, un enfoque común es construir una **imagen de contenedor de Linux**. Normalmente se realiza usando <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. Luego puedes desplegar esa imagen de contenedor de varias formas.
 
@@ -6,7 +6,7 @@ Usar contenedores de Linux tiene varias ventajas, incluyendo **seguridad**, **re
 
 /// tip | Consejo
 
-¿Tienes prisa y ya conoces esto? Salta al [`Dockerfile` más abajo 👇](#construir-una-imagen-de-docker-para-fastapi).
+¿Tienes prisa y ya conoces esto? Salta al [`Dockerfile` más abajo 👇](#build-a-docker-image-for-fastapi).
 
 ///
 
@@ -32,7 +32,7 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 
 </details>
 
-## Qué es un Contenedor
+## Qué es un Contenedor { #what-is-a-container }
 
 Los contenedores (principalmente contenedores de Linux) son una forma muy **ligera** de empaquetar aplicaciones incluyendo todas sus dependencias y archivos necesarios, manteniéndolos aislados de otros contenedores (otras aplicaciones o componentes) en el mismo sistema.
 
@@ -42,11 +42,11 @@ De esta forma, los contenedores consumen **pocos recursos**, una cantidad compar
 
 Los contenedores también tienen sus propios procesos de ejecución **aislados** (normalmente solo un proceso), sistema de archivos y red, simplificando el despliegue, la seguridad, el desarrollo, etc.
 
-## Qué es una Imagen de Contenedor
+## Qué es una Imagen de Contenedor { #what-is-a-container-image }
 
 Un **contenedor** se ejecuta desde una **imagen de contenedor**.
 
-Una imagen de contenedor es una versión **estática** de todos los archivos, variables de entorno y el comando/programa por defecto que debería estar presente en un contenedor. **Estático** aquí significa que la imagen de contenedor **no se está ejecutando**, no está siendo ejecutada, son solo los archivos empaquetados y los metadatos.
+Una imagen de contenedor es una versión **estática** de todos los archivos, variables de entorno y el comando/programa por defecto que debería estar presente en un contenedor. **Estático** aquí significa que la **imagen** de contenedor no se está ejecutando, no está siendo ejecutada, son solo los archivos empaquetados y los metadatos.
 
 En contraste con una "**imagen de contenedor**" que son los contenidos estáticos almacenados, un "**contenedor**" normalmente se refiere a la instance en ejecución, lo que está siendo **ejecutado**.
 
@@ -56,7 +56,7 @@ Una imagen de contenedor es comparable al archivo de **programa** y sus contenid
 
 Y el **contenedor** en sí (en contraste con la **imagen de contenedor**) es la instance real en ejecución de la imagen, comparable a un **proceso**. De hecho, un contenedor solo se está ejecutando cuando tiene un **proceso en ejecución** (y normalmente es solo un proceso). El contenedor se detiene cuando no hay un proceso en ejecución en él.
 
-## Imágenes de Contenedor
+## Imágenes de Contenedor { #container-images }
 
 Docker ha sido una de las herramientas principales para crear y gestionar **imágenes de contenedor** y **contenedores**.
 
@@ -77,9 +77,9 @@ De esta manera, en muchos casos puedes aprender sobre contenedores y Docker y re
 
 Así, ejecutarías **múltiples contenedores** con diferentes cosas, como una base de datos, una aplicación de Python, un servidor web con una aplicación frontend en React, y conectarlos entre sí a través de su red interna.
 
-Todos los sistemas de gestión de contenedores (como Docker o Kubernetes) tienen estas características de redes integradas en ellos.
+Todos los sistemas de gestión de contenedores (como Docker o Kubernetes) tienen estas funcionalidades de redes integradas.
 
-## Contenedores y Procesos
+## Contenedores y Procesos { #containers-and-processes }
 
 Una **imagen de contenedor** normalmente incluye en sus metadatos el programa o comando por defecto que debería ser ejecutado cuando el **contenedor** se inicie y los parámetros que deben pasar a ese programa. Muy similar a lo que sería si estuviera en la línea de comandos.
 
@@ -91,7 +91,7 @@ Un contenedor normalmente tiene un **proceso único**, pero también es posible
 
 Pero no es posible tener un contenedor en ejecución sin **al menos un proceso en ejecución**. Si el proceso principal se detiene, el contenedor se detiene.
 
-## Construir una Imagen de Docker para FastAPI
+## Construir una Imagen de Docker para FastAPI { #build-a-docker-image-for-fastapi }
 
 ¡Bien, construyamos algo ahora! 🚀
 
@@ -103,7 +103,7 @@ Esto es lo que querrías hacer en **la mayoría de los casos**, por ejemplo:
 * Al ejecutar en un **Raspberry Pi**
 * Usando un servicio en la nube que ejecutaría una imagen de contenedor por ti, etc.
 
-### Requisitos del Paquete
+### Requisitos del Paquete { #package-requirements }
 
 Normalmente tendrías los **requisitos del paquete** para tu aplicación en algún archivo.
 
@@ -138,7 +138,7 @@ Existen otros formatos y herramientas para definir e instalar dependencias de pa
 
 ///
 
-### Crear el Código de **FastAPI**
+### Crear el Código de **FastAPI** { #create-the-fastapi-code }
 
 * Crea un directorio `app` y entra en él.
 * Crea un archivo vacío `__init__.py`.
@@ -162,7 +162,7 @@ def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
-### Dockerfile
+### Dockerfile { #dockerfile }
 
 Ahora, en el mismo directorio del proyecto, crea un archivo `Dockerfile` con:
 
@@ -238,7 +238,7 @@ Asegúrate de **siempre** usar la **forma exec** de la instrucción `CMD`, como
 
 ///
 
-#### Usar `CMD` - Forma Exec
+#### Usar `CMD` - Forma Exec { #use-cmd-exec-form }
 
 La instrucción Docker <a href="https://docs.docker.com/reference/dockerfile/#cmd" class="external-link" target="_blank">`CMD`</a> se puede escribir usando dos formas:
 
@@ -262,20 +262,20 @@ Puedes leer más sobre esto en las <a href="https://docs.docker.com/reference/do
 
 Esto puede ser bastante notorio al usar `docker compose`. Consulta esta sección de preguntas frecuentes de Docker Compose para más detalles técnicos: <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">¿Por qué mis servicios tardan 10 segundos en recrearse o detenerse?</a>.
 
-#### Estructura de Directorios
+#### Estructura de Directorios { #directory-structure }
 
 Ahora deberías tener una estructura de directorios como:
 
 ```
 .
 ├── app
-│   ├── __init__.py
+│   ├── __init__.py
 │   └── main.py
 ├── Dockerfile
 └── requirements.txt
 ```
 
-#### Detrás de un Proxy de Terminación TLS
+#### Detrás de un Proxy de Terminación TLS { #behind-a-tls-termination-proxy }
 
 Si estás ejecutando tu contenedor detrás de un Proxy de Terminación TLS (load balancer) como Nginx o Traefik, añade la opción `--proxy-headers`, esto le dirá a Uvicorn (a través de la CLI de FastAPI) que confíe en los headers enviados por ese proxy indicando que la aplicación se está ejecutando detrás de HTTPS, etc.
 
@@ -283,7 +283,7 @@ Si estás ejecutando tu contenedor detrás de un Proxy de Terminación TLS (load
 CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"]
 ```
 
-#### Cache de Docker
+#### Caché de Docker { #docker-cache }
 
 Hay un truco importante en este `Dockerfile`, primero copiamos **el archivo con las dependencias solo**, no el resto del código. Déjame decirte por qué es así.
 
@@ -315,7 +315,7 @@ Luego, cerca del final del `Dockerfile`, copiamos todo el código. Como esto es
 COPY ./app /code/app
 ```
 
-### Construir la Imagen de Docker
+### Construir la Imagen de Docker { #build-the-docker-image }
 
 Ahora que todos los archivos están en su lugar, vamos a construir la imagen del contenedor.
 
@@ -340,7 +340,7 @@ En este caso, es el mismo directorio actual (`.`).
 
 ///
 
-### Iniciar el Contenedor Docker
+### Iniciar el Contenedor Docker { #start-the-docker-container }
 
 * Ejecuta un contenedor basado en tu imagen:
 
@@ -352,7 +352,7 @@ $ docker run -d --name mycontainer -p 80:80 myimage
 
 </div>
 
-## Revísalo
+## Revísalo { #check-it }
 
 Deberías poder revisarlo en la URL de tu contenedor de Docker, por ejemplo: <a href="http://192.168.99.100/items/5?q=somequery" class="external-link" target="_blank">http://192.168.99.100/items/5?q=somequery</a> o <a href="http://127.0.0.1/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1/items/5?q=somequery</a> (o equivalente, usando tu host de Docker).
 
@@ -362,7 +362,7 @@ Verás algo como:
 {"item_id": 5, "q": "somequery"}
 ```
 
-## Documentación Interactiva de la API
+## Documentación Interactiva de la API { #interactive-api-docs }
 
 Ahora puedes ir a <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> o <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> (o equivalente, usando tu host de Docker).
 
@@ -370,7 +370,7 @@ Verás la documentación interactiva automática de la API (proporcionada por <a
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-## Documentación Alternativa de la API
+## Documentación Alternativa de la API { #alternative-api-docs }
 
 Y también puedes ir a <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> o <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> (o equivalente, usando tu host de Docker).
 
@@ -378,7 +378,7 @@ Verás la documentación alternativa automática (proporcionada por <a href="htt
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Construir una Imagen de Docker con un FastAPI de Un Solo Archivo
+## Construir una Imagen de Docker con un FastAPI de Un Solo Archivo { #build-a-docker-image-with-a-single-file-fastapi }
 
 Si tu FastAPI es un solo archivo, por ejemplo, `main.py` sin un directorio `./app`, tu estructura de archivos podría verse así:
 
@@ -413,7 +413,7 @@ CMD ["fastapi", "run", "main.py", "--port", "80"]
 
 Cuando pasas el archivo a `fastapi run`, detectará automáticamente que es un archivo único y no parte de un paquete y sabrá cómo importarlo y servir tu aplicación FastAPI. 😎
 
-## Conceptos de Despliegue
+## Conceptos de Despliegue { #deployment-concepts }
 
 Hablemos nuevamente de algunos de los mismos [Conceptos de Despliegue](concepts.md){.internal-link target=_blank} en términos de contenedores.
 
@@ -430,7 +430,7 @@ Revisemos estos **conceptos de despliegue** en términos de contenedores:
 * Memoria
 * Pasos previos antes de comenzar
 
-## HTTPS
+## HTTPS { #https }
 
 Si nos enfocamos solo en la **imagen de contenedor** para una aplicación FastAPI (y luego el **contenedor** en ejecución), HTTPS normalmente sería manejado **externamente** por otra herramienta.
 
@@ -444,7 +444,7 @@ Traefik tiene integraciones con Docker, Kubernetes, y otros, por lo que es muy f
 
 Alternativamente, HTTPS podría ser manejado por un proveedor de la nube como uno de sus servicios (mientras que la aplicación aún se ejecuta en un contenedor).
 
-## Ejecutar en el Inicio y Reinicios
+## Ejecutar en el Inicio y Reinicios { #running-on-startup-and-restarts }
 
 Normalmente hay otra herramienta encargada de **iniciar y ejecutar** tu contenedor.
 
@@ -454,7 +454,7 @@ En la mayoría (o todas) de las casos, hay una opción sencilla para habilitar l
 
 Sin usar contenedores, hacer que las aplicaciones se ejecuten al inicio y con reinicios puede ser engorroso y difícil. Pero al **trabajar con contenedores** en la mayoría de los casos, esa funcionalidad se incluye por defecto. ✨
 
-## Replicación - Número de Procesos
+## Replicación - Número de Procesos { #replication-number-of-processes }
 
 Si tienes un <abbr title="Un grupo de máquinas que están configuradas para estar conectadas y trabajar juntas de alguna manera.">cluster</abbr> de máquinas con **Kubernetes**, Docker Swarm Mode, Nomad, u otro sistema complejo similar para gestionar contenedores distribuidos en varias máquinas, entonces probablemente querrás manejar la **replicación** a nivel de **cluster** en lugar de usar un **gestor de procesos** (como Uvicorn con workers) en cada contenedor.
 
@@ -462,7 +462,7 @@ Uno de esos sistemas de gestión de contenedores distribuidos como Kubernetes no
 
 En esos casos, probablemente desearías construir una **imagen de Docker desde cero** como se [explica arriba](#dockerfile), instalando tus dependencias, y ejecutando **un solo proceso de Uvicorn** en lugar de usar múltiples workers de Uvicorn.
 
-### Load Balancer
+### Load Balancer { #load-balancer }
 
 Al usar contenedores, normalmente tendrías algún componente **escuchando en el puerto principal**. Podría posiblemente ser otro contenedor que es también un **Proxy de Terminación TLS** para manejar **HTTPS** o alguna herramienta similar.
 
@@ -476,17 +476,17 @@ El mismo componente **Proxy de Terminación TLS** usado para HTTPS probablemente
 
 Y al trabajar con contenedores, el mismo sistema que usas para iniciarlos y gestionarlos ya tendría herramientas internas para transmitir la **comunicación en red** (e.g., requests HTTP) desde ese **load balancer** (que también podría ser un **Proxy de Terminación TLS**) a los contenedores con tu aplicación.
 
-### Un Load Balancer - Múltiples Contenedores Worker
+### Un Load Balancer - Múltiples Contenedores Worker { #one-load-balancer-multiple-worker-containers }
 
 Al trabajar con **Kubernetes** u otros sistemas de gestión de contenedores distribuidos similares, usar sus mecanismos de red internos permitiría que el único **load balancer** que está escuchando en el **puerto** principal transmita la comunicación (requests) a posiblemente **múltiples contenedores** ejecutando tu aplicación.
 
 Cada uno de estos contenedores ejecutando tu aplicación normalmente tendría **solo un proceso** (e.g., un proceso Uvicorn ejecutando tu aplicación FastAPI). Todos serían **contenedores idénticos**, ejecutando lo mismo, pero cada uno con su propio proceso, memoria, etc. De esa forma, aprovecharías la **paralelización** en **diferentes núcleos** de la CPU, o incluso en **diferentes máquinas**.
 
-Y el sistema de contenedores distribuido con el **load balancer** **distribuiría las requests** a cada uno de los contenedores **replicados** que ejecutan tu aplicación **en turnos**. Así, cada request podría ser manejado por uno de los múltiples **contenedores replicados** ejecutando tu aplicación.
+Y el sistema de contenedores distribuido con el **load balancer** **distribuiría las requests** a cada uno de los contenedores con tu aplicación **en turnos**. Así, cada request podría ser manejada por uno de los múltiples **contenedores replicados** ejecutando tu aplicación.
 
-Y normalmente este **load balancer** podría manejar requests que vayan a *otras* aplicaciones en tu cluster (p. ej., a un dominio diferente, o bajo un prefijo de ruta de URL diferente), y transmitiría esa comunicación a los contenedores correctos para *esa otra* aplicación ejecutándose en tu cluster.
+Y normalmente este **load balancer** podría manejar requests que vayan a *otras* aplicaciones en tu cluster (p. ej., a un dominio diferente, o bajo un prefijo de path de URL diferente), y transmitiría esa comunicación a los contenedores correctos para *esa otra* aplicación ejecutándose en tu cluster.
 
-### Un Proceso por Contenedor
+### Un Proceso por Contenedor { #one-process-per-container }
 
 En este tipo de escenario, probablemente querrías tener **un solo proceso (Uvicorn) por contenedor**, ya que ya estarías manejando la replicación a nivel de cluster.
 
@@ -494,7 +494,7 @@ Así que, en este caso, **no** querrías tener múltiples workers en el contened
 
 Tener otro gestor de procesos dentro del contenedor (como sería con múltiples workers) solo añadiría **complejidad innecesaria** que probablemente ya estés manejando con tu sistema de cluster.
 
-### Contenedores con Múltiples Procesos y Casos Especiales
+### Contenedores con Múltiples Procesos y Casos Especiales { #containers-with-multiple-processes-and-special-cases }
 
 Por supuesto, hay **casos especiales** donde podrías querer tener **un contenedor** con varios **worker processes de Uvicorn** dentro.
 
@@ -519,11 +519,11 @@ CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
 
 Aquí hay algunos ejemplos de cuándo eso podría tener sentido:
 
-#### Una Aplicación Simple
+#### Una Aplicación Simple { #a-simple-app }
 
 Podrías querer un gestor de procesos en el contenedor si tu aplicación es **lo suficientemente simple** que pueda ejecutarse en un **servidor único**, no un cluster.
 
-#### Docker Compose
+#### Docker Compose { #docker-compose }
 
 Podrías estar desplegando en un **servidor único** (no un cluster) con **Docker Compose**, por lo que no tendrías una forma fácil de gestionar la replicación de contenedores (con Docker Compose) mientras se preserva la red compartida y el **load balancing**.
 
@@ -540,7 +540,7 @@ El punto principal es que, **ninguna** de estas son **reglas escritas en piedra*
 * Memoria
 * Pasos previos antes de comenzar
 
-## Memoria
+## Memoria { #memory }
 
 Si ejecutas **un solo proceso por contenedor**, tendrás una cantidad de memoria más o menos bien definida, estable y limitada consumida por cada uno de esos contenedores (más de uno si están replicados).
 
@@ -550,11 +550,11 @@ Si tu aplicación es **simple**, probablemente esto **no será un problema**, y
 
 Si ejecutas **múltiples procesos por contenedor**, tendrás que asegurarte de que el número de procesos iniciados no **consuma más memoria** de la que está disponible.
 
-## Pasos Previos Antes de Comenzar y Contenedores
+## Pasos Previos Antes de Comenzar y Contenedores { #previous-steps-before-starting-and-containers }
 
 Si estás usando contenedores (por ejemplo, Docker, Kubernetes), entonces hay dos enfoques principales que puedes usar.
 
-### Múltiples Contenedores
+### Múltiples Contenedores { #multiple-containers }
 
 Si tienes **múltiples contenedores**, probablemente cada uno ejecutando un **proceso único** (por ejemplo, en un cluster de **Kubernetes**), entonces probablemente querrías tener un **contenedor separado** realizando el trabajo de los **pasos previos** en un solo contenedor, ejecutando un solo proceso, **antes** de ejecutar los contenedores worker replicados.
 
@@ -566,13 +566,13 @@ Si estás usando Kubernetes, probablemente sería un <a href="https://kubernetes
 
 Si en tu caso de uso no hay problema en ejecutar esos pasos previos **múltiples veces en paralelo** (por ejemplo, si no estás ejecutando migraciones de base de datos, sino simplemente verificando si la base de datos está lista), entonces también podrías simplemente ponerlos en cada contenedor justo antes de iniciar el proceso principal.
 
-### Un Contenedor Único
+### Un Contenedor Único { #single-container }
 
 Si tienes una configuración simple, con un **contenedor único** que luego inicia múltiples **worker processes** (o también solo un proceso), entonces podrías ejecutar esos pasos previos en el mismo contenedor, justo antes de iniciar el proceso con la aplicación.
 
-### Imagen Base de Docker
+### Imagen Base de Docker { #base-docker-image }
 
-Solía haber una imagen official de Docker de FastAPI: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Pero ahora está obsoleta. ⛔️
+Solía haber una imagen official de Docker de FastAPI: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi-docker</a>. Pero ahora está obsoleta. ⛔️
 
 Probablemente **no** deberías usar esta imagen base de Docker (o cualquier otra similar).
 
@@ -588,7 +588,7 @@ Pero ahora que Uvicorn (y el comando `fastapi`) soportan el uso de `--workers`,
 
 ///
 
-## Desplegar la Imagen del Contenedor
+## Desplegar la Imagen del Contenedor { #deploy-the-container-image }
 
 Después de tener una Imagen de Contenedor (Docker) hay varias maneras de desplegarla.
 
@@ -600,11 +600,11 @@ Por ejemplo:
 * Con otra herramienta como Nomad
 * Con un servicio en la nube que tome tu imagen de contenedor y la despliegue
 
-## Imagen de Docker con `uv`
+## Imagen de Docker con `uv` { #docker-image-with-uv }
 
 Si estás usando <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> para instalar y gestionar tu proyecto, puedes seguir su <a href="https://docs.astral.sh/uv/guides/integration/docker/" class="external-link" target="_blank">guía de Docker de uv</a>.
 
-## Resumen
+## Resumen { #recap }
 
 Usando sistemas de contenedores (por ejemplo, con **Docker** y **Kubernetes**) se vuelve bastante sencillo manejar todos los **conceptos de despliegue**:
 

docs/es/docs/deployment/fastapicloud.md

@@ -0,0 +1,65 @@
+# FastAPI Cloud { #fastapi-cloud }
+
+Puedes desplegar tu app de FastAPI en <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a> con un solo comando; ve y únete a la lista de espera si aún no lo has hecho. 🚀
+
+## Iniciar sesión { #login }
+
+Asegúrate de que ya tienes una cuenta de **FastAPI Cloud** (te invitamos desde la lista de espera 😉).
+
+Luego inicia sesión:
+
+<div class="termy">
+
+```console
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+## Desplegar { #deploy }
+
+Ahora despliega tu app, con un solo comando:
+
+<div class="termy">
+
+```console
+$ fastapi deploy
+
+Deploying to FastAPI Cloud...
+
+✅ Deployment successful!
+
+🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
+```
+
+</div>
+
+¡Eso es todo! Ahora puedes acceder a tu app en esa URL. ✨
+
+## Acerca de FastAPI Cloud { #about-fastapi-cloud }
+
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** está creado por el mismo autor y equipo detrás de **FastAPI**.
+
+Agiliza el proceso de **crear**, **desplegar** y **acceder** a una API con el mínimo esfuerzo.
+
+Aporta la misma **experiencia de desarrollador** de crear apps con FastAPI al **desplegarlas** en la nube. 🎉
+
+También se encargará de la mayoría de las cosas que necesitas al desplegar una app, como:
+
+* HTTPS
+* Replicación, con autoescalado basado en requests
+* etc.
+
+FastAPI Cloud es el sponsor principal y proveedor de financiación de los proyectos open source de *FastAPI and friends*. ✨
+
+## Desplegar en otros proveedores de la nube { #deploy-to-other-cloud-providers }
+
+FastAPI es open source y está basado en estándares. Puedes desplegar apps de FastAPI en cualquier proveedor de la nube que elijas.
+
+Sigue las guías de tu proveedor de la nube para desplegar apps de FastAPI con ellos. 🤓
+
+## Despliega tu propio servidor { #deploy-your-own-server }
+
+También te enseñaré más adelante en esta guía de **Despliegue** todos los detalles, para que puedas entender qué está pasando, qué tiene que ocurrir o cómo desplegar apps de FastAPI por tu cuenta, también con tus propios servidores. 🤓

docs/es/docs/deployment/https.md

@@ -1,4 +1,4 @@
-# Sobre HTTPS
+# Sobre HTTPS { #about-https }
 
 Es fácil asumir que HTTPS es algo que simplemente está "activado" o no.
 
@@ -28,7 +28,7 @@ Ahora, desde una **perspectiva de desarrollador**, aquí hay varias cosas a tene
 * **Por defecto**, eso significaría que solo puedes tener **un certificado HTTPS por dirección IP**.
     * No importa cuán grande sea tu servidor o qué tan pequeña pueda ser cada aplicación que tengas en él.
     * Sin embargo, hay una **solución** para esto.
-* Hay una **extensión** para el protocolo **TLS** (el que maneja la encriptación a nivel de TCP, antes de HTTP) llamada **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication">SNI</abbr></a>**.
+* Hay una **extensión** para el protocolo **TLS** (el que maneja la encriptación a nivel de TCP, antes de HTTP) llamada **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication – Indicación del nombre del servidor">SNI</abbr></a>**.
     * Esta extensión SNI permite que un solo servidor (con una **sola dirección IP**) tenga **varios certificados HTTPS** y sirva **múltiples dominios/aplicaciones HTTPS**.
     * Para que esto funcione, un componente (programa) **único** que se ejecute en el servidor, escuchando en la **dirección IP pública**, debe tener **todos los certificados HTTPS** en el servidor.
 * **Después** de obtener una conexión segura, el protocolo de comunicación sigue siendo **HTTP**.
@@ -43,7 +43,7 @@ Algunas de las opciones que podrías usar como un TLS Termination Proxy son:
 * Nginx
 * HAProxy
 
-## Let's Encrypt
+## Let's Encrypt { #lets-encrypt }
 
 Antes de Let's Encrypt, estos **certificados HTTPS** eran vendidos por terceros.
 
@@ -51,17 +51,17 @@ El proceso para adquirir uno de estos certificados solía ser complicado, requer
 
 Pero luego se creó **<a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a>**.
 
-Es un proyecto de la Linux Foundation. Proporciona **certificados HTTPS de forma gratuita**, de manera automatizada. Estos certificados usan toda la seguridad criptográfica estándar, y tienen una corta duración (aproximadamente 3 meses), por lo que la **seguridad es en realidad mejor** debido a su corta vida útil.
+Es un proyecto de la Linux Foundation. Proporciona **certificados HTTPS de forma gratuita**, de manera automatizada. Estos certificados usan toda la seguridad criptográfica estándar, y tienen una corta duración (aproximadamente 3 meses), por lo que la **seguridad es en realidad mejor** debido a su lifespan reducida.
 
 Los dominios son verificados de manera segura y los certificados se generan automáticamente. Esto también permite automatizar la renovación de estos certificados.
 
 La idea es automatizar la adquisición y renovación de estos certificados para que puedas tener **HTTPS seguro, gratuito, para siempre**.
 
-## HTTPS para Desarrolladores
+## HTTPS para Desarrolladores { #https-for-developers }
 
 Aquí tienes un ejemplo de cómo podría ser una API HTTPS, paso a paso, prestando atención principalmente a las ideas importantes para los desarrolladores.
 
-### Nombre de Dominio
+### Nombre de Dominio { #domain-name }
 
 Probablemente todo comenzaría adquiriendo un **nombre de dominio**. Luego, lo configurarías en un servidor DNS (posiblemente tu mismo proveedor de la nube).
 
@@ -77,7 +77,7 @@ Esta parte del Nombre de Dominio es mucho antes de HTTPS, pero como todo depende
 
 ///
 
-### DNS
+### DNS { #dns }
 
 Ahora centrémonos en todas las partes realmente de HTTPS.
 
@@ -87,7 +87,7 @@ Los servidores DNS le dirían al navegador que use una **dirección IP** especí
 
 <img src="/img/deployment/https/https01.drawio.svg">
 
-### Inicio del Handshake TLS
+### Inicio del Handshake TLS { #tls-handshake-start }
 
 El navegador luego se comunicaría con esa dirección IP en el **puerto 443** (el puerto HTTPS).
 
@@ -97,7 +97,7 @@ La primera parte de la comunicación es solo para establecer la conexión entre
 
 Esta interacción entre el cliente y el servidor para establecer la conexión TLS se llama **handshake TLS**.
 
-### TLS con Extensión SNI
+### TLS con Extensión SNI { #tls-with-sni-extension }
 
 **Solo un proceso** en el servidor puede estar escuchando en un **puerto** específico en una **dirección IP** específica. Podría haber otros procesos escuchando en otros puertos en la misma dirección IP, pero solo uno para cada combinación de dirección IP y puerto.
 
@@ -127,7 +127,7 @@ Ten en cuenta que la encriptación de la comunicación ocurre a nivel de **TCP**
 
 ///
 
-### Request HTTPS
+### Request HTTPS { #https-request }
 
 Ahora que el cliente y el servidor (específicamente el navegador y el TLS Termination Proxy) tienen una **conexión TCP encriptada**, pueden iniciar la **comunicación HTTP**.
 
@@ -135,19 +135,19 @@ Así que, el cliente envía un **request HTTPS**. Esto es simplemente un request
 
 <img src="/img/deployment/https/https04.drawio.svg">
 
-### Desencriptar el Request
+### Desencriptar el Request { #decrypt-the-request }
 
 El TLS Termination Proxy usaría la encriptación acordada para **desencriptar el request**, y transmitiría el **request HTTP simple (desencriptado)** al proceso que ejecuta la aplicación (por ejemplo, un proceso con Uvicorn ejecutando la aplicación FastAPI).
 
 <img src="/img/deployment/https/https05.drawio.svg">
 
-### Response HTTP
+### Response HTTP { #http-response }
 
 La aplicación procesaría el request y enviaría un **response HTTP simple (sin encriptar)** al TLS Termination Proxy.
 
 <img src="/img/deployment/https/https06.drawio.svg">
 
-### Response HTTPS
+### Response HTTPS { #https-response }
 
 El TLS Termination Proxy entonces **encriptaría el response** usando la criptografía acordada antes (que comenzó con el certificado para `someapp.example.com`), y lo enviaría de vuelta al navegador.
 
@@ -157,7 +157,7 @@ Luego, el navegador verificaría que el response sea válido y encriptado con la
 
 El cliente (navegador) sabrá que el response proviene del servidor correcto porque está utilizando la criptografía que acordaron usando el **certificado HTTPS** anteriormente.
 
-### Múltiples Aplicaciones
+### Múltiples Aplicaciones { #multiple-applications }
 
 En el mismo servidor (o servidores), podrían haber **múltiples aplicaciones**, por ejemplo, otros programas API o una base de datos.
 
@@ -167,7 +167,7 @@ Solo un proceso puede estar gestionando la IP y puerto específica (el TLS Termi
 
 De esa manera, el TLS Termination Proxy podría gestionar HTTPS y certificados para **múltiples dominios**, para múltiples aplicaciones, y luego transmitir los requests a la aplicación correcta en cada caso.
 
-### Renovación de Certificados
+### Renovación de Certificados { #certificate-renewal }
 
 En algún momento en el futuro, cada certificado **expiraría** (alrededor de 3 meses después de haberlo adquirido).
 
@@ -190,7 +190,39 @@ Para hacer eso, y para acomodar diferentes necesidades de aplicaciones, hay vari
 
 Todo este proceso de renovación, mientras aún se sirve la aplicación, es una de las principales razones por las que querrías tener un **sistema separado para gestionar el HTTPS** con un TLS Termination Proxy en lugar de simplemente usar los certificados TLS con el servidor de aplicaciones directamente (por ejemplo, Uvicorn).
 
-## Resumen
+## Headers reenviados por el proxy { #proxy-forwarded-headers }
+
+Al usar un proxy para gestionar HTTPS, tu **servidor de aplicaciones** (por ejemplo Uvicorn vía FastAPI CLI) no sabe nada sobre el proceso HTTPS, se comunica con HTTP simple con el **TLS Termination Proxy**.
+
+Este **proxy** normalmente configuraría algunos headers HTTP sobre la marcha antes de transmitir el request al **servidor de aplicaciones**, para hacerle saber al servidor de aplicaciones que el request está siendo **reenviado** por el proxy.
+
+/// note | Detalles técnicos
+
+Los headers del proxy son:
+
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-For" class="external-link" target="_blank">X-Forwarded-For</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Proto" class="external-link" target="_blank">X-Forwarded-Proto</a>
+* <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/X-Forwarded-Host" class="external-link" target="_blank">X-Forwarded-Host</a>
+
+///
+
+Aun así, como el **servidor de aplicaciones** no sabe que está detrás de un **proxy** de confianza, por defecto, no confiaría en esos headers.
+
+Pero puedes configurar el **servidor de aplicaciones** para confiar en los headers reenviados enviados por el **proxy**. Si estás usando FastAPI CLI, puedes usar la *Opción de la CLI* `--forwarded-allow-ips` para indicarle desde qué IPs debería confiar en esos headers reenviados.
+
+Por ejemplo, si el **servidor de aplicaciones** solo está recibiendo comunicación del **proxy** de confianza, puedes establecerlo en `--forwarded-allow-ips="*"` para hacer que confíe en todas las IPs entrantes, ya que solo recibirá requests desde la IP que sea utilizada por el **proxy**.
+
+De esta manera la aplicación podrá saber cuál es su propia URL pública, si está usando HTTPS, el dominio, etc.
+
+Esto sería útil, por ejemplo, para manejar correctamente redirecciones.
+
+/// tip | Consejo
+
+Puedes aprender más sobre esto en la documentación de [Detrás de un proxy - Habilitar headers reenviados por el proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
+
+///
+
+## Resumen { #recap }
 
 Tener **HTTPS** es muy importante y bastante **crítico** en la mayoría de los casos. La mayor parte del esfuerzo que como desarrollador tienes que poner en torno a HTTPS es solo sobre **entender estos conceptos** y cómo funcionan.
 

docs/es/docs/deployment/index.md

@@ -1,8 +1,8 @@
-# Despliegue
+# Despliegue { #deployment }
 
 Desplegar una aplicación **FastAPI** es relativamente fácil.
 
-## Qué Significa Despliegue
+## Qué Significa Despliegue { #what-does-deployment-mean }
 
 **Desplegar** una aplicación significa realizar los pasos necesarios para hacerla **disponible para los usuarios**.
 
@@ -10,12 +10,14 @@ Para una **API web**, normalmente implica ponerla en una **máquina remota**, co
 
 Esto contrasta con las etapas de **desarrollo**, donde estás constantemente cambiando el código, rompiéndolo y arreglándolo, deteniendo y reiniciando el servidor de desarrollo, etc.
 
-## Estrategias de Despliegue
+## Estrategias de Despliegue { #deployment-strategies }
 
 Hay varias maneras de hacerlo dependiendo de tu caso de uso específico y las herramientas que utilices.
 
 Podrías **desplegar un servidor** tú mismo utilizando una combinación de herramientas, podrías usar un **servicio en la nube** que hace parte del trabajo por ti, u otras opciones posibles.
 
+Por ejemplo, nosotros, el equipo detrás de FastAPI, construimos <a href="https://fastapicloud.com" class="external-link" target="_blank">**FastAPI Cloud**</a>, para hacer que desplegar aplicaciones de FastAPI en la nube sea lo más ágil posible, con la misma experiencia de desarrollador de trabajar con FastAPI.
+
 Te mostraré algunos de los conceptos principales que probablemente deberías tener en cuenta al desplegar una aplicación **FastAPI** (aunque la mayoría se aplica a cualquier otro tipo de aplicación web).
 
 Verás más detalles a tener en cuenta y algunas de las técnicas para hacerlo en las siguientes secciones. ✨

docs/es/docs/deployment/server-workers.md

@@ -1,4 +1,4 @@
-# Servidores Workers - Uvicorn con Workers
+# Servidores Workers - Uvicorn con Workers { #server-workers-uvicorn-with-workers }
 
 Vamos a revisar esos conceptos de despliegue de antes:
 
@@ -25,7 +25,7 @@ En particular, cuando corras en **Kubernetes** probablemente **no** querrás usa
 
 ///
 
-## Múltiples Workers
+## Múltiples Workers { #multiple-workers }
 
 Puedes iniciar múltiples workers con la opción de línea de comando `--workers`:
 
@@ -36,56 +36,43 @@ Si usas el comando `fastapi`:
 <div class="termy">
 
 ```console
-$ <pre> <font color="#4E9A06">fastapi</font> run --workers 4 <u style="text-decoration-style:single">main.py</u>
-<font color="#3465A4">INFO    </font> Using path <font color="#3465A4">main.py</font>
-<font color="#3465A4">INFO    </font> Resolved absolute path <font color="#75507B">/home/user/code/awesomeapp/</font><font color="#AD7FA8">main.py</font>
-<font color="#3465A4">INFO    </font> Searching for package file structure from directories with <font color="#3465A4">__init__.py</font> files
-<font color="#3465A4">INFO    </font> Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+$ <font color="#4E9A06">fastapi</font> run --workers 4 <u style="text-decoration-style:solid">main.py</u>
 
- ╭─ <font color="#8AE234"><b>Python module file</b></font> ─╮
- │                      │
- │  🐍 main.py          │
- │                      │
- ╰──────────────────────╯
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting production server 🚀
 
-<font color="#3465A4">INFO    </font> Importing module <font color="#4E9A06">main</font>
-<font color="#3465A4">INFO    </font> Found importable FastAPI app
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
- ╭─ <font color="#8AE234"><b>Importable FastAPI app</b></font> ─╮
- │                          │
- │  <span style="background-color:#272822"><font color="#FF4689">from</font></span><span style="background-color:#272822"><font color="#F8F8F2"> main </font></span><span style="background-color:#272822"><font color="#FF4689">import</font></span><span style="background-color:#272822"><font color="#F8F8F2"> app</font></span><span style="background-color:#272822">  </span>  │
- │                          │
- ╰──────────────────────────╯
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-<font color="#3465A4">INFO    </font> Using import string <font color="#8AE234"><b>main:app</b></font>
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
 
- <font color="#4E9A06">╭─────────── FastAPI CLI - Production mode ───────────╮</font>
- <font color="#4E9A06">│                                                     │</font>
- <font color="#4E9A06">│  Serving at: http://0.0.0.0:8000                    │</font>
- <font color="#4E9A06">│                                                     │</font>
- <font color="#4E9A06">│  API docs: http://0.0.0.0:8000/docs                 │</font>
- <font color="#4E9A06">│                                                     │</font>
- <font color="#4E9A06">│  Running in production mode, for development use:   │</font>
- <font color="#4E9A06">│                                                     │</font>
- <font color="#4E9A06">│  </font><font color="#8AE234"><b>fastapi dev</b></font><font color="#4E9A06">                                        │</font>
- <font color="#4E9A06">│                                                     │</font>
- <font color="#4E9A06">╰─────────────────────────────────────────────────────╯</font>
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-<font color="#4E9A06">INFO</font>:     Uvicorn running on <b>http://0.0.0.0:8000</b> (Press CTRL+C to quit)
-<font color="#4E9A06">INFO</font>:     Started parent process [<font color="#34E2E2"><b>27365</b></font>]
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">27368</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">27369</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">27370</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">27367</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
-</pre>
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000/docs</u></font>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://0.0.0.0:8000</u></font> <b>(</b>Press CTRL+C to
+             quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started parent process <b>[</b><font color="#34E2E2"><b>27365</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27368</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27369</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27370</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>27367</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
 ```
 
 </div>
@@ -124,7 +111,7 @@ La única opción nueva aquí es `--workers` indicando a Uvicorn que inicie 4 wo
 
 También puedes ver que muestra el **PID** de cada proceso, `27365` para el proceso padre (este es el **gestor de procesos**) y uno para cada worker process: `27368`, `27369`, `27370`, y `27367`.
 
-## Conceptos de Despliegue
+## Conceptos de Despliegue { #deployment-concepts }
 
 Aquí viste cómo usar múltiples **workers** para **paralelizar** la ejecución de la aplicación, aprovechar los **múltiples núcleos** del CPU, y poder servir **más requests**.
 
@@ -137,13 +124,13 @@ De la lista de conceptos de despliegue de antes, usar workers ayudaría principa
 * **Memoria**
 * **Pasos previos antes de empezar**
 
-## Contenedores y Docker
+## Contenedores y Docker { #containers-and-docker }
 
 En el próximo capítulo sobre [FastAPI en Contenedores - Docker](docker.md){.internal-link target=_blank} te explicaré algunas estrategias que podrías usar para manejar los otros **conceptos de despliegue**.
 
 Te mostraré cómo **construir tu propia imagen desde cero** para ejecutar un solo proceso de Uvicorn. Es un proceso sencillo y probablemente es lo que querrías hacer al usar un sistema de gestión de contenedores distribuido como **Kubernetes**.
 
-## Resumen
+## Resumen { #recap }
 
 Puedes usar múltiples worker processes con la opción CLI `--workers` con los comandos `fastapi` o `uvicorn` para aprovechar los **CPUs de múltiples núcleos**, para ejecutar **múltiples procesos en paralelo**.
 

docs/es/docs/deployment/versions.md

@@ -1,4 +1,4 @@
-# Sobre las versiones de FastAPI
+# Sobre las versiones de FastAPI { #about-fastapi-versions }
 
 **FastAPI** ya se está utilizando en producción en muchas aplicaciones y sistemas. Y la cobertura de tests se mantiene al 100%. Pero su desarrollo sigue avanzando rápidamente.
 
@@ -8,7 +8,7 @@ Por eso las versiones actuales siguen siendo `0.x.x`, esto refleja que cada vers
 
 Puedes crear aplicaciones de producción con **FastAPI** ahora mismo (y probablemente ya lo has estado haciendo desde hace algún tiempo), solo debes asegurarte de que utilizas una versión que funciona correctamente con el resto de tu código.
 
-## Fijar tu versión de `fastapi`
+## Fija tu versión de `fastapi` { #pin-your-fastapi-version }
 
 Lo primero que debes hacer es "fijar" la versión de **FastAPI** que estás usando a la versión específica más reciente que sabes que funciona correctamente para tu aplicación.
 
@@ -32,11 +32,11 @@ eso significaría que usarías las versiones `0.112.0` o superiores, pero menore
 
 Si utilizas cualquier otra herramienta para gestionar tus instalaciones, como `uv`, Poetry, Pipenv, u otras, todas tienen una forma que puedes usar para definir versiones específicas para tus paquetes.
 
-## Versiones disponibles
+## Versiones disponibles { #available-versions }
 
 Puedes ver las versiones disponibles (por ejemplo, para revisar cuál es la más reciente) en las [Release Notes](../release-notes.md){.internal-link target=_blank}.
 
-## Sobre las versiones
+## Sobre las versiones { #about-versions }
 
 Siguiendo las convenciones del Semantic Versioning, cualquier versión por debajo de `1.0.0` podría potencialmente añadir cambios incompatibles.
 
@@ -62,7 +62,7 @@ El "MINOR" es el número en el medio, por ejemplo, en `0.2.3`, la versión MINOR
 
 ///
 
-## Actualizando las versiones de FastAPI
+## Actualizando las versiones de FastAPI { #upgrading-the-fastapi-versions }
 
 Deberías añadir tests para tu aplicación.
 
@@ -72,7 +72,7 @@ Después de tener tests, puedes actualizar la versión de **FastAPI** a una más
 
 Si todo está funcionando, o después de hacer los cambios necesarios, y todos tus tests pasan, entonces puedes fijar tu `fastapi` a esa nueva versión más reciente.
 
-## Sobre Starlette
+## Sobre Starlette { #about-starlette }
 
 No deberías fijar la versión de `starlette`.
 
@@ -80,7 +80,7 @@ Diferentes versiones de **FastAPI** utilizarán una versión más reciente espec
 
 Así que, puedes simplemente dejar que **FastAPI** use la versión correcta de Starlette.
 
-## Sobre Pydantic
+## Sobre Pydantic { #about-pydantic }
 
 Pydantic incluye los tests para **FastAPI** con sus propios tests, así que nuevas versiones de Pydantic (por encima de `1.0.0`) siempre son compatibles con FastAPI.
 

docs/es/docs/environment-variables.md

@@ -1,4 +1,4 @@
-# Variables de Entorno
+# Variables de Entorno { #environment-variables }
 
 /// tip | Consejo
 
@@ -10,7 +10,7 @@ Una variable de entorno (también conocida como "**env var**") es una variable q
 
 Las variables de entorno pueden ser útiles para manejar **configuraciones** de aplicaciones, como parte de la **instalación** de Python, etc.
 
-## Crear y Usar Variables de Entorno
+## Crear y Usar Variables de Entorno { #create-and-use-env-vars }
 
 Puedes **crear** y usar variables de entorno en la **shell (terminal)**, sin necesidad de Python:
 
@@ -50,7 +50,7 @@ Hello Wade Wilson
 
 ////
 
-## Leer Variables de Entorno en Python
+## Leer Variables de Entorno en Python { #read-env-vars-in-python }
 
 También podrías crear variables de entorno **fuera** de Python, en la terminal (o con cualquier otro método), y luego **leerlas en Python**.
 
@@ -157,7 +157,7 @@ Puedes leer más al respecto en <a href="https://12factor.net/config" class="ext
 
 ///
 
-## Tipos y Validación
+## Tipos y Validación { #types-and-validation }
 
 Estas variables de entorno solo pueden manejar **strings de texto**, ya que son externas a Python y deben ser compatibles con otros programas y el resto del sistema (e incluso con diferentes sistemas operativos, como Linux, Windows, macOS).
 
@@ -165,7 +165,7 @@ Esto significa que **cualquier valor** leído en Python desde una variable de en
 
 Aprenderás más sobre cómo usar variables de entorno para manejar **configuraciones de aplicación** en la [Guía del Usuario Avanzado - Ajustes y Variables de Entorno](./advanced/settings.md){.internal-link target=_blank}.
 
-## Variable de Entorno `PATH`
+## Variable de Entorno `PATH` { #path-environment-variable }
 
 Hay una variable de entorno **especial** llamada **`PATH`** que es utilizada por los sistemas operativos (Linux, macOS, Windows) para encontrar programas a ejecutar.
 
@@ -209,7 +209,7 @@ Por ejemplo, cuando escribes `python` en la terminal, el sistema operativo busca
 
 Si lo encuentra, entonces lo **utilizará**. De lo contrario, continúa buscando en los **otros directorios**.
 
-### Instalando Python y Actualizando el `PATH`
+### Instalando Python y Actualizando el `PATH` { #installing-python-and-updating-the-path }
 
 Cuando instalas Python, se te podría preguntar si deseas actualizar la variable de entorno `PATH`.
 
@@ -287,7 +287,7 @@ $ C:\opt\custompython\bin\python
 
 Esta información será útil al aprender sobre [Entornos Virtuales](virtual-environments.md){.internal-link target=_blank}.
 
-## Conclusión
+## Conclusión { #conclusion }
 
 Con esto deberías tener una comprensión básica de qué son las **variables de entorno** y cómo usarlas en Python.
 

docs/es/docs/how-to/authentication-error-status-code.md

@@ -0,0 +1,17 @@
+# Usar los códigos de estado antiguos 403 para errores de autenticación { #use-old-403-authentication-error-status-codes }
+
+Antes de FastAPI versión `0.122.0`, cuando las utilidades de seguridad integradas devolvían un error al cliente después de una autenticación fallida, usaban el código de estado HTTP `403 Forbidden`.
+
+A partir de FastAPI versión `0.122.0`, usan el código de estado HTTP `401 Unauthorized`, más apropiado, y devuelven un `WWW-Authenticate` header adecuado en la response, siguiendo las especificaciones HTTP, <a href="https://datatracker.ietf.org/doc/html/rfc7235#section-3.1" class="external-link" target="_blank">RFC 7235</a>, <a href="https://datatracker.ietf.org/doc/html/rfc9110#name-401-unauthorized" class="external-link" target="_blank">RFC 9110</a>.
+
+Pero si por alguna razón tus clientes dependen del comportamiento anterior, puedes volver a él sobrescribiendo el método `make_not_authenticated_error` en tus clases de seguridad.
+
+Por ejemplo, puedes crear una subclase de `HTTPBearer` que devuelva un error `403 Forbidden` en lugar del `401 Unauthorized` por defecto:
+
+{* ../../docs_src/authentication_error_status_code/tutorial001_an_py39.py hl[9:13] *}
+
+/// tip | Consejo
+
+Ten en cuenta que la función devuelve la instance de la excepción, no la lanza. El lanzamiento se hace en el resto del código interno.
+
+///

docs/es/docs/how-to/conditional-openapi.md

@@ -1,8 +1,8 @@
-# OpenAPI Condicional
+# OpenAPI condicional { #conditional-openapi }
 
 Si lo necesitaras, podrías usar configuraciones y variables de entorno para configurar OpenAPI condicionalmente según el entorno, e incluso desactivarlo por completo.
 
-## Sobre seguridad, APIs y documentación
+## Sobre seguridad, APIs y documentación { #about-security-apis-and-docs }
 
 Ocultar las interfaces de usuario de la documentación en producción *no debería* ser la forma de proteger tu API.
 
@@ -17,13 +17,13 @@ Si quieres asegurar tu API, hay varias cosas mejores que puedes hacer, por ejemp
 * Asegúrate de tener modelos Pydantic bien definidos para tus request bodies y responses.
 * Configura los permisos y roles necesarios usando dependencias.
 * Nunca guardes contraseñas en texto plano, solo hashes de contraseñas.
-* Implementa y utiliza herramientas criptográficas bien conocidas, como Passlib y JWT tokens, etc.
-* Añade controles de permisos más detallados con OAuth2 scopes donde sea necesario.
+* Implementa y utiliza herramientas criptográficas bien conocidas, como pwdlib y JWT tokens, etc.
+* Añade controles de permisos más detallados con Scopes de OAuth2 donde sea necesario.
 * ...etc.
 
 No obstante, podrías tener un caso de uso muy específico donde realmente necesites desactivar la documentación de la API para algún entorno (por ejemplo, para producción) o dependiendo de configuraciones de variables de entorno.
 
-## OpenAPI condicional desde configuraciones y variables de entorno
+## OpenAPI condicional desde configuraciones y variables de entorno { #conditional-openapi-from-settings-and-env-vars }
 
 Puedes usar fácilmente las mismas configuraciones de Pydantic para configurar tu OpenAPI generado y las interfaces de usuario de la documentación.
 
@@ -31,7 +31,7 @@ Por ejemplo:
 
 {* ../../docs_src/conditional_openapi/tutorial001.py hl[6,11] *}
 
-Aquí declaramos la configuración `openapi_url` con el mismo valor predeterminado de `"/openapi.json"`.
+Aquí declaramos la configuración `openapi_url` con el mismo valor por defecto de `"/openapi.json"`.
 
 Y luego la usamos al crear la app de `FastAPI`.
 

docs/es/docs/how-to/configure-swagger-ui.md

@@ -1,4 +1,4 @@
-# Configurar Swagger UI
+# Configurar Swagger UI { #configure-swagger-ui }
 
 Puedes configurar algunos <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">parámetros adicionales de Swagger UI</a>.
 
@@ -8,7 +8,7 @@ Para configurarlos, pasa el argumento `swagger_ui_parameters` al crear el objeto
 
 FastAPI convierte las configuraciones a **JSON** para hacerlas compatibles con JavaScript, ya que eso es lo que Swagger UI necesita.
 
-## Desactivar el resaltado de sintaxis
+## Desactivar el resaltado de sintaxis { #disable-syntax-highlighting }
 
 Por ejemplo, podrías desactivar el resaltado de sintaxis en Swagger UI.
 
@@ -24,7 +24,7 @@ Pero puedes desactivarlo estableciendo `syntaxHighlight` en `False`:
 
 <img src="/img/tutorial/extending-openapi/image03.png">
 
-## Cambiar el tema
+## Cambiar el tema { #change-the-theme }
 
 De la misma manera, podrías configurar el tema del resaltado de sintaxis con la clave `"syntaxHighlight.theme"` (ten en cuenta que tiene un punto en el medio):
 
@@ -34,13 +34,13 @@ Esa configuración cambiaría el tema de color del resaltado de sintaxis:
 
 <img src="/img/tutorial/extending-openapi/image04.png">
 
-## Cambiar los parámetros predeterminados de Swagger UI
+## Cambiar los parámetros predeterminados de Swagger UI { #change-default-swagger-ui-parameters }
 
 FastAPI incluye algunos parámetros de configuración predeterminados apropiados para la mayoría de los casos de uso.
 
 Incluye estas configuraciones predeterminadas:
 
-{* ../../fastapi/openapi/docs.py ln[8:23] hl[17:23] *}
+{* ../../fastapi/openapi/docs.py ln[9:24] hl[18:24] *}
 
 Puedes sobrescribir cualquiera de ellos estableciendo un valor diferente en el argumento `swagger_ui_parameters`.
 
@@ -48,11 +48,11 @@ Por ejemplo, para desactivar `deepLinking` podrías pasar estas configuraciones
 
 {* ../../docs_src/configure_swagger_ui/tutorial003.py hl[3] *}
 
-## Otros parámetros de Swagger UI
+## Otros parámetros de Swagger UI { #other-swagger-ui-parameters }
 
 Para ver todas las demás configuraciones posibles que puedes usar, lee la <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">documentación oficial de los parámetros de Swagger UI</a>.
 
-## Configuraciones solo de JavaScript
+## Configuraciones solo de JavaScript { #javascript-only-settings }
 
 Swagger UI también permite otras configuraciones que son objetos **solo de JavaScript** (por ejemplo, funciones de JavaScript).
 

docs/es/docs/how-to/custom-docs-ui-assets.md

@@ -1,26 +1,26 @@
-# Recursos Estáticos Personalizados para la Docs UI (Self-Hosting)
+# Recursos Estáticos Personalizados para la Docs UI (self hosting) { #custom-docs-ui-static-assets-self-hosting }
 
 La documentación de la API utiliza **Swagger UI** y **ReDoc**, y cada uno de estos necesita algunos archivos JavaScript y CSS.
 
-Por defecto, esos archivos se sirven desde un <abbr title="Content Delivery Network: Un servicio, normalmente compuesto de varios servidores, que proporciona archivos estáticos, como JavaScript y CSS. Se utiliza comúnmente para servir esos archivos desde el servidor más cercano al cliente, mejorando el rendimiento.">CDN</abbr>.
+Por defecto, esos archivos se sirven desde un <abbr title="Content Delivery Network – Red de entrega de contenidos: Un servicio, normalmente compuesto de varios servidores, que proporciona archivos estáticos, como JavaScript y CSS. Se usa comúnmente para servir esos archivos desde el servidor más cercano al cliente, mejorando el rendimiento.">CDN</abbr>.
 
 Pero es posible personalizarlo, puedes establecer un CDN específico, o servir los archivos tú mismo.
 
-## CDN Personalizado para JavaScript y CSS
+## CDN Personalizado para JavaScript y CSS { #custom-cdn-for-javascript-and-css }
 
-Digamos que quieres usar un <abbr title="Content Delivery Network">CDN</abbr> diferente, por ejemplo, quieres usar `https://unpkg.com/`.
+Digamos que quieres usar un <abbr title="Content Delivery Network – Red de entrega de contenidos">CDN</abbr> diferente, por ejemplo, quieres usar `https://unpkg.com/`.
 
 Esto podría ser útil si, por ejemplo, vives en un país que restringe algunas URLs.
 
-### Desactiva la documentación automática
+### Desactiva la documentación automática { #disable-the-automatic-docs }
 
-El primer paso es desactivar la documentación automática, ya que por defecto, esos usan el CDN predeterminado.
+El primer paso es desactivar la documentación automática, ya que por defecto, esos usan el CDN por defecto.
 
 Para desactivarlos, establece sus URLs en `None` cuando crees tu aplicación de `FastAPI`:
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[8] *}
 
-### Incluye la documentación personalizada
+### Incluye la documentación personalizada { #include-the-custom-docs }
 
 Ahora puedes crear las *path operations* para la documentación personalizada.
 
@@ -28,7 +28,7 @@ Puedes reutilizar las funciones internas de FastAPI para crear las páginas HTML
 
 * `openapi_url`: la URL donde la página HTML para la documentación puede obtener el OpenAPI esquema de tu API. Puedes usar aquí el atributo `app.openapi_url`.
 * `title`: el título de tu API.
-* `oauth2_redirect_url`: puedes usar `app.swagger_ui_oauth2_redirect_url` aquí para usar el valor predeterminado.
+* `oauth2_redirect_url`: puedes usar `app.swagger_ui_oauth2_redirect_url` aquí para usar el valor por defecto.
 * `swagger_js_url`: la URL donde el HTML para tu documentación de Swagger UI puede obtener el archivo **JavaScript**. Esta es la URL personalizada del CDN.
 * `swagger_css_url`: la URL donde el HTML para tu documentación de Swagger UI puede obtener el archivo **CSS**. Esta es la URL personalizada del CDN.
 
@@ -46,23 +46,23 @@ Swagger UI lo manejará detrás de escena para ti, pero necesita este auxiliar d
 
 ///
 
-### Crea una *path operation* para probarlo
+### Crea una *path operation* para probarlo { #create-a-path-operation-to-test-it }
 
 Ahora, para poder probar que todo funciona, crea una *path operation*:
 
 {* ../../docs_src/custom_docs_ui/tutorial001.py hl[36:38] *}
 
-### Pruébalo
+### Pruébalo { #test-it }
 
 Ahora, deberías poder ir a tu documentación en <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, y recargar la página, cargará esos recursos desde el nuevo CDN.
 
-## Self-hosting de JavaScript y CSS para la documentación
+## self hosting de JavaScript y CSS para la documentación { #self-hosting-javascript-and-css-for-docs }
 
-El self-hosting de JavaScript y CSS podría ser útil si, por ejemplo, necesitas que tu aplicación siga funcionando incluso offline, sin acceso a Internet, o en una red local.
+El self hosting de JavaScript y CSS podría ser útil si, por ejemplo, necesitas que tu aplicación siga funcionando incluso offline, sin acceso a Internet, o en una red local.
 
 Aquí verás cómo servir esos archivos tú mismo, en la misma aplicación de FastAPI, y configurar la documentación para usarla.
 
-### Estructura de archivos del proyecto
+### Estructura de archivos del proyecto { #project-file-structure }
 
 Supongamos que la estructura de archivos de tu proyecto se ve así:
 
@@ -85,7 +85,7 @@ Tu nueva estructura de archivos podría verse así:
 └── static/
 ```
 
-### Descarga los archivos
+### Descarga los archivos { #download-the-files }
 
 Descarga los archivos estáticos necesarios para la documentación y ponlos en ese directorio `static/`.
 
@@ -113,14 +113,14 @@ Después de eso, tu estructura de archivos podría verse así:
     └── swagger-ui.css
 ```
 
-### Sirve los archivos estáticos
+### Sirve los archivos estáticos { #serve-the-static-files }
 
 * Importa `StaticFiles`.
 * "Monta" una instance de `StaticFiles()` en un path específico.
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[7,11] *}
 
-### Prueba los archivos estáticos
+### Prueba los archivos estáticos { #test-the-static-files }
 
 Inicia tu aplicación y ve a <a href="http://127.0.0.1:8000/static/redoc.standalone.js" class="external-link" target="_blank">http://127.0.0.1:8000/static/redoc.standalone.js</a>.
 
@@ -138,7 +138,7 @@ Eso confirma que puedes servir archivos estáticos desde tu aplicación, y que c
 
 Ahora podemos configurar la aplicación para usar esos archivos estáticos para la documentación.
 
-### Desactiva la documentación automática para archivos estáticos
+### Desactiva la documentación automática para archivos estáticos { #disable-the-automatic-docs-for-static-files }
 
 Igual que cuando usas un CDN personalizado, el primer paso es desactivar la documentación automática, ya que esos usan el CDN por defecto.
 
@@ -146,7 +146,7 @@ Para desactivarlos, establece sus URLs en `None` cuando crees tu aplicación de
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[9] *}
 
-### Incluye la documentación personalizada para archivos estáticos
+### Incluye la documentación personalizada para archivos estáticos { #include-the-custom-docs-for-static-files }
 
 Y de la misma manera que con un CDN personalizado, ahora puedes crear las *path operations* para la documentación personalizada.
 
@@ -154,7 +154,7 @@ Nuevamente, puedes reutilizar las funciones internas de FastAPI para crear las p
 
 * `openapi_url`: la URL donde la página HTML para la documentación puede obtener el OpenAPI esquema de tu API. Puedes usar aquí el atributo `app.openapi_url`.
 * `title`: el título de tu API.
-* `oauth2_redirect_url`: puedes usar `app.swagger_ui_oauth2_redirect_url` aquí para usar el valor predeterminado.
+* `oauth2_redirect_url`: puedes usar `app.swagger_ui_oauth2_redirect_url` aquí para usar el valor por defecto.
 * `swagger_js_url`: la URL donde el HTML para tu documentación de Swagger UI puede obtener el archivo **JavaScript**. **Este es el que tu propia aplicación está sirviendo ahora**.
 * `swagger_css_url`: la URL donde el HTML para tu documentación de Swagger UI puede obtener el archivo **CSS**. **Este es el que tu propia aplicación está sirviendo ahora**.
 
@@ -172,13 +172,13 @@ Swagger UI lo manejará detrás de escena para ti, pero necesita este auxiliar d
 
 ///
 
-### Crea una *path operation* para probar archivos estáticos
+### Crea una *path operation* para probar archivos estáticos { #create-a-path-operation-to-test-static-files }
 
 Ahora, para poder probar que todo funciona, crea una *path operation*:
 
 {* ../../docs_src/custom_docs_ui/tutorial002.py hl[39:41] *}
 
-### Prueba la UI de Archivos Estáticos
+### Prueba la UI de Archivos Estáticos { #test-static-files-ui }
 
 Ahora, deberías poder desconectar tu WiFi, ir a tu documentación en <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, y recargar la página.
 

docs/es/docs/how-to/custom-request-and-route.md

@@ -1,4 +1,4 @@
-# Clase personalizada de Request y APIRoute
+# Clase personalizada de Request y APIRoute { #custom-request-and-apiroute-class }
 
 En algunos casos, puede que quieras sobrescribir la lógica utilizada por las clases `Request` y `APIRoute`.
 
@@ -14,7 +14,7 @@ Si apenas estás comenzando con **FastAPI**, quizás quieras saltar esta secció
 
 ///
 
-## Casos de uso
+## Casos de uso { #use-cases }
 
 Algunos casos de uso incluyen:
 
@@ -22,13 +22,13 @@ Algunos casos de uso incluyen:
 * Descomprimir cuerpos de requests comprimidos con gzip.
 * Registrar automáticamente todos los request bodies.
 
-## Manejo de codificaciones personalizadas de request body
+## Manejo de codificaciones personalizadas de request body { #handling-custom-request-body-encodings }
 
 Veamos cómo hacer uso de una subclase personalizada de `Request` para descomprimir requests gzip.
 
 Y una subclase de `APIRoute` para usar esa clase de request personalizada.
 
-### Crear una clase personalizada `GzipRequest`
+### Crear una clase personalizada `GzipRequest` { #create-a-custom-gziprequest-class }
 
 /// tip | Consejo
 
@@ -42,9 +42,9 @@ Si no hay `gzip` en el header, no intentará descomprimir el cuerpo.
 
 De esa manera, la misma clase de ruta puede manejar requests comprimidos con gzip o no comprimidos.
 
-{* ../../docs_src/custom_request_and_route/tutorial001.py hl[8:15] *}
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[9:16] *}
 
-### Crear una clase personalizada `GzipRoute`
+### Crear una clase personalizada `GzipRoute` { #create-a-custom-gziproute-class }
 
 A continuación, creamos una subclase personalizada de `fastapi.routing.APIRoute` que hará uso de `GzipRequest`.
 
@@ -54,7 +54,7 @@ Este método devuelve una función. Y esa función es la que recibirá un reques
 
 Aquí lo usamos para crear un `GzipRequest` a partir del request original.
 
-{* ../../docs_src/custom_request_and_route/tutorial001.py hl[18:26] *}
+{* ../../docs_src/custom_request_and_route/tutorial001_an_py310.py hl[19:27] *}
 
 /// note | Detalles técnicos
 
@@ -78,7 +78,7 @@ Después de eso, toda la lógica de procesamiento es la misma.
 
 Pero debido a nuestros cambios en `GzipRequest.body`, el request body se descomprimirá automáticamente cuando sea cargado por **FastAPI** si es necesario.
 
-## Accediendo al request body en un manejador de excepciones
+## Accediendo al request body en un manejador de excepciones { #accessing-the-request-body-in-an-exception-handler }
 
 /// tip | Consejo
 
@@ -92,18 +92,18 @@ También podemos usar este mismo enfoque para acceder al request body en un mane
 
 Todo lo que necesitamos hacer es manejar el request dentro de un bloque `try`/`except`:
 
-{* ../../docs_src/custom_request_and_route/tutorial002.py hl[13,15] *}
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[14,16] *}
 
 Si ocurre una excepción, la `Request instance` aún estará en el alcance, así que podemos leer y hacer uso del request body cuando manejamos el error:
 
-{* ../../docs_src/custom_request_and_route/tutorial002.py hl[16:18] *}
+{* ../../docs_src/custom_request_and_route/tutorial002_an_py310.py hl[17:19] *}
 
-## Clase personalizada `APIRoute` en un router
+## Clase personalizada `APIRoute` en un router { #custom-apiroute-class-in-a-router }
 
 También puedes establecer el parámetro `route_class` de un `APIRouter`:
 
-{* ../../docs_src/custom_request_and_route/tutorial003.py hl[26] *}
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[26] *}
 
 En este ejemplo, las *path operations* bajo el `router` usarán la clase personalizada `TimedRoute`, y tendrán un header `X-Response-Time` extra en el response con el tiempo que tomó generar el response:
 
-{* ../../docs_src/custom_request_and_route/tutorial003.py hl[13:20] *}
+{* ../../docs_src/custom_request_and_route/tutorial003_py310.py hl[13:20] *}

docs/es/docs/how-to/extending-openapi.md

@@ -1,10 +1,10 @@
-# Extender OpenAPI
+# Extender OpenAPI { #extending-openapi }
 
 Hay algunos casos en los que podrías necesitar modificar el esquema de OpenAPI generado.
 
 En esta sección verás cómo hacerlo.
 
-## El proceso normal
+## El proceso normal { #the-normal-process }
 
 El proceso normal (por defecto) es el siguiente.
 
@@ -33,31 +33,31 @@ El parámetro `summary` está disponible en OpenAPI 3.1.0 y versiones superiores
 
 ///
 
-## Sobrescribir los valores por defecto
+## Sobrescribir los valores por defecto { #overriding-the-defaults }
 
 Usando la información anterior, puedes usar la misma función de utilidad para generar el esquema de OpenAPI y sobrescribir cada parte que necesites.
 
 Por ejemplo, vamos a añadir <a href="https://github.com/Rebilly/ReDoc/blob/master/docs/redoc-vendor-extensions.md#x-logo" class="external-link" target="_blank">la extensión OpenAPI de ReDoc para incluir un logo personalizado</a>.
 
-### **FastAPI** normal
+### **FastAPI** normal { #normal-fastapi }
 
 Primero, escribe toda tu aplicación **FastAPI** como normalmente:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[1,4,7:9] *}
 
-### Generar el esquema de OpenAPI
+### Generar el esquema de OpenAPI { #generate-the-openapi-schema }
 
 Luego, usa la misma función de utilidad para generar el esquema de OpenAPI, dentro de una función `custom_openapi()`:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[2,15:21] *}
 
-### Modificar el esquema de OpenAPI
+### Modificar el esquema de OpenAPI { #modify-the-openapi-schema }
 
 Ahora puedes añadir la extensión de ReDoc, agregando un `x-logo` personalizado al "objeto" `info` en el esquema de OpenAPI:
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[22:24] *}
 
-### Cachear el esquema de OpenAPI
+### Cachear el esquema de OpenAPI { #cache-the-openapi-schema }
 
 Puedes usar la propiedad `.openapi_schema` como un "cache", para almacenar tu esquema generado.
 
@@ -67,13 +67,13 @@ Se generará solo una vez, y luego se usará el mismo esquema cacheado para las
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *}
 
-### Sobrescribir el método
+### Sobrescribir el método { #override-the-method }
 
 Ahora puedes reemplazar el método `.openapi()` por tu nueva función.
 
 {* ../../docs_src/extending_openapi/tutorial001.py hl[29] *}
 
-### Revisa
+### Revisa { #check-it }
 
 Una vez que vayas a <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> verás que estás usando tu logo personalizado (en este ejemplo, el logo de **FastAPI**):
 

docs/es/docs/how-to/general.md

@@ -1,39 +1,39 @@
-# General - Cómo Hacer - Recetas
+# General - Cómo Hacer - Recetas { #general-how-to-recipes }
 
 Aquí tienes varias indicaciones hacia otros lugares en la documentación, para preguntas generales o frecuentes.
 
-## Filtrar Datos - Seguridad
+## Filtrar Datos - Seguridad { #filter-data-security }
 
 Para asegurarte de que no devuelves más datos de los que deberías, lee la documentación para [Tutorial - Modelo de Response - Tipo de Retorno](../tutorial/response-model.md){.internal-link target=_blank}.
 
-## Etiquetas de Documentación - OpenAPI
+## Etiquetas de Documentación - OpenAPI { #documentation-tags-openapi }
 
 Para agregar etiquetas a tus *path operations*, y agruparlas en la interfaz de usuario de la documentación, lee la documentación para [Tutorial - Configuraciones de Path Operation - Etiquetas](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
 
-## Resumen y Descripción de Documentación - OpenAPI
+## Resumen y Descripción de Documentación - OpenAPI { #documentation-summary-and-description-openapi }
 
 Para agregar un resumen y descripción a tus *path operations*, y mostrarlos en la interfaz de usuario de la documentación, lee la documentación para [Tutorial - Configuraciones de Path Operation - Resumen y Descripción](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
 
-## Documentación de Descripción de Response - OpenAPI
+## Documentación de Descripción de Response - OpenAPI { #documentation-response-description-openapi }
 
 Para definir la descripción del response, mostrada en la interfaz de usuario de la documentación, lee la documentación para [Tutorial - Configuraciones de Path Operation - Descripción del Response](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
 
-## Documentar la Deprecación de una *Path Operation* - OpenAPI
+## Documentar la Deprecación de una *Path Operation* - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
 
 Para deprecar una *path operation*, y mostrarla en la interfaz de usuario de la documentación, lee la documentación para [Tutorial - Configuraciones de Path Operation - Deprecación](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
 
-## Convertir cualquier Dato a Compatible con JSON
+## Convertir cualquier Dato a Compatible con JSON { #convert-any-data-to-json-compatible }
 
 Para convertir cualquier dato a compatible con JSON, lee la documentación para [Tutorial - Codificador Compatible con JSON](../tutorial/encoder.md){.internal-link target=_blank}.
 
-## Metadatos OpenAPI - Documentación
+## Metadatos OpenAPI - Documentación { #openapi-metadata-docs }
 
 Para agregar metadatos a tu esquema de OpenAPI, incluyendo una licencia, versión, contacto, etc, lee la documentación para [Tutorial - Metadatos y URLs de Documentación](../tutorial/metadata.md){.internal-link target=_blank}.
 
-## URL Personalizada de OpenAPI
+## URL Personalizada de OpenAPI { #openapi-custom-url }
 
 Para personalizar la URL de OpenAPI (o eliminarla), lee la documentación para [Tutorial - Metadatos y URLs de Documentación](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
 
-## URLs de Documentación de OpenAPI
+## URLs de Documentación de OpenAPI { #openapi-docs-urls }
 
 Para actualizar las URLs usadas para las interfaces de usuario de documentación generadas automáticamente, lee la documentación para [Tutorial - Metadatos y URLs de Documentación](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.

docs/es/docs/how-to/graphql.md

@@ -1,4 +1,4 @@
-# GraphQL
+# GraphQL { #graphql }
 
 Como **FastAPI** se basa en el estándar **ASGI**, es muy fácil integrar cualquier paquete de **GraphQL** que también sea compatible con ASGI.
 
@@ -14,7 +14,7 @@ Asegúrate de evaluar si los **beneficios** para tu caso de uso compensan los **
 
 ///
 
-## Paquetes de GraphQL
+## Paquetes de GraphQL { #graphql-libraries }
 
 Aquí algunos de los paquetes de **GraphQL** que tienen soporte **ASGI**. Podrías usarlos con **FastAPI**:
 
@@ -27,7 +27,7 @@ Aquí algunos de los paquetes de **GraphQL** que tienen soporte **ASGI**. Podrí
 * <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>
     * Con <a href="https://github.com/ciscorn/starlette-graphene3" class="external-link" target="_blank">starlette-graphene3</a>
 
-## GraphQL con Strawberry
+## GraphQL con Strawberry { #graphql-with-strawberry }
 
 Si necesitas o quieres trabajar con **GraphQL**, <a href="https://strawberry.rocks/" class="external-link" target="_blank">**Strawberry**</a> es el paquete **recomendado** ya que tiene un diseño muy similar al diseño de **FastAPI**, todo basado en **anotaciones de tipos**.
 
@@ -35,13 +35,13 @@ Dependiendo de tu caso de uso, podrías preferir usar un paquete diferente, pero
 
 Aquí tienes una pequeña vista previa de cómo podrías integrar Strawberry con FastAPI:
 
-{* ../../docs_src/graphql/tutorial001.py hl[3,22,25:26] *}
+{* ../../docs_src/graphql/tutorial001.py hl[3,22,25] *}
 
 Puedes aprender más sobre Strawberry en la <a href="https://strawberry.rocks/" class="external-link" target="_blank">documentación de Strawberry</a>.
 
 Y también la documentación sobre <a href="https://strawberry.rocks/docs/integrations/fastapi" class="external-link" target="_blank">Strawberry con FastAPI</a>.
 
-## `GraphQLApp` viejo de Starlette
+## `GraphQLApp` viejo de Starlette { #older-graphqlapp-from-starlette }
 
 Las versiones anteriores de Starlette incluían una clase `GraphQLApp` para integrar con <a href="https://graphene-python.org/" class="external-link" target="_blank">Graphene</a>.
 
@@ -53,7 +53,7 @@ Si necesitas GraphQL, aún te recomendaría revisar <a href="https://strawberry.
 
 ///
 
-## Aprende Más
+## Aprende Más { #learn-more }
 
 Puedes aprender más sobre **GraphQL** en la <a href="https://graphql.org/" class="external-link" target="_blank">documentación oficial de GraphQL</a>.
 

docs/es/docs/how-to/index.md

@@ -1,4 +1,4 @@
-# How To - Recetas
+# Cómo hacer - Recetas { #how-to-recipes }
 
 Aquí verás diferentes recetas o guías de "cómo hacer" para **varios temas**.
 
@@ -8,6 +8,6 @@ Si algo parece interesante y útil para tu proyecto, adelante y revísalo, pero
 
 /// tip | Consejo
 
-Si quieres **aprender FastAPI** de una manera estructurada (recomendado), ve y lee el [Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} capítulo por capítulo.
+Si quieres **aprender FastAPI** de una manera estructurada (recomendado), ve y lee el [Tutorial - Guía de Usuario](../tutorial/index.md){.internal-link target=_blank} capítulo por capítulo en su lugar.
 
 ///

docs/es/docs/how-to/migrate-from-pydantic-v1-to-pydantic-v2.md

@@ -0,0 +1,133 @@
+# Migra de Pydantic v1 a Pydantic v2 { #migrate-from-pydantic-v1-to-pydantic-v2 }
+
+Si tienes una app de FastAPI antigua, podrías estar usando Pydantic versión 1.
+
+FastAPI ha tenido compatibilidad con Pydantic v1 o v2 desde la versión 0.100.0.
+
+Si tenías instalado Pydantic v2, lo usaba. Si en cambio tenías Pydantic v1, usaba ese.
+
+Pydantic v1 está deprecado y su soporte se eliminará en las próximas versiones de FastAPI, deberías migrar a Pydantic v2. Así obtendrás las funcionalidades, mejoras y correcciones más recientes.
+
+/// warning | Advertencia
+
+Además, el equipo de Pydantic dejó de dar soporte a Pydantic v1 para las versiones más recientes de Python, comenzando con Python 3.14.
+
+Si quieres usar las funcionalidades más recientes de Python, tendrás que asegurarte de usar Pydantic v2.
+
+///
+
+Si tienes una app de FastAPI antigua con Pydantic v1, aquí te muestro cómo migrarla a Pydantic v2 y las nuevas funcionalidades en FastAPI 0.119.0 para ayudarte con una migración gradual.
+
+## Guía oficial { #official-guide }
+
+Pydantic tiene una <a href="https://docs.pydantic.dev/latest/migration/" class="external-link" target="_blank">Guía de migración</a> oficial de v1 a v2.
+
+También incluye qué cambió, cómo las validaciones ahora son más correctas y estrictas, posibles consideraciones, etc.
+
+Puedes leerla para entender mejor qué cambió.
+
+## Tests { #tests }
+
+Asegúrate de tener [tests](../tutorial/testing.md){.internal-link target=_blank} para tu app y de ejecutarlos en integración continua (CI).
+
+Así podrás hacer la actualización y asegurarte de que todo sigue funcionando como esperas.
+
+## `bump-pydantic` { #bump-pydantic }
+
+En muchos casos, cuando usas modelos de Pydantic normales sin personalizaciones, podrás automatizar gran parte del proceso de migración de Pydantic v1 a Pydantic v2.
+
+Puedes usar <a href="https://github.com/pydantic/bump-pydantic" class="external-link" target="_blank">`bump-pydantic`</a> del mismo equipo de Pydantic.
+
+Esta herramienta te ayudará a cambiar automáticamente la mayor parte del código que necesita cambiarse.
+
+Después de esto, puedes ejecutar los tests y revisa si todo funciona. Si es así, ya terminaste. 😎
+
+## Pydantic v1 en v2 { #pydantic-v1-in-v2 }
+
+Pydantic v2 incluye todo lo de Pydantic v1 como un submódulo `pydantic.v1`.
+
+Esto significa que puedes instalar la versión más reciente de Pydantic v2 e importar y usar los componentes viejos de Pydantic v1 desde ese submódulo, como si tuvieras instalado el Pydantic v1 antiguo.
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial001_an_py310.py hl[1,4] *}
+
+### Compatibilidad de FastAPI con Pydantic v1 en v2 { #fastapi-support-for-pydantic-v1-in-v2 }
+
+Desde FastAPI 0.119.0, también hay compatibilidad parcial para Pydantic v1 desde dentro de Pydantic v2, para facilitar la migración a v2.
+
+Así que podrías actualizar Pydantic a la última versión 2 y cambiar los imports para usar el submódulo `pydantic.v1`, y en muchos casos simplemente funcionaría.
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial002_an_py310.py hl[2,5,15] *}
+
+/// warning | Advertencia
+
+Ten en cuenta que, como el equipo de Pydantic ya no da soporte a Pydantic v1 en versiones recientes de Python, empezando por Python 3.14, usar `pydantic.v1` tampoco está soportado en Python 3.14 y superiores.
+
+///
+
+### Pydantic v1 y v2 en la misma app { #pydantic-v1-and-v2-on-the-same-app }
+
+No está soportado por Pydantic tener un modelo de Pydantic v2 con sus propios campos definidos como modelos de Pydantic v1 o viceversa.
+
+```mermaid
+graph TB
+    subgraph "❌ Not Supported"
+        direction TB
+        subgraph V2["Pydantic v2 Model"]
+            V1Field["Pydantic v1 Model"]
+        end
+        subgraph V1["Pydantic v1 Model"]
+            V2Field["Pydantic v2 Model"]
+        end
+    end
+
+    style V2 fill:#f9fff3
+    style V1 fill:#fff6f0
+    style V1Field fill:#fff6f0
+    style V2Field fill:#f9fff3
+```
+
+...pero puedes tener modelos separados usando Pydantic v1 y v2 en la misma app.
+
+```mermaid
+graph TB
+    subgraph "✅ Supported"
+        direction TB
+        subgraph V2["Pydantic v2 Model"]
+            V2Field["Pydantic v2 Model"]
+        end
+        subgraph V1["Pydantic v1 Model"]
+            V1Field["Pydantic v1 Model"]
+        end
+    end
+
+    style V2 fill:#f9fff3
+    style V1 fill:#fff6f0
+    style V1Field fill:#fff6f0
+    style V2Field fill:#f9fff3
+```
+
+En algunos casos, incluso es posible tener modelos de Pydantic v1 y v2 en la misma path operation de tu app de FastAPI:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
+
+En el ejemplo anterior, el modelo de entrada es un modelo de Pydantic v1 y el modelo de salida (definido en `response_model=ItemV2`) es un modelo de Pydantic v2.
+
+### Parámetros de Pydantic v1 { #pydantic-v1-parameters }
+
+Si necesitas usar algunas de las herramientas específicas de FastAPI para parámetros como `Body`, `Query`, `Form`, etc. con modelos de Pydantic v1, puedes importarlas de `fastapi.temp_pydantic_v1_params` mientras terminas la migración a Pydantic v2:
+
+{* ../../docs_src/pydantic_v1_in_v2/tutorial004_an_py310.py hl[4,18] *}
+
+### Migra por pasos { #migrate-in-steps }
+
+/// tip | Consejo
+
+Primero prueba con `bump-pydantic`; si tus tests pasan y eso funciona, entonces terminaste con un solo comando. ✨
+
+///
+
+Si `bump-pydantic` no funciona para tu caso, puedes usar la compatibilidad de modelos Pydantic v1 y v2 en la misma app para hacer la migración a Pydantic v2 de forma gradual.
+
+Podrías primero actualizar Pydantic para usar la última versión 2 y cambiar los imports para usar `pydantic.v1` para todos tus modelos.
+
+Luego puedes empezar a migrar tus modelos de Pydantic v1 a v2 por grupos, en pasos graduales. 🚶

docs/es/docs/how-to/separate-openapi-schemas.md

@@ -1,4 +1,4 @@
-# Separación de Esquemas OpenAPI para Entrada y Salida o No
+# Separación de Esquemas OpenAPI para Entrada y Salida o No { #separate-openapi-schemas-for-input-and-output-or-not }
 
 Al usar **Pydantic v2**, el OpenAPI generado es un poco más exacto y **correcto** que antes. 😎
 
@@ -6,13 +6,13 @@ De hecho, en algunos casos, incluso tendrá **dos JSON Schemas** en OpenAPI para
 
 Veamos cómo funciona eso y cómo cambiarlo si necesitas hacerlo.
 
-## Modelos Pydantic para Entrada y Salida
+## Modelos Pydantic para Entrada y Salida { #pydantic-models-for-input-and-output }
 
 Digamos que tienes un modelo Pydantic con valores por defecto, como este:
 
 {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py ln[1:7] hl[7] *}
 
-### Modelo para Entrada
+### Modelo para Entrada { #model-for-input }
 
 Si usas este modelo como entrada, como aquí:
 
@@ -20,7 +20,7 @@ Si usas este modelo como entrada, como aquí:
 
 ...entonces el campo `description` **no será requerido**. Porque tiene un valor por defecto de `None`.
 
-### Modelo de Entrada en la Documentación
+### Modelo de Entrada en la Documentación { #input-model-in-docs }
 
 Puedes confirmar eso en la documentación, el campo `description` no tiene un **asterisco rojo**, no está marcado como requerido:
 
@@ -28,7 +28,7 @@ Puedes confirmar eso en la documentación, el campo `description` no tiene un **
 <img src="/img/tutorial/separate-openapi-schemas/image01.png">
 </div>
 
-### Modelo para Salida
+### Modelo para Salida { #model-for-output }
 
 Pero si usas el mismo modelo como salida, como aquí:
 
@@ -36,7 +36,7 @@ Pero si usas el mismo modelo como salida, como aquí:
 
 ...entonces, porque `description` tiene un valor por defecto, si **no devuelves nada** para ese campo, aún tendrá ese **valor por defecto**.
 
-### Modelo para Datos de Response de Salida
+### Modelo para Datos de Response de Salida { #model-for-output-response-data }
 
 Si interactúas con la documentación y revisas el response, aunque el código no agregó nada en uno de los campos `description`, el response JSON contiene el valor por defecto (`null`):
 
@@ -46,7 +46,7 @@ Si interactúas con la documentación y revisas el response, aunque el código n
 
 Esto significa que **siempre tendrá un valor**, solo que a veces el valor podría ser `None` (o `null` en JSON).
 
-Eso significa que, los clientes que usan tu API no tienen que comprobar si el valor existe o no, pueden **asumir que el campo siempre estará allí**, pero solo que en algunos casos tendrá el valor por defecto de `None`.
+Eso significa que, los clientes que usan tu API no tienen que revisar si el valor existe o no, pueden **asumir que el campo siempre estará allí**, pero solo que en algunos casos tendrá el valor por defecto de `None`.
 
 La forma de describir esto en OpenAPI es marcar ese campo como **requerido**, porque siempre estará allí.
 
@@ -55,7 +55,7 @@ Debido a eso, el JSON Schema para un modelo puede ser diferente dependiendo de s
 * para **entrada** el `description` **no será requerido**
 * para **salida** será **requerido** (y posiblemente `None`, o en términos de JSON, `null`)
 
-### Modelo para Salida en la Documentación
+### Modelo para Salida en la Documentación { #model-for-output-in-docs }
 
 También puedes revisar el modelo de salida en la documentación, **ambos** `name` y `description` están marcados como **requeridos** con un **asterisco rojo**:
 
@@ -63,7 +63,7 @@ También puedes revisar el modelo de salida en la documentación, **ambos** `nam
 <img src="/img/tutorial/separate-openapi-schemas/image03.png">
 </div>
 
-### Modelo para Entrada y Salida en la Documentación
+### Modelo para Entrada y Salida en la Documentación { #model-for-input-and-output-in-docs }
 
 Y si revisas todos los esquemas disponibles (JSON Schemas) en OpenAPI, verás que hay dos, uno `Item-Input` y uno `Item-Output`.
 
@@ -77,7 +77,7 @@ Pero para `Item-Output`, `description` **es requerido**, tiene un asterisco rojo
 
 Con esta funcionalidad de **Pydantic v2**, la documentación de tu API es más **precisa**, y si tienes clientes y SDKs autogenerados, también serán más precisos, con una mejor **experiencia para desarrolladores** y consistencia. 🎉
 
-## No Separar Esquemas
+## No Separar Esquemas { #do-not-separate-schemas }
 
 Ahora, hay algunos casos donde podrías querer tener el **mismo esquema para entrada y salida**.
 
@@ -93,12 +93,12 @@ El soporte para `separate_input_output_schemas` fue agregado en FastAPI `0.102.0
 
 {* ../../docs_src/separate_openapi_schemas/tutorial002_py310.py hl[10] *}
 
-### Mismo Esquema para Modelos de Entrada y Salida en la Documentación
+### Mismo Esquema para Modelos de Entrada y Salida en la Documentación { #same-schema-for-input-and-output-models-in-docs }
 
 Y ahora habrá un único esquema para entrada y salida para el modelo, solo `Item`, y tendrá `description` como **no requerido**:
 
 <div class="screenshot">
-<img src="/img/tutorial/separate_openapi_schemas/image05.png">
+<img src="/img/tutorial/separate-openapi-schemas/image05.png">
 </div>
 
 Este es el mismo comportamiento que en Pydantic v1. 🤓

docs/es/docs/how-to/testing-database.md

@@ -1,4 +1,4 @@
-# Probando una Base de Datos
+# Probando una Base de Datos { #testing-a-database }
 
 Puedes estudiar sobre bases de datos, SQL y SQLModel en la <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">documentación de SQLModel</a>. 🤓
 

docs/es/docs/index.md

@@ -1,11 +1,11 @@
-# FastAPI
+# FastAPI { #fastapi }
 
 <style>
 .md-content .md-typeset h1 { display: none; }
 </style>
 
 <p align="center">
-  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+  <a href="https://fastapi.tiangolo.com/es"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
 </p>
 <p align="center">
     <em>FastAPI framework, alto rendimiento, fácil de aprender, rápido de programar, listo para producción</em>
@@ -27,7 +27,7 @@
 
 ---
 
-**Documentación**: <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
+**Documentación**: <a href="https://fastapi.tiangolo.com/es" target="_blank">https://fastapi.tiangolo.com</a>
 
 **Código Fuente**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
 
@@ -35,12 +35,12 @@
 
 FastAPI es un framework web moderno, rápido (de alto rendimiento), para construir APIs con Python basado en las anotaciones de tipos estándar de Python.
 
-Las características clave son:
+Las funcionalidades clave son:
 
 * **Rápido**: Muy alto rendimiento, a la par con **NodeJS** y **Go** (gracias a Starlette y Pydantic). [Uno de los frameworks Python más rápidos disponibles](#performance).
 * **Rápido de programar**: Aumenta la velocidad para desarrollar funcionalidades en aproximadamente un 200% a 300%. *
 * **Menos bugs**: Reduce en aproximadamente un 40% los errores inducidos por humanos (desarrolladores). *
-* **Intuitivo**: Gran soporte para editores. <abbr title="también conocido como autocompletado, IntelliSense">Autocompletado</abbr> en todas partes. Menos tiempo depurando.
+* **Intuitivo**: Gran soporte para editores. <abbr title="también conocido como auto-complete, autocompletado, IntelliSense">Autocompletado</abbr> en todas partes. Menos tiempo depurando.
 * **Fácil**: Diseñado para ser fácil de usar y aprender. Menos tiempo leyendo documentación.
 * **Corto**: Minimiza la duplicación de código. Múltiples funcionalidades desde cada declaración de parámetro. Menos bugs.
 * **Robusto**: Obtén código listo para producción. Con documentación interactiva automática.
@@ -48,24 +48,30 @@ Las características clave son:
 
 <small>* estimación basada en pruebas con un equipo de desarrollo interno, construyendo aplicaciones de producción.</small>
 
-## Sponsors
+## Sponsors { #sponsors }
 
 <!-- sponsors -->
 
-{% if sponsors %}
+### Sponsor Keystone { #keystone-sponsor }
+
+{% for sponsor in sponsors.keystone -%}
+<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
+{% endfor -%}
+
+### Sponsors Oro y Plata { #gold-and-silver-sponsors }
+
 {% for sponsor in sponsors.gold -%}
 <a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
 {% endfor -%}
 {%- for sponsor in sponsors.silver -%}
 <a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
 {% endfor %}
-{% endif %}
 
 <!-- /sponsors -->
 
-<a href="https://fastapi.tiangolo.com/fastapi-people/#sponsors" class="external-link" target="_blank">Otros sponsors</a>
+<a href="https://fastapi.tiangolo.com/es/fastapi-people/#sponsors" class="external-link" target="_blank">Otros sponsors</a>
 
-## Opiniones
+## Opiniones { #opinions }
 
 "_[...] Estoy usando **FastAPI** un montón estos días. [...] De hecho, estoy planeando usarlo para todos los servicios de **ML de mi equipo en Microsoft**. Algunos de ellos se están integrando en el núcleo del producto **Windows** y algunos productos de **Office**._"
 
@@ -111,24 +117,24 @@ Las características clave son:
 
 ---
 
-## **Typer**, el FastAPI de las CLIs
+## **Typer**, el FastAPI de las CLIs { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
 
-Si estás construyendo una aplicación de <abbr title="Interfaz de Línea de Comandos">CLI</abbr> para ser usada en el terminal en lugar de una API web, revisa <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+Si estás construyendo una aplicación de <abbr title="Command Line Interface – Interfaz de Línea de Comandos">CLI</abbr> para ser usada en la terminal en lugar de una API web, revisa <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
 
 **Typer** es el hermano pequeño de FastAPI. Y está destinado a ser el **FastAPI de las CLIs**. ⌨️ 🚀
 
-## Requisitos
+## Requisitos { #requirements }
 
 FastAPI se apoya en hombros de gigantes:
 
 * <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> para las partes web.
 * <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> para las partes de datos.
 
-## Instalación
+## Instalación { #installation }
 
-Crea y activa un <a href="https://fastapi.tiangolo.com/virtual-environments/" class="external-link" target="_blank">entorno virtual</a> y luego instala FastAPI:
+Crea y activa un <a href="https://fastapi.tiangolo.com/es/virtual-environments/" class="external-link" target="_blank">entorno virtual</a> y luego instala FastAPI:
 
 <div class="termy">
 
@@ -142,11 +148,11 @@ $ pip install "fastapi[standard]"
 
 **Nota**: Asegúrate de poner `"fastapi[standard]"` entre comillas para asegurar que funcione en todas las terminales.
 
-## Ejemplo
+## Ejemplo { #example }
 
-### Créalo
+### Créalo { #create-it }
 
-* Crea un archivo `main.py` con:
+Crea un archivo `main.py` con:
 
 ```Python
 from typing import Union
@@ -191,11 +197,11 @@ async def read_item(item_id: int, q: Union[str, None] = None):
 
 **Nota**:
 
-Si no lo sabes, revisa la sección _"¿Con prisa?"_ sobre <a href="https://fastapi.tiangolo.com/async/#in-a-hurry" target="_blank">`async` y `await` en la documentación</a>.
+Si no lo sabes, revisa la sección _"¿Con prisa?"_ sobre <a href="https://fastapi.tiangolo.com/es/async/#in-a-hurry" target="_blank">`async` y `await` en la documentación</a>.
 
 </details>
 
-### Córrelo
+### Córrelo { #run-it }
 
 Corre el servidor con:
 
@@ -233,11 +239,11 @@ El comando `fastapi dev` lee tu archivo `main.py`, detecta la app **FastAPI** en
 
 Por defecto, `fastapi dev` comenzará con auto-recarga habilitada para el desarrollo local.
 
-Puedes leer más sobre esto en la <a href="https://fastapi.tiangolo.com/fastapi-cli/" target="_blank">documentación del CLI de FastAPI</a>.
+Puedes leer más sobre esto en la <a href="https://fastapi.tiangolo.com/es/fastapi-cli/" target="_blank">documentación del CLI de FastAPI</a>.
 
 </details>
 
-### Revísalo
+### Revísalo { #check-it }
 
 Abre tu navegador en <a href="http://127.0.0.1:8000/items/5?q=somequery" class="external-link" target="_blank">http://127.0.0.1:8000/items/5?q=somequery</a>.
 
@@ -254,7 +260,7 @@ Ya creaste una API que:
 * El _path_ `/items/{item_id}` tiene un _parámetro de path_ `item_id` que debe ser un `int`.
 * El _path_ `/items/{item_id}` tiene un _parámetro de query_ `q` opcional que es un `str`.
 
-### Documentación interactiva de la API
+### Documentación interactiva de la API { #interactive-api-docs }
 
 Ahora ve a <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -262,7 +268,7 @@ Verás la documentación interactiva automática de la API (proporcionada por <a
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Documentación de API Alternativa
+### Documentación de API Alternativa { #alternative-api-docs }
 
 Y ahora, ve a <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -270,7 +276,7 @@ Verás la documentación alternativa automática (proporcionada por <a href="htt
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Actualización del Ejemplo
+## Actualización del Ejemplo { #example-upgrade }
 
 Ahora modifica el archivo `main.py` para recibir un body desde un request `PUT`.
 
@@ -308,7 +314,7 @@ def update_item(item_id: int, item: Item):
 
 El servidor `fastapi dev` debería recargarse automáticamente.
 
-### Actualización de la Documentación Interactiva de la API
+### Actualización de la Documentación Interactiva de la API { #interactive-api-docs-upgrade }
 
 Ahora ve a <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -324,7 +330,7 @@ Ahora ve a <a href="http://127.0.0.1:8000/docs" class="external-link" target="_b
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
 
-### Actualización de la Documentación Alternativa de la API
+### Actualización de la Documentación Alternativa de la API { #alternative-api-docs-upgrade }
 
 Y ahora, ve a <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
@@ -332,7 +338,7 @@ Y ahora, ve a <a href="http://127.0.0.1:8000/redoc" class="external-link" target
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Resumen
+### Resumen { #recap }
 
 En resumen, declaras **una vez** los tipos de parámetros, body, etc. como parámetros de función.
 
@@ -427,7 +433,7 @@ Intenta cambiar la línea con:
 
 ![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
 
-Para un ejemplo más completo incluyendo más funcionalidades, ve al <a href="https://fastapi.tiangolo.com/tutorial/">Tutorial - Guía del Usuario</a>.
+Para un ejemplo más completo incluyendo más funcionalidades, ve al <a href="https://fastapi.tiangolo.com/es/tutorial/">Tutorial - Guía del Usuario</a>.
 
 **Alerta de spoilers**: el tutorial - guía del usuario incluye:
 
@@ -444,17 +450,69 @@ Para un ejemplo más completo incluyendo más funcionalidades, ve al <a href="ht
     * **Sesiones de Cookies**
     * ...y más.
 
-## Rendimiento
+### Despliega tu app (opcional) { #deploy-your-app-optional }
+
+Opcionalmente puedes desplegar tu app de FastAPI en <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, ve y únete a la lista de espera si no lo has hecho. 🚀
+
+Si ya tienes una cuenta de **FastAPI Cloud** (te invitamos desde la lista de espera 😉), puedes desplegar tu aplicación con un solo comando.
+
+Antes de desplegar, asegúrate de haber iniciado sesión:
+
+<div class="termy">
+
+```console
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+Luego despliega tu app:
+
+<div class="termy">
+
+```console
+$ fastapi deploy
+
+Deploying to FastAPI Cloud...
+
+✅ Deployment successful!
+
+🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
+```
+
+</div>
+
+¡Eso es todo! Ahora puedes acceder a tu app en esa URL. ✨
+
+#### Acerca de FastAPI Cloud { #about-fastapi-cloud }
+
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** está construido por el mismo autor y equipo detrás de **FastAPI**.
+
+Optimiza el proceso de **construir**, **desplegar** y **acceder** a una API con un esfuerzo mínimo.
+
+Trae la misma **experiencia de desarrollador** de construir apps con FastAPI a **desplegarlas** en la nube. 🎉
+
+FastAPI Cloud es el sponsor principal y proveedor de financiamiento para los proyectos open source *FastAPI and friends*. ✨
+
+#### Despliega en otros proveedores de cloud { #deploy-to-other-cloud-providers }
+
+FastAPI es open source y está basado en estándares. Puedes desplegar apps de FastAPI en cualquier proveedor de cloud que elijas.
+
+Sigue las guías de tu proveedor de cloud para desplegar apps de FastAPI con ellos. 🤓
+
+## Rendimiento { #performance }
 
 Benchmarks independientes de TechEmpower muestran aplicaciones **FastAPI** ejecutándose bajo Uvicorn como <a href="https://www.techempower.com/benchmarks/#section=test&runid=7464e520-0dc2-473d-bd34-dbdfd7e85911&hw=ph&test=query&l=zijzen-7" class="external-link" target="_blank">uno de los frameworks Python más rápidos disponibles</a>, solo por debajo de Starlette y Uvicorn (usados internamente por FastAPI). (*)
 
-Para entender más sobre esto, ve la sección <a href="https://fastapi.tiangolo.com/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
+Para entender más sobre esto, ve la sección <a href="https://fastapi.tiangolo.com/es/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
 
-## Dependencias
+## Dependencias { #dependencies }
 
 FastAPI depende de Pydantic y Starlette.
 
-### Dependencias `standard`
+### Dependencias `standard` { #standard-dependencies }
 
 Cuando instalas FastAPI con `pip install "fastapi[standard]"` viene con el grupo `standard` de dependencias opcionales:
 
@@ -465,19 +523,24 @@ Usadas por Pydantic:
 Usadas por Starlette:
 
 * <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Requerido si deseas usar el `TestClient`.
-* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Requerido si deseas usar la configuración de plantilla predeterminada.
+* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Requerido si deseas usar la configuración de plantilla por defecto.
 * <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Requerido si deseas soportar <abbr title="convertir el string que viene de un request HTTP en datos de Python">"parsing"</abbr> de forms, con `request.form()`.
 
-Usadas por FastAPI / Starlette:
+Usadas por FastAPI:
 
 * <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - para el servidor que carga y sirve tu aplicación. Esto incluye `uvicorn[standard]`, que incluye algunas dependencias (por ejemplo, `uvloop`) necesarias para servir con alto rendimiento.
-* `fastapi-cli` - para proporcionar el comando `fastapi`.
+* `fastapi-cli[standard]` - para proporcionar el comando `fastapi`.
+    * Esto incluye `fastapi-cloud-cli`, que te permite desplegar tu aplicación de FastAPI en <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
 
-### Sin Dependencias `standard`
+### Sin Dependencias `standard` { #without-standard-dependencies }
 
 Si no deseas incluir las dependencias opcionales `standard`, puedes instalar con `pip install fastapi` en lugar de `pip install "fastapi[standard]"`.
 
-### Dependencias Opcionales Adicionales
+### Sin `fastapi-cloud-cli` { #without-fastapi-cloud-cli }
+
+Si quieres instalar FastAPI con las dependencias standard pero sin `fastapi-cloud-cli`, puedes instalar con `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+
+### Dependencias Opcionales Adicionales { #additional-optional-dependencies }
 
 Existen algunas dependencias adicionales que podrías querer instalar.
 
@@ -491,6 +554,6 @@ Dependencias opcionales adicionales de FastAPI:
 * <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Requerido si deseas usar `ORJSONResponse`.
 * <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Requerido si deseas usar `UJSONResponse`.
 
-## Licencia
+## Licencia { #license }
 
 Este proyecto tiene licencia bajo los términos de la licencia MIT.

docs/es/docs/learn/index.md

@@ -1,4 +1,4 @@
-# Aprende
+# Aprende { #learn }
 
 Aquí están las secciones introductorias y los tutoriales para aprender **FastAPI**.
 

docs/es/docs/project-generation.md

@@ -1,4 +1,4 @@
-# Plantilla Full Stack FastAPI
+# Plantilla Full Stack FastAPI { #full-stack-fastapi-template }
 
 Las plantillas, aunque normalmente vienen con una configuración específica, están diseñadas para ser flexibles y personalizables. Esto te permite modificarlas y adaptarlas a los requisitos de tu proyecto, haciéndolas un excelente punto de partida. 🏁
 
@@ -6,23 +6,23 @@ Puedes usar esta plantilla para comenzar, ya que incluye gran parte de la config
 
 Repositorio de GitHub: <a href="https://github.com/tiangolo/full-stack-fastapi-template" class="external-link" target="_blank">Plantilla Full Stack FastAPI</a>
 
-## Plantilla Full Stack FastAPI - Tecnología y Funcionalidades
+## Plantilla Full Stack FastAPI - Tecnología y Funcionalidades { #full-stack-fastapi-template-technology-stack-and-features }
 
-- ⚡ [**FastAPI**](https://fastapi.tiangolo.com) para la API del backend en Python.
+- ⚡ [**FastAPI**](https://fastapi.tiangolo.com/es) para la API del backend en Python.
     - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) para las interacciones con bases de datos SQL en Python (ORM).
     - 🔍 [Pydantic](https://docs.pydantic.dev), utilizado por FastAPI, para la validación de datos y gestión de configuraciones.
     - 💾 [PostgreSQL](https://www.postgresql.org) como base de datos SQL.
 - 🚀 [React](https://react.dev) para el frontend.
     - 💃 Usando TypeScript, hooks, [Vite](https://vitejs.dev), y otras partes de una stack moderna de frontend.
-    - 🎨 [Chakra UI](https://chakra-ui.com) para los componentes del frontend.
+    - 🎨 [Tailwind CSS](https://tailwindcss.com) y [shadcn/ui](https://ui.shadcn.com) para los componentes del frontend.
     - 🤖 Un cliente de frontend generado automáticamente.
-    - 🧪 [Playwright](https://playwright.dev) para pruebas End-to-End.
+    - 🧪 [Playwright](https://playwright.dev) para escribir pruebas End-to-End.
     - 🦇 Soporte para modo oscuro.
 - 🐋 [Docker Compose](https://www.docker.com) para desarrollo y producción.
 - 🔒 Hashing seguro de contraseñas por defecto.
 - 🔑 Autenticación con tokens JWT.
 - 📫 Recuperación de contraseñas basada en email.
 - ✅ Pruebas con [Pytest](https://pytest.org).
-- 📞 [Traefik](https://traefik.io) como proxy inverso / balanceador de carga.
+- 📞 [Traefik](https://traefik.io) como proxy inverso / load balancer.
 - 🚢 Instrucciones de despliegue usando Docker Compose, incluyendo cómo configurar un proxy Traefik frontend para manejar certificados HTTPS automáticos.
 - 🏭 CI (integración continua) y CD (despliegue continuo) basados en GitHub Actions.

docs/es/docs/python-types.md

@@ -1,4 +1,4 @@
-# Introducción a Tipos en Python
+# Introducción a Tipos en Python { #python-types-intro }
 
 Python tiene soporte para "anotaciones de tipos" opcionales (también llamadas "type hints").
 
@@ -18,7 +18,7 @@ Si eres un experto en Python, y ya sabes todo sobre las anotaciones de tipos, sa
 
 ///
 
-## Motivación
+## Motivación { #motivation }
 
 Comencemos con un ejemplo simple:
 
@@ -38,7 +38,7 @@ La función hace lo siguiente:
 
 {* ../../docs_src/python_types/tutorial001.py hl[2] *}
 
-### Edítalo
+### Edítalo { #edit-it }
 
 Es un programa muy simple.
 
@@ -58,7 +58,7 @@ Pero, tristemente, no obtienes nada útil:
 
 <img src="/img/python-types/image01.png">
 
-### Añadir tipos
+### Añadir tipos { #add-types }
 
 Modifiquemos una sola línea de la versión anterior.
 
@@ -102,7 +102,7 @@ Con eso, puedes desplazarte, viendo las opciones, hasta que encuentres la que "t
 
 <img src="/img/python-types/image03.png">
 
-## Más motivación
+## Más motivación { #more-motivation }
 
 Revisa esta función, ya tiene anotaciones de tipos:
 
@@ -116,13 +116,13 @@ Ahora sabes que debes corregirlo, convertir `age` a un string con `str(age)`:
 
 {* ../../docs_src/python_types/tutorial004.py hl[2] *}
 
-## Declaración de tipos
+## Declaración de tipos { #declaring-types }
 
 Acabas de ver el lugar principal para declarar anotaciones de tipos. Como parámetros de función.
 
 Este también es el lugar principal donde los utilizarías con **FastAPI**.
 
-### Tipos simples
+### Tipos simples { #simple-types }
 
 Puedes declarar todos los tipos estándar de Python, no solo `str`.
 
@@ -135,7 +135,7 @@ Puedes usar, por ejemplo:
 
 {* ../../docs_src/python_types/tutorial005.py hl[1] *}
 
-### Tipos genéricos con parámetros de tipo
+### Tipos genéricos con parámetros de tipo { #generic-types-with-type-parameters }
 
 Hay algunas estructuras de datos que pueden contener otros valores, como `dict`, `list`, `set` y `tuple`. Y los valores internos también pueden tener su propio tipo.
 
@@ -143,7 +143,7 @@ Estos tipos que tienen tipos internos se denominan tipos "**genéricos**". Y es
 
 Para declarar esos tipos y los tipos internos, puedes usar el módulo estándar de Python `typing`. Existe específicamente para soportar estas anotaciones de tipos.
 
-#### Versiones más recientes de Python
+#### Versiones más recientes de Python { #newer-versions-of-python }
 
 La sintaxis que utiliza `typing` es **compatible** con todas las versiones, desde Python 3.6 hasta las versiones más recientes, incluyendo Python 3.9, Python 3.10, etc.
 
@@ -157,7 +157,7 @@ Por ejemplo, "**Python 3.6+**" significa que es compatible con Python 3.6 o supe
 
 Si puedes usar las **últimas versiones de Python**, utiliza los ejemplos para la última versión, esos tendrán la **mejor y más simple sintaxis**, por ejemplo, "**Python 3.10+**".
 
-#### Lista
+#### Lista { #list }
 
 Por ejemplo, vamos a definir una variable para ser una `list` de `str`.
 
@@ -221,7 +221,7 @@ Nota que la variable `item` es uno de los elementos en la lista `items`.
 
 Y aún así, el editor sabe que es un `str` y proporciona soporte para eso.
 
-#### Tuple y Set
+#### Tuple y Set { #tuple-and-set }
 
 Harías lo mismo para declarar `tuple`s y `set`s:
 
@@ -246,7 +246,7 @@ Esto significa:
 * La variable `items_t` es un `tuple` con 3 ítems, un `int`, otro `int`, y un `str`.
 * La variable `items_s` es un `set`, y cada uno de sus ítems es del tipo `bytes`.
 
-#### Dict
+#### Dict { #dict }
 
 Para definir un `dict`, pasas 2 parámetros de tipo, separados por comas.
 
@@ -276,7 +276,7 @@ Esto significa:
     * Las claves de este `dict` son del tipo `str` (digamos, el nombre de cada ítem).
     * Los valores de este `dict` son del tipo `float` (digamos, el precio de cada ítem).
 
-#### Union
+#### Union { #union }
 
 Puedes declarar que una variable puede ser cualquier de **varios tipos**, por ejemplo, un `int` o un `str`.
 
@@ -302,7 +302,7 @@ En Python 3.10 también hay una **nueva sintaxis** donde puedes poner los posibl
 
 En ambos casos, esto significa que `item` podría ser un `int` o un `str`.
 
-#### Posiblemente `None`
+#### Posiblemente `None` { #possibly-none }
 
 Puedes declarar que un valor podría tener un tipo, como `str`, pero que también podría ser `None`.
 
@@ -334,7 +334,7 @@ Esto también significa que en Python 3.10, puedes usar `Something | None`:
 
 ////
 
-//// tab | Python 3.8+ alternative
+//// tab | Python 3.8+ alternativa
 
 ```Python hl_lines="1  4"
 {!> ../../docs_src/python_types/tutorial009b.py!}
@@ -342,7 +342,7 @@ Esto también significa que en Python 3.10, puedes usar `Something | None`:
 
 ////
 
-#### Uso de `Union` u `Optional`
+#### Uso de `Union` u `Optional` { #using-union-or-optional }
 
 Si estás usando una versión de Python inferior a 3.10, aquí tienes un consejo desde mi punto de vista muy **subjetivo**:
 
@@ -377,7 +377,7 @@ La buena noticia es que, una vez que estés en Python 3.10, no tendrás que preo
 
 Y entonces no tendrás que preocuparte por nombres como `Optional` y `Union`. 😎
 
-#### Tipos genéricos
+#### Tipos genéricos { #generic-types }
 
 Estos tipos que toman parámetros de tipo en corchetes se llaman **Tipos Genéricos** o **Genéricos**, por ejemplo:
 
@@ -429,7 +429,7 @@ Y lo mismo que con Python 3.8, desde el módulo `typing`:
 
 ////
 
-### Clases como tipos
+### Clases como tipos { #classes-as-types }
 
 También puedes declarar una clase como el tipo de una variable.
 
@@ -449,7 +449,7 @@ Nota que esto significa "`one_person` es una **instance** de la clase `Person`".
 
 No significa "`one_person` es la **clase** llamada `Person`".
 
-## Modelos Pydantic
+## Modelos Pydantic { #pydantic-models }
 
 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> es un paquete de Python para realizar la validación de datos.
 
@@ -503,13 +503,13 @@ Pydantic tiene un comportamiento especial cuando utilizas `Optional` o `Union[So
 
 ///
 
-## Anotaciones de tipos con metadata
+## Anotaciones de tipos con metadata { #type-hints-with-metadata-annotations }
 
-Python también tiene una funcionalidad que permite poner **<abbr title="Datos sobre los datos, en este caso, información sobre el tipo, por ejemplo, una descripción.">metadata</abbr> adicional** en estas anotaciones de tipos usando `Annotated`.
+Python también tiene una funcionalidad que permite poner **<abbr title="Datos sobre los datos, en este caso, información sobre el tipo, por ejemplo, una descripción.">metadatos</abbr> adicional** en estas anotaciones de tipos usando `Annotated`.
 
 //// tab | Python 3.9+
 
-En Python 3.9, `Annotated` es parte de la librería estándar, así que puedes importarlo desde `typing`.
+En Python 3.9, `Annotated` es parte de la standard library, así que puedes importarlo desde `typing`.
 
 ```Python hl_lines="1  4"
 {!> ../../docs_src/python_types/tutorial013_py39.py!}
@@ -547,7 +547,7 @@ Y también que tu código será muy compatible con muchas otras herramientas y p
 
 ///
 
-## Anotaciones de tipos en **FastAPI**
+## Anotaciones de tipos en **FastAPI** { #type-hints-in-fastapi }
 
 **FastAPI** aprovecha estas anotaciones de tipos para hacer varias cosas.
 

docs/es/docs/resources/index.md

@@ -1,3 +1,3 @@
-# Recursos
+# Recursos { #resources }
 
-Recursos adicionales, enlaces externos, artículos y más. ✈️
+Recursos adicionales, enlaces externos y más. ✈️

docs/es/docs/tutorial/bigger-applications.md

@@ -1,4 +1,4 @@
-# Aplicaciones más grandes - Múltiples archivos
+# Aplicaciones más grandes - Múltiples archivos { #bigger-applications-multiple-files }
 
 Si estás construyendo una aplicación o una API web, rara vez podrás poner todo en un solo archivo.
 
@@ -10,7 +10,7 @@ Si vienes de Flask, esto sería el equivalente a los Blueprints de Flask.
 
 ///
 
-## Un ejemplo de estructura de archivos
+## Un ejemplo de estructura de archivos { #an-example-file-structure }
 
 Digamos que tienes una estructura de archivos como esta:
 
@@ -71,7 +71,7 @@ La misma estructura de archivos con comentarios:
 │       └── admin.py     # submódulo "admin", por ejemplo import app.internal.admin
 ```
 
-## `APIRouter`
+## `APIRouter` { #apirouter }
 
 Digamos que el archivo dedicado solo a manejar usuarios es el submódulo en `/app/routers/users.py`.
 
@@ -81,23 +81,19 @@ Pero todavía es parte de la misma aplicación/web API de **FastAPI** (es parte
 
 Puedes crear las *path operations* para ese módulo usando `APIRouter`.
 
-### Importar `APIRouter`
+### Importar `APIRouter` { #import-apirouter }
 
 Lo importas y creas una "instance" de la misma manera que lo harías con la clase `FastAPI`:
 
-```Python hl_lines="1  3" title="app/routers/users.py"
-{!../../docs_src/bigger_applications/app/routers/users.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
 
-### *Path operations* con `APIRouter`
+### *Path operations* con `APIRouter` { #path-operations-with-apirouter }
 
 Y luego lo usas para declarar tus *path operations*.
 
 Úsalo de la misma manera que usarías la clase `FastAPI`:
 
-```Python hl_lines="6  11  16" title="app/routers/users.py"
-{!../../docs_src/bigger_applications/app/routers/users.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
 
 Puedes pensar en `APIRouter` como una clase "mini `FastAPI`".
 
@@ -113,53 +109,25 @@ En este ejemplo, la variable se llama `router`, pero puedes nombrarla como quier
 
 Vamos a incluir este `APIRouter` en la aplicación principal de `FastAPI`, pero primero, revisemos las dependencias y otro `APIRouter`.
 
-## Dependencias
+## Dependencias { #dependencies }
 
 Vemos que vamos a necesitar algunas dependencias usadas en varios lugares de la aplicación.
 
 Así que las ponemos en su propio módulo `dependencies` (`app/dependencies.py`).
 
-Ahora utilizaremos una dependencia simple para leer un encabezado `X-Token` personalizado:
+Ahora utilizaremos una dependencia simple para leer un header `X-Token` personalizado:
 
-//// tab | Python 3.9+
-
-```Python hl_lines="3  6-8" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app_an_py39/dependencies.py!}
-```
-
-////
-
-//// tab | Python 3.8+
-
-```Python hl_lines="1  5-7" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app_an/dependencies.py!}
-```
-
-////
-
-//// tab | Python 3.8+ non-Annotated
+{* ../../docs_src/bigger_applications/app_an_py39/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
 
 /// tip | Consejo
 
-Preferiblemente usa la versión `Annotated` si es posible.
-
-///
-
-```Python hl_lines="1  4-6" title="app/dependencies.py"
-{!> ../../docs_src/bigger_applications/app/dependencies.py!}
-```
-
-////
-
-/// tip | Consejo
-
-Estamos usando un encabezado inventado para simplificar este ejemplo.
+Estamos usando un header inventado para simplificar este ejemplo.
 
 Pero en casos reales obtendrás mejores resultados usando las [utilidades de Seguridad](security/index.md){.internal-link target=_blank} integradas.
 
 ///
 
-## Otro módulo con `APIRouter`
+## Otro módulo con `APIRouter` { #another-module-with-apirouter }
 
 Digamos que también tienes los endpoints dedicados a manejar "items" de tu aplicación en el módulo `app/routers/items.py`.
 
@@ -181,9 +149,7 @@ Sabemos que todas las *path operations* en este módulo tienen el mismo:
 
 Entonces, en lugar de agregar todo eso a cada *path operation*, podemos agregarlo al `APIRouter`.
 
-```Python hl_lines="5-10  16  21" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
 
 Como el path de cada *path operation* tiene que empezar con `/`, como en:
 
@@ -234,7 +200,7 @@ Los parámetros `prefix`, `tags`, `responses`, y `dependencies` son (como en muc
 
 ///
 
-### Importar las dependencias
+### Importar las dependencias { #import-the-dependencies }
 
 Este código vive en el módulo `app.routers.items`, el archivo `app/routers/items.py`.
 
@@ -242,11 +208,9 @@ Y necesitamos obtener la función de dependencia del módulo `app.dependencies`,
 
 Así que usamos un import relativo con `..` para las dependencias:
 
-```Python hl_lines="3" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[3] title["app/routers/items.py"] *}
 
-#### Cómo funcionan los imports relativos
+#### Cómo funcionan los imports relativos { #how-relative-imports-work }
 
 /// tip | Consejo
 
@@ -309,15 +273,13 @@ Eso se referiría a algún paquete arriba de `app/`, con su propio archivo `__in
 
 Pero ahora sabes cómo funciona, para que puedas usar imports relativos en tus propias aplicaciones sin importar cuán complejas sean. 🤓
 
-### Agregar algunos `tags`, `responses`, y `dependencies` personalizados
+### Agregar algunos `tags`, `responses`, y `dependencies` personalizados { #add-some-custom-tags-responses-and-dependencies }
 
 No estamos agregando el prefijo `/items` ni los `tags=["items"]` a cada *path operation* porque los hemos añadido al `APIRouter`.
 
 Pero aún podemos agregar _más_ `tags` que se aplicarán a una *path operation* específica, y también algunas `responses` extra específicas para esa *path operation*:
 
-```Python hl_lines="30-31" title="app/routers/items.py"
-{!../../docs_src/bigger_applications/app/routers/items.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[30:31] title["app/routers/items.py"] *}
 
 /// tip | Consejo
 
@@ -327,7 +289,7 @@ Y también tendrá ambas responses en la documentación, una para `404` y otra p
 
 ///
 
-## El `FastAPI` principal
+## El `FastAPI` principal { #the-main-fastapi }
 
 Ahora, veamos el módulo en `app/main.py`.
 
@@ -335,27 +297,25 @@ Aquí es donde importas y usas la clase `FastAPI`.
 
 Este será el archivo principal en tu aplicación que conecta todo.
 
-### Importar `FastAPI`
+Y como la mayor parte de tu lógica ahora vivirá en su propio módulo específico, el archivo principal será bastante simple.
+
+### Importar `FastAPI` { #import-fastapi }
 
 Importas y creas una clase `FastAPI` como de costumbre.
 
 Y podemos incluso declarar [dependencias globales](dependencies/global-dependencies.md){.internal-link target=_blank} que se combinarán con las dependencias para cada `APIRouter`:
 
-```Python hl_lines="1  3  7" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[1,3,7] title["app/main.py"] *}
 
-### Importar el `APIRouter`
+### Importar el `APIRouter` { #import-the-apirouter }
 
 Ahora importamos los otros submódulos que tienen `APIRouter`s:
 
-```Python hl_lines="4-5" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[4:5] title["app/main.py"] *}
 
 Como los archivos `app/routers/users.py` y `app/routers/items.py` son submódulos que son parte del mismo paquete de Python `app`, podemos usar un solo punto `.` para importarlos usando "imports relativos".
 
-### Cómo funciona la importación
+### Cómo funciona la importación { #how-the-importing-works }
 
 La sección:
 
@@ -397,7 +357,7 @@ Para aprender más sobre Paquetes y Módulos de Python, lee <a href="https://doc
 
 ///
 
-### Evitar colisiones de nombres
+### Evitar colisiones de nombres { #avoid-name-collisions }
 
 Estamos importando el submódulo `items` directamente, en lugar de importar solo su variable `router`.
 
@@ -414,17 +374,13 @@ el `router` de `users` sobrescribiría el de `items` y no podríamos usarlos al
 
 Así que, para poder usar ambos en el mismo archivo, importamos los submódulos directamente:
 
-```Python hl_lines="5" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
 
-### Incluir los `APIRouter`s para `users` y `items`
+### Incluir los `APIRouter`s para `users` y `items` { #include-the-apirouters-for-users-and-items }
 
 Ahora, incluyamos los `router`s de los submódulos `users` y `items`:
 
-```Python hl_lines="10-11" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[10:11] title["app/main.py"] *}
 
 /// info | Información
 
@@ -456,7 +412,7 @@ Así que no afectará el rendimiento. ⚡
 
 ///
 
-### Incluir un `APIRouter` con un `prefix`, `tags`, `responses`, y `dependencies` personalizados
+### Incluir un `APIRouter` con un `prefix`, `tags`, `responses`, y `dependencies` personalizados { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
 
 Ahora, imaginemos que tu organización te dio el archivo `app/internal/admin.py`.
 
@@ -464,17 +420,13 @@ Contiene un `APIRouter` con algunas *path operations* de administración que tu
 
 Para este ejemplo será súper simple. Pero digamos que porque está compartido con otros proyectos en la organización, no podemos modificarlo y agregar un `prefix`, `dependencies`, `tags`, etc. directamente al `APIRouter`:
 
-```Python hl_lines="3" title="app/internal/admin.py"
-{!../../docs_src/bigger_applications/app/internal/admin.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/internal/admin.py hl[3] title["app/internal/admin.py"] *}
 
 Pero aún queremos configurar un `prefix` personalizado al incluir el `APIRouter` para que todas sus *path operations* comiencen con `/admin`, queremos asegurarlo con las `dependencies` que ya tenemos para este proyecto, y queremos incluir `tags` y `responses`.
 
 Podemos declarar todo eso sin tener que modificar el `APIRouter` original pasando esos parámetros a `app.include_router()`:
 
-```Python hl_lines="14-17" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[14:17] title["app/main.py"] *}
 
 De esa manera, el `APIRouter` original permanecerá sin modificar, por lo que aún podemos compartir ese mismo archivo `app/internal/admin.py` con otros proyectos en la organización.
 
@@ -489,15 +441,13 @@ Pero eso solo afectará a ese `APIRouter` en nuestra aplicación, no en ningún
 
 Así, por ejemplo, otros proyectos podrían usar el mismo `APIRouter` con un método de autenticación diferente.
 
-### Incluir una *path operation*
+### Incluir una *path operation* { #include-a-path-operation }
 
 También podemos agregar *path operations* directamente a la aplicación de `FastAPI`.
 
 Aquí lo hacemos... solo para mostrar que podemos 🤷:
 
-```Python hl_lines="21-23" title="app/main.py"
-{!../../docs_src/bigger_applications/app/main.py!}
-```
+{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[21:23] title["app/main.py"] *}
 
 y funcionará correctamente, junto con todas las otras *path operations* añadidas con `app.include_router()`.
 
@@ -515,7 +465,7 @@ Como no podemos simplemente aislarlos y "montarlos" independientemente del resto
 
 ///
 
-## Revisa la documentación automática de la API
+## Revisa la documentación automática de la API { #check-the-automatic-api-docs }
 
 Ahora, ejecuta tu aplicación:
 
@@ -535,7 +485,7 @@ Verás la documentación automática de la API, incluyendo los paths de todos lo
 
 <img src="/img/tutorial/bigger-applications/image01.png">
 
-## Incluir el mismo router múltiples veces con diferentes `prefix`
+## Incluir el mismo router múltiples veces con diferentes `prefix` { #include-the-same-router-multiple-times-with-different-prefix }
 
 También puedes usar `.include_router()` múltiples veces con el *mismo* router usando diferentes prefijos.
 
@@ -543,7 +493,7 @@ Esto podría ser útil, por ejemplo, para exponer la misma API bajo diferentes p
 
 Este es un uso avanzado que quizás no necesites realmente, pero está allí en caso de que lo necesites.
 
-## Incluir un `APIRouter` en otro
+## Incluir un `APIRouter` en otro { #include-an-apirouter-in-another }
 
 De la misma manera que puedes incluir un `APIRouter` en una aplicación `FastAPI`, puedes incluir un `APIRouter` en otro `APIRouter` usando:
 

docs/es/docs/tutorial/body-fields.md

@@ -1,8 +1,8 @@
-# Body - Campos
+# Body - Campos { #body-fields }
 
 De la misma manera que puedes declarar validaciones adicionales y metadatos en los parámetros de las *path operation function* con `Query`, `Path` y `Body`, puedes declarar validaciones y metadatos dentro de los modelos de Pydantic usando `Field` de Pydantic.
 
-## Importar `Field`
+## Importar `Field` { #import-field }
 
 Primero, tienes que importarlo:
 
@@ -14,7 +14,7 @@ Fíjate que `Field` se importa directamente desde `pydantic`, no desde `fastapi`
 
 ///
 
-## Declarar atributos del modelo
+## Declarar atributos del modelo { #declare-model-attributes }
 
 Después puedes utilizar `Field` con los atributos del modelo:
 
@@ -40,7 +40,7 @@ Observa cómo cada atributo del modelo con un tipo, un valor por defecto y `Fiel
 
 ///
 
-## Agregar información extra
+## Agregar información extra { #add-extra-information }
 
 Puedes declarar información extra en `Field`, `Query`, `Body`, etc. Y será incluida en el JSON Schema generado.
 
@@ -53,7 +53,7 @@ Como estas claves no necesariamente tienen que ser parte de la especificación d
 
 ///
 
-## Resumen
+## Resumen { #recap }
 
 Puedes utilizar `Field` de Pydantic para declarar validaciones adicionales y metadatos para los atributos del modelo.
 

docs/es/docs/tutorial/body-multiple-params.md

@@ -1,24 +1,22 @@
-# Cuerpo - Múltiples Parámetros
+# Cuerpo - Múltiples Parámetros { #body-multiple-parameters }
 
 Ahora que hemos visto cómo usar `Path` y `Query`, veamos usos más avanzados de las declaraciones del request body.
 
-## Mezclar `Path`, `Query` y parámetros del cuerpo
+## Mezclar `Path`, `Query` y parámetros del cuerpo { #mix-path-query-and-body-parameters }
 
 Primero, por supuesto, puedes mezclar las declaraciones de parámetros de `Path`, `Query` y del request body libremente y **FastAPI** sabrá qué hacer.
 
-Y también puedes declarar parámetros del cuerpo como opcionales, estableciendo el valor predeterminado a `None`:
+Y también puedes declarar parámetros del cuerpo como opcionales, estableciendo el valor por defecto a `None`:
 
 {* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
 
-## Múltiples parámetros del cuerpo
-
 /// note | Nota
 
 Ten en cuenta que, en este caso, el `item` que se tomaría del cuerpo es opcional. Ya que tiene un valor por defecto de `None`.
 
 ///
 
-## Múltiples parámetros del cuerpo
+## Múltiples parámetros del cuerpo { #multiple-body-parameters }
 
 En el ejemplo anterior, las *path operations* esperarían un cuerpo JSON con los atributos de un `Item`, como:
 
@@ -64,7 +62,7 @@ Ten en cuenta que aunque el `item` se declaró de la misma manera que antes, aho
 
 Realizará la validación de los datos compuestos, y los documentará así para el esquema de OpenAPI y la documentación automática.
 
-## Valores singulares en el cuerpo
+## Valores singulares en el cuerpo { #singular-values-in-body }
 
 De la misma manera que hay un `Query` y `Path` para definir datos extra para parámetros de query y path, **FastAPI** proporciona un equivalente `Body`.
 
@@ -96,7 +94,7 @@ En este caso, **FastAPI** esperará un cuerpo como:
 
 Nuevamente, convertirá los tipos de datos, validará, documentará, etc.
 
-## Múltiples parámetros de cuerpo y query
+## Múltiples parámetros de cuerpo y query { #multiple-body-params-and-query }
 
 Por supuesto, también puedes declarar parámetros adicionales de query siempre que lo necesites, además de cualquier parámetro del cuerpo.
 
@@ -122,7 +120,7 @@ Por ejemplo:
 
 ///
 
-## Embeber un solo parámetro de cuerpo
+## Embeber un solo parámetro de cuerpo { #embed-a-single-body-parameter }
 
 Supongamos que solo tienes un único parámetro de cuerpo `item` de un modelo Pydantic `Item`.
 
@@ -162,7 +160,7 @@ en lugar de:
 }
 ```
 
-## Resumen
+## Resumen { #recap }
 
 Puedes añadir múltiples parámetros de cuerpo a tu *path operation function*, aunque un request solo puede tener un único cuerpo.
 

docs/es/docs/tutorial/body-nested-models.md

@@ -1,8 +1,8 @@
-# Cuerpo - Modelos Anidados
+# Cuerpo - Modelos Anidados { #body-nested-models }
 
 Con **FastAPI**, puedes definir, validar, documentar y usar modelos anidados de manera arbitraria (gracias a Pydantic).
 
-## Campos de lista
+## Campos de lista { #list-fields }
 
 Puedes definir un atributo como un subtipo. Por ejemplo, una `list` en Python:
 
@@ -10,11 +10,11 @@ Puedes definir un atributo como un subtipo. Por ejemplo, una `list` en Python:
 
 Esto hará que `tags` sea una lista, aunque no declare el tipo de los elementos de la lista.
 
-## Campos de lista con parámetro de tipo
+## Campos de lista con parámetro de tipo { #list-fields-with-type-parameter }
 
 Pero Python tiene una forma específica de declarar listas con tipos internos, o "parámetros de tipo":
 
-### Importar `List` de typing
+### Importar `List` de typing { #import-typings-list }
 
 En Python 3.9 y superior, puedes usar el `list` estándar para declarar estas anotaciones de tipo como veremos a continuación. 💡
 
@@ -22,7 +22,7 @@ Pero en versiones de Python anteriores a 3.9 (desde 3.6 en adelante), primero ne
 
 {* ../../docs_src/body_nested_models/tutorial002.py hl[1] *}
 
-### Declarar una `list` con un parámetro de tipo
+### Declarar una `list` con un parámetro de tipo { #declare-a-list-with-a-type-parameter }
 
 Para declarar tipos que tienen parámetros de tipo (tipos internos), como `list`, `dict`, `tuple`:
 
@@ -51,7 +51,7 @@ Así, en nuestro ejemplo, podemos hacer que `tags` sea específicamente una "lis
 
 {* ../../docs_src/body_nested_models/tutorial002_py310.py hl[12] *}
 
-## Tipos de conjunto
+## Tipos de conjunto { #set-types }
 
 Pero luego pensamos en ello, y nos damos cuenta de que los tags no deberían repetirse, probablemente serían strings únicos.
 
@@ -67,7 +67,7 @@ Y siempre que emitas esos datos, incluso si la fuente tenía duplicados, se emit
 
 Y también se anotará/documentará en consecuencia.
 
-## Modelos Anidados
+## Modelos Anidados { #nested-models }
 
 Cada atributo de un modelo Pydantic tiene un tipo.
 
@@ -77,13 +77,13 @@ Así que, puedes declarar "objetos" JSON anidados profundamente con nombres de a
 
 Todo eso, de manera arbitraria.
 
-### Definir un submodelo
+### Definir un submodelo { #define-a-submodel }
 
 Por ejemplo, podemos definir un modelo `Image`:
 
 {* ../../docs_src/body_nested_models/tutorial004_py310.py hl[7:9] *}
 
-### Usar el submodelo como tipo
+### Usar el submodelo como tipo { #use-the-submodel-as-a-type }
 
 Y luego podemos usarlo como el tipo de un atributo:
 
@@ -112,7 +112,7 @@ Nuevamente, haciendo solo esa declaración, con **FastAPI** obtienes:
 * Validación de datos
 * Documentación automática
 
-## Tipos especiales y validación
+## Tipos especiales y validación { #special-types-and-validation }
 
 Además de tipos singulares normales como `str`, `int`, `float`, etc., puedes usar tipos singulares más complejos que heredan de `str`.
 
@@ -124,7 +124,7 @@ Por ejemplo, como en el modelo `Image` tenemos un campo `url`, podemos declararl
 
 El string será verificado para ser una URL válida, y documentado en JSON Schema / OpenAPI como tal.
 
-## Atributos con listas de submodelos
+## Atributos con listas de submodelos { #attributes-with-lists-of-submodels }
 
 También puedes usar modelos Pydantic como subtipos de `list`, `set`, etc.:
 
@@ -162,7 +162,7 @@ Nota cómo la clave `images` ahora tiene una lista de objetos de imagen.
 
 ///
 
-## Modelos anidados profundamente
+## Modelos anidados profundamente { #deeply-nested-models }
 
 Puedes definir modelos anidados tan profundamente como desees:
 
@@ -174,7 +174,7 @@ Observa cómo `Offer` tiene una lista de `Item`s, que a su vez tienen una lista
 
 ///
 
-## Cuerpos de listas puras
+## Cuerpos de listas puras { #bodies-of-pure-lists }
 
 Si el valor superior del cuerpo JSON que esperas es un `array` JSON (una `list` en Python), puedes declarar el tipo en el parámetro de la función, al igual que en los modelos Pydantic:
 
@@ -192,7 +192,7 @@ como en:
 
 {* ../../docs_src/body_nested_models/tutorial008_py39.py hl[13] *}
 
-## Soporte de editor en todas partes
+## Soporte de editor en todas partes { #editor-support-everywhere }
 
 Y obtienes soporte de editor en todas partes.
 
@@ -204,7 +204,7 @@ No podrías obtener este tipo de soporte de editor si estuvieras trabajando dire
 
 Pero tampoco tienes que preocuparte por ellos, los `dicts` entrantes se convierten automáticamente y tu salida se convierte automáticamente a JSON también.
 
-## Cuerpos de `dict`s arbitrarios
+## Cuerpos de `dict`s arbitrarios { #bodies-of-arbitrary-dicts }
 
 También puedes declarar un cuerpo como un `dict` con claves de algún tipo y valores de algún otro tipo.
 
@@ -234,7 +234,7 @@ Y el `dict` que recibas como `weights` tendrá realmente claves `int` y valores
 
 ///
 
-## Resumen
+## Resumen { #recap }
 
 Con **FastAPI** tienes la máxima flexibilidad proporcionada por los modelos Pydantic, manteniendo tu código simple, corto y elegante.
 

docs/es/docs/tutorial/body-updates.md

@@ -1,6 +1,6 @@
-# Cuerpo - Actualizaciones
+# Cuerpo - Actualizaciones { #body-updates }
 
-## Actualización reemplazando con `PUT`
+## Actualización reemplazando con `PUT` { #update-replacing-with-put }
 
 Para actualizar un ítem puedes utilizar la operación de <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
 
@@ -10,7 +10,7 @@ Puedes usar el `jsonable_encoder` para convertir los datos de entrada en datos q
 
 `PUT` se usa para recibir datos que deben reemplazar los datos existentes.
 
-### Advertencia sobre el reemplazo
+### Advertencia sobre el reemplazo { #warning-about-replacing }
 
 Esto significa que si quieres actualizar el ítem `bar` usando `PUT` con un body que contenga:
 
@@ -26,7 +26,7 @@ debido a que no incluye el atributo ya almacenado `"tax": 20.2`, el modelo de en
 
 Y los datos se guardarían con ese "nuevo" `tax` de `10.5`.
 
-## Actualizaciones parciales con `PATCH`
+## Actualizaciones parciales con `PATCH` { #partial-updates-with-patch }
 
 También puedes usar la operación de <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> para actualizar *parcialmente* datos.
 
@@ -44,7 +44,7 @@ Pero esta guía te muestra, más o menos, cómo se pretende que se usen.
 
 ///
 
-### Uso del parámetro `exclude_unset` de Pydantic
+### Uso del parámetro `exclude_unset` de Pydantic { #using-pydantics-exclude-unset-parameter }
 
 Si quieres recibir actualizaciones parciales, es muy útil usar el parámetro `exclude_unset` en el `.model_dump()` del modelo de Pydantic.
 
@@ -64,7 +64,7 @@ Luego puedes usar esto para generar un `dict` solo con los datos que se establec
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
 
-### Uso del parámetro `update` de Pydantic
+### Uso del parámetro `update` de Pydantic { #using-pydantics-update-parameter }
 
 Ahora, puedes crear una copia del modelo existente usando `.model_copy()`, y pasar el parámetro `update` con un `dict` que contenga los datos a actualizar.
 
@@ -80,7 +80,7 @@ Como `stored_item_model.model_copy(update=update_data)`:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
 
-### Resumen de actualizaciones parciales
+### Resumen de actualizaciones parciales { #partial-updates-recap }
 
 En resumen, para aplicar actualizaciones parciales deberías:
 

docs/es/docs/tutorial/body.md

@@ -1,4 +1,4 @@
-# Request Body
+# Request Body { #request-body }
 
 Cuando necesitas enviar datos desde un cliente (digamos, un navegador) a tu API, los envías como un **request body**.
 
@@ -18,13 +18,13 @@ Como no se recomienda, la documentación interactiva con Swagger UI no mostrará
 
 ///
 
-## Importar `BaseModel` de Pydantic
+## Importar `BaseModel` de Pydantic { #import-pydantics-basemodel }
 
 Primero, necesitas importar `BaseModel` de `pydantic`:
 
 {* ../../docs_src/body/tutorial001_py310.py hl[2] *}
 
-## Crea tu modelo de datos
+## Crea tu modelo de datos { #create-your-data-model }
 
 Luego, declaras tu modelo de datos como una clase que hereda de `BaseModel`.
 
@@ -54,7 +54,7 @@ Por ejemplo, el modelo anterior declara un “`object`” JSON (o `dict` en Pyth
 }
 ```
 
-## Decláralo como un parámetro
+## Decláralo como un parámetro { #declare-it-as-a-parameter }
 
 Para añadirlo a tu *path operation*, decláralo de la misma manera que declaraste parámetros de path y query:
 
@@ -62,7 +62,7 @@ Para añadirlo a tu *path operation*, decláralo de la misma manera que declaras
 
 ...y declara su tipo como el modelo que creaste, `Item`.
 
-## Resultados
+## Resultados { #results }
 
 Con solo esa declaración de tipo en Python, **FastAPI** hará lo siguiente:
 
@@ -73,9 +73,9 @@ Con solo esa declaración de tipo en Python, **FastAPI** hará lo siguiente:
 * Proporcionar los datos recibidos en el parámetro `item`.
     * Como lo declaraste en la función como de tipo `Item`, también tendrás todo el soporte del editor (autocompletado, etc.) para todos los atributos y sus tipos.
 * Generar definiciones de <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> para tu modelo, que también puedes usar en cualquier otro lugar si tiene sentido para tu proyecto.
-* Esquemas que serán parte del esquema de OpenAPI generado y usados por la <abbr title="User Interfaces">UIs</abbr> de documentación automática.
+* Esos esquemas serán parte del esquema de OpenAPI generado y usados por las <abbr title="User Interfaces – Interfaces de usuario">UIs</abbr> de documentación automática.
 
-## Documentación automática
+## Documentación automática { #automatic-docs }
 
 Los JSON Schemas de tus modelos serán parte del esquema OpenAPI generado y se mostrarán en la documentación API interactiva:
 
@@ -85,7 +85,7 @@ Y también se utilizarán en la documentación API dentro de cada *path operatio
 
 <img src="/img/tutorial/body/image02.png">
 
-## Soporte del editor
+## Soporte del editor { #editor-support }
 
 En tu editor, dentro de tu función, obtendrás anotaciones de tipos y autocompletado en todas partes (esto no sucedería si recibieras un `dict` en lugar de un modelo de Pydantic):
 
@@ -121,13 +121,21 @@ Mejora el soporte del editor para modelos de Pydantic, con:
 
 ///
 
-## Usa el modelo
+## Usa el modelo { #use-the-model }
 
 Dentro de la función, puedes acceder a todos los atributos del objeto modelo directamente:
 
 {* ../../docs_src/body/tutorial002_py310.py *}
 
-## Request body + parámetros de path
+/// info | Información
+
+En Pydantic v1 el método se llamaba `.dict()`, se marcó como obsoleto (pero sigue soportado) en Pydantic v2, y se renombró a `.model_dump()`.
+
+Los ejemplos aquí usan `.dict()` por compatibilidad con Pydantic v1, pero deberías usar `.model_dump()` si puedes usar Pydantic v2.
+
+///
+
+## Request body + parámetros de path { #request-body-path-parameters }
 
 Puedes declarar parámetros de path y request body al mismo tiempo.
 
@@ -135,7 +143,7 @@ Puedes declarar parámetros de path y request body al mismo tiempo.
 
 {* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
 
-## Request body + path + parámetros de query
+## Request body + path + parámetros de query { #request-body-path-query-parameters }
 
 También puedes declarar parámetros de **body**, **path** y **query**, todos al mismo tiempo.
 
@@ -159,6 +167,6 @@ Pero agregar las anotaciones de tipos permitirá que tu editor te brinde un mejo
 
 ///
 
-## Sin Pydantic
+## Sin Pydantic { #without-pydantic }
 
-Si no quieres usar modelos de Pydantic, también puedes usar parámetros **Body**. Consulta la documentación para [Body - Multiples Parametros: Valores singulares en body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Si no quieres usar modelos de Pydantic, también puedes usar parámetros **Body**. Consulta la documentación para [Body - Multiple Parameters: Singular values in body](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.

docs/es/docs/tutorial/cookie-param-models.md

@@ -1,4 +1,4 @@
-# Modelos de Cookies
+# Modelos de Cookies { #cookie-parameter-models }
 
 Si tienes un grupo de **cookies** que están relacionadas, puedes crear un **modelo de Pydantic** para declararlas. 🍪
 
@@ -16,7 +16,7 @@ Esta misma técnica se aplica a `Query`, `Cookie`, y `Header`. 😎
 
 ///
 
-## Cookies con un Modelo de Pydantic
+## Cookies con un Modelo de Pydantic { #cookies-with-a-pydantic-model }
 
 Declara los parámetros de **cookie** que necesites en un **modelo de Pydantic**, y luego declara el parámetro como `Cookie`:
 
@@ -24,7 +24,7 @@ Declara los parámetros de **cookie** que necesites en un **modelo de Pydantic**
 
 **FastAPI** **extraerá** los datos para **cada campo** de las **cookies** recibidas en el request y te entregará el modelo de Pydantic que definiste.
 
-## Revisa la Documentación
+## Revisa la Documentación { #check-the-docs }
 
 Puedes ver las cookies definidas en la UI de la documentación en `/docs`:
 
@@ -42,7 +42,7 @@ Pero incluso si **rellenas los datos** y haces clic en "Execute", como la UI de
 
 ///
 
-## Prohibir Cookies Extra
+## Prohibir Cookies Extra { #forbid-extra-cookies }
 
 En algunos casos de uso especiales (probablemente no muy comunes), podrías querer **restringir** las cookies que deseas recibir.
 
@@ -50,7 +50,7 @@ Tu API ahora tiene el poder de controlar su propio <abbr title="Esto es una brom
 
 Puedes usar la configuración del modelo de Pydantic para `prohibir` cualquier campo `extra`:
 
-{* ../../docs_src/cookie_param_models/tutorial002_an_py39.py hl[10] *}
+{* ../../docs_src/cookie_param_models/tutorial002_an_py310.py hl[10] *}
 
 Si un cliente intenta enviar algunas **cookies extra**, recibirán un response de **error**.
 
@@ -71,6 +71,6 @@ Por ejemplo, si el cliente intenta enviar una cookie `santa_tracker` con un valo
 }
 ```
 
-## Resumen
+## Resumen { #summary }
 
 Puedes usar **modelos de Pydantic** para declarar <abbr title="Toma una última cookie antes de irte. 🍪">**cookies**</abbr> en **FastAPI**. 😎

docs/es/docs/tutorial/cookie-params.md

@@ -1,14 +1,14 @@
-# Parámetros de Cookie
+# Parámetros de Cookie { #cookie-parameters }
 
 Puedes definir parámetros de Cookie de la misma manera que defines los parámetros `Query` y `Path`.
 
-## Importar `Cookie`
+## Importar `Cookie` { #import-cookie }
 
 Primero importa `Cookie`:
 
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}
 
-## Declarar parámetros de `Cookie`
+## Declarar parámetros de `Cookie` { #declare-cookie-parameters }
 
 Luego declara los parámetros de cookie usando la misma estructura que con `Path` y `Query`.
 
@@ -30,6 +30,16 @@ Para declarar cookies, necesitas usar `Cookie`, porque de lo contrario los pará
 
 ///
 
-## Resumen
+/// info | Información
+
+Ten en cuenta que, como **los navegadores manejan las cookies** de formas especiales y por detrás, **no** permiten fácilmente que **JavaScript** las toque.
+
+Si vas a la **UI de la documentación de la API** en `/docs` podrás ver la **documentación** de cookies para tus *path operations*.
+
+Pero incluso si **rellenas los datos** y haces clic en "Execute", como la UI de la documentación funciona con **JavaScript**, las cookies no se enviarán y verás un mensaje de **error** como si no hubieras escrito ningún valor.
+
+///
+
+## Resumen { #recap }
 
 Declara cookies con `Cookie`, usando el mismo patrón común que `Query` y `Path`.

docs/es/docs/tutorial/cors.md

@@ -1,8 +1,8 @@
-# CORS (Cross-Origin Resource Sharing)
+# CORS (Cross-Origin Resource Sharing) { #cors-cross-origin-resource-sharing }
 
 <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">CORS o "Cross-Origin Resource Sharing"</a> se refiere a situaciones en las que un frontend que se ejecuta en un navegador tiene código JavaScript que se comunica con un backend, y el backend está en un "origen" diferente al frontend.
 
-## Origen
+## Origen { #origin }
 
 Un origen es la combinación de protocolo (`http`, `https`), dominio (`myapp.com`, `localhost`, `localhost.tiangolo.com`) y puerto (`80`, `443`, `8080`).
 
@@ -14,7 +14,7 @@ Así que, todos estos son orígenes diferentes:
 
 Aunque todos están en `localhost`, usan protocolos o puertos diferentes, por lo tanto, son "orígenes" diferentes.
 
-## Pasos
+## Pasos { #steps }
 
 Entonces, digamos que tienes un frontend corriendo en tu navegador en `http://localhost:8080`, y su JavaScript está tratando de comunicarse con un backend corriendo en `http://localhost` (porque no especificamos un puerto, el navegador asumirá el puerto por defecto `80`).
 
@@ -24,7 +24,7 @@ Para lograr esto, el backend `:80` debe tener una lista de "orígenes permitidos
 
 En este caso, la lista tendría que incluir `http://localhost:8080` para que el frontend `:8080` funcione correctamente.
 
-## Comodines
+## Comodines { #wildcards }
 
 También es posible declarar la lista como `"*"` (un "comodín") para decir que todos están permitidos.
 
@@ -32,7 +32,7 @@ Pero eso solo permitirá ciertos tipos de comunicación, excluyendo todo lo que
 
 Así que, para que todo funcione correctamente, es mejor especificar explícitamente los orígenes permitidos.
 
-## Usa `CORSMiddleware`
+## Usa `CORSMiddleware` { #use-corsmiddleware }
 
 Puedes configurarlo en tu aplicación **FastAPI** usando el `CORSMiddleware`.
 
@@ -56,23 +56,26 @@ Se admiten los siguientes argumentos:
 * `allow_origin_regex` - Una cadena regex para coincidir con orígenes que deberían estar permitidos para hacer requests cross-origin. por ejemplo, `'https://.*\.example\.org'`.
 * `allow_methods` - Una lista de métodos HTTP que deberían estar permitidos para requests cross-origin. Por defecto es `['GET']`. Puedes usar `['*']` para permitir todos los métodos estándar.
 * `allow_headers` - Una lista de headers de request HTTP que deberían estar soportados para requests cross-origin. Por defecto es `[]`. Puedes usar `['*']` para permitir todos los headers. Los headers `Accept`, `Accept-Language`, `Content-Language` y `Content-Type` siempre están permitidos para <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#simple_requests" class="external-link" rel="noopener" target="_blank">requests CORS simples</a>.
-* `allow_credentials` - Indica que las cookies deberían estar soportadas para requests cross-origin. Por defecto es `False`. Además, `allow_origins` no puede ser configurado a `['*']` para que las credenciales estén permitidas, los orígenes deben ser especificados.
+* `allow_credentials` - Indica que las cookies deberían estar soportadas para requests cross-origin. Por defecto es `False`.
+
+    Ninguno de `allow_origins`, `allow_methods` y `allow_headers` puede establecerse a `['*']` si `allow_credentials` está configurado a `True`. Todos deben ser <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS#credentialed_requests_and_wildcards" class="external-link" rel="noopener" target="_blank">especificados explícitamente</a>.
+
 * `expose_headers` - Indica cualquier header de response que debería ser accesible para el navegador. Por defecto es `[]`.
 * `max_age` - Establece un tiempo máximo en segundos para que los navegadores almacenen en caché los responses CORS. Por defecto es `600`.
 
 El middleware responde a dos tipos particulares de request HTTP...
 
-### Requests de preflight CORS
+### Requests de preflight CORS { #cors-preflight-requests }
 
 Estos son cualquier request `OPTIONS` con headers `Origin` y `Access-Control-Request-Method`.
 
 En este caso, el middleware interceptará el request entrante y responderá con los headers CORS adecuados, y un response `200` o `400` con fines informativos.
 
-### Requests simples
+### Requests simples { #simple-requests }
 
 Cualquier request con un header `Origin`. En este caso, el middleware pasará el request a través de lo normal, pero incluirá los headers CORS adecuados en el response.
 
-## Más info
+## Más info { #more-info }
 
 Para más información sobre <abbr title="Cross-Origin Resource Sharing">CORS</abbr>, revisa la <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS" class="external-link" target="_blank">documentación de CORS de Mozilla</a>.
 

docs/es/docs/tutorial/debugging.md

@@ -1,14 +1,14 @@
-# Depuración
+# Depuración { #debugging }
 
 Puedes conectar el depurador en tu editor, por ejemplo con Visual Studio Code o PyCharm.
 
-## Llama a `uvicorn`
+## Llama a `uvicorn` { #call-uvicorn }
 
 En tu aplicación de FastAPI, importa y ejecuta `uvicorn` directamente:
 
 {* ../../docs_src/debugging/tutorial001.py hl[1,15] *}
 
-### Acerca de `__name__ == "__main__"`
+### Acerca de `__name__ == "__main__"` { #about-name-main }
 
 El objetivo principal de `__name__ == "__main__"` es tener algo de código que se ejecute cuando tu archivo es llamado con:
 
@@ -26,7 +26,7 @@ pero no es llamado cuando otro archivo lo importa, como en:
 from myapp import app
 ```
 
-#### Más detalles
+#### Más detalles { #more-details }
 
 Supongamos que tu archivo se llama `myapp.py`.
 
@@ -78,7 +78,7 @@ Para más información, revisa <a href="https://docs.python.org/3/library/__main
 
 ///
 
-## Ejecuta tu código con tu depurador
+## Ejecuta tu código con tu depurador { #run-your-code-with-your-debugger }
 
 Dado que estás ejecutando el servidor Uvicorn directamente desde tu código, puedes llamar a tu programa de Python (tu aplicación FastAPI) directamente desde el depurador.
 

docs/es/docs/tutorial/dependencies/classes-as-dependencies.md

@@ -1,8 +1,8 @@
-# Clases como dependencias
+# Clases como dependencias { #classes-as-dependencies }
 
 Antes de profundizar en el sistema de **Inyección de Dependencias**, vamos a mejorar el ejemplo anterior.
 
-## Un `dict` del ejemplo anterior
+## Un `dict` del ejemplo anterior { #a-dict-from-the-previous-example }
 
 En el ejemplo anterior, estábamos devolviendo un `dict` de nuestra dependencia ("dependable"):
 
@@ -14,7 +14,7 @@ Y sabemos que los editores no pueden proporcionar mucho soporte (como autocomple
 
 Podemos hacerlo mejor...
 
-## Qué hace a una dependencia
+## Qué hace a una dependencia { #what-makes-a-dependency }
 
 Hasta ahora has visto dependencias declaradas como funciones.
 
@@ -38,7 +38,7 @@ something(some_argument, some_keyword_argument="foo")
 
 entonces es un "callable".
 
-## Clases como dependencias
+## Clases como dependencias { #classes-as-dependencies_1 }
 
 Puedes notar que para crear una instance de una clase en Python, utilizas esa misma sintaxis.
 
@@ -89,7 +89,7 @@ En ambos casos, tendrá:
 
 En ambos casos, los datos serán convertidos, validados, documentados en el esquema de OpenAPI, etc.
 
-## Úsalo
+## Úsalo { #use-it }
 
 Ahora puedes declarar tu dependencia usando esta clase.
 
@@ -97,7 +97,7 @@ Ahora puedes declarar tu dependencia usando esta clase.
 
 **FastAPI** llama a la clase `CommonQueryParams`. Esto crea una "instance" de esa clase y la instance será pasada como el parámetro `commons` a tu función.
 
-## Anotación de tipos vs `Depends`
+## Anotación de tipos vs `Depends` { #type-annotation-vs-depends }
 
 Nota cómo escribimos `CommonQueryParams` dos veces en el código anterior:
 
@@ -193,7 +193,7 @@ Pero declarar el tipo es recomendable, ya que de esa manera tu editor sabrá lo
 
 <img src="/img/tutorial/dependencies/image02.png">
 
-## Atajo
+## Atajo { #shortcut }
 
 Pero ves que estamos teniendo algo de repetición de código aquí, escribiendo `CommonQueryParams` dos veces:
 

docs/es/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md

@@ -1,4 +1,4 @@
-# Dependencias en decoradores de *path operation*
+# Dependencias en decoradores de *path operation* { #dependencies-in-path-operation-decorators }
 
 En algunos casos realmente no necesitas el valor de retorno de una dependencia dentro de tu *path operation function*.
 
@@ -8,7 +8,7 @@ Pero aún necesitas que sea ejecutada/resuelta.
 
 Para esos casos, en lugar de declarar un parámetro de *path operation function* con `Depends`, puedes añadir una `list` de `dependencies` al decorador de *path operation*.
 
-## Agregar `dependencies` al decorador de *path operation*
+## Agregar `dependencies` al decorador de *path operation* { #add-dependencies-to-the-path-operation-decorator }
 
 El decorador de *path operation* recibe un argumento opcional `dependencies`.
 
@@ -36,23 +36,23 @@ Pero en casos reales, al implementar seguridad, obtendrías más beneficios usan
 
 ///
 
-## Errores de dependencias y valores de retorno
+## Errores de dependencias y valores de retorno { #dependencies-errors-and-return-values }
 
 Puedes usar las mismas *funciones* de dependencia que usas normalmente.
 
-### Requisitos de dependencia
+### Requisitos de dependencia { #dependency-requirements }
 
 Pueden declarar requisitos de request (como headers) u otras sub-dependencias:
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[8,13] *}
 
-### Lanzar excepciones
+### Lanzar excepciones { #raise-exceptions }
 
 Estas dependencias pueden `raise` excepciones, igual que las dependencias normales:
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[10,15] *}
 
-### Valores de retorno
+### Valores de retorno { #return-values }
 
 Y pueden devolver valores o no, los valores no serán usados.
 
@@ -60,10 +60,10 @@ Así que, puedes reutilizar una dependencia normal (que devuelve un valor) que y
 
 {* ../../docs_src/dependencies/tutorial006_an_py39.py hl[11,16] *}
 
-## Dependencias para un grupo de *path operations*
+## Dependencias para un grupo de *path operations* { #dependencies-for-a-group-of-path-operations }
 
 Más adelante, cuando leas sobre cómo estructurar aplicaciones más grandes ([Aplicaciones Más Grandes - Múltiples Archivos](../../tutorial/bigger-applications.md){.internal-link target=_blank}), posiblemente con múltiples archivos, aprenderás cómo declarar un único parámetro `dependencies` para un grupo de *path operations*.
 
-## Dependencias Globales
+## Dependencias Globales { #global-dependencies }
 
 A continuación veremos cómo añadir dependencias a toda la aplicación `FastAPI`, de modo que se apliquen a cada *path operation*.