🎨 Auto format

.github/workflows/test.yml

@@ -49,45 +49,31 @@ jobs:
       matrix:
         os: [ windows-latest, macos-latest ]
         python-version: [ "3.14" ]
-        uv-resolution:
-          - highest
-        starlette-src:
-          - starlette-pypi
-          - starlette-git
         include:
           - os: ubuntu-latest
             python-version: "3.9"
             coverage: coverage
-            uv-resolution: lowest-direct
           - os: macos-latest
             python-version: "3.10"
             coverage: coverage
-            uv-resolution: highest
           - os: windows-latest
             python-version: "3.12"
             coverage: coverage
-            uv-resolution: lowest-direct
           - os: ubuntu-latest
             python-version: "3.13"
             coverage: coverage
-            uv-resolution: highest
             # Ubuntu with 3.13 needs coverage for CodSpeed benchmarks
           - os: ubuntu-latest
             python-version: "3.13"
             coverage: coverage
-            uv-resolution: highest
             codspeed: codspeed
           - os: ubuntu-latest
             python-version: "3.14"
             coverage: coverage
-            uv-resolution: highest
-            starlette-src: starlette-git
       fail-fast: false
     runs-on: ${{ matrix.os }}
     env:
       UV_PYTHON: ${{ matrix.python-version }}
-      UV_RESOLUTION: ${{ matrix.uv-resolution }}
-      STARLETTE_SRC: ${{ matrix.starlette-src }}
     steps:
       - name: Dump GitHub context
         env:
@@ -106,14 +92,11 @@ jobs:
             pyproject.toml
             uv.lock
       - name: Install Dependencies
-        run: uv sync --no-dev --group tests --extra all
-      - name: Install Starlette from source
-        if: matrix.starlette-src == 'starlette-git'
-        run: uv pip install "git+https://github.com/Kludex/starlette@main"
+        run: uv sync --locked --no-dev --group tests --extra all
       - run: mkdir coverage
       - name: Test
         if: matrix.codspeed != 'codspeed'
-        run: uv run --no-sync bash scripts/test.sh
+        run: uv run bash scripts/test.sh
         env:
           COVERAGE_FILE: coverage/.coverage.${{ runner.os }}-py${{ matrix.python-version }}
           CONTEXT: ${{ runner.os }}-py${{ matrix.python-version }}
@@ -125,7 +108,7 @@ jobs:
             CONTEXT: ${{ runner.os }}-py${{ matrix.python-version }}
         with:
           mode: simulation
-          run: uv run --no-sync coverage run -m pytest tests/ --codspeed
+          run: uv run coverage run -m pytest tests/ --codspeed
       # Do not store coverage for all possible combinations to avoid file size max errors in Smokeshow
       - name: Store coverage files
         if: matrix.coverage == 'coverage'

.github/workflows/translate.yml

@@ -35,11 +35,6 @@ on:
         type: boolean
         required: false
         default: false
-      max:
-        description: Maximum number of items to translate (e.g. 10)
-        type: number
-        required: false
-        default: 10
 
 jobs:
   langs:
@@ -120,4 +115,3 @@ jobs:
           EN_PATH: ${{ github.event.inputs.en_path }}
           COMMAND: ${{ matrix.command }}
           COMMIT_IN_PLACE: ${{ github.event.inputs.commit_in_place }}
-          MAX: ${{ github.event.inputs.max }}

docs/de/docs/advanced/wsgi.md

@@ -6,29 +6,13 @@ Dazu können Sie die `WSGIMiddleware` verwenden und damit Ihre WSGI-Anwendung wr
 
 ## `WSGIMiddleware` verwenden { #using-wsgimiddleware }
 
-/// info | Info
-
-Dafür muss `a2wsgi` installiert sein, z. B. mit `pip install a2wsgi`.
-
-///
-
-Sie müssen `WSGIMiddleware` aus `a2wsgi` importieren.
+Sie müssen `WSGIMiddleware` importieren.
 
 Wrappen Sie dann die WSGI-Anwendung (z. B. Flask) mit der Middleware.
 
 Und dann mounten Sie das auf einem Pfad.
 
-{* ../../docs_src/wsgi/tutorial001_py39.py hl[1,3,23] *}
-
-/// note | Hinweis
-
-Früher wurde empfohlen, `WSGIMiddleware` aus `fastapi.middleware.wsgi` zu verwenden, dies ist jetzt deprecatet.
-
-Stattdessen wird empfohlen, das Paket `a2wsgi` zu verwenden. Die Nutzung bleibt gleich.
-
-Stellen Sie lediglich sicher, dass das Paket `a2wsgi` installiert ist und importieren Sie `WSGIMiddleware` korrekt aus `a2wsgi`.
-
-///
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
 ## Es testen { #check-it }
 

docs/de/docs/deployment/docker.md

@@ -145,6 +145,8 @@ Es gibt andere Formate und Tools zum Definieren und Installieren von Paketabhän
 * Erstellen Sie eine `main.py`-Datei mit:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -156,7 +158,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 

docs/de/docs/index.md

@@ -161,6 +161,8 @@ $ pip install "fastapi[standard]"
 Erstellen Sie eine Datei `main.py` mit:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -172,7 +174,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -181,7 +183,9 @@ def read_item(item_id: int, q: str | None = None):
 
 Wenn Ihr Code `async` / `await` verwendet, benutzen Sie `async def`:
 
-```Python hl_lines="7  12"
+```Python hl_lines="9  14"
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -193,7 +197,7 @@ async def read_root():
 
 
 @app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -284,7 +288,9 @@ Sie sehen die alternative automatische Dokumentation (bereitgestellt von <a href
 
 Deklarieren Sie den Body mit Standard-Python-Typen, dank Pydantic.
 
-```Python hl_lines="2  7-10 23-25"
+```Python hl_lines="4  9-12  25-27"
+from typing import Union
+
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -294,7 +300,7 @@ app = FastAPI()
 class Item(BaseModel):
     name: str
     price: float
-    is_offer: bool | None = None
+    is_offer: Union[bool, None] = None
 
 
 @app.get("/")
@@ -303,7 +309,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 
 

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

@@ -1,6 +1,6 @@
 # Body – Mehrere Parameter { #body-multiple-parameters }
 
-Nun, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von <abbr title="Requestbody">Requestbody</abbr>-Deklarationen an.
+Nun, da wir gesehen haben, wie `Path` und `Query` verwendet werden, schauen wir uns fortgeschrittenere Verwendungsmöglichkeiten von <abbr title="Anfragekörper">Requestbody</abbr>-Deklarationen an.
 
 ## `Path`-, `Query`- und Body-Parameter vermischen { #mix-path-query-and-body-parameters }
 
@@ -101,13 +101,13 @@ Natürlich können Sie auch, wann immer Sie das brauchen, weitere Query-Paramete
 Da einfache Werte standardmäßig als Query-Parameter interpretiert werden, müssen Sie `Query` nicht explizit hinzufügen, Sie können einfach schreiben:
 
 ```Python
-q: str | None = None
+q: Union[str, None] = None
 ```
 
-Oder in Python 3.9:
+Oder in Python 3.10 und darüber:
 
 ```Python
-q: Union[str, None] = None
+q: str | None = None
 ```
 
 Zum Beispiel:

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

@@ -52,7 +52,7 @@ In diesem Fall macht es Sinn, die Tags in einem `Enum` zu speichern.
 
 Sie können eine <abbr title="Zusammenfassung">`summary`</abbr> und eine <abbr title="Beschreibung">`description`</abbr> hinzufügen:
 
-{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
 ## Beschreibung mittels Docstring { #description-from-docstring }
 
@@ -70,7 +70,7 @@ Es wird in der interaktiven Dokumentation verwendet:
 
 Sie können die Response mit dem Parameter `response_description` beschreiben:
 
-{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
 /// info | Info
 

docs/en/docs/advanced/advanced-dependencies.md

@@ -120,7 +120,7 @@ The exit code, the automatic closing of the `Session` in:
 
 {* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}
 
-...would be run after the response finishes sending the slow data:
+...would be run after the the response finishes sending the slow data:
 
 {* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}
 

docs/en/docs/contributing.md

@@ -179,23 +179,19 @@ as Uvicorn by default will use the port `8000`, the documentation on port `8008`
 
 Help with translations is VERY MUCH appreciated! And it can't be done without the help from the community. 🌎 🚀
 
+Here are the steps to help with translations.
+
+#### Translation PRs
+
 Translation pull requests are made by LLMs guided with prompts designed by the FastAPI team together with the community of native speakers for each supported language.
 
-#### LLM Prompt per Language
+These translations are normally still reviewed by native speakers, and here's where you can help!
 
-Each language has a directory: <a href="https://github.com/fastapi/fastapi/tree/master/docs" class="external-link" target="_blank">https://github.com/fastapi/fastapi/tree/master/docs</a>, in it you can see a file `llm-prompt.md` with the prompt specific for that language.
+* Check the currently <a href="https://github.com/fastapi/fastapi/pulls" class="external-link" target="_blank">existing pull requests</a> for your language. You can filter the pull requests by the ones with the label for your language. For example, for Spanish, the label is <a href="https://github.com/fastapi/fastapi/pulls?q=is%3Aopen+sort%3Aupdated-desc+label%3Alang-es+label%3Aawaiting-review" class="external-link" target="_blank">`lang-es`</a>.
 
-For example, for Spanish, the prompt is at: <a href="https://github.com/fastapi/fastapi/blob/master/docs/es/llm-prompt.md" class="external-link" target="_blank">`docs/es/llm-prompt.md`</a>.
+* When reviewing a pull request, it's better not to suggest changes in the same pull request, because it is LLM generated, and it won't be possible to make sure that small individual changes are replicated in other similar sections, or that they are preserved when translating the same content again.
 
-If you see mistakes in your language, you can make suggestions to the prompt in that file for your language, and request the specific pages you would like to re-generate after the changes.
-
-#### Reviewing Translation PRs
-
-You can also check the currently <a href="https://github.com/fastapi/fastapi/pulls" class="external-link" target="_blank">existing pull requests</a> for your language. You can filter the pull requests by the ones with the label for your language. For example, for Spanish, the label is <a href="https://github.com/fastapi/fastapi/pulls?q=is%3Aopen+sort%3Aupdated-desc+label%3Alang-es+label%3Aawaiting-review" class="external-link" target="_blank">`lang-es`</a>.
-
-When reviewing a pull request, it's better not to suggest changes in the same pull request, because it is LLM generated, and it won't be possible to make sure that small individual changes are replicated in other similar sections, or that they are preserved when translating the same content again.
-
-Instead of adding suggestions to the translation PR, make the suggestions to the LLM prompt file for that language, in a new PR. For example, for Spanish, the LLM prompt file is at: <a href="https://github.com/fastapi/fastapi/blob/master/docs/es/llm-prompt.md" class="external-link" target="_blank">`docs/es/llm-prompt.md`</a>.
+* Instead of adding suggestions to the translation PR, make the suggestions to the LLM prompt file for that language, in a new PR. For example, for Spanish, the LLM prompt file is at: <a href="https://github.com/fastapi/fastapi/blob/master/docs/es/llm-prompt.md" class="external-link" target="_blank">`docs/es/llm-prompt.md`</a>.
 
 /// tip
 
@@ -205,9 +201,9 @@ Check the docs about <a href="https://help.github.com/en/github/collaborating-wi
 
 #### Subscribe to Notifications for Your Language
 
-Check if there's a <a href="https://github.com/fastapi/fastapi/discussions/categories/translations" class="external-link" target="_blank">GitHub Discussion</a> to coordinate translations for your language. You can subscribe to it, and when there's a new pull request to review, an automatic comment will be added to the discussion.
+* Check if there's a <a href="https://github.com/fastapi/fastapi/discussions/categories/translations" class="external-link" target="_blank">GitHub Discussion</a> to coordinate translations for your language. You can subscribe to it, and when there's a new pull request to review, an automatic comment will be added to the discussion.
 
-To check the 2-letter code for the language you want to translate, you can use the table <a href="https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes" class="external-link" target="_blank">List of ISO 639-1 codes</a>.
+* To check the 2-letter code for the language you want to translate, you can use the table <a href="https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes" class="external-link" target="_blank">List of ISO 639-1 codes</a>.
 
 #### Request a New Language
 

docs/en/docs/release-notes.md

@@ -7,63 +7,6 @@ hide:
 
 ## Latest Changes
 
-## 0.128.3
-
-### Refactors
-
-* ♻️ Re-implement `on_event` in FastAPI for compatibility with the next Starlette, while keeping backwards compatibility. PR [#14851](https://github.com/fastapi/fastapi/pull/14851) by [@tiangolo](https://github.com/tiangolo).
-
-### Upgrades
-
-* ⬆️ Upgrade Starlette supported version range to `starlette>=0.40.0,<1.0.0`. PR [#14853](https://github.com/fastapi/fastapi/pull/14853) by [@tiangolo](https://github.com/tiangolo).
-
-### Translations
-
-* 🌐 Update translations for ru (update-outdated). PR [#14834](https://github.com/fastapi/fastapi/pull/14834) by [@tiangolo](https://github.com/tiangolo).
-
-### Internal
-
-* 👷 Run tests with Starlette from git. PR [#14849](https://github.com/fastapi/fastapi/pull/14849) by [@tiangolo](https://github.com/tiangolo).
-* 👷 Run tests with lower bound uv sync, upgrade `fastapi[all]` minimum dependencies: `ujson >=5.8.0`, `orjson >=3.9.3`. PR [#14846](https://github.com/fastapi/fastapi/pull/14846) by [@tiangolo](https://github.com/tiangolo).
-
-## 0.128.2
-
-### Features
-
-* ✨ Add support for PEP695 `TypeAliasType`. PR [#13920](https://github.com/fastapi/fastapi/pull/13920) by [@cstruct](https://github.com/cstruct).
-* ✨ Allow `Response` type hint as dependency annotation. PR [#14794](https://github.com/fastapi/fastapi/pull/14794) by [@jonathan-fulton](https://github.com/jonathan-fulton).
-
-### Fixes
-
-* 🐛 Fix using `Json[list[str]]` type (issue #10997). PR [#14616](https://github.com/fastapi/fastapi/pull/14616) by [@mkanetsuna](https://github.com/mkanetsuna).
-
-### Docs
-
-* 📝 Update docs for translations. PR [#14830](https://github.com/fastapi/fastapi/pull/14830) by [@tiangolo](https://github.com/tiangolo).
-* 📝 Fix duplicate word in `advanced-dependencies.md`. PR [#14815](https://github.com/fastapi/fastapi/pull/14815) by [@Rayyan-Oumlil](https://github.com/Rayyan-Oumlil).
-
-### Translations
-
-* 🌐 Enable Traditional Chinese translations. PR [#14842](https://github.com/fastapi/fastapi/pull/14842) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Enable French docs translations. PR [#14841](https://github.com/fastapi/fastapi/pull/14841) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for fr (translate-page). PR [#14837](https://github.com/fastapi/fastapi/pull/14837) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for de (update-outdated). PR [#14836](https://github.com/fastapi/fastapi/pull/14836) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for pt (update-outdated). PR [#14833](https://github.com/fastapi/fastapi/pull/14833) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for ko (update-outdated). PR [#14835](https://github.com/fastapi/fastapi/pull/14835) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for es (update-outdated). PR [#14832](https://github.com/fastapi/fastapi/pull/14832) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for tr (update-outdated). PR [#14831](https://github.com/fastapi/fastapi/pull/14831) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for tr (add-missing). PR [#14790](https://github.com/fastapi/fastapi/pull/14790) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for fr (update-outdated). PR [#14826](https://github.com/fastapi/fastapi/pull/14826) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for zh-hant (update-outdated). PR [#14825](https://github.com/fastapi/fastapi/pull/14825) by [@tiangolo](https://github.com/tiangolo).
-* 🌐 Update translations for uk (update-outdated). PR [#14822](https://github.com/fastapi/fastapi/pull/14822) by [@tiangolo](https://github.com/tiangolo).
-* 🔨 Update docs and translations scripts, enable Turkish. PR [#14824](https://github.com/fastapi/fastapi/pull/14824) by [@tiangolo](https://github.com/tiangolo).
-
-### Internal
-
-* 🔨 Add max pages to translate to configs. PR [#14840](https://github.com/fastapi/fastapi/pull/14840) by [@tiangolo](https://github.com/tiangolo).
-
-## 0.128.1
-
 ### Features
 
 * ✨ Add `viewport` meta tag to improve Swagger UI on mobile devices. PR [#14777](https://github.com/fastapi/fastapi/pull/14777) by [@Joab0](https://github.com/Joab0).
@@ -127,7 +70,6 @@ hide:
 
 ### Internal
 
-* ⬇️ Downgrade LLM translations model to GPT-5 to reduce mistakes. PR [#14823](https://github.com/fastapi/fastapi/pull/14823) by [@tiangolo](https://github.com/tiangolo).
 * 🐛 Fix translation script commit in place. PR [#14818](https://github.com/fastapi/fastapi/pull/14818) by [@tiangolo](https://github.com/tiangolo).
 * 🔨 Update translation script to retry if LLM-response doesn't pass validation with Translation Fixer tool. PR [#14749](https://github.com/fastapi/fastapi/pull/14749) by [@YuriiMotov](https://github.com/YuriiMotov).
 * 👷 Run tests only on relevant code changes (not on docs). PR [#14813](https://github.com/fastapi/fastapi/pull/14813) by [@tiangolo](https://github.com/tiangolo).

docs/en/mkdocs.yml

@@ -317,8 +317,6 @@ extra:
     name: de - Deutsch
   - link: /es/
     name: es - español
-  - link: /fr/
-    name: fr - français
   - link: /ja/
     name: ja - 日本語
   - link: /ko/
@@ -327,12 +325,8 @@ extra:
     name: pt - português
   - link: /ru/
     name: ru - русский язык
-  - link: /tr/
-    name: tr - Türkçe
   - link: /uk/
     name: uk - українська мова
-  - link: /zh-hant/
-    name: zh-hant - 繁體中文
 extra_css:
 - css/termynal.css
 - css/custom.css

docs/es/docs/advanced/wsgi.md

@@ -2,33 +2,17 @@
 
 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 el `WSGIMiddleware` y usarlo para envolver tu aplicación WSGI, por ejemplo, Flask, Django, etc.
+Para eso, puedes usar `WSGIMiddleware` y usarlo para envolver tu aplicación WSGI, por ejemplo, Flask, Django, etc.
 
 ## Usando `WSGIMiddleware` { #using-wsgimiddleware }
 
-/// info | Información
-
-Esto requiere instalar `a2wsgi`, por ejemplo con `pip install a2wsgi`.
-
-///
-
-Necesitas importar `WSGIMiddleware` de `a2wsgi`.
+Necesitas importar `WSGIMiddleware`.
 
 Luego envuelve la aplicación WSGI (p. ej., Flask) con el middleware.
 
 Y luego móntala bajo un path.
 
-{* ../../docs_src/wsgi/tutorial001_py39.py hl[1,3,23] *}
-
-/// note | Nota
-
-Anteriormente, se recomendaba usar `WSGIMiddleware` de `fastapi.middleware.wsgi`, pero ahora está deprecado.
-
-Se aconseja usar el paquete `a2wsgi` en su lugar. El uso sigue siendo el mismo.
-
-Solo asegúrate de tener instalado el paquete `a2wsgi` e importar `WSGIMiddleware` correctamente desde `a2wsgi`.
-
-///
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
 ## Revisa { #check-it }
 

docs/es/docs/deployment/docker.md

@@ -145,6 +145,8 @@ Existen otros formatos y herramientas para definir e instalar dependencias de pa
 * Crea un archivo `main.py` con:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -156,7 +158,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -570,7 +572,7 @@ Si tienes una configuración simple, con un **contenedor único** que luego inic
 
 ### 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).
 

docs/es/docs/index.md

@@ -161,6 +161,8 @@ $ pip install "fastapi[standard]"
 Crea un archivo `main.py` con:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -172,7 +174,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -181,7 +183,9 @@ def read_item(item_id: int, q: str | None = None):
 
 Si tu código usa `async` / `await`, usa `async def`:
 
-```Python hl_lines="7  12"
+```Python hl_lines="9  14"
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -193,7 +197,7 @@ async def read_root():
 
 
 @app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -284,7 +288,9 @@ Ahora modifica el archivo `main.py` para recibir un body desde un request `PUT`.
 
 Declara el body usando tipos estándar de Python, gracias a Pydantic.
 
-```Python hl_lines="2  7-10 23-25"
+```Python hl_lines="4  9-12  25-27"
+from typing import Union
+
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -294,7 +300,7 @@ app = FastAPI()
 class Item(BaseModel):
     name: str
     price: float
-    is_offer: bool | None = None
+    is_offer: Union[bool, None] = None
 
 
 @app.get("/")
@@ -303,7 +309,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 
 

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

@@ -101,13 +101,13 @@ Por supuesto, también puedes declarar parámetros adicionales de query siempre
 Como, por defecto, los valores singulares se interpretan como parámetros de query, no tienes que añadir explícitamente un `Query`, solo puedes hacer:
 
 ```Python
-q: str | None = None
+q: Union[str, None] = None
 ```
 
-O en Python 3.9:
+O en Python 3.10 y superior:
 
 ```Python
-q: Union[str, None] = None
+q: str | None = None
 ```
 
 Por ejemplo:

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

@@ -52,7 +52,7 @@ En estos casos, podría tener sentido almacenar las tags en un `Enum`.
 
 Puedes añadir un `summary` y `description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
 ## Descripción desde docstring { #description-from-docstring }
 
@@ -70,7 +70,7 @@ Será usado en la documentación interactiva:
 
 Puedes especificar la descripción del response con el parámetro `response_description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
 /// info | Información
 

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

@@ -1,6 +1,6 @@
-# Réponses supplémentaires dans OpenAPI { #additional-responses-in-openapi }
+# Réponses supplémentaires dans OpenAPI
 
-/// warning | Alertes
+/// warning | Attention
 
 Ceci concerne un sujet plutôt avancé.
 
@@ -14,9 +14,9 @@ Ces réponses supplémentaires seront incluses dans le schéma OpenAPI, elles ap
 
 Mais pour ces réponses supplémentaires, vous devez vous assurer de renvoyer directement une `Response` comme `JSONResponse`, avec votre code HTTP et votre contenu.
 
-## Réponse supplémentaire avec `model` { #additional-response-with-model }
+## Réponse supplémentaire avec `model`
 
-Vous pouvez passer à vos décorateurs de *chemin d'accès* un paramètre `responses`.
+Vous pouvez ajouter à votre décorateur de *paramètre de chemin* un paramètre `responses`.
 
 Il prend comme valeur un `dict` dont les clés sont des codes HTTP pour chaque réponse, comme `200`, et la valeur de ces clés sont d'autres `dict` avec des informations pour chacun d'eux.
 
@@ -26,7 +26,7 @@ Chacun de ces `dict` de réponse peut avoir une clé `model`, contenant un modè
 
 Par exemple, pour déclarer une autre réponse avec un code HTTP `404` et un modèle Pydantic `Message`, vous pouvez écrire :
 
-{* ../../docs_src/additional_responses/tutorial001_py39.py hl[18,22] *}
+{* ../../docs_src/additional_responses/tutorial001.py hl[18,22] *}
 
 /// note | Remarque
 
@@ -49,7 +49,7 @@ Le bon endroit est :
 
 ///
 
-Les réponses générées au format OpenAPI pour ce *chemin d'accès* seront :
+Les réponses générées au format OpenAPI pour cette *opération de chemin* seront :
 
 ```JSON hl_lines="3-12"
 {
@@ -169,13 +169,13 @@ Les schémas sont référencés à un autre endroit du modèle OpenAPI :
 }
 ```
 
-## Types de médias supplémentaires pour la réponse principale { #additional-media-types-for-the-main-response }
+## Types de médias supplémentaires pour la réponse principale
 
 Vous pouvez utiliser ce même paramètre `responses` pour ajouter différents types de médias pour la même réponse principale.
 
-Par exemple, vous pouvez ajouter un type de média supplémentaire `image/png`, en déclarant que votre *chemin d'accès* peut renvoyer un objet JSON (avec le type de média `application/json`) ou une image PNG :
+Par exemple, vous pouvez ajouter un type de média supplémentaire `image/png`, en déclarant que votre *opération de chemin* peut renvoyer un objet JSON (avec le type de média `application/json`) ou une image PNG :
 
-{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}
+{* ../../docs_src/additional_responses/tutorial002.py hl[19:24,28] *}
 
 /// note | Remarque
 
@@ -191,7 +191,7 @@ Mais si vous avez spécifié une classe de réponse personnalisée avec `None` c
 
 ///
 
-## Combiner les informations { #combining-information }
+## Combinaison d'informations
 
 Vous pouvez également combiner des informations de réponse provenant de plusieurs endroits, y compris les paramètres `response_model`, `status_code` et `responses`.
 
@@ -203,17 +203,17 @@ Par exemple, vous pouvez déclarer une réponse avec un code HTTP `404` qui util
 
 Et une réponse avec un code HTTP `200` qui utilise votre `response_model`, mais inclut un `example` personnalisé :
 
-{* ../../docs_src/additional_responses/tutorial003_py39.py hl[20:31] *}
+{* ../../docs_src/additional_responses/tutorial003.py hl[20:31] *}
 
 Tout sera combiné et inclus dans votre OpenAPI, et affiché dans la documentation de l'API :
 
 <img src="/img/tutorial/additional-responses/image01.png">
 
-## Combinez les réponses prédéfinies et les réponses personnalisées { #combine-predefined-responses-and-custom-ones }
+## Combinez les réponses prédéfinies et les réponses personnalisées
 
-Vous voulez peut-être avoir des réponses prédéfinies qui s'appliquent à de nombreux *chemins d'accès*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *chemin d'accès*.
+Vous voulez peut-être avoir des réponses prédéfinies qui s'appliquent à de nombreux *paramètre de chemin*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *opération de chemin*.
 
-Dans ces cas, vous pouvez utiliser la technique Python « unpacking » d'un `dict` avec `**dict_to_unpack` :
+Dans ces cas, vous pouvez utiliser la technique Python "d'affection par décomposition" (appelé _unpacking_ en anglais) d'un `dict` avec `**dict_to_unpack` :
 
 ```Python
 old_dict = {
@@ -233,15 +233,15 @@ Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la n
 }
 ```
 
-Vous pouvez utiliser cette technique pour réutiliser certaines réponses prédéfinies dans vos *chemins d'accès* et les combiner avec des réponses personnalisées supplémentaires.
+Vous pouvez utiliser cette technique pour réutiliser certaines réponses prédéfinies dans vos *paramètres de chemin* et les combiner avec des réponses personnalisées supplémentaires.
 
 Par exemple:
 
-{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
+{* ../../docs_src/additional_responses/tutorial004.py hl[13:17,26] *}
 
-## Plus d'informations sur les réponses OpenAPI { #more-information-about-openapi-responses }
+## Plus d'informations sur les réponses OpenAPI
 
 Pour voir exactement ce que vous pouvez inclure dans les réponses, vous pouvez consulter ces sections dans la spécification OpenAPI :
 
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object" class="external-link" target="_blank">Objet Responses de OpenAPI</a>, il inclut le `Response Object`.
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object" class="external-link" target="_blank">Objet Response de OpenAPI</a>, vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramètre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#responsesObject" class="external-link" target="_blank">Objet Responses de OpenAPI </a>, il inclut le `Response Object`.
+* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md#responseObject" class="external-link" target="_blank">Objet Response de OpenAPI </a>, vous pouvez inclure n'importe quoi directement dans chaque réponse à l'intérieur de votre paramètre `responses`. Y compris `description`, `headers`, `content` (à l'intérieur de cela, vous déclarez différents types de médias et schémas JSON) et `links`.

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

@@ -1,28 +1,28 @@
-# Codes HTTP supplémentaires { #additional-status-codes }
+# Codes HTTP supplémentaires
 
 Par défaut, **FastAPI** renverra les réponses à l'aide d'une structure de données `JSONResponse`, en plaçant la réponse de votre  *chemin d'accès* à l'intérieur de cette `JSONResponse`.
 
 Il utilisera le code HTTP par défaut ou celui que vous avez défini dans votre *chemin d'accès*.
 
-## Codes HTTP supplémentaires { #additional-status-codes_1 }
+## Codes HTTP supplémentaires
 
 Si vous souhaitez renvoyer des codes HTTP supplémentaires en plus du code principal, vous pouvez le faire en renvoyant directement une `Response`, comme une `JSONResponse`, et en définissant directement le code HTTP supplémentaire.
 
-Par exemple, disons que vous voulez avoir un *chemin d'accès* qui permet de mettre à jour les éléments et renvoie les codes HTTP 200 « OK » en cas de succès.
+Par exemple, disons que vous voulez avoir un *chemin d'accès* qui permet de mettre à jour les éléments et renvoie les codes HTTP 200 "OK" en cas de succès.
 
-Mais vous voulez aussi qu'il accepte de nouveaux éléments. Et lorsque les éléments n'existaient pas auparavant, il les crée et renvoie un code HTTP de 201 « Créé ».
+Mais vous voulez aussi qu'il accepte de nouveaux éléments. Et lorsque les éléments n'existaient pas auparavant, il les crée et renvoie un code HTTP de 201 "Créé".
 
 Pour y parvenir, importez `JSONResponse` et renvoyez-y directement votre contenu, en définissant le `status_code` que vous souhaitez :
 
-{* ../../docs_src/additional_status_codes/tutorial001_an_py310.py hl[4,25] *}
+{* ../../docs_src/additional_status_codes/tutorial001.py hl[4,25] *}
 
-/// warning | Alertes
+/// warning | Attention
 
 Lorsque vous renvoyez une `Response` directement, comme dans l'exemple ci-dessus, elle sera renvoyée directement.
 
 Elle ne sera pas sérialisée avec un modèle.
 
-Assurez-vous qu'il contient les données souhaitées et que les valeurs sont dans un format JSON valide (si vous utilisez une `JSONResponse`).
+Assurez-vous qu'il contient les données souhaitées et que les valeurs soient dans un format JSON valides (si vous utilisez une `JSONResponse`).
 
 ///
 
@@ -30,12 +30,12 @@ Assurez-vous qu'il contient les données souhaitées et que les valeurs sont dan
 
 Vous pouvez également utiliser `from starlette.responses import JSONResponse`.
 
-Pour plus de commodités, **FastAPI** fournit les objets `starlette.responses` sous forme d'un alias accessible par `fastapi.responses`. Mais la plupart des réponses disponibles proviennent directement de Starlette. Il en est de même avec `status`.
+Pour plus de commodités, **FastAPI** fournit les objets `starlette.responses` sous forme d'un alias accessible par `fastapi.responses`. Mais la plupart des réponses disponibles proviennent directement de Starlette. Il en est de même avec l'objet `statut`.
 
 ///
 
-## Documents OpenAPI et API { #openapi-and-api-docs }
+## Documents OpenAPI et API
 
 Si vous renvoyez directement des codes HTTP et des réponses supplémentaires, ils ne seront pas inclus dans le schéma OpenAPI (la documentation de l'API), car FastAPI n'a aucun moyen de savoir à l'avance ce que vous allez renvoyer.
 
-Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires](additional-responses.md){.internal-link target=_blank}.
+Mais vous pouvez documenter cela dans votre code, en utilisant : [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.

docs/fr/docs/advanced/index.md

@@ -1,21 +1,27 @@
-# Guide de l'utilisateur avancé { #advanced-user-guide }
+# Guide de l'utilisateur avancé
 
-## Caractéristiques supplémentaires { #additional-features }
+## Caractéristiques supplémentaires
 
 Le [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank} devrait suffire à vous faire découvrir toutes les fonctionnalités principales de **FastAPI**.
 
 Dans les sections suivantes, vous verrez des options, configurations et fonctionnalités supplémentaires.
 
-/// tip | Astuce
+/// note | Remarque
 
-Les sections suivantes ne sont **pas nécessairement « avancées »**.
+Les sections de ce chapitre ne sont **pas nécessairement "avancées"**.
 
-Et il est possible que, pour votre cas d'utilisation, la solution se trouve dans l'une d'entre elles.
+Et il est possible que pour votre cas d'utilisation, la solution se trouve dans l'un d'entre eux.
 
 ///
 
-## Lire d'abord le tutoriel { #read-the-tutorial-first }
+## Lisez d'abord le didacticiel
 
 Vous pouvez utiliser la plupart des fonctionnalités de **FastAPI** grâce aux connaissances du [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank}.
 
 Et les sections suivantes supposent que vous l'avez lu et que vous en connaissez les idées principales.
+
+## Cours TestDriven.io
+
+Si vous souhaitez suivre un cours pour débutants avancés pour compléter cette section de la documentation, vous pouvez consulter : <a href="https://testdrive.io/courses/tdd-fastapi/" class="external- link" target="_blank">Développement piloté par les tests avec FastAPI et Docker</a> par **TestDriven.io**.
+
+10 % de tous les bénéfices de ce cours sont reversés au développement de **FastAPI**. 🎉 😄

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

@@ -1,108 +1,106 @@
-# Configuration avancée des chemins d'accès { #path-operation-advanced-configuration }
+# Configuration avancée des paramètres de chemin
 
-## ID d’opération OpenAPI { #openapi-operationid }
+## ID d'opération OpenAPI
 
-/// warning | Alertes
+/// warning | Attention
 
-Si vous n’êtes pas un « expert » d’OpenAPI, vous n’en avez probablement pas besoin.
+Si vous n'êtes pas un "expert" en OpenAPI, vous n'en avez probablement pas besoin.
 
 ///
 
-Vous pouvez définir l’OpenAPI `operationId` à utiliser dans votre chemin d’accès avec le paramètre `operation_id`.
+Dans OpenAPI, les chemins sont des ressources, tels que /users/ ou /items/, exposées par votre API, et les opérations sont les méthodes HTTP utilisées pour manipuler ces chemins, telles que GET, POST ou DELETE. Les operationId sont des chaînes uniques facultatives utilisées pour identifier une opération d'un chemin. Vous pouvez définir l'OpenAPI `operationId` à utiliser dans votre *opération de chemin* avec le paramètre `operation_id`.
 
-Vous devez vous assurer qu’il est unique pour chaque opération.
+Vous devez vous assurer qu'il est unique pour chaque opération.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial001_py39.py hl[6] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *}
 
-### Utiliser le nom de la fonction de chemin d’accès comme operationId { #using-the-path-operation-function-name-as-the-operationid }
+### Utilisation du nom *path operation function* comme operationId
 
-Si vous souhaitez utiliser les noms de fonction de vos API comme `operationId`, vous pouvez les parcourir tous et remplacer l’`operation_id` de chaque chemin d’accès en utilisant leur `APIRoute.name`.
+Si vous souhaitez utiliser les noms de fonction de vos API comme `operationId`, vous pouvez les parcourir tous et remplacer chaque `operation_id` de l'*opération de chemin* en utilisant leur `APIRoute.name`.
 
-Vous devez le faire après avoir ajouté tous vos chemins d’accès.
+Vous devriez le faire après avoir ajouté toutes vos *paramètres de chemin*.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py39.py hl[2, 12:21, 24] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial002.py hl[2,12:21,24] *}
 
 /// tip | Astuce
 
-Si vous appelez manuellement `app.openapi()`, vous devez mettre à jour les `operationId` avant cela.
+Si vous appelez manuellement `app.openapi()`, vous devez mettre à jour les `operationId` avant.
 
 ///
 
-/// warning | Alertes
+/// warning | Attention
 
-Si vous faites cela, vous devez vous assurer que chacune de vos fonctions de chemin d’accès a un nom unique.
+Pour faire cela, vous devez vous assurer que chacun de vos *chemin* ait un nom unique.
 
-Même si elles se trouvent dans des modules différents (fichiers Python).
+Même s'ils se trouvent dans des modules différents (fichiers Python).
 
 ///
 
-## Exclusion d’OpenAPI { #exclude-from-openapi }
+## Exclusion d'OpenAPI
 
-Pour exclure un chemin d’accès du schéma OpenAPI généré (et donc des systèmes de documentation automatiques), utilisez le paramètre `include_in_schema` et définissez-le à `False` :
+Pour exclure un *chemin* du schéma OpenAPI généré (et donc des systèmes de documentation automatiques), utilisez le paramètre `include_in_schema` et assignez-lui la valeur `False` :
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial003_py39.py hl[6] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial003.py hl[6] *}
 
-## Description avancée depuis la docstring { #advanced-description-from-docstring }
+## Description avancée de docstring
 
-Vous pouvez limiter les lignes utilisées de la docstring d’une fonction de chemin d’accès pour OpenAPI.
+Vous pouvez limiter le texte utilisé de la docstring d'une *fonction de chemin* qui sera affiché sur OpenAPI.
 
-L’ajout d’un `\f` (un caractère « saut de page » échappé) amène **FastAPI** à tronquer la sortie utilisée pour OpenAPI à cet endroit.
+L'ajout d'un `\f` (un caractère d'échappement "form feed") va permettre à **FastAPI** de tronquer la sortie utilisée pour OpenAPI à ce stade.
 
-Cela n’apparaîtra pas dans la documentation, mais d’autres outils (comme Sphinx) pourront utiliser le reste.
+Il n'apparaîtra pas dans la documentation, mais d'autres outils (tel que Sphinx) pourront utiliser le reste.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial004.py hl[19:29] *}
 
-## Réponses supplémentaires { #additional-responses }
+## Réponses supplémentaires
 
-Vous avez probablement vu comment déclarer le `response_model` et le `status_code` pour un chemin d’accès.
+Vous avez probablement vu comment déclarer le `response_model` et le `status_code` pour une *opération de chemin*.
 
-Cela définit les métadonnées sur la réponse principale d’un chemin d’accès.
+Cela définit les métadonnées sur la réponse principale d'une *opération de chemin*.
 
 Vous pouvez également déclarer des réponses supplémentaires avec leurs modèles, codes de statut, etc.
 
-Il y a un chapitre entier dans la documentation à ce sujet, vous pouvez le lire dans [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Il y a un chapitre entier ici dans la documentation à ce sujet, vous pouvez le lire sur [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
 
-## OpenAPI supplémentaire { #openapi-extra }
+## OpenAPI supplémentaire
 
-Lorsque vous déclarez un chemin d’accès dans votre application, **FastAPI** génère automatiquement les métadonnées pertinentes à propos de ce chemin d’accès à inclure dans le schéma OpenAPI.
+Lorsque vous déclarez un *chemin* dans votre application, **FastAPI** génère automatiquement les métadonnées concernant ce *chemin* à inclure dans le schéma OpenAPI.
 
 /// note | Détails techniques
 
-Dans la spécification OpenAPI, cela s’appelle l’<a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">objet Operation</a>.
+La spécification OpenAPI appelle ces métadonnées des <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">Objets d'opération</a>.
 
 ///
 
-Il contient toutes les informations sur le chemin d’accès et est utilisé pour générer la documentation automatique.
+Il contient toutes les informations sur le *chemin* et est utilisé pour générer automatiquement la documentation.
 
 Il inclut les `tags`, `parameters`, `requestBody`, `responses`, etc.
 
-Ce schéma OpenAPI spécifique à un chemin d’accès est normalement généré automatiquement par **FastAPI**, mais vous pouvez également l’étendre.
+Ce schéma OpenAPI spécifique aux *operations* est normalement généré automatiquement par **FastAPI**, mais vous pouvez également l'étendre.
 
 /// tip | Astuce
 
-Ceci est un point d’extension de bas niveau.
-
-Si vous avez seulement besoin de déclarer des réponses supplémentaires, un moyen plus pratique de le faire est d’utiliser [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Si vous avez seulement besoin de déclarer des réponses supplémentaires, un moyen plus pratique de le faire est d'utiliser les [réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
 
 ///
 
-Vous pouvez étendre le schéma OpenAPI pour un chemin d’accès en utilisant le paramètre `openapi_extra`.
+Vous pouvez étendre le schéma OpenAPI pour une *opération de chemin* en utilisant le paramètre `openapi_extra`.
 
-### Extensions OpenAPI { #openapi-extensions }
+### Extensions OpenAPI
 
-Cet `openapi_extra` peut être utile, par exemple, pour déclarer des [Extensions OpenAPI](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) :
+Cet `openapi_extra` peut être utile, par exemple, pour déclarer [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) :
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial005_py39.py hl[6] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial005.py hl[6] *}
 
-Si vous ouvrez la documentation automatique de l’API, votre extension apparaîtra en bas du chemin d’accès spécifique.
+Si vous ouvrez la documentation automatique de l'API, votre extension apparaîtra au bas du *chemin* spécifique.
 
 <img src="/img/tutorial/path-operation-advanced-configuration/image01.png">
 
-Et si vous consultez l’OpenAPI résultant (à `/openapi.json` dans votre API), vous verrez également votre extension comme partie du chemin d’accès spécifique :
+Et dans le fichier openapi généré (`/openapi.json`), vous verrez également votre extension dans le cadre du *chemin* spécifique :
 
 ```JSON hl_lines="22"
 {
-    "openapi": "3.1.0",
+    "openapi": "3.0.2",
     "info": {
         "title": "FastAPI",
         "version": "0.1.0"
@@ -129,44 +127,44 @@ Et si vous consultez l’OpenAPI résultant (à `/openapi.json` dans votre API),
 }
 ```
 
-### Personnaliser le schéma OpenAPI d’un chemin d’accès { #custom-openapi-path-operation-schema }
+### Personnalisation du Schéma OpenAPI pour un chemin
 
-Le dictionnaire dans `openapi_extra` sera fusionné en profondeur avec le schéma OpenAPI généré automatiquement pour le chemin d’accès.
+Le dictionnaire contenu dans la variable `openapi_extra` sera fusionné avec le schéma OpenAPI généré automatiquement pour l'*opération de chemin*.
 
 Ainsi, vous pouvez ajouter des données supplémentaires au schéma généré automatiquement.
 
-Par exemple, vous pourriez décider de lire et de valider la requête avec votre propre code, sans utiliser les fonctionnalités automatiques de FastAPI avec Pydantic, mais vous pourriez tout de même vouloir définir la requête dans le schéma OpenAPI.
+Par exemple, vous pouvez décider de lire et de valider la requête avec votre propre code, sans utiliser les fonctionnalités automatiques de validation proposée par Pydantic, mais vous pouvez toujours définir la requête dans le schéma OpenAPI.
 
-Vous pourriez le faire avec `openapi_extra` :
+Vous pouvez le faire avec `openapi_extra` :
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial006_py39.py hl[19:36, 39:40] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial006.py hl[20:37,39:40] *}
 
-Dans cet exemple, nous n’avons déclaré aucun modèle Pydantic. En fait, le corps de la requête n’est même pas <abbr title="converti d'un format simple, comme des octets, en objets Python">parsé</abbr> en JSON, il est lu directement en tant que `bytes`, et la fonction `magic_data_reader()` serait chargée de l’analyser d’une manière ou d’une autre.
+Dans cet exemple, nous n'avons déclaré aucun modèle Pydantic. En fait, le corps de la requête n'est même pas <abbr title="converti d'un format simple, comme des octets, en objets Python">parsé</abbr> en tant que JSON, il est lu directement en tant que `bytes`, et la fonction `magic_data_reader()` serait chargé de l'analyser d'une manière ou d'une autre.
 
 Néanmoins, nous pouvons déclarer le schéma attendu pour le corps de la requête.
 
-### Type de contenu OpenAPI personnalisé { #custom-openapi-content-type }
+### Type de contenu OpenAPI personnalisé
 
-En utilisant cette même astuce, vous pourriez utiliser un modèle Pydantic pour définir le JSON Schema qui est ensuite inclus dans la section de schéma OpenAPI personnalisée pour le chemin d’accès.
+En utilisant cette même astuce, vous pouvez utiliser un modèle Pydantic pour définir le schéma JSON qui est ensuite inclus dans la section de schéma OpenAPI personnalisée pour le *chemin* concerné.
 
-Et vous pourriez le faire même si le type de données dans la requête n’est pas du JSON.
+Et vous pouvez le faire même si le type de données dans la requête n'est pas au format JSON.
 
-Par exemple, dans cette application nous n’utilisons pas la fonctionnalité intégrée de FastAPI pour extraire le JSON Schema des modèles Pydantic ni la validation automatique pour le JSON. En fait, nous déclarons le type de contenu de la requête comme YAML, pas JSON :
+Dans cet exemple, nous n'utilisons pas les fonctionnalités de FastAPI pour extraire le schéma JSON des modèles Pydantic ni la validation automatique pour JSON. En fait, nous déclarons le type de contenu de la requête en tant que YAML, et non JSON :
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[17:22,24] *}
 
-Néanmoins, bien que nous n’utilisions pas la fonctionnalité intégrée par défaut, nous utilisons toujours un modèle Pydantic pour générer manuellement le JSON Schema pour les données que nous souhaitons recevoir en YAML.
+Néanmoins, bien que nous n'utilisions pas la fonctionnalité par défaut, nous utilisons toujours un modèle Pydantic pour générer manuellement le schéma JSON pour les données que nous souhaitons recevoir en YAML.
 
-Ensuite, nous utilisons directement la requête et extrayons le corps en tant que `bytes`. Cela signifie que FastAPI n’essaiera même pas d’analyser le payload de la requête en JSON.
+Ensuite, nous utilisons directement la requête et extrayons son contenu en tant qu'octets. Cela signifie que FastAPI n'essaiera même pas d'analyser le payload de la requête en tant que JSON.
 
-Ensuite, dans notre code, nous analysons directement ce contenu YAML, puis nous utilisons à nouveau le même modèle Pydantic pour valider le contenu YAML :
+Et nous analysons directement ce contenu YAML, puis nous utilisons à nouveau le même modèle Pydantic pour valider le contenu YAML :
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
+{* ../../docs_src/path_operation_advanced_configuration/tutorial007.py hl[26:33] *}
 
 /// tip | Astuce
 
 Ici, nous réutilisons le même modèle Pydantic.
 
-Mais de la même manière, nous aurions pu le valider autrement.
+Mais nous aurions pu tout aussi bien pu le valider d'une autre manière.
 
 ///

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

@@ -1,20 +1,20 @@
-# Renvoyer directement une réponse { #return-a-response-directly }
+# Renvoyer directement une réponse
 
-Lorsque vous créez un *chemin d'accès* **FastAPI**, vous pouvez normalement retourner n'importe quelle donnée : un `dict`, une `list`, un modèle Pydantic, un modèle de base de données, etc.
+Lorsque vous créez une *opération de chemins* **FastAPI**, vous pouvez normalement retourner n'importe quelle donnée : un `dict`, une `list`, un modèle Pydantic, un modèle de base de données, etc.
 
-Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [Encodeur compatible JSON](../tutorial/encoder.md){.internal-link target=_blank}.
+Par défaut, **FastAPI** convertirait automatiquement cette valeur de retour en JSON en utilisant le `jsonable_encoder` expliqué dans [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.
 
 Ensuite, en arrière-plan, il mettra ces données JSON-compatible (par exemple un `dict`) à l'intérieur d'un `JSONResponse` qui sera utilisé pour envoyer la réponse au client.
 
-Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *chemins d'accès*.
+Mais vous pouvez retourner une `JSONResponse` directement à partir de vos *opérations de chemin*.
 
 Cela peut être utile, par exemple, pour retourner des en-têtes personnalisés ou des cookies.
 
-## Renvoyer une `Response` { #return-a-response }
+## Renvoyer une `Response`
 
 En fait, vous pouvez retourner n'importe quelle `Response` ou n'importe quelle sous-classe de celle-ci.
 
-/// tip | Astuce
+/// note | Remarque
 
 `JSONResponse` est elle-même une sous-classe de `Response`.
 
@@ -24,27 +24,27 @@ Et quand vous retournez une `Response`, **FastAPI** la transmet directement.
 
 Elle ne fera aucune conversion de données avec les modèles Pydantic, elle ne convertira pas le contenu en un type quelconque.
 
-Cela vous donne beaucoup de flexibilité. Vous pouvez retourner n'importe quel type de données, surcharger n'importe quelle déclaration ou validation de données, etc.
+Cela vous donne beaucoup de flexibilité. Vous pouvez retourner n'importe quel type de données, surcharger n'importe quelle déclaration ou validation de données.
 
-## Utiliser le `jsonable_encoder` dans une `Response` { #using-the-jsonable-encoder-in-a-response }
+## Utiliser le `jsonable_encoder` dans une `Response`
 
-Parce que **FastAPI** n'apporte aucune modification à une `Response` que vous retournez, vous devez vous assurer que son contenu est prêt pour cela.
+Parce que **FastAPI** n'apporte aucune modification à une `Response` que vous retournez, vous devez vous assurer que son contenu est prêt à être utilisé (sérialisable).
 
 Par exemple, vous ne pouvez pas mettre un modèle Pydantic dans une `JSONResponse` sans d'abord le convertir en un `dict` avec tous les types de données (comme `datetime`, `UUID`, etc.) convertis en types compatibles avec JSON.
 
-Pour ces cas, vous pouvez utiliser le `jsonable_encoder` pour convertir vos données avant de les passer à une réponse :
+Pour ces cas, vous pouvez spécifier un appel à `jsonable_encoder` pour convertir vos données avant de les passer à une réponse :
 
-{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
+{* ../../docs_src/response_directly/tutorial001.py hl[6:7,21:22] *}
 
 /// note | Détails techniques
 
 Vous pouvez aussi utiliser `from starlette.responses import JSONResponse`.
 
-**FastAPI** fournit le même `starlette.responses` que `fastapi.responses` juste par commodité pour vous, le développeur. Mais la plupart des réponses disponibles proviennent directement de Starlette.
+**FastAPI** fournit le même objet `starlette.responses` que `fastapi.responses` juste par commodité pour le développeur. Mais la plupart des réponses disponibles proviennent directement de Starlette.
 
 ///
 
-## Renvoyer une `Response` personnalisée { #returning-a-custom-response }
+## Renvoyer une `Response` personnalisée
 
 L'exemple ci-dessus montre toutes les parties dont vous avez besoin, mais il n'est pas encore très utile, car vous auriez pu retourner l'`item` directement, et **FastAPI** l'aurait mis dans une `JSONResponse` pour vous, en le convertissant en `dict`, etc. Tout cela par défaut.
 
@@ -54,9 +54,9 @@ Disons que vous voulez retourner une réponse <a href="https://en.wikipedia.org/
 
 Vous pouvez mettre votre contenu XML dans une chaîne de caractères, la placer dans une `Response`, et la retourner :
 
-{* ../../docs_src/response_directly/tutorial002_py39.py hl[1,18] *}
+{* ../../docs_src/response_directly/tutorial002.py hl[1,18] *}
 
-## Notes { #notes }
+## Notes
 
 Lorsque vous renvoyez une `Response` directement, ses données ne sont pas validées, converties (sérialisées), ni documentées automatiquement.
 

docs/fr/docs/benchmarks.md

@@ -1,34 +1,34 @@
-# Tests de performance { #benchmarks }
+# Test de performance
 
-Les benchmarks indépendants de TechEmpower montrent que les applications **FastAPI** s’exécutant avec Uvicorn sont <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">parmi les frameworks Python les plus rapides disponibles</a>, seulement en dessous de Starlette et Uvicorn eux‑mêmes (tous deux utilisés en interne par FastAPI).
+Les tests de performance de TechEmpower montrent que les applications **FastAPI** tournant sous Uvicorn comme <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">étant l'un des frameworks Python les plus rapides disponibles</a>, seulement inférieur à Starlette et Uvicorn (tous deux utilisés au cœur de FastAPI). (*)
 
-Mais en prêtant attention aux tests de performance et aux comparaisons, vous devez tenir compte de ce qui suit.
+Mais en prêtant attention aux tests de performance et aux comparaisons, il faut tenir compte de ce qu'il suit.
 
-## Tests de performance et rapidité { #benchmarks-and-speed }
+## Tests de performance et rapidité
 
 Lorsque vous vérifiez les tests de performance, il est commun de voir plusieurs outils de différents types comparés comme équivalents.
 
 En particulier, on voit Uvicorn, Starlette et FastAPI comparés (parmi de nombreux autres outils).
 
-Plus le problème résolu par un outil est simple, meilleures seront les performances obtenues. Et la plupart des tests de performance ne prennent pas en compte les fonctionnalités additionnelles fournies par les outils.
+Plus le problème résolu par un outil est simple, mieux seront les performances obtenues. Et la plupart des tests de performance ne prennent pas en compte les fonctionnalités additionnelles fournies par les outils.
 
 La hiérarchie est la suivante :
 
 * **Uvicorn** : un serveur ASGI
-    * **Starlette** : (utilise Uvicorn) un microframework web
-        * **FastAPI**: (utilise Starlette) un microframework pour API disposant de fonctionnalités additionnelles pour la création d'API, avec la validation des données, etc.
+    * **Starlette** : (utilise Uvicorn) un micro-framework web
+        * **FastAPI**: (utilise Starlette) un micro-framework pour API disposant de fonctionnalités additionnelles pour la création d'API, avec la validation des données, etc.
 
 * **Uvicorn** :
-    * A les meilleures performances, étant donné qu'il n'a pas beaucoup de code mis à part le serveur en lui‑même.
-    * On n'écrit pas une application directement avec Uvicorn. Cela signifie que le code devrait inclure, au minimum, plus ou moins tout le code offert par Starlette (ou **FastAPI**). Et si on fait cela, l'application finale aura la même surcharge que si on avait utilisé un framework, tout en minimisant la quantité de code et les bugs.
-    * Si on compare Uvicorn, il faut le comparer à d'autres serveurs d'applications comme Daphne, Hypercorn, uWSGI, etc.
+    * A les meilleures performances, étant donné qu'il n'a pas beaucoup de code mis-à-part le serveur en lui-même.
+    * On n'écrit pas une application avec uniquement Uvicorn. Cela signifie que le code devrait inclure plus ou moins, au minimum, tout le code offert par Starlette (ou **FastAPI**). Et si on fait cela, l'application finale apportera les mêmes complications que si on avait utilisé un framework et que l'on avait minimisé la quantité de code et de bugs.
+    * Si on compare Uvicorn, il faut le comparer à d'autre applications de serveurs comme Daphne, Hypercorn, uWSGI, etc.
 * **Starlette** :
-    * A les secondes meilleures performances après Uvicorn. En réalité, Starlette utilise Uvicorn. De ce fait, il ne peut qu’être plus « lent » qu'Uvicorn car il requiert l'exécution de plus de code.
-    * Cependant, il apporte les outils pour construire une application web simple, avec un routage basé sur des chemins, etc.
-    * Si on compare Starlette, il faut le comparer à d'autres frameworks web (ou microframeworks) comme Sanic, Flask, Django, etc.
+    * A les seconde meilleures performances après Uvicorn. Starlette utilise en réalité Uvicorn. De ce fait, il ne peut qu’être plus "lent" qu'Uvicorn car il requiert l'exécution de plus de code.
+    * Cependant il nous apporte les outils pour construire une application web simple, avec un routage basé sur des chemins, etc.
+    * Si on compare Starlette, il faut le comparer à d'autres frameworks web (ou micorframework) comme Sanic, Flask, Django, etc.
 * **FastAPI** :
-    * Comme Starlette utilise Uvicorn et ne peut donc pas être plus rapide que lui, **FastAPI** utilise Starlette et ne peut donc pas être plus rapide que lui.
-    * FastAPI apporte des fonctionnalités supplémentaires à Starlette. Des fonctionnalités dont vous avez presque toujours besoin lors de la création d'une API, comme la validation des données et la sérialisation. En l'utilisant, vous obtenez une documentation automatique « gratuitement » (la documentation automatique n'ajoute même pas de surcharge à l’exécution, elle est générée au démarrage).
-    * Si on n'utilisait pas FastAPI mais directement Starlette (ou un autre outil comme Sanic, Flask, Responder, etc.), il faudrait implémenter toute la validation des données et la sérialisation soi‑même. L'application finale aurait donc la même surcharge que si elle avait été construite avec FastAPI. Et dans de nombreux cas, cette validation des données et cette sérialisation représentent la plus grande quantité de code écrite dans les applications.
-    * De ce fait, en utilisant FastAPI on minimise le temps de développement, les bugs, le nombre de lignes de code, et on obtient probablement les mêmes performances (voire de meilleures performances) que l'on aurait pu avoir sans ce framework (car il aurait fallu tout implémenter dans votre code).
-    * Si on compare FastAPI, il faut le comparer à d'autres frameworks d’application web (ou ensembles d'outils) qui fournissent la validation des données, la sérialisation et la documentation, comme Flask-apispec, NestJS, Molten, etc. Des frameworks avec validation des données, sérialisation et documentation automatiques intégrées.
+    * Comme Starlette, FastAPI utilise Uvicorn et ne peut donc pas être plus rapide que ce dernier.
+    * FastAPI apporte des fonctionnalités supplémentaires à Starlette. Des fonctionnalités qui sont nécessaires presque systématiquement lors de la création d'une API, comme la validation des données, la sérialisation. En utilisant FastAPI, on obtient une documentation automatiquement (qui ne requiert aucune manipulation pour être mise en place).
+    * Si on n'utilisait pas FastAPI mais directement Starlette (ou un outil équivalent comme Sanic, Flask, Responder, etc) il faudrait implémenter la validation des données et la sérialisation par nous-même. Le résultat serait donc le même dans les deux cas mais du travail supplémentaire serait à réaliser avec Starlette, surtout en considérant que la validation des données et la sérialisation représentent la plus grande quantité de code à écrire dans une application.
+    * De ce fait, en utilisant FastAPI on minimise le temps de développement, les bugs, le nombre de lignes de code, et on obtient les mêmes performances (si ce n'est de meilleurs performances) que l'on aurait pu avoir sans ce framework (en ayant à implémenter de nombreuses fonctionnalités importantes par nous-mêmes).
+    * Si on compare FastAPI, il faut le comparer à d'autres frameworks web (ou ensemble d'outils) qui fournissent la validation des données, la sérialisation et la documentation, comme Flask-apispec, NestJS, Molten, etc.

docs/fr/docs/deployment/docker.md

@@ -1,150 +1,75 @@
-# FastAPI dans des conteneurs - Docker { #fastapi-in-containers-docker }
+# Déployer avec Docker
 
-Lors du déploiement d'applications FastAPI, une approche courante consiste à construire une **image de conteneur Linux**. C'est généralement fait avec <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. Vous pouvez ensuite déployer cette image de conteneur de plusieurs façons possibles.
+Dans cette section, vous verrez des instructions et des liens vers des guides pour savoir comment :
 
-L'utilisation de conteneurs Linux présente plusieurs avantages, notamment la **sécurité**, la **réplicabilité**, la **simplicité**, entre autres.
+* Faire de votre application **FastAPI** une image/conteneur Docker avec une performance maximale. En environ **5 min**.
+* (Optionnellement) comprendre ce que vous, en tant que développeur, devez savoir sur HTTPS.
+* Configurer un cluster en mode Docker Swarm avec HTTPS automatique, même sur un simple serveur à 5 dollars US/mois. En environ **20 min**.
+* Générer et déployer une application **FastAPI** complète, en utilisant votre cluster Docker Swarm, avec HTTPS, etc. En environ **10 min**.
+
+Vous pouvez utiliser <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a> pour le déploiement. Il présente plusieurs avantages comme la sécurité, la réplicabilité, la simplicité de développement, etc.
+
+Si vous utilisez Docker, vous pouvez utiliser l'image Docker officielle :
+
+## <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>
+
+Cette image est dotée d'un mécanisme d'"auto-tuning", de sorte qu'il vous suffit d'ajouter votre code pour obtenir automatiquement des performances très élevées. Et sans faire de sacrifices.
+
+Mais vous pouvez toujours changer et mettre à jour toutes les configurations avec des variables d'environnement ou des fichiers de configuration.
 
 /// tip | Astuce
 
-Vous êtes pressé et vous connaissez déjà tout ça ? Allez directement au [`Dockerfile` ci-dessous 👇](#build-a-docker-image-for-fastapi).
+Pour voir toutes les configurations et options, rendez-vous sur la page de l'image Docker : <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>.
 
 ///
 
-<details>
-<summary>Aperçu du Dockerfile 👀</summary>
+## Créer un `Dockerfile`
+
+* Allez dans le répertoire de votre projet.
+* Créez un `Dockerfile` avec :
 
 ```Dockerfile
-FROM python:3.9
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7
 
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-COPY ./app /code/app
-
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-
-# Si vous exécutez derrière un proxy comme Nginx ou Traefik, ajoutez --proxy-headers
-# CMD ["fastapi", "run", "app/main.py", "--port", "80", "--proxy-headers"]
+COPY ./app /app
 ```
 
-</details>
+### Applications plus larges
 
-## Qu'est-ce qu'un conteneur { #what-is-a-container }
+Si vous avez suivi la section sur la création d' [Applications avec plusieurs fichiers](../tutorial/bigger-applications.md){.internal-link target=_blank}, votre `Dockerfile` pourrait ressembler à ceci :
 
-Les conteneurs (principalement les conteneurs Linux) sont un moyen très **léger** d'empaqueter des applications, y compris toutes leurs dépendances et les fichiers nécessaires, tout en les isolant des autres conteneurs (autres applications ou composants) dans le même système.
+```Dockerfile
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7
 
-Les conteneurs Linux s'exécutent en utilisant le même noyau Linux que l'hôte (machine, machine virtuelle, serveur cloud, etc.). Cela signifie simplement qu'ils sont très légers (comparés à des machines virtuelles complètes émulant un système d'exploitation entier).
-
-Ainsi, les conteneurs consomment **peu de ressources**, une quantité comparable à l'exécution directe des processus (alors qu'une machine virtuelle consommerait beaucoup plus).
-
-Les conteneurs ont également leurs propres processus d'exécution **isolés** (généralement un seul processus), leur système de fichiers et leur réseau, ce qui simplifie le déploiement, la sécurité, le développement, etc.
-
-## Qu'est-ce qu'une image de conteneur { #what-is-a-container-image }
-
-Un **conteneur** s'exécute à partir d'une **image de conteneur**.
-
-Une image de conteneur est une version **statique** de tous les fichiers, des variables d'environnement et de la commande/le programme par défaut devant être présents dans un conteneur. Ici, **statique** signifie que l'**image** du conteneur ne s'exécute pas, elle n'est pas en cours d'exécution, ce ne sont que les fichiers et métadonnées empaquetés.
-
-Par opposition à une « **image de conteneur** » qui correspond aux contenus statiques stockés, un « **conteneur** » fait normalement référence à l'instance en cours d'exécution, la chose qui est **exécutée**.
-
-Lorsque le **conteneur** est démarré et en cours d'exécution (démarré à partir d'une **image de conteneur**), il peut créer ou modifier des fichiers, des variables d'environnement, etc. Ces changements n'existeront que dans ce conteneur, mais ne persisteront pas dans l'image de conteneur sous-jacente (ils ne seront pas enregistrés sur le disque).
-
-Une image de conteneur est comparable au **programme** et à ses contenus, par exemple `python` et un fichier `main.py`.
-
-Et le **conteneur** lui-même (par opposition à l'**image de conteneur**) est l'instance en cours d'exécution réelle de l'image, comparable à un **processus**. En fait, un conteneur ne fonctionne que lorsqu'il a un **processus en cours d'exécution** (et normalement, il s'agit d'un seul processus). Le conteneur s'arrête lorsqu'aucun processus n'y est en cours d'exécution.
-
-## Images de conteneur { #container-images }
-
-Docker a été l'un des principaux outils pour créer et gérer des **images de conteneur** et des **conteneurs**.
-
-Et il existe un <a href="https://hub.docker.com/" class="external-link" target="_blank">Docker Hub</a> public avec des **images de conteneur officielles** pré-construites pour de nombreux outils, environnements, bases de données et applications.
-
-Par exemple, il existe une <a href="https://hub.docker.com/_/python" class="external-link" target="_blank">image Python officielle</a>.
-
-Et il existe beaucoup d'autres images pour différentes choses comme des bases de données, par exemple :
-
-* <a href="https://hub.docker.com/_/postgres" class="external-link" target="_blank">PostgreSQL</a>
-* <a href="https://hub.docker.com/_/mysql" class="external-link" target="_blank">MySQL</a>
-* <a href="https://hub.docker.com/_/mongo" class="external-link" target="_blank">MongoDB</a>
-* <a href="https://hub.docker.com/_/redis" class="external-link" target="_blank">Redis</a>, etc.
-
-En utilisant une image de conteneur pré-construite, il est très facile de **combiner** et d'utiliser différents outils. Par exemple, pour essayer une nouvelle base de données. Dans la plupart des cas, vous pouvez utiliser les **images officielles** et simplement les configurer avec des variables d'environnement.
-
-Ainsi, dans de nombreux cas, vous pouvez apprendre les conteneurs et Docker et réutiliser ces connaissances avec de nombreux outils et composants différents.
-
-Vous exécuteriez donc **plusieurs conteneurs** avec des éléments différents, comme une base de données, une application Python, un serveur web avec une application frontend React, et les connecter entre eux via leur réseau interne.
-
-Tous les systèmes de gestion de conteneurs (comme Docker ou Kubernetes) disposent de ces fonctionnalités réseau intégrées.
-
-## Conteneurs et processus { #containers-and-processes }
-
-Une **image de conteneur** inclut normalement dans ses métadonnées le programme/la commande par défaut à exécuter lorsque le **conteneur** est démarré et les paramètres à transmettre à ce programme. Très similaire à ce que vous utiliseriez en ligne de commande.
-
-Lorsqu'un **conteneur** est démarré, il exécutera cette commande/ce programme (bien que vous puissiez la/le remplacer et faire exécuter une autre commande/un autre programme).
-
-Un conteneur fonctionne tant que le **processus principal** (commande ou programme) est en cours d'exécution.
-
-Un conteneur a normalement un **seul processus**, mais il est aussi possible de démarrer des sous-processus à partir du processus principal, et ainsi vous aurez **plusieurs processus** dans le même conteneur.
-
-Mais il n'est pas possible d'avoir un conteneur en cours d'exécution sans **au moins un processus en cours**. Si le processus principal s'arrête, le conteneur s'arrête.
-
-## Construire une image Docker pour FastAPI { #build-a-docker-image-for-fastapi }
-
-Très bien, construisons quelque chose maintenant ! 🚀
-
-Je vais vous montrer comment construire une **image Docker** pour FastAPI **à partir de zéro**, basée sur l'image **officielle Python**.
-
-C'est ce que vous voudrez faire dans **la plupart des cas**, par exemple :
-
-* Utiliser **Kubernetes** ou des outils similaires
-* Exécuter sur un **Raspberry Pi**
-* Utiliser un service cloud qui exécuterait une image de conteneur pour vous, etc.
-
-### Dépendances des paquets { #package-requirements }
-
-Vous aurez normalement les **dépendances des paquets** de votre application dans un fichier.
-
-Cela dépendra principalement de l'outil que vous utilisez pour **installer** ces dépendances.
-
-La manière la plus courante consiste à avoir un fichier `requirements.txt` avec les noms des paquets et leurs versions, un par ligne.
-
-Vous utiliserez bien sûr les mêmes idées que vous avez lues dans [À propos des versions de FastAPI](versions.md){.internal-link target=_blank} pour définir les plages de versions.
-
-Par exemple, votre `requirements.txt` pourrait ressembler à :
-
-```
-fastapi[standard]>=0.113.0,<0.114.0
-pydantic>=2.7.0,<3.0.0
+COPY ./app /app/app
 ```
 
-Et vous installerez normalement ces dépendances de paquets avec `pip`, par exemple :
+### Raspberry Pi et autres architectures
 
-<div class="termy">
+Si vous utilisez Docker sur un Raspberry Pi (qui a un processeur ARM) ou toute autre architecture, vous pouvez créer un `Dockerfile` à partir de zéro, basé sur une image de base Python (qui est multi-architecture) et utiliser Uvicorn seul.
 
-```console
-$ pip install -r requirements.txt
----> 100%
-Successfully installed fastapi pydantic
+Dans ce cas, votre `Dockerfile` pourrait ressembler à ceci :
+
+```Dockerfile
+FROM python:3.7
+
+RUN pip install fastapi uvicorn
+
+EXPOSE 80
+
+COPY ./app /app
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "80"]
 ```
 
-</div>
+## Créer le code **FastAPI**.
 
-/// info
-
-Il existe d'autres formats et outils pour définir et installer des dépendances de paquets.
-
-///
-
-### Créer le code **FastAPI** { #create-the-fastapi-code }
-
-* Créez un répertoire `app` et entrez dedans.
-* Créez un fichier vide `__init__.py`.
-* Créez un fichier `main.py` avec :
+* Créer un répertoire `app` et y entrer.
+* Créez un fichier `main.py` avec :
 
 ```Python
+from typing import Optional
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -156,168 +81,22 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Optional[str] = None):
     return {"item_id": item_id, "q": q}
 ```
 
-### Dockerfile { #dockerfile }
-
-Maintenant, dans le même répertoire de projet, créez un fichier `Dockerfile` avec :
-
-```{ .dockerfile .annotate }
-# (1)!
-FROM python:3.9
-
-# (2)!
-WORKDIR /code
-
-# (3)!
-COPY ./requirements.txt /code/requirements.txt
-
-# (4)!
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# (5)!
-COPY ./app /code/app
-
-# (6)!
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-```
-
-1. Démarrer à partir de l'image de base Python officielle.
-
-2. Définir le répertoire de travail courant sur `/code`.
-
-    C'est là que nous placerons le fichier `requirements.txt` et le répertoire `app`.
-
-3. Copier le fichier des dépendances vers le répertoire `/code`.
-
-    Copier **uniquement** le fichier des dépendances en premier, pas le reste du code.
-
-    Comme ce fichier **ne change pas souvent**, Docker le détectera et utilisera le **cache** pour cette étape, ce qui activera le cache pour l'étape suivante aussi.
-
-4. Installer les dépendances listées dans le fichier des dépendances.
-
-    L'option `--no-cache-dir` indique à `pip` de ne pas enregistrer localement les paquets téléchargés, car cela ne sert que si `pip` devait être relancé pour installer les mêmes paquets, mais ce n'est pas le cas lorsque l'on travaille avec des conteneurs.
-
-    /// note | Remarque
-
-    Le `--no-cache-dir` concerne uniquement `pip`, cela n'a rien à voir avec Docker ou les conteneurs.
-
-    ///
-
-    L'option `--upgrade` indique à `pip` de mettre à niveau les paquets s'ils sont déjà installés.
-
-    Comme l'étape précédente de copie du fichier peut être détectée par le **cache Docker**, cette étape **utilisera également le cache Docker** lorsqu'il est disponible.
-
-    L'utilisation du cache à cette étape vous **fera gagner** beaucoup de **temps** lors de la reconstruction de l'image encore et encore pendant le développement, au lieu de **télécharger et installer** toutes les dépendances **à chaque fois**.
-
-5. Copier le répertoire `./app` dans le répertoire `/code`.
-
-    Comme cela contient tout le code qui est ce qui **change le plus fréquemment**, le **cache** Docker ne sera pas facilement utilisé pour cette étape ou pour les **étapes suivantes**.
-
-    Il est donc important de placer cela **vers la fin** du `Dockerfile`, pour optimiser les temps de construction de l'image de conteneur.
-
-6. Définir la **commande** pour utiliser `fastapi run`, qui utilise Uvicorn sous le capot.
-
-    `CMD` prend une liste de chaînes, chacune de ces chaînes correspond à ce que vous taperiez en ligne de commande séparé par des espaces.
-
-    Cette commande sera exécutée à partir du **répertoire de travail courant**, le même répertoire `/code` que vous avez défini plus haut avec `WORKDIR /code`.
-
-/// tip | Astuce
-
-Passez en revue ce que fait chaque ligne en cliquant sur chaque bulle numérotée dans le code. 👆
-
-///
-
-/// warning | Alertes
-
-Vous devez vous assurer d'utiliser **toujours** la **forme exec** de l'instruction `CMD`, comme expliqué ci-dessous.
-
-///
-
-#### Utiliser `CMD` - Forme Exec { #use-cmd-exec-form }
-
-L'instruction Docker <a href="https://docs.docker.com/reference/dockerfile/#cmd" class="external-link" target="_blank">`CMD`</a> peut être écrite sous deux formes :
-
-✅ Forme **Exec** :
-
-```Dockerfile
-# ✅ À faire
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-```
-
-⛔️ Forme **Shell** :
-
-```Dockerfile
-# ⛔️ À ne pas faire
-CMD fastapi run app/main.py --port 80
-```
-
-Assurez-vous d'utiliser toujours la forme **exec** pour garantir que FastAPI peut s'arrêter proprement et que les [événements de cycle de vie](../advanced/events.md){.internal-link target=_blank} sont déclenchés.
-
-Vous pouvez en lire davantage dans la <a href="https://docs.docker.com/reference/dockerfile/#shell-and-exec-form" class="external-link" target="_blank">documentation Docker sur les formes shell et exec</a>.
-
-Cela peut être très visible lors de l'utilisation de `docker compose`. Voir cette section de la FAQ Docker Compose pour plus de détails techniques : <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">Pourquoi mes services mettent-ils 10 secondes à se recréer ou à s'arrêter ?</a>.
-
-#### Structure du répertoire { #directory-structure }
-
-Vous devriez maintenant avoir une structure de répertoire comme :
+* Vous devriez maintenant avoir une structure de répertoire telle que :
 
 ```
 .
 ├── app
-│   ├── __init__.py
 │   └── main.py
-├── Dockerfile
-└── requirements.txt
+└── Dockerfile
 ```
 
-#### Derrière un proxy de terminaison TLS { #behind-a-tls-termination-proxy }
+## Construire l'image Docker
 
-Si vous exécutez votre conteneur derrière un proxy de terminaison TLS (load balancer) comme Nginx ou Traefik, ajoutez l'option `--proxy-headers`, cela indiquera à Uvicorn (via la CLI FastAPI) de faire confiance aux en-têtes envoyés par ce proxy lui indiquant que l'application s'exécute derrière HTTPS, etc.
-
-```Dockerfile
-CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"]
-```
-
-#### Cache Docker { #docker-cache }
-
-Il y a une astuce importante dans ce `Dockerfile`, nous copions d'abord **le fichier des dépendances seul**, pas le reste du code. Laissez-moi vous expliquer pourquoi.
-
-```Dockerfile
-COPY ./requirements.txt /code/requirements.txt
-```
-
-Docker et d'autres outils **construisent** ces images de conteneur **de manière incrémentale**, en ajoutant **une couche au-dessus de l'autre**, en commençant par le haut du `Dockerfile` et en ajoutant tous les fichiers créés par chacune des instructions du `Dockerfile`.
-
-Docker et des outils similaires utilisent également un **cache interne** lors de la construction de l'image : si un fichier n'a pas changé depuis la dernière construction de l'image de conteneur, alors il va **réutiliser la même couche** créée la dernière fois, au lieu de recopier le fichier et créer une nouvelle couche à partir de zéro.
-
-Éviter simplement la copie des fichiers n'améliore pas nécessairement les choses de manière significative, mais comme il a utilisé le cache pour cette étape, il peut **utiliser le cache pour l'étape suivante**. Par exemple, il peut utiliser le cache pour l'instruction qui installe les dépendances avec :
-
-```Dockerfile
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-```
-
-Le fichier des dépendances **ne changera pas fréquemment**. Ainsi, en copiant uniquement ce fichier, Docker pourra **utiliser le cache** pour cette étape.
-
-Et ensuite, Docker pourra **utiliser le cache pour l'étape suivante** qui télécharge et installe ces dépendances. Et c'est là que nous **gagnons beaucoup de temps**. ✨ ... et évitons l'ennui en attendant. 😪😆
-
-Télécharger et installer les dépendances de paquets **peut prendre des minutes**, mais utiliser le **cache** ne **prendra que quelques secondes** au plus.
-
-Et comme vous reconstruirez l'image de conteneur encore et encore pendant le développement pour vérifier que vos modifications de code fonctionnent, cela vous fera gagner beaucoup de temps cumulé.
-
-Ensuite, vers la fin du `Dockerfile`, nous copions tout le code. Comme c'est ce qui **change le plus fréquemment**, nous le plaçons vers la fin, car presque toujours, tout ce qui suit cette étape ne pourra pas utiliser le cache.
-
-```Dockerfile
-COPY ./app /code/app
-```
-
-### Construire l'image Docker { #build-the-docker-image }
-
-Maintenant que tous les fichiers sont en place, construisons l'image de conteneur.
-
-* Allez dans le répertoire du projet (là où se trouve votre `Dockerfile`, contenant votre répertoire `app`).
+* Allez dans le répertoire du projet (dans lequel se trouve votre `Dockerfile`, contenant votre répertoire `app`).
 * Construisez votre image FastAPI :
 
 <div class="termy">
@@ -330,17 +109,9 @@ $ docker build -t myimage .
 
 </div>
 
-/// tip | Astuce
+## Démarrer le conteneur Docker
 
-Remarquez le `.` à la fin, équivalent à `./`, il indique à Docker le répertoire à utiliser pour construire l'image de conteneur.
-
-Dans ce cas, c'est le même répertoire courant (`.`).
-
-///
-
-### Démarrer le conteneur Docker { #start-the-docker-container }
-
-* Exécutez un conteneur basé sur votre image :
+* Exécutez un conteneur basé sur votre image :
 
 <div class="termy">
 
@@ -350,269 +121,65 @@ $ docker run -d --name mycontainer -p 80:80 myimage
 
 </div>
 
-## Vérifier { #check-it }
+Vous disposez maintenant d'un serveur FastAPI optimisé dans un conteneur Docker. Configuré automatiquement pour votre
+serveur actuel (et le nombre de cœurs du CPU).
 
-Vous devriez pouvoir le vérifier via l'URL de votre conteneur Docker, par exemple : <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> ou <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> (ou équivalent, en utilisant votre hôte Docker).
+## Vérifier
 
-Vous verrez quelque chose comme :
+Vous devriez pouvoir accéder à votre application via l'URL de votre conteneur Docker, par exemple : <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> ou <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> (ou équivalent, en utilisant votre hôte Docker).
+
+Vous verrez quelque chose comme :
 
 ```JSON
 {"item_id": 5, "q": "somequery"}
 ```
 
-## Documentation interactive de l'API { #interactive-api-docs }
+## Documentation interactive de l'API
 
-Vous pouvez maintenant aller sur <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> ou <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> (ou équivalent, en utilisant votre hôte Docker).
+Vous pouvez maintenant visiter <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> ou <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> (ou équivalent, en utilisant votre hôte Docker).
 
-Vous verrez la documentation interactive automatique de l'API (fournie par <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
+Vous verrez la documentation interactive automatique de l'API (fournie par <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-## Documentation alternative de l'API { #alternative-api-docs }
+## Documentation de l'API alternative
 
-Et vous pouvez aussi aller sur <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> ou <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> (ou équivalent, en utilisant votre hôte Docker).
+Et vous pouvez également aller sur <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> ou <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> (ou équivalent, en utilisant votre hôte Docker).
 
-Vous verrez la documentation automatique alternative (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
+Vous verrez la documentation automatique alternative (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Construire une image Docker avec un FastAPI mono-fichier { #build-a-docker-image-with-a-single-file-fastapi }
+## Traefik
 
-Si votre FastAPI est un seul fichier, par exemple `main.py` sans répertoire `./app`, votre structure de fichiers pourrait ressembler à ceci :
+<a href="https://traefik.io/" class="external-link" target="_blank">Traefik</a> est un reverse proxy/load balancer
+haute performance. Il peut faire office de "Proxy de terminaison TLS" (entre autres fonctionnalités).
 
-```
-.
-├── Dockerfile
-├── main.py
-└── requirements.txt
-```
+Il est intégré à Let's Encrypt. Ainsi, il peut gérer toutes les parties HTTPS, y compris l'acquisition et le renouvellement des certificats.
 
-Vous n'auriez alors qu'à changer les chemins correspondants pour copier le fichier dans le `Dockerfile` :
-
-```{ .dockerfile .annotate hl_lines="10  13" }
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# (1)!
-COPY ./main.py /code/
-
-# (2)!
-CMD ["fastapi", "run", "main.py", "--port", "80"]
-```
-
-1. Copier le fichier `main.py` directement dans le répertoire `/code` (sans répertoire `./app`).
-
-2. Utiliser `fastapi run` pour servir votre application dans le fichier unique `main.py`.
-
-Lorsque vous passez le fichier à `fastapi run`, il détectera automatiquement qu'il s'agit d'un fichier unique et non d'un package et saura comment l'importer et servir votre application FastAPI. 😎
-
-## Concepts de déploiement { #deployment-concepts }
-
-Parlons à nouveau de certains des mêmes [Concepts de déploiement](concepts.md){.internal-link target=_blank} en termes de conteneurs.
-
-Les conteneurs sont principalement un outil pour simplifier le processus de **construction et de déploiement** d'une application, mais ils n'imposent pas une approche particulière pour gérer ces **concepts de déploiement**, et il existe plusieurs stratégies possibles.
-
-La **bonne nouvelle**, c'est qu'avec chaque stratégie différente, il existe un moyen de couvrir tous les concepts de déploiement. 🎉
-
-Passons en revue ces **concepts de déploiement** en termes de conteneurs :
-
-* HTTPS
-* Exécution au démarrage
-* Redémarrages
-* Réplication (le nombre de processus en cours d'exécution)
-* Mémoire
-* Étapes préalables au démarrage
-
-## HTTPS { #https }
-
-Si l'on se concentre uniquement sur l'**image de conteneur** pour une application FastAPI (et plus tard sur le **conteneur** en cours d'exécution), HTTPS serait normalement géré **à l'extérieur** par un autre outil.
-
-Cela pourrait être un autre conteneur, par exemple avec <a href="https://traefik.io/" class="external-link" target="_blank">Traefik</a>, gérant **HTTPS** et l'acquisition **automatique** des **certificats**.
-
-/// tip | Astuce
-
-Traefik s'intègre avec Docker, Kubernetes, et d'autres, donc il est très facile de configurer HTTPS pour vos conteneurs avec lui.
-
-///
-
-Alternativement, HTTPS pourrait être géré par un fournisseur cloud comme l'un de leurs services (tout en exécutant l'application dans un conteneur).
-
-## Exécution au démarrage et redémarrages { #running-on-startup-and-restarts }
-
-Il y a normalement un autre outil chargé de **démarrer et exécuter** votre conteneur.
-
-Cela pourrait être **Docker** directement, **Docker Compose**, **Kubernetes**, un **service cloud**, etc.
-
-Dans la plupart (ou toutes) des situations, il existe une option simple pour activer l'exécution du conteneur au démarrage et activer les redémarrages en cas d'échec. Par exemple, dans Docker, c'est l'option de ligne de commande `--restart`.
-
-Sans utiliser de conteneurs, faire en sorte que les applications s'exécutent au démarrage et avec redémarrages peut être fastidieux et difficile. Mais en **travaillant avec des conteneurs**, dans la plupart des cas, cette fonctionnalité est incluse par défaut. ✨
-
-## Réplication - Nombre de processus { #replication-number-of-processes }
-
-Si vous avez un <abbr title="Un groupe de machines configurées pour être connectées et fonctionner ensemble d'une certaine manière.">cluster</abbr> de machines avec **Kubernetes**, Docker Swarm Mode, Nomad, ou un autre système complexe similaire pour gérer des conteneurs distribués sur plusieurs machines, alors vous voudrez probablement **gérer la réplication** au **niveau du cluster** plutôt que d'utiliser un **gestionnaire de processus** (comme Uvicorn avec workers) dans chaque conteneur.
-
-L'un de ces systèmes de gestion de conteneurs distribués comme Kubernetes dispose normalement d'une manière intégrée de gérer la **réplication des conteneurs** tout en supportant l'**équilibrage de charge** des requêtes entrantes. Le tout au **niveau du cluster**.
-
-Dans ces cas, vous voudrez probablement construire une **image Docker à partir de zéro** comme [expliqué ci-dessus](#dockerfile), en installant vos dépendances et en exécutant **un seul processus Uvicorn** au lieu d'utiliser plusieurs workers Uvicorn.
-
-### Équilibreur de charge { #load-balancer }
-
-Lors de l'utilisation de conteneurs, vous aurez normalement un composant **à l'écoute sur le port principal**. Cela pourrait être un autre conteneur qui est également un **proxy de terminaison TLS** pour gérer **HTTPS** ou un outil similaire.
-
-Comme ce composant prend la **charge** des requêtes et la distribue entre les workers de façon (espérons-le) **équilibrée**, on l'appelle également communément un **équilibreur de charge**.
-
-/// tip | Astuce
-
-Le même composant de **proxy de terminaison TLS** utilisé pour HTTPS sera probablement aussi un **équilibreur de charge**.
-
-///
-
-Et en travaillant avec des conteneurs, le même système que vous utilisez pour les démarrer et les gérer dispose déjà d'outils internes pour transmettre la **communication réseau** (par ex. les requêtes HTTP) depuis cet **équilibreur de charge** (qui peut aussi être un **proxy de terminaison TLS**) vers le ou les conteneurs avec votre application.
-
-### Un équilibreur de charge - Plusieurs conteneurs worker { #one-load-balancer-multiple-worker-containers }
-
-Lorsque vous travaillez avec **Kubernetes** ou des systèmes de gestion de conteneurs distribués similaires, l'utilisation de leurs mécanismes réseau internes permet au **seul équilibreur de charge** à l'écoute sur le **port** principal de transmettre la communication (les requêtes) vers potentiellement **plusieurs conteneurs** exécutant votre application.
-
-Chacun de ces conteneurs exécutant votre application aura normalement **un seul processus** (par ex. un processus Uvicorn exécutant votre application FastAPI). Ils seront tous des **conteneurs identiques**, exécutant la même chose, mais chacun avec son propre processus, sa mémoire, etc. De cette façon, vous profiterez de la **parallélisation** sur **différents cœurs** du CPU, voire sur **différentes machines**.
-
-Et le système de conteneurs distribués avec l'**équilibreur de charge** **distribuera les requêtes** à chacun des conteneurs exécutant votre application **à tour de rôle**. Ainsi, chaque requête pourrait être traitée par l'un des multiples **conteneurs répliqués** exécutant votre application.
-
-Et normalement cet **équilibreur de charge** pourra gérer des requêtes qui vont vers *d'autres* applications dans votre cluster (par ex. vers un autre domaine, ou sous un autre préfixe de chemin d'URL), et transmettra cette communication aux bons conteneurs pour *cette autre* application s'exécutant dans votre cluster.
-
-### Un processus par conteneur { #one-process-per-container }
-
-Dans ce type de scénario, vous voudrez probablement avoir **un seul processus (Uvicorn) par conteneur**, puisque vous gérez déjà la réplication au niveau du cluster.
-
-Donc, dans ce cas, vous **ne voudrez pas** avoir plusieurs workers dans le conteneur, par exemple avec l'option de ligne de commande `--workers`. Vous voudrez avoir **un seul processus Uvicorn** par conteneur (mais probablement plusieurs conteneurs).
-
-Avoir un autre gestionnaire de processus à l'intérieur du conteneur (comme ce serait le cas avec plusieurs workers) n'ajouterait que de la **complexité inutile** que vous gérez très probablement déjà avec votre système de cluster.
-
-### Conteneurs avec plusieurs processus et cas particuliers { #containers-with-multiple-processes-and-special-cases }
-
-Bien sûr, il existe des **cas particuliers** où vous pourriez vouloir avoir **un conteneur** avec plusieurs **processus worker Uvicorn** à l'intérieur.
-
-Dans ces cas, vous pouvez utiliser l'option de ligne de commande `--workers` pour définir le nombre de workers que vous souhaitez exécuter :
-
-```{ .dockerfile .annotate }
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-COPY ./app /code/app
-
-# (1)!
-CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
-```
-
-1. Ici, nous utilisons l'option de ligne de commande `--workers` pour définir le nombre de workers à 4.
-
-Voici quelques exemples où cela pourrait avoir du sens :
-
-#### Une application simple { #a-simple-app }
-
-Vous pourriez vouloir un gestionnaire de processus dans le conteneur si votre application est **suffisamment simple** pour s'exécuter sur un **seul serveur**, pas un cluster.
-
-#### Docker Compose { #docker-compose }
-
-Vous pourriez déployer sur un **seul serveur** (pas un cluster) avec **Docker Compose**, donc vous n'auriez pas un moyen simple de gérer la réplication des conteneurs (avec Docker Compose) tout en préservant le réseau partagé et l'**équilibrage de charge**.
-
-Vous pourriez alors vouloir avoir **un seul conteneur** avec un **gestionnaire de processus** qui démarre **plusieurs processus worker** à l'intérieur.
+Il est également intégré à Docker. Ainsi, vous pouvez déclarer vos domaines dans les configurations de chaque application et faire en sorte qu'elles lisent ces configurations, génèrent les certificats HTTPS et servent via HTTPS à votre application automatiquement, sans nécessiter aucune modification de leurs configurations.
 
 ---
 
-L'idée principale est que **rien** de tout cela ne sont des **règles gravées dans la pierre** que vous devez suivre aveuglément. Vous pouvez utiliser ces idées pour **évaluer votre propre cas d'usage** et décider de la meilleure approche pour votre système, en vérifiant comment gérer les concepts suivants :
+Avec ces informations et ces outils, passez à la section suivante pour tout combiner.
 
-* Sécurité - HTTPS
-* Exécution au démarrage
-* Redémarrages
-* Réplication (le nombre de processus en cours d'exécution)
-* Mémoire
-* Étapes préalables au démarrage
+## Cluster en mode Docker Swarm avec Traefik et HTTPS
 
-## Mémoire { #memory }
+Vous pouvez avoir un cluster en mode Docker Swarm configuré en quelques minutes (environ 20 min) avec un processus Traefik principal gérant HTTPS (y compris l'acquisition et le renouvellement des certificats).
 
-Si vous exécutez **un seul processus par conteneur**, vous aurez une quantité de mémoire consommée plus ou moins bien définie, stable et limitée par chacun de ces conteneurs (plus d'un s'ils sont répliqués).
+En utilisant le mode Docker Swarm, vous pouvez commencer par un "cluster" d'une seule machine (il peut même s'agir
+d'un serveur à 5 USD/mois) et ensuite vous pouvez vous développer autant que vous le souhaitez en ajoutant d'autres serveurs.
 
-Vous pouvez alors définir ces mêmes limites et exigences de mémoire dans vos configurations pour votre système de gestion de conteneurs (par exemple dans **Kubernetes**). De cette façon, il pourra **répliquer les conteneurs** sur les **machines disponibles** en tenant compte de la quantité de mémoire dont ils ont besoin et de la quantité disponible sur les machines du cluster.
+Pour configurer un cluster en mode Docker Swarm avec Traefik et la gestion de HTTPS, suivez ce guide :
 
-Si votre application est **simple**, cela ne sera probablement **pas un problème**, et vous n'aurez peut-être pas besoin de spécifier des limites de mémoire strictes. Mais si vous **utilisez beaucoup de mémoire** (par exemple avec des modèles de **machine learning**), vous devez vérifier combien de mémoire vous consommez et ajuster le **nombre de conteneurs** qui s'exécutent sur **chaque machine** (et peut-être ajouter plus de machines à votre cluster).
+### <a href="https://medium.com/@tiangolo/docker-swarm-mode-and-traefik-for-a-https-cluster-20328dba6232" class="external-link" target="_blank">Docker Swarm Mode et Traefik pour un cluster HTTPS</a>
 
-Si vous exécutez **plusieurs processus par conteneur**, vous devez vous assurer que le nombre de processus démarrés ne **consomme pas plus de mémoire** que ce qui est disponible.
+### Déployer une application FastAPI
 
-## Étapes préalables au démarrage et conteneurs { #previous-steps-before-starting-and-containers }
+La façon la plus simple de tout mettre en place, serait d'utiliser les [**Générateurs de projet FastAPI**](../project-generation.md){.internal-link target=_blank}.
 
-Si vous utilisez des conteneurs (par ex. Docker, Kubernetes), alors il existe deux approches principales que vous pouvez utiliser.
+Le génerateur de projet adéquat est conçu pour être intégré à ce cluster Docker Swarm avec Traefik et HTTPS décrit ci-dessus.
 
-### Plusieurs conteneurs { #multiple-containers }
+Vous pouvez générer un projet en 2 min environ.
 
-Si vous avez **plusieurs conteneurs**, probablement chacun exécutant un **seul processus** (par exemple, dans un cluster **Kubernetes**), alors vous voudrez probablement avoir un **conteneur séparé** effectuant le travail des **étapes préalables** dans un seul conteneur, exécutant un seul processus, **avant** d'exécuter les conteneurs worker répliqués.
-
-/// info
-
-Si vous utilisez Kubernetes, ce sera probablement un <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers/" class="external-link" target="_blank">Init Container</a>.
-
-///
-
-Si, dans votre cas d'usage, il n'y a pas de problème à exécuter ces étapes préalables **plusieurs fois en parallèle** (par exemple si vous n'exécutez pas de migrations de base de données, mais vérifiez simplement si la base de données est prête), alors vous pourriez aussi simplement les mettre dans chaque conteneur juste avant de démarrer le processus principal.
-
-### Un seul conteneur { #single-container }
-
-Si vous avez une configuration simple, avec **un seul conteneur** qui démarre ensuite plusieurs **processus worker** (ou un seul processus aussi), vous pouvez alors exécuter ces étapes préalables dans le même conteneur, juste avant de démarrer le processus avec l'application.
-
-### Image Docker de base { #base-docker-image }
-
-Il existait une image Docker officielle FastAPI : <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Mais elle est désormais dépréciée. ⛔️
-
-Vous ne devriez probablement **pas** utiliser cette image Docker de base (ni aucune autre similaire).
-
-Si vous utilisez **Kubernetes** (ou autres) et que vous définissez déjà la **réplication** au niveau du cluster, avec plusieurs **conteneurs**. Dans ces cas, il est préférable de **construire une image à partir de zéro** comme décrit ci-dessus : [Construire une image Docker pour FastAPI](#build-a-docker-image-for-fastapi).
-
-Et si vous devez avoir plusieurs workers, vous pouvez simplement utiliser l'option de ligne de commande `--workers`.
-
-/// note | Détails techniques
-
-L'image Docker a été créée à une époque où Uvicorn ne supportait pas la gestion et le redémarrage des workers morts, il fallait donc utiliser Gunicorn avec Uvicorn, ce qui ajoutait pas mal de complexité, uniquement pour que Gunicorn gère et redémarre les processus worker Uvicorn.
-
-Mais maintenant qu'Uvicorn (et la commande `fastapi`) supporte l'usage de `--workers`, il n'y a plus de raison d'utiliser une image Docker de base au lieu de construire la vôtre (c'est à peu près la même quantité de code 😅).
-
-///
-
-## Déployer l'image de conteneur { #deploy-the-container-image }
-
-Après avoir une image de conteneur (Docker), il existe plusieurs façons de la déployer.
-
-Par exemple :
-
-* Avec **Docker Compose** sur un seul serveur
-* Avec un cluster **Kubernetes**
-* Avec un cluster Docker Swarm Mode
-* Avec un autre outil comme Nomad
-* Avec un service cloud qui prend votre image de conteneur et la déploie
-
-## Image Docker avec `uv` { #docker-image-with-uv }
-
-Si vous utilisez <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> pour installer et gérer votre projet, vous pouvez suivre leur <a href="https://docs.astral.sh/uv/guides/integration/docker/" class="external-link" target="_blank">guide Docker pour uv</a>.
-
-## Récapitulatif { #recap }
-
-Avec les systèmes de conteneurs (par ex. avec **Docker** et **Kubernetes**), il devient assez simple de gérer tous les **concepts de déploiement** :
-
-* HTTPS
-* Exécution au démarrage
-* Redémarrages
-* Réplication (le nombre de processus en cours d'exécution)
-* Mémoire
-* Étapes préalables au démarrage
-
-Dans la plupart des cas, vous ne voudrez probablement pas utiliser d'image de base, et au contraire **construire une image de conteneur à partir de zéro** basée sur l'image Docker Python officielle.
-
-En prenant soin de l'**ordre** des instructions dans le `Dockerfile` et du **cache Docker**, vous pouvez **minimiser les temps de construction**, maximiser votre productivité (et éviter l'ennui). 😎
+Le projet généré a des instructions pour le déployer et le faire prend 2 min de plus.

docs/fr/docs/deployment/https.md

@@ -1,231 +1,56 @@
-# À propos de HTTPS { #about-https }
+# À propos de HTTPS
 
-Il est facile de supposer que HTTPS est quelque chose qui est simplement « activé » ou non.
+Il est facile de penser que HTTPS peut simplement être "activé" ou non.
 
 Mais c'est beaucoup plus complexe que cela.
 
-/// tip | Astuce
+/// tip
 
-Si vous êtes pressé ou si cela ne vous intéresse pas, continuez avec les sections suivantes pour obtenir des instructions étape par étape afin de tout configurer avec différentes techniques.
+Si vous êtes pressé ou si cela ne vous intéresse pas, passez aux sections suivantes pour obtenir des instructions étape par étape afin de tout configurer avec différentes techniques.
 
 ///
 
-Pour apprendre les bases du HTTPS, du point de vue d'un utilisateur, consultez <a href="https://howhttps.works/" class="external-link" target="_blank">https://howhttps.works/</a>.
+Pour apprendre les bases du HTTPS, du point de vue d'un utilisateur, consultez <a href="https://howhttps.works/"
+class="external-link" target="_blank">https://howhttps.works/</a>.
 
 Maintenant, du point de vue d'un développeur, voici plusieurs choses à avoir en tête en pensant au HTTPS :
 
-* Pour le HTTPS, **le serveur** doit **disposer de « certificats »** générés par une **tierce partie**.
-    * Ces certificats sont en réalité **acquis** auprès de la tierce partie, et non « générés ».
-* Les certificats ont une **durée de vie**.
-    * Ils **expirent**.
-    * Puis ils doivent être **renouvelés**, **acquis à nouveau** auprès de la tierce partie.
-* Le cryptage de la connexion se fait au **niveau TCP**.
-    * C'est une couche **en dessous de HTTP**.
-    * Donc, la gestion du **certificat et du cryptage** est effectuée **avant HTTP**.
-* **TCP ne connaît pas les « domaines »**. Il ne connaît que les adresses IP.
-    * L'information sur le **domaine spécifique** demandé se trouve dans les **données HTTP**.
-* Les **certificats HTTPS** « certifient » un **certain domaine**, mais le protocole et le cryptage se font au niveau TCP, **avant de savoir** quel domaine est traité.
-* **Par défaut**, cela signifie que vous ne pouvez avoir qu'**un seul certificat HTTPS par adresse IP**.
-    * Quelle que soit la taille de votre serveur ou la petitesse de chacune des applications qu'il contient.
-    * Il existe cependant une **solution** à ce problème.
-* Il existe une **extension** du protocole **TLS** (celui qui gère le cryptage au niveau TCP, avant HTTP) appelée **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication - Indication du nom du serveur">SNI</abbr></a>**.
-    * Cette extension SNI permet à un seul serveur (avec une **seule adresse IP**) d'avoir **plusieurs certificats HTTPS** et de servir **plusieurs domaines/applications HTTPS**.
-    * Pour que cela fonctionne, un **seul** composant (programme) fonctionnant sur le serveur, écoutant sur l'**adresse IP publique**, doit avoir **tous les certificats HTTPS** du serveur.
-* **Après** l'établissement d'une connexion sécurisée, le protocole de communication est **toujours HTTP**.
-    * Le contenu est **crypté**, même s'il est envoyé avec le **protocole HTTP**.
+* Pour le HTTPS, le serveur a besoin de "certificats" générés par une tierce partie.
+    * Ces certificats sont en fait acquis auprès de la tierce partie, et non "générés".
+* Les certificats ont une durée de vie.
+    * Ils expirent.
+    * Puis ils doivent être renouvelés et acquis à nouveau auprès de la tierce partie.
+* Le cryptage de la connexion se fait au niveau du protocole TCP.
+    * C'est une couche en dessous de HTTP.
+    * Donc, le certificat et le traitement du cryptage sont faits avant HTTP.
+* TCP ne connaît pas les "domaines", seulement les adresses IP.
+    * L'information sur le domaine spécifique demandé se trouve dans les données HTTP.
+* Les certificats HTTPS "certifient" un certain domaine, mais le protocole et le cryptage se font au niveau TCP, avant de savoir quel domaine est traité.
+* Par défaut, cela signifie que vous ne pouvez avoir qu'un seul certificat HTTPS par adresse IP.
+    * Quelle que soit la taille de votre serveur ou la taille de chacune des applications qu'il contient.
+    * Il existe cependant une solution à ce problème.
+* Il existe une extension du protocole TLS (celui qui gère le cryptage au niveau TCP, avant HTTP) appelée <a
+  href="https://fr.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr
+  title="Server Name Indication (indication du nom du serveur)">SNI (indication du nom du serveur)</abbr></a>.
+    * Cette extension SNI permet à un seul serveur (avec une seule adresse IP) d'avoir plusieurs certificats HTTPS et de servir plusieurs domaines/applications HTTPS.
+    * Pour que cela fonctionne, un seul composant (programme) fonctionnant sur le serveur, écoutant sur l'adresse IP publique, doit avoir tous les certificats HTTPS du serveur.
+* Après avoir obtenu une connexion sécurisée, le protocole de communication est toujours HTTP.
+    * Le contenu est crypté, même s'il est envoyé avec le protocole HTTP.
 
-Il est courant d'avoir **un seul programme/serveur HTTP** fonctionnant sur le serveur (la machine, l'hôte, etc.) et **gérant toutes les parties HTTPS** : recevoir les **requêtes HTTPS chiffrées**, envoyer les **requêtes HTTP déchiffrées** à l'application HTTP réelle fonctionnant sur le même serveur (l'application **FastAPI**, dans ce cas), prendre la **réponse HTTP** de l'application, la **chiffrer** en utilisant le **certificat HTTPS** approprié et la renvoyer au client en utilisant **HTTPS**. Ce serveur est souvent appelé un **<a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">Proxy de terminaison TLS</a>**.
+Il est courant d'avoir un seul programme/serveur HTTP fonctionnant sur le serveur (la machine, l'hôte, etc.) et
+gérant toutes les parties HTTPS : envoyer les requêtes HTTP décryptées à l'application HTTP réelle fonctionnant sur
+le même serveur (dans ce cas, l'application **FastAPI**), prendre la réponse HTTP de l'application, la crypter en utilisant le certificat approprié et la renvoyer au client en utilisant HTTPS. Ce serveur est souvent appelé un <a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">Proxy de terminaison TLS</a>.
 
-Parmi les options que vous pourriez utiliser comme Proxy de terminaison TLS :
+## Let's Encrypt
 
-* Traefik (qui peut également gérer les renouvellements de certificats)
-* Caddy (qui peut également gérer les renouvellements de certificats)
-* Nginx
-* HAProxy
+Avant Let's Encrypt, ces certificats HTTPS étaient vendus par des tiers de confiance.
 
-## Let's Encrypt { #lets-encrypt }
+Le processus d'acquisition d'un de ces certificats était auparavant lourd, nécessitait pas mal de paperasses et les certificats étaient assez chers.
 
-Avant Let's Encrypt, ces **certificats HTTPS** étaient vendus par des tiers de confiance.
+Mais ensuite, <a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a> a été créé.
 
-Le processus d'acquisition de l'un de ces certificats était auparavant lourd, nécessitait pas mal de paperasses et les certificats étaient assez chers.
-
-Mais ensuite, **<a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a>** a été créé.
-
-Il s'agit d'un projet de la Fondation Linux. Il fournit **des certificats HTTPS gratuitement**, de manière automatisée. Ces certificats utilisent toutes les sécurités cryptographiques standard et ont une durée de vie courte (environ 3 mois), de sorte que la **sécurité est en fait meilleure** en raison de leur durée de vie réduite.
+Il s'agit d'un projet de la Fondation Linux. Il fournit des certificats HTTPS gratuitement. De manière automatisée. Ces certificats utilisent toutes les sécurités cryptographiques standard et ont une durée de vie courte (environ 3 mois), de sorte que la sécurité est en fait meilleure en raison de leur durée de vie réduite.
 
 Les domaines sont vérifiés de manière sécurisée et les certificats sont générés automatiquement. Cela permet également d'automatiser le renouvellement de ces certificats.
 
-L'idée est d'automatiser l'acquisition et le renouvellement de ces certificats, afin que vous puissiez disposer d'un **HTTPS sécurisé, gratuitement et pour toujours**.
-
-## HTTPS pour les développeurs { #https-for-developers }
-
-Voici un exemple de ce à quoi pourrait ressembler une API HTTPS, étape par étape, en portant principalement attention aux idées importantes pour les développeurs.
-
-### Nom de domaine { #domain-name }
-
-Tout commencerait probablement par le fait que vous **acquériez** un **nom de domaine**. Ensuite, vous le configureriez dans un serveur DNS (possiblement le même que votre fournisseur cloud).
-
-Vous obtiendriez probablement un serveur cloud (une machine virtuelle) ou quelque chose de similaire, et il aurait une adresse IP **publique** <abbr title="Qui ne change pas">fixe</abbr>.
-
-Dans le ou les serveurs DNS, vous configureriez un enregistrement (un « `A record` ») pour faire pointer **votre domaine** vers l'**adresse IP publique de votre serveur**.
-
-Vous feriez probablement cela une seule fois, la première fois, lors de la mise en place de l'ensemble.
-
-/// tip | Astuce
-
-Cette partie relative au nom de domaine intervient bien avant HTTPS, mais comme tout dépend du domaine et de l'adresse IP, il vaut la peine de la mentionner ici.
-
-///
-
-### DNS { #dns }
-
-Concentrons-nous maintenant sur toutes les parties réellement liées à HTTPS.
-
-D'abord, le navigateur vérifierait auprès des **serveurs DNS** quelle est l'**IP du domaine**, dans ce cas, `someapp.example.com`.
-
-Les serveurs DNS indiqueraient au navigateur d'utiliser une **adresse IP** spécifique. Ce serait l'adresse IP publique utilisée par votre serveur, celle que vous avez configurée dans les serveurs DNS.
-
-<img src="/img/deployment/https/https01.drawio.svg">
-
-### Début de la négociation TLS (Handshake) { #tls-handshake-start }
-
-Le navigateur communiquerait ensuite avec cette adresse IP sur le **port 443** (le port HTTPS).
-
-La première partie de la communication consiste simplement à établir la connexion entre le client et le serveur et à décider des clés cryptographiques qu'ils utiliseront, etc.
-
-<img src="/img/deployment/https/https02.drawio.svg">
-
-Cette interaction entre le client et le serveur pour établir la connexion TLS s'appelle la **négociation TLS (TLS handshake)**.
-
-### TLS avec l'extension SNI { #tls-with-sni-extension }
-
-**Un seul processus** sur le serveur peut écouter sur un **port** spécifique d'une **adresse IP** spécifique. Il pourrait y avoir d'autres processus écoutant sur d'autres ports de la même adresse IP, mais un seul pour chaque combinaison d'adresse IP et de port.
-
-TLS (HTTPS) utilise par défaut le port spécifique `443`. C'est donc le port dont nous aurions besoin.
-
-Comme un seul processus peut écouter sur ce port, le processus qui le ferait serait le **Proxy de terminaison TLS**.
-
-Le Proxy de terminaison TLS aurait accès à un ou plusieurs **certificats TLS** (certificats HTTPS).
-
-En utilisant l'**extension SNI** mentionnée plus haut, le Proxy de terminaison TLS vérifierait lequel des certificats TLS (HTTPS) disponibles il devrait utiliser pour cette connexion, en choisissant celui qui correspond au domaine attendu par le client.
-
-Dans ce cas, il utiliserait le certificat pour `someapp.example.com`.
-
-<img src="/img/deployment/https/https03.drawio.svg">
-
-Le client **fait déjà confiance** à l'entité qui a généré ce certificat TLS (dans ce cas Let's Encrypt, mais nous y reviendrons plus tard), il peut donc **vérifier** que le certificat est valide.
-
-Ensuite, en utilisant le certificat, le client et le Proxy de terminaison TLS **décident comment chiffrer** le reste de la **communication TCP**. Cela termine la partie **négociation TLS**.
-
-Après cela, le client et le serveur disposent d'une **connexion TCP chiffrée**, c'est ce que fournit TLS. Ils peuvent alors utiliser cette connexion pour démarrer la **communication HTTP** proprement dite.
-
-Et c'est ce qu'est **HTTPS** : c'est simplement du **HTTP** à l'intérieur d'une **connexion TLS sécurisée** au lieu d'une connexion TCP pure (non chiffrée).
-
-/// tip | Astuce
-
-Remarquez que le cryptage de la communication se produit au **niveau TCP**, pas au niveau HTTP.
-
-///
-
-### Requête HTTPS { #https-request }
-
-Maintenant que le client et le serveur (spécifiquement le navigateur et le Proxy de terminaison TLS) ont une **connexion TCP chiffrée**, ils peuvent démarrer la **communication HTTP**.
-
-Ainsi, le client envoie une **requête HTTPS**. Ce n'est qu'une requête HTTP à travers une connexion TLS chiffrée.
-
-<img src="/img/deployment/https/https04.drawio.svg">
-
-### Déchiffrer la requête { #decrypt-the-request }
-
-Le Proxy de terminaison TLS utiliserait le chiffrement convenu pour **déchiffrer la requête**, et transmettrait la **requête HTTP en clair (déchiffrée)** au processus exécutant l'application (par exemple un processus avec Uvicorn exécutant l'application FastAPI).
-
-<img src="/img/deployment/https/https05.drawio.svg">
-
-### Réponse HTTP { #http-response }
-
-L'application traiterait la requête et enverrait une **réponse HTTP en clair (non chiffrée)** au Proxy de terminaison TLS.
-
-<img src="/img/deployment/https/https06.drawio.svg">
-
-### Réponse HTTPS { #https-response }
-
-Le Proxy de terminaison TLS **chiffrerait ensuite la réponse** en utilisant la cryptographie convenue auparavant (qui a commencé avec le certificat pour `someapp.example.com`), et la renverrait au navigateur.
-
-Ensuite, le navigateur vérifierait que la réponse est valide et chiffrée avec la bonne clé cryptographique, etc. Il **déchiffrerait la réponse** et la traiterait.
-
-<img src="/img/deployment/https/https07.drawio.svg">
-
-Le client (navigateur) saura que la réponse provient du bon serveur parce qu'elle utilise la cryptographie convenue auparavant à l'aide du **certificat HTTPS**.
-
-### Applications multiples { #multiple-applications }
-
-Sur le même serveur (ou les mêmes serveurs), il pourrait y avoir **plusieurs applications**, par exemple d'autres programmes d'API ou une base de données.
-
-Un seul processus peut gérer l'adresse IP et le port spécifiques (le Proxy de terminaison TLS dans notre exemple), mais les autres applications/processus peuvent également s'exécuter sur le ou les serveurs, tant qu'ils n'essaient pas d'utiliser la même **combinaison d'adresse IP publique et de port**.
-
-<img src="/img/deployment/https/https08.drawio.svg">
-
-De cette façon, le Proxy de terminaison TLS pourrait gérer HTTPS et les certificats pour **plusieurs domaines**, pour plusieurs applications, puis transmettre les requêtes à la bonne application dans chaque cas.
-
-### Renouvellement des certificats { #certificate-renewal }
-
-À un moment donné dans le futur, chaque certificat **expirerait** (environ 3 mois après son acquisition).
-
-Ensuite, il y aurait un autre programme (dans certains cas c'est un autre programme, dans d'autres cas cela pourrait être le même Proxy de terminaison TLS) qui communiquerait avec Let's Encrypt et renouvellerait le ou les certificats.
-
-<img src="/img/deployment/https/https.drawio.svg">
-
-Les **certificats TLS** sont **associés à un nom de domaine**, pas à une adresse IP.
-
-Ainsi, pour renouveler les certificats, le programme de renouvellement doit **prouver** à l'autorité (Let's Encrypt) qu'il **« possède » et contrôle ce domaine**.
-
-Pour ce faire, et pour s'adapter aux différents besoins des applications, il existe plusieurs façons de procéder. Parmi les plus courantes :
-
-* **Modifier certains enregistrements DNS**.
-    * Pour cela, le programme de renouvellement doit prendre en charge les API du fournisseur DNS ; ainsi, selon le fournisseur DNS que vous utilisez, cela peut être ou non une option.
-* **S'exécuter comme un serveur** (au moins pendant le processus d'acquisition du certificat) sur l'adresse IP publique associée au domaine.
-    * Comme nous l'avons dit plus haut, un seul processus peut écouter sur une adresse IP et un port spécifiques.
-    * C'est l'une des raisons pour lesquelles il est très utile que le même Proxy de terminaison TLS prenne également en charge le processus de renouvellement des certificats.
-    * Sinon, vous pourriez avoir à arrêter le Proxy de terminaison TLS momentanément, démarrer le programme de renouvellement pour acquérir les certificats, puis les configurer avec le Proxy de terminaison TLS, et ensuite redémarrer le Proxy de terminaison TLS. Ce n'est pas idéal, car votre/vos application(s) ne seront pas disponibles pendant le temps où le Proxy de terminaison TLS est arrêté.
-
-Tout ce processus de renouvellement, tout en continuant à servir l'application, est l'une des principales raisons pour lesquelles vous voudriez avoir un **système séparé pour gérer HTTPS** avec un Proxy de terminaison TLS, au lieu d'utiliser directement les certificats TLS avec le serveur d'application (par exemple Uvicorn).
-
-## En-têtes Proxy Forwarded { #proxy-forwarded-headers }
-
-Lorsque vous utilisez un proxy pour gérer HTTPS, votre **serveur d'application** (par exemple Uvicorn via FastAPI CLI) ne connaît rien du processus HTTPS, il communique en HTTP en clair avec le **Proxy de terminaison TLS**.
-
-Ce **proxy** définirait normalement certains en-têtes HTTP à la volée avant de transmettre la requête au **serveur d'application**, pour informer le serveur d'application que la requête est **transmise** par le proxy.
-
-/// note | Détails techniques
-
-Les en-têtes du proxy sont :
-
-* <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>
-
-///
-
-Néanmoins, comme le **serveur d'application** ne sait pas qu'il se trouve derrière un **proxy** de confiance, par défaut, il ne ferait pas confiance à ces en-têtes.
-
-Mais vous pouvez configurer le **serveur d'application** pour qu'il fasse confiance aux en-têtes transmis (*forwarded*) envoyés par le **proxy**. Si vous utilisez FastAPI CLI, vous pouvez utiliser l'*option CLI* `--forwarded-allow-ips` pour lui indiquer à partir de quelles IP il doit faire confiance à ces en-têtes transmis.
-
-Par exemple, si le **serveur d'application** ne reçoit des communications que du **proxy** de confiance, vous pouvez définir `--forwarded-allow-ips="*"` pour lui faire faire confiance à toutes les IP entrantes, puisqu'il ne recevra des requêtes que depuis l'IP utilisée par le **proxy**.
-
-De cette façon, l'application sera en mesure de savoir quelle est sa propre URL publique, si elle utilise HTTPS, le domaine, etc.
-
-Cela serait utile, par exemple, pour gérer correctement les redirections.
-
-/// tip | Astuce
-
-Vous pouvez en savoir plus dans la documentation [Derrière un proxy - Activer les en-têtes transmis par le proxy](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
-
-///
-
-## Récapitulatif { #recap }
-
-Disposer de **HTTPS** est très important, et assez **critique** dans la plupart des cas. La majeure partie de l'effort que vous, en tant que développeur, devez fournir autour de HTTPS consiste simplement à **comprendre ces concepts** et leur fonctionnement.
-
-Mais une fois que vous connaissez les informations de base sur **HTTPS pour les développeurs**, vous pouvez facilement combiner et configurer différents outils pour vous aider à tout gérer simplement.
-
-Dans certains des prochains chapitres, je vous montrerai plusieurs exemples concrets de configuration de **HTTPS** pour des applications **FastAPI**. 🔒
+L'idée est d'automatiser l'acquisition et le renouvellement de ces certificats, afin que vous puissiez disposer d'un HTTPS sécurisé, gratuitement et pour toujours.

docs/fr/docs/deployment/index.md

@@ -1,8 +1,8 @@
-# Déploiement { #deployment }
+# Déploiement
 
 Le déploiement d'une application **FastAPI** est relativement simple.
 
-## Que signifie le déploiement { #what-does-deployment-mean }
+## Que signifie le déploiement
 
 **Déployer** une application signifie effectuer les étapes nécessaires pour la rendre **disponible pour les
 utilisateurs**.
@@ -14,7 +14,7 @@ l'application efficacement et sans interruption ni problème.
 Ceci contraste avec les étapes de **développement**, où vous êtes constamment en train de modifier le code, de le casser
 et de le réparer, d'arrêter et de redémarrer le serveur de développement, _etc._
 
-## Stratégies de déploiement { #deployment-strategies }
+## Stratégies de déploiement
 
 Il existe plusieurs façons de procéder, en fonction de votre cas d'utilisation spécifique et des outils que vous
 utilisez.
@@ -22,8 +22,6 @@ utilisez.
 Vous pouvez **déployer un serveur** vous-même en utilisant une combinaison d'outils, vous pouvez utiliser un **service
 cloud** qui fait une partie du travail pour vous, ou encore d'autres options possibles.
 
-Par exemple, nous, l'équipe derrière FastAPI, avons créé <a href="https://fastapicloud.com" class="external-link" target="_blank">**FastAPI Cloud**</a>, pour rendre le déploiement d'applications FastAPI dans le cloud aussi fluide que possible, avec la même expérience développeur que lorsque vous travaillez avec FastAPI.
-
 Je vais vous montrer certains des principaux concepts que vous devriez probablement avoir à l'esprit lors du déploiement
 d'une application **FastAPI** (bien que la plupart de ces concepts s'appliquent à tout autre type d'application web).
 

docs/fr/docs/deployment/manually.md

@@ -1,82 +1,33 @@
-# Exécuter un serveur manuellement { #run-a-server-manually }
+# Exécuter un serveur manuellement - Uvicorn
 
-## Utiliser la commande `fastapi run` { #use-the-fastapi-run-command }
+La principale chose dont vous avez besoin pour exécuter une application **FastAPI** sur une machine serveur distante est un programme serveur ASGI tel que **Uvicorn**.
 
-En bref, utilisez `fastapi run` pour servir votre application FastAPI :
-
-<div class="termy">
-
-```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 production server 🚀
-
-             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>
-
-   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
-             the following code:
-
-             <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>
-
-      <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>  Started server process <b>[</b><font color="#34E2E2"><b>2306215</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>  Application startup complete.
-     <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>
-```
-
-</div>
-
-Cela fonctionnerait pour la plupart des cas. 😎
-
-Vous pourriez utiliser cette commande par exemple pour démarrer votre application **FastAPI** dans un conteneur, sur un serveur, etc.
-
-## Serveurs ASGI { #asgi-servers }
-
-Allons un peu plus en détail.
-
-FastAPI utilise un standard pour construire des frameworks web Python et des serveurs appelé <abbr title="Asynchronous Server Gateway Interface - Interface passerelle serveur asynchrone">ASGI</abbr>. FastAPI est un framework web ASGI.
-
-La principale chose dont vous avez besoin pour exécuter une application **FastAPI** (ou toute autre application ASGI) sur une machine serveur distante est un programme serveur ASGI comme **Uvicorn**, c'est celui utilisé par défaut par la commande `fastapi`.
-
-Il existe plusieurs alternatives, notamment :
+Il existe 3 principales alternatives :
 
 * <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a> : un serveur ASGI haute performance.
-* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a> : un serveur ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
-* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a> : le serveur ASGI conçu pour Django Channels.
-* <a href="https://github.com/emmett-framework/granian" class="external-link" target="_blank">Granian</a> : un serveur HTTP Rust pour les applications Python.
-* <a href="https://unit.nginx.org/howto/fastapi/" class="external-link" target="_blank">NGINX Unit</a> : NGINX Unit est un environnement d'exécution d'applications web léger et polyvalent.
+* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a> : un serveur
+  ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
+* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a> : le serveur ASGI
+  conçu pour Django Channels.
 
-## Machine serveur et programme serveur { #server-machine-and-server-program }
+## Machine serveur et programme serveur
 
 Il y a un petit détail sur les noms à garder à l'esprit. 💡
 
-Le mot « serveur » est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).
+Le mot "**serveur**" est couramment utilisé pour désigner à la fois l'ordinateur distant/cloud (la machine physique ou virtuelle) et également le programme qui s'exécute sur cette machine (par exemple, Uvicorn).
 
-Gardez cela à l'esprit lorsque vous lisez « serveur » en général, cela pourrait faire référence à l'une de ces deux choses.
+Gardez cela à l'esprit lorsque vous lisez "serveur" en général, cela pourrait faire référence à l'une de ces deux choses.
 
-Lorsqu'on se réfère à la machine distante, il est courant de l'appeler **serveur**, mais aussi **machine**, **VM** (machine virtuelle), **nœud**. Tout cela fait référence à un type de machine distante, exécutant normalement Linux, sur laquelle vous exécutez des programmes.
+Lorsqu'on se réfère à la machine distante, il est courant de l'appeler **serveur**, mais aussi **machine**, **VM** (machine virtuelle), **nœud**. Tout cela fait référence à un type de machine distante, exécutant  Linux, en règle générale, sur laquelle vous exécutez des programmes.
 
-## Installer le programme serveur { #install-the-server-program }
 
-Lorsque vous installez FastAPI, il est fourni avec un serveur de production, Uvicorn, et vous pouvez le démarrer avec la commande `fastapi run`.
+## Installer le programme serveur
 
-Mais vous pouvez également installer un serveur ASGI manuellement.
+Vous pouvez installer un serveur compatible ASGI avec :
 
-Vous devez créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, l'activer, puis vous pouvez installer l'application serveur.
+//// tab | Uvicorn
 
-Par exemple, pour installer Uvicorn :
+* <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>, un serveur ASGI rapide comme l'éclair, basé sur uvloop et httptools.
 
 <div class="termy">
 
@@ -88,21 +39,39 @@ $ pip install "uvicorn[standard]"
 
 </div>
 
-Un processus similaire s'appliquerait à tout autre programme de serveur ASGI.
-
 /// tip | Astuce
 
 En ajoutant `standard`, Uvicorn va installer et utiliser quelques dépendances supplémentaires recommandées.
 
-Cela inclut `uvloop`, le remplaçant hautes performances de `asyncio`, qui fournit le gros gain de performance en matière de concurrence.
-
-Lorsque vous installez FastAPI avec quelque chose comme `pip install "fastapi[standard]"`, vous obtenez déjà `uvicorn[standard]` aussi.
+Cela inclut `uvloop`, le remplaçant performant de `asyncio`, qui fournit le gros gain de performance en matière de concurrence.
 
 ///
 
-## Exécuter le programme serveur { #run-the-server-program }
+////
 
-Si vous avez installé un serveur ASGI manuellement, vous devrez normalement passer une chaîne d'import dans un format spécial pour qu'il importe votre application FastAPI :
+//// tab | Hypercorn
+
+* <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>, un serveur ASGI également compatible avec HTTP/2.
+
+<div class="termy">
+
+```console
+$ pip install hypercorn
+
+---> 100%
+```
+
+</div>
+
+...ou tout autre serveur ASGI.
+
+////
+
+## Exécutez le programme serveur
+
+Vous pouvez ensuite exécuter votre application de la même manière que vous l'avez fait dans les tutoriels, mais sans l'option `--reload`, par exemple :
+
+//// tab | Uvicorn
 
 <div class="termy">
 
@@ -114,44 +83,85 @@ $ uvicorn main:app --host 0.0.0.0 --port 80
 
 </div>
 
-/// note | Remarque
+////
 
-La commande `uvicorn main:app` fait référence à :
+//// tab | Hypercorn
 
-* `main` : le fichier `main.py` (le « module » Python).
-* `app` : l'objet créé dans `main.py` avec la ligne `app = FastAPI()`.
+<div class="termy">
 
-C'est équivalent à :
+```console
+$ hypercorn main:app --bind 0.0.0.0:80
 
-```Python
-from main import app
+Running on 0.0.0.0:8080 over http (CTRL + C to quit)
 ```
 
-///
+</div>
 
-Chaque programme de serveur ASGI alternatif aurait une commande similaire, vous pouvez en lire plus dans leur documentation respective.
+////
 
-/// warning | Alertes
+/// warning
 
-Uvicorn et d'autres serveurs prennent en charge une option `--reload` utile pendant le développement.
+N'oubliez pas de supprimer l'option `--reload` si vous l'utilisiez.
 
-L'option `--reload` consomme beaucoup plus de ressources, est plus instable, etc.
+ L'option `--reload` consomme beaucoup plus de ressources, est plus instable, etc.
 
-Cela aide beaucoup pendant le **développement**, mais vous **ne devriez pas** l'utiliser en **production**.
+ Cela aide beaucoup pendant le **développement**, mais vous **ne devriez pas** l'utiliser en **production**.
 
 ///
 
-## Concepts de déploiement { #deployment-concepts }
+## Hypercorn avec Trio
 
-Ces exemples exécutent le programme serveur (par exemple Uvicorn), en démarrant **un seul processus**, à l'écoute sur toutes les IP (`0.0.0.0`) sur un port prédéfini (par exemple `80`).
+Starlette et **FastAPI** sont basés sur
+<a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>, qui les rend
+compatibles avec <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a>, de la bibliothèque standard Python et
+<a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>.
 
-C'est l'idée de base. Mais vous voudrez probablement vous occuper de certaines choses supplémentaires, comme :
+Néanmoins, Uvicorn n'est actuellement compatible qu'avec asyncio, et il utilise normalement <a href="https://github.
+com/MagicStack/uvloop" class="external-link" target="_blank">`uvloop`</a >, le remplaçant hautes performances de `asyncio`.
 
-* Sécurité - HTTPS
-* Exécution au démarrage
-* Redémarrages
-* Réplication (le nombre de processus en cours d'exécution)
-* Mémoire
-* Étapes précédant le démarrage
+Mais si vous souhaitez utiliser directement **Trio**, vous pouvez utiliser **Hypercorn** car il le prend en charge. ✨
 
-Je vous en dirai plus sur chacun de ces concepts, sur la manière d'y réfléchir, et donnerai quelques exemples concrets avec des stratégies pour les gérer dans les prochains chapitres. 🚀
+### Installer Hypercorn avec Trio
+
+Vous devez d'abord installer Hypercorn avec le support Trio :
+
+<div class="termy">
+
+```console
+$ pip install "hypercorn[trio]"
+---> 100%
+```
+
+</div>
+
+### Exécuter avec Trio
+
+Ensuite, vous pouvez passer l'option de ligne de commande `--worker-class` avec la valeur `trio` :
+
+<div class="termy">
+
+```console
+$ hypercorn main:app --worker-class trio
+```
+
+</div>
+
+Et cela démarrera Hypercorn avec votre application en utilisant Trio comme backend.
+
+Vous pouvez désormais utiliser Trio en interne dans votre application. Ou mieux encore, vous pouvez utiliser AnyIO pour que votre code reste compatible avec Trio et asyncio. 🎉
+
+## Concepts de déploiement
+
+Ces exemples lancent le programme serveur (e.g. Uvicorn), démarrant **un seul processus**, sur toutes les IPs (`0.0.
+0.0`) sur un port prédéfini (par example, `80`).
+
+C'est l'idée de base. Mais vous vous préoccuperez probablement de certains concepts supplémentaires, tels que ... :
+
+* la sécurité - HTTPS
+* l'exécution au démarrage
+* les redémarrages
+* la réplication (le nombre de processus en cours d'exécution)
+* la mémoire
+* les étapes précédant le démarrage
+
+Je vous en dirai plus sur chacun de ces concepts, sur la façon de les aborder, et donnerai quelques exemples concrets avec des stratégies pour les traiter dans les prochains chapitres. 🚀

docs/fr/docs/deployment/versions.md

@@ -1,93 +1,101 @@
-# À propos des versions de FastAPI { #about-fastapi-versions }
+# À propos des versions de FastAPI
 
-**FastAPI** est déjà utilisé en production dans de nombreuses applications et de nombreux systèmes. Et la couverture de tests est maintenue à 100 %. Mais son développement avance toujours rapidement.
+**FastAPI** est déjà utilisé en production dans de nombreuses applications et systèmes. Et la couverture de test est maintenue à 100 %. Mais son développement est toujours aussi rapide.
 
-De nouvelles fonctionnalités sont ajoutées fréquemment, des bogues sont corrigés régulièrement et le code s'améliore continuellement.
+De nouvelles fonctionnalités sont ajoutées fréquemment, des bogues sont corrigés régulièrement et le code est
+amélioré continuellement.
 
-C'est pourquoi les versions actuelles sont toujours `0.x.x`, cela reflète que chaque version pourrait potentiellement comporter des changements non rétrocompatibles. Cela suit les conventions de <a href="https://semver.org/" class="external-link" target="_blank">versionnage sémantique</a>.
+C'est pourquoi les versions actuelles sont toujours `0.x.x`, cela reflète que chaque version peut potentiellement
+recevoir des changements non rétrocompatibles. Cela suit les conventions de <a href="https://semver.org/" class="external-link"
+target="_blank">versionnage sémantique</a>.
 
 Vous pouvez créer des applications de production avec **FastAPI** dès maintenant (et vous le faites probablement depuis un certain temps), vous devez juste vous assurer que vous utilisez une version qui fonctionne correctement avec le reste de votre code.
 
-## Épingler votre version de `fastapi` { #pin-your-fastapi-version }
+## Épinglez votre version de `fastapi`
 
-La première chose que vous devez faire est « épingler » la version de **FastAPI** que vous utilisez à la dernière version spécifique dont vous savez qu’elle fonctionne correctement pour votre application.
+Tout d'abord il faut "épingler" la version de **FastAPI** que vous utilisez à la dernière version dont vous savez
+qu'elle fonctionne correctement pour votre application.
 
-Par exemple, disons que vous utilisez la version `0.112.0` dans votre application.
+Par exemple, disons que vous utilisez la version `0.45.0` dans votre application.
 
-Si vous utilisez un fichier `requirements.txt`, vous pouvez spécifier la version avec :
+Si vous utilisez un fichier `requirements.txt`, vous pouvez spécifier la version avec :
 
 ```txt
-fastapi[standard]==0.112.0
+fastapi==0.45.0
 ```
 
-ce qui signifierait que vous utiliseriez exactement la version `0.112.0`.
+ce qui signifierait que vous utiliseriez exactement la version `0.45.0`.
 
-Ou vous pourriez aussi l'épingler avec :
-
-```txt
-fastapi[standard]>=0.112.0,<0.113.0
-```
-
-cela signifierait que vous utiliseriez les versions `0.112.0` ou supérieures, mais inférieures à `0.113.0`, par exemple, une version `0.112.2` serait toujours acceptée.
-
-Si vous utilisez un autre outil pour gérer vos installations, comme `uv`, Poetry, Pipenv, ou autres, ils ont tous un moyen que vous pouvez utiliser pour définir des versions spécifiques pour vos paquets.
-
-## Versions disponibles { #available-versions }
-
-Vous pouvez consulter les versions disponibles (par exemple, pour vérifier quelle est la dernière version en date) dans les [Notes de version](../release-notes.md){.internal-link target=_blank}.
-
-## À propos des versions { #about-versions }
-
-Suivant les conventions de versionnage sémantique, toute version inférieure à `1.0.0` peut potentiellement ajouter des changements non rétrocompatibles.
-
-FastAPI suit également la convention selon laquelle tout changement de version « PATCH » concerne des corrections de bogues et des changements rétrocompatibles.
-
-/// tip | Astuce
-
-Le « PATCH » est le dernier chiffre, par exemple, dans `0.2.3`, la version PATCH est `3`.
-
-///
-
-Donc, vous devriez être en mesure d'épingler une version comme suit :
+Ou vous pourriez aussi l'épingler avec :
 
 ```txt
 fastapi>=0.45.0,<0.46.0
 ```
 
-Les changements non rétrocompatibles et les nouvelles fonctionnalités sont ajoutés dans les versions « MINOR ».
+cela signifierait que vous utiliseriez les versions `0.45.0` ou supérieures, mais inférieures à `0.46.0`, par exemple, une version `0.45.2` serait toujours acceptée.
+
+Si vous utilisez un autre outil pour gérer vos installations, comme Poetry, Pipenv, ou autres, ils ont tous un moyen que vous pouvez utiliser pour définir des versions spécifiques pour vos paquets.
+
+## Versions disponibles
+
+Vous pouvez consulter les versions disponibles (par exemple, pour vérifier quelle est la dernière version en date) dans les [Notes de version](../release-notes.md){.internal-link target=_blank}.
+
+## À propos des versions
+
+Suivant les conventions de versionnage sémantique, toute version inférieure à `1.0.0` peut potentiellement ajouter
+des changements non rétrocompatibles.
+
+FastAPI suit également la convention que tout changement de version "PATCH" est pour des corrections de bogues et
+des changements rétrocompatibles.
 
 /// tip | Astuce
 
-Le « MINOR » est le numéro au milieu, par exemple, dans `0.2.3`, la version MINOR est `2`.
+Le "PATCH" est le dernier chiffre, par exemple, dans `0.2.3`, la version PATCH est `3`.
 
 ///
 
-## Mettre à niveau les versions de FastAPI { #upgrading-the-fastapi-versions }
+Donc, vous devriez être capable d'épingler une version comme suit :
 
-Vous devez ajouter des tests pour votre application.
+```txt
+fastapi>=0.45.0,<0.46.0
+```
 
-Avec **FastAPI** c'est très facile (merci à Starlette), consultez les documents : [Tests](../tutorial/testing.md){.internal-link target=_blank}
+Les changements non rétrocompatibles et les nouvelles fonctionnalités sont ajoutés dans les versions "MINOR".
 
-Après avoir des tests, vous pouvez mettre à niveau la version de **FastAPI** vers une version plus récente et vous assurer que tout votre code fonctionne correctement en exécutant vos tests.
+/// tip | Astuce
 
-Si tout fonctionne, ou après avoir effectué les changements nécessaires, et que tous vos tests passent, vous pouvez alors épingler votre `fastapi` à cette nouvelle version récente.
+Le "MINOR" est le numéro au milieu, par exemple, dans `0.2.3`, la version MINOR est `2`.
 
-## À propos de Starlette { #about-starlette }
+///
 
-Vous ne devez pas épingler la version de `starlette`.
+## Mise à jour des versions FastAPI
+
+Vous devriez tester votre application.
+
+Avec **FastAPI** c'est très facile (merci à Starlette), consultez la documentation : [Testing](../tutorial/testing.md){.internal-link target=_blank}
+
+Après avoir effectué des tests, vous pouvez mettre à jour la version **FastAPI** vers une version plus récente, et vous assurer que tout votre code fonctionne correctement en exécutant vos tests.
+
+Si tout fonctionne, ou après avoir fait les changements nécessaires, et que tous vos tests passent, vous pouvez
+épingler votre version de `fastapi` à cette nouvelle version récente.
+
+## À propos de Starlette
+
+Vous ne devriez pas épingler la version de `starlette`.
 
 Différentes versions de **FastAPI** utiliseront une version spécifique plus récente de Starlette.
 
 Ainsi, vous pouvez simplement laisser **FastAPI** utiliser la bonne version de Starlette.
 
-## À propos de Pydantic { #about-pydantic }
+## À propos de Pydantic
 
-Pydantic inclut les tests pour **FastAPI** avec ses propres tests, ainsi les nouvelles versions de Pydantic (au-dessus de `1.0.0`) sont toujours compatibles avec FastAPI.
+Pydantic inclut des tests pour **FastAPI** avec ses propres tests, ainsi les nouvelles versions de Pydantic (au-dessus
+de `1.0.0`) sont toujours compatibles avec **FastAPI**.
 
-Vous pouvez épingler Pydantic à toute version supérieure à `1.0.0` qui fonctionne pour vous.
+Vous pouvez épingler Pydantic à toute version supérieure à `1.0.0` qui fonctionne pour vous et inférieure à `2.0.0`.
 
-Par exemple :
+Par exemple :
 
 ```txt
-pydantic>=2.7.0,<3.0.0
+pydantic>=1.2.0,<2.0.0
 ```

docs/fr/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/fr"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
 </p>
 <p align="center">
     <em>Framework FastAPI, haute performance, facile à apprendre, rapide à coder, prêt pour la production</em>
@@ -27,7 +27,7 @@
 
 ---
 
-**Documentation** : <a href="https://fastapi.tiangolo.com/fr" target="_blank">https://fastapi.tiangolo.com/fr</a>
+**Documentation** : <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
 
 **Code Source** : <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
 
@@ -37,130 +37,128 @@ FastAPI est un framework web moderne et rapide (haute performance) pour la créa
 
 Les principales fonctionnalités sont :
 
-* **Rapide** : très hautes performances, au niveau de **NodeJS** et **Go** (grâce à Starlette et Pydantic). [L'un des frameworks Python les plus rapides](#performance).
-* **Rapide à coder** : augmente la vitesse de développement des fonctionnalités d'environ 200 % à 300 %. *
-* **Moins de bugs** : réduit d'environ 40 % les erreurs induites par le développeur. *
-* **Intuitif** : excellente compatibilité avec les éditeurs. <abbr title="également appelé autocomplétion, IntelliSense">Autocomplétion</abbr> partout. Moins de temps passé à déboguer.
-* **Facile** : conçu pour être facile à utiliser et à apprendre. Moins de temps passé à lire les documents.
-* **Concis** : diminue la duplication de code. Plusieurs fonctionnalités à partir de chaque déclaration de paramètre. Moins de bugs.
-* **Robuste** : obtenez un code prêt pour la production. Avec une documentation interactive automatique.
-* **Basé sur des normes** : basé sur (et entièrement compatible avec) les standards ouverts pour les APIs : <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (précédemment connu sous le nom de Swagger) et <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+* **Rapidité** : De très hautes performances, au niveau de **NodeJS** et **Go** (grâce à Starlette et Pydantic). [L'un des frameworks Python les plus rapides](#performance).
+* **Rapide à coder** : Augmente la vitesse de développement des fonctionnalités d'environ 200 % à 300 %. *
+* **Moins de bugs** : Réduit d'environ 40 % les erreurs induites par le développeur. *
+* **Intuitif** : Excellente compatibilité avec les IDE. <abbr title="également connu sous le nom d'auto-complétion, autocomplétion, IntelliSense">Complétion</abbr> complète. Moins de temps passé à déboguer.
+* **Facile** : Conçu pour être facile à utiliser et à apprendre. Moins de temps passé à lire la documentation.
+* **Concis** : Diminue la duplication de code. De nombreuses fonctionnalités liées à la déclaration de chaque paramètre. Moins de bugs.
+* **Robuste** : Obtenez un code prêt pour la production. Avec une documentation interactive automatique.
+* **Basé sur des normes** : Basé sur (et entièrement compatible avec) les standards ouverts pour les APIs : <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (précédemment connu sous le nom de Swagger) et <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
 
 <small>* estimation basée sur des tests d'une équipe de développement interne, construisant des applications de production.</small>
 
-## Sponsors { #sponsors }
+## Sponsors
 
 <!-- sponsors -->
 
-### Sponsor clé de voûte { #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 Or et Argent { #gold-and-silver-sponsors }
-
+{% if 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/fr/fastapi-people/#sponsors" class="external-link" target="_blank">Autres sponsors</a>
+<a href="https://fastapi.tiangolo.com/fastapi-people/#sponsors" class="external-link" target="_blank">Other sponsors</a>
 
-## Opinions { #opinions }
+## Opinions
 
-« _[...] J'utilise beaucoup **FastAPI** ces derniers temps. [...] Je prévois de l'utiliser dans mon équipe pour tous les **services de ML chez Microsoft**. Certains d'entre eux sont intégrés au cœur de **Windows** et à certains produits **Office**._ »
+"_[...] J'utilise beaucoup **FastAPI** ces derniers temps. [...] Je prévois de l'utiliser dans mon équipe pour tous les **services de ML chez Microsoft**. Certains d'entre eux seront intégrés dans le coeur de **Windows** et dans certains produits **Office**._"
 
 <div style="text-align: right; margin-right: 10%;">Kabir Khan - <strong>Microsoft</strong> <a href="https://github.com/fastapi/fastapi/pull/26" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-« _Nous avons adopté la bibliothèque **FastAPI** pour créer un serveur **REST** qui peut être interrogé pour obtenir des **prédictions**. [pour Ludwig]_ »
+"_Nous avons adopté la bibliothèque **FastAPI** pour créer un serveur **REST** qui peut être interrogé pour obtenir des **prédictions**. [pour Ludwig]_"
 
-<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, et Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin et Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-« _**Netflix** est heureux d'annoncer la publication en open source de notre framework d'orchestration de **gestion de crise** : **Dispatch** ! [construit avec **FastAPI**]_ »
+"_**Netflix** a le plaisir d'annoncer la sortie en open-source de notre framework d'orchestration de **gestion de crise** : **Dispatch** ! [construit avec **FastAPI**]_"
 
 <div style="text-align: right; margin-right: 10%;">Kevin Glisson, Marc Vilanova, Forest Monsen - <strong>Netflix</strong> <a href="https://netflixtechblog.com/introducing-dispatch-da4b8a2a8072" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-« _Je suis plus qu'enthousiaste à propos de **FastAPI**. C'est tellement fun !_ »
+"_Je suis très enthousiaste à propos de **FastAPI**. C'est un bonheur !_"
 
-<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong>Animateur du podcast <a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a></strong> <a href="https://x.com/brianokken/status/1112220079972728832" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong>Auteur du podcast <a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a></strong> <a href="https://x.com/brianokken/status/1112220079972728832" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-« _Honnêtement, ce que vous avez construit a l'air super solide et soigné. À bien des égards, c'est ce que je voulais que **Hug** soit — c'est vraiment inspirant de voir quelqu'un construire ça._ »
+"_Honnêtement, ce que vous avez construit a l'air super solide et élégant. A bien des égards, c'est comme ça que je voulais que **Hug** soit - c'est vraiment inspirant de voir quelqu'un construire ça._"
 
-<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong>Créateur de <a href="https://github.com/hugapi/hug" target="_blank">Hug</a></strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(ref)</small></a></div>
+<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong> Créateur de <a href="https://github.com/hugapi/hug" target="_blank">Hug</a></strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-« _Si vous cherchez à apprendre un **framework moderne** pour créer des APIs REST, regardez **FastAPI** [...] C'est rapide, facile à utiliser et facile à apprendre [...]_ »
+"_Si vous cherchez à apprendre un **framework moderne** pour créer des APIs REST, regardez **FastAPI** [...] C'est rapide, facile à utiliser et à apprendre [...]_"
 
-« _Nous sommes passés à **FastAPI** pour nos **APIs** [...] Je pense que vous l'aimerez [...]_ »
+"_Nous sommes passés à **FastAPI** pour nos **APIs** [...] Je pense que vous l'aimerez [...]_"
 
 <div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong>Fondateurs de <a href="https://explosion.ai" target="_blank">Explosion AI</a> - Créateurs de <a href="https://spacy.io" target="_blank">spaCy</a></strong> <a href="https://x.com/_inesmontani/status/1144173225322143744" target="_blank"><small>(ref)</small></a> - <a href="https://x.com/honnibal/status/1144031421859655680" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-« _Si quelqu'un cherche à construire une API Python de production, je recommande vivement **FastAPI**. Il est **magnifiquement conçu**, **simple à utiliser** et **hautement scalable**. Il est devenu un **composant clé** de notre stratégie de développement API-first et alimente de nombreuses automatisations et services tels que notre ingénieur TAC virtuel._ »
+"_Si quelqu'un cherche à construire une API Python de production, je recommande vivement **FastAPI**. Il est **bien conçu**, **simple à utiliser** et **très évolutif**. Il est devenu un **composant clé** dans notre stratégie de développement API first et il est à l'origine de nombreux automatismes et services tels que notre ingénieur virtuel TAC._"
 
 <div style="text-align: right; margin-right: 10%;">Deon Pillsbury - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-## Mini documentaire FastAPI { #fastapi-mini-documentary }
-
-Un <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">mini documentaire FastAPI</a> est sorti fin 2025, vous pouvez le regarder en ligne :
-
-<a href="https://www.youtube.com/watch?v=mpR8ngthqiE" target="_blank"><img src="https://fastapi.tiangolo.com/img/fastapi-documentary.jpg" alt="FastAPI Mini Documentary"></a>
-
-## **Typer**, le FastAPI des CLIs { #typer-the-fastapi-of-clis }
+## **Typer**, le FastAPI des <abbr title="Command Line Interface">CLI</abbr>
 
 <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 vous construisez une application <abbr title="Command Line Interface - Interface en ligne de commande">CLI</abbr> à utiliser dans un terminal au lieu d'une API web, regardez <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+Si vous souhaitez construire une application <abbr title="Command Line Interface">CLI</abbr> utilisable dans un terminal au lieu d'une API web, regardez <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
 
-**Typer** est le petit frère de FastAPI. Et il est destiné à être le **FastAPI des CLIs**. ⌨️ 🚀
+**Typer** est le petit frère de FastAPI. Et il est destiné à être le **FastAPI des <abbr title="Command Line Interface">CLI</abbr>**. ⌨️ 🚀
 
-## Prérequis { #requirements }
+## Prérequis
 
 FastAPI repose sur les épaules de géants :
 
 * <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> pour les parties web.
 * <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> pour les parties données.
 
-## Installation { #installation }
-
-Créez et activez un <a href="https://fastapi.tiangolo.com/fr/virtual-environments/" class="external-link" target="_blank">environnement virtuel</a> puis installez FastAPI :
+## Installation
 
 <div class="termy">
 
 ```console
-$ pip install "fastapi[standard]"
+$ pip install fastapi
 
 ---> 100%
 ```
 
 </div>
 
-**Remarque** : Vous devez vous assurer de mettre « fastapi[standard] » entre guillemets pour garantir que cela fonctionne dans tous les terminaux.
+Vous aurez également besoin d'un serveur ASGI pour la production tel que <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a> ou <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a>.
 
-## Exemple { #example }
+<div class="termy">
 
-### Créer { #create-it }
+```console
+$ pip install "uvicorn[standard]"
 
-Créez un fichier `main.py` avec :
+---> 100%
+```
+
+</div>
+
+## Exemple
+
+### Créez
+
+* Créez un fichier `main.py` avec :
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -172,16 +170,18 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
 <details markdown="1">
-<summary>Ou utilisez <code>async def</code>...</summary>
+<summary>Ou utilisez <code>async def</code> ...</summary>
 
 Si votre code utilise `async` / `await`, utilisez `async def` :
 
-```Python hl_lines="7  12"
+```Python hl_lines="9  14"
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -193,41 +193,28 @@ async def read_root():
 
 
 @app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
-**Remarque** :
+**Note**
 
-Si vous ne savez pas, consultez la section « Vous êtes pressés ? » à propos de <a href="https://fastapi.tiangolo.com/fr/async/#in-a-hurry" target="_blank">`async` et `await` dans la documentation</a>.
+Si vous n'êtes pas familier avec cette notion, consultez la section _"Vous êtes pressés ?"_ à propos de <a href="https://fastapi.tiangolo.com/fr/async/#vous-etes-presses" target="_blank">`async` et `await` dans la documentation</a>.
 
 </details>
 
-### Lancer { #run-it }
+### Lancez
 
 Lancez le serveur avec :
 
 <div class="termy">
 
 ```console
-$ fastapi dev main.py
+$ uvicorn main:app --reload
 
- ╭────────── FastAPI CLI - Development mode ───────────╮
- │                                                     │
- │  Serving at: http://127.0.0.1:8000                  │
- │                                                     │
- │  API docs: http://127.0.0.1:8000/docs               │
- │                                                     │
- │  Running in development mode, for production use:   │
- │                                                     │
- │  fastapi run                                        │
- │                                                     │
- ╰─────────────────────────────────────────────────────╯
-
-INFO:     Will watch for changes in these directories: ['/home/user/code/awesomeapp']
 INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-INFO:     Started reloader process [2248755] using WatchFiles
-INFO:     Started server process [2248757]
+INFO:     Started reloader process [28720]
+INFO:     Started server process [28722]
 INFO:     Waiting for application startup.
 INFO:     Application startup complete.
 ```
@@ -235,34 +222,34 @@ INFO:     Application startup complete.
 </div>
 
 <details markdown="1">
-<summary>À propos de la commande <code>fastapi dev main.py</code>...</summary>
+<summary>À propos de la commande <code>uvicorn main:app --reload</code> ...</summary>
 
-La commande `fastapi dev` lit votre fichier `main.py`, détecte l'application **FastAPI** qu'il contient et lance un serveur avec <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>.
+La commande `uvicorn main:app` fait référence à :
 
-Par défaut, `fastapi dev` démarre avec le rechargement automatique activé pour le développement local.
-
-Vous pouvez en savoir plus dans la <a href="https://fastapi.tiangolo.com/fr/fastapi-cli/" target="_blank">documentation de la CLI FastAPI</a>.
+* `main` : le fichier `main.py` (le "module" Python).
+* `app` : l'objet créé à l'intérieur de `main.py` avec la ligne `app = FastAPI()`.
+* `--reload` : fait redémarrer le serveur après des changements de code. À n'utiliser que pour le développement.
 
 </details>
 
-### Vérifier { #check-it }
+### Vérifiez
 
 Ouvrez votre navigateur à l'adresse <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>.
 
-Vous verrez la réponse JSON :
+Vous obtenez alors cette réponse <abbr title="JavaScript Object Notation">JSON</abbr> :
 
 ```JSON
 {"item_id": 5, "q": "somequery"}
 ```
 
-Vous avez déjà créé une API qui :
+Vous venez de créer une API qui :
 
-* Reçoit des requêtes HTTP sur les _chemins_ `/` et `/items/{item_id}`.
-* Les deux _chemins_ acceptent des <em>opérations</em> `GET` (également connues sous le nom de _méthodes_ HTTP).
-* Le _chemin_ `/items/{item_id}` a un _paramètre de chemin_ `item_id` qui doit être un `int`.
-* Le _chemin_ `/items/{item_id}` a un _paramètre de requête_ optionnel `q` de type `str`.
+* Reçoit les requêtes HTTP pour les _chemins_ `/` et `/items/{item_id}`.
+* Les deux _chemins_ acceptent des <em>opérations</em> `GET` (également connu sous le nom de _méthodes_ HTTP).
+* Le _chemin_ `/items/{item_id}` a un  _<abbr title="en anglais : path parameter">paramètre</abbr>_ `item_id` qui doit être un `int`.
+* Le _chemin_ `/items/{item_id}` a un _<abbr title="en anglais : query param">paramètre de requête</abbr>_ optionnel `q` de type `str`.
 
-### Documentation API interactive { #interactive-api-docs }
+### Documentation API interactive
 
 Maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
@@ -270,21 +257,23 @@ Vous verrez la documentation interactive automatique de l'API (fournie par <a hr
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Documentation API alternative { #alternative-api-docs }
+### Documentation API alternative
 
 Et maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-Vous verrez la documentation alternative automatique (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
+Vous verrez la documentation interactive automatique de l'API (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-## Mettre à niveau l'exemple { #example-upgrade }
+## Exemple plus poussé
 
-Modifiez maintenant le fichier `main.py` pour recevoir un corps depuis une requête `PUT`.
+Maintenant, modifiez le fichier `main.py` pour recevoir <abbr title="en anglais : body">le corps</abbr> d'une requête `PUT`.
 
-Déclarez le corps en utilisant les types Python standard, grâce à Pydantic.
+Déclarez ce corps en utilisant les types Python standards, grâce à Pydantic.
+
+```Python hl_lines="4  9-12  25-27"
+from typing import Union
 
-```Python hl_lines="2  7-10 23-25"
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -294,7 +283,7 @@ app = FastAPI()
 class Item(BaseModel):
     name: str
     price: float
-    is_offer: bool | None = None
+    is_offer: Union[bool, None] = None
 
 
 @app.get("/")
@@ -303,7 +292,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 
 
@@ -312,35 +301,35 @@ def update_item(item_id: int, item: Item):
     return {"item_name": item.name, "item_id": item_id}
 ```
 
-Le serveur `fastapi dev` devrait se recharger automatiquement.
+Le serveur se recharge normalement automatiquement (car vous avez pensé à `--reload` dans la commande `uvicorn` ci-dessus).
 
-### Mettre à niveau la documentation API interactive { #interactive-api-docs-upgrade }
+### Plus loin avec la documentation API interactive
 
 Maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
-* La documentation interactive de l'API sera automatiquement mise à jour, y compris le nouveau corps :
+* La documentation interactive de l'API sera automatiquement mise à jour, y compris le nouveau corps de la requête :
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
-* Cliquez sur le bouton « Try it out », il vous permet de renseigner les paramètres et d'interagir directement avec l'API :
+* Cliquez sur le bouton "Try it out", il vous permet de renseigner les paramètres et d'interagir directement avec l'API :
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-04-swagger-03.png)
 
-* Cliquez ensuite sur le bouton « Execute », l'interface utilisateur communiquera avec votre API, enverra les paramètres, obtiendra les résultats et les affichera à l'écran :
+* Cliquez ensuite sur le bouton "Execute", l'interface utilisateur communiquera avec votre API, enverra les paramètres, obtiendra les résultats et les affichera à l'écran :
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
 
-### Mettre à niveau la documentation API alternative { #alternative-api-docs-upgrade }
+### Plus loin avec la documentation API alternative
 
 Et maintenant, rendez-vous sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-* La documentation alternative reflètera également le nouveau paramètre de requête et le nouveau corps :
+* La documentation alternative reflétera également le nouveau paramètre de requête et le nouveau corps :
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### En résumé { #recap }
+### En résumé
 
-En résumé, vous déclarez **une fois** les types de paramètres, le corps, etc. en tant que paramètres de fonction.
+En résumé, vous déclarez **une fois** les types de paramètres, <abbr title="en anglais : body">le corps</abbr>  de la requête, etc. en tant que paramètres de fonction.
 
 Vous faites cela avec les types Python standard modernes.
 
@@ -348,7 +337,7 @@ Vous n'avez pas à apprendre une nouvelle syntaxe, les méthodes ou les classes
 
 Juste du **Python** standard.
 
-Par exemple, pour un `int` :
+Par exemple, pour un `int`:
 
 ```Python
 item_id: int
@@ -362,54 +351,54 @@ item: Item
 
 ... et avec cette déclaration unique, vous obtenez :
 
-* Une assistance dans l'éditeur, notamment :
-    * l'autocomplétion.
+* Une assistance dans votre IDE, notamment :
+    * la complétion.
     * la vérification des types.
 * La validation des données :
     * des erreurs automatiques et claires lorsque les données ne sont pas valides.
-    * une validation même pour les objets JSON profondément imbriqués.
-* <abbr title="aussi connu sous le nom de : serialization, parsing, marshalling">Conversion</abbr> des données d'entrée : venant du réseau vers les données et types Python. Lecture depuis :
-    * JSON.
-    * Paramètres de chemin.
-    * Paramètres de requête.
-    * Cookies.
-    * En-têtes.
-    * Formulaires.
-    * Fichiers.
-* <abbr title="aussi connu sous le nom de : serialization, parsing, marshalling">Conversion</abbr> des données de sortie : conversion des données et types Python en données réseau (au format JSON) :
-    * Conversion des types Python (`str`, `int`, `float`, `bool`, `list`, etc).
-    * Objets `datetime`.
-    * Objets `UUID`.
-    * Modèles de base de données.
-    * ... et bien plus.
-* Documentation API interactive automatique, avec 2 interfaces utilisateur au choix :
+    * une validation même pour les objets <abbr title="JavaScript Object Notation">JSON</abbr> profondément imbriqués.
+* <abbr title="aussi connu sous le nom de : serialization, parsing, marshalling">Une conversion</abbr> des données d'entrée : venant du réseau et allant vers les données et types de Python, permettant de lire :
+    * le <abbr title="JavaScript Object Notation">JSON</abbr>.
+    * <abbr title="en anglais : path parameters">les paramètres du chemin</abbr>.
+    * <abbr title="en anglais : query parameters">les paramètres de la requête</abbr>.
+    * les cookies.
+    * <abbr title="en anglais : headers">les en-têtes</abbr>.
+    * <abbr title="en anglais : forms">les formulaires</abbr>.
+    * <abbr title="en anglais : files">les fichiers</abbr>.
+* <abbr title="aussi connu sous le nom de : serialization, parsing, marshalling">La conversion</abbr> des données de sortie : conversion des données et types Python en données réseau (au format <abbr title="JavaScript Object Notation">JSON</abbr>), permettant de convertir :
+    * les types Python (`str`, `int`, `float`, `bool`, `list`, etc).
+    * les objets `datetime`.
+    * les objets `UUID`.
+    * les modèles de base de données.
+    * ... et beaucoup plus.
+* La documentation API interactive automatique, avec 2 interfaces utilisateur au choix :
     * Swagger UI.
     * ReDoc.
 
 ---
 
-Pour revenir à l'exemple de code précédent, **FastAPI** va :
+Pour revenir à l'exemple de code précédent, **FastAPI** permet de :
 
-* Valider la présence d'un `item_id` dans le chemin pour les requêtes `GET` et `PUT`.
+* Valider que `item_id` existe dans le chemin des requêtes `GET` et `PUT`.
 * Valider que `item_id` est de type `int` pour les requêtes `GET` et `PUT`.
-    * Si ce n'est pas le cas, le client verra une erreur utile et claire.
-* Vérifier s'il existe un paramètre de requête optionnel nommé `q` (comme dans `http://127.0.0.1:8000/items/foo?q=somequery`) pour les requêtes `GET`.
-    * Comme le paramètre `q` est déclaré avec `= None`, il est optionnel.
-    * Sans le `None`, il serait requis (comme l'est le corps dans le cas de `PUT`).
-* Pour les requêtes `PUT` vers `/items/{item_id}`, lire le corps au format JSON :
-    * Vérifier qu'il a un attribut obligatoire `name` qui doit être un `str`.
-    * Vérifier qu'il a un attribut obligatoire `price` qui doit être un `float`.
-    * Vérifier qu'il a un attribut optionnel `is_offer`, qui doit être un `bool`, s'il est présent.
-    * Tout cela fonctionne également pour les objets JSON profondément imbriqués.
-* Convertir automatiquement depuis et vers JSON.
-* Tout documenter avec OpenAPI, qui peut être utilisé par :
-    * des systèmes de documentation interactive.
-    * des systèmes de génération automatique de clients, pour de nombreux langages.
+    * Si ce n'est pas le cas, le client voit une erreur utile et claire.
+* Vérifier qu'il existe un paramètre de requête facultatif nommé `q` (comme dans `http://127.0.0.1:8000/items/foo?q=somequery`) pour les requêtes `GET`.
+    * Puisque le paramètre `q` est déclaré avec `= None`, il est facultatif.
+    * Sans le `None`, il serait nécessaire (comme l'est <abbr title="en anglais : body">le corps</abbr> de la requête dans le cas du `PUT`).
+* Pour les requêtes `PUT` vers `/items/{item_id}`, de lire <abbr title="en anglais : body">le corps</abbr>  en <abbr title="JavaScript Object Notation">JSON</abbr> :
+    * Vérifier qu'il a un attribut obligatoire `name` qui devrait être un `str`.
+    * Vérifier qu'il a un attribut obligatoire `prix` qui doit être un `float`.
+    * Vérifier qu'il a un attribut facultatif `is_offer`, qui devrait être un `bool`, s'il est présent.
+    * Tout cela fonctionnerait également pour les objets <abbr title="JavaScript Object Notation">JSON</abbr> profondément imbriqués.
+* Convertir de et vers <abbr title="JavaScript Object Notation">JSON</abbr> automatiquement.
+* Documenter tout avec OpenAPI, qui peut être utilisé par :
+    * Les systèmes de documentation interactifs.
+    * Les systèmes de génération automatique de code client, pour de nombreuses langues.
 * Fournir directement 2 interfaces web de documentation interactive.
 
 ---
 
-Nous n'avons fait qu'effleurer la surface, mais vous avez déjà une idée de la façon dont tout fonctionne.
+Nous n'avons fait qu'effleurer la surface, mais vous avez déjà une idée de la façon dont tout cela fonctionne.
 
 Essayez de changer la ligne contenant :
 
@@ -423,137 +412,61 @@ Essayez de changer la ligne contenant :
         ... "item_name": item.name ...
 ```
 
-... à :
+... vers :
 
 ```Python
         ... "item_price": item.price ...
 ```
 
-... et voyez comment votre éditeur complète automatiquement les attributs et connaît leurs types :
+... et voyez comment votre éditeur complétera automatiquement les attributs et connaîtra leurs types :
 
-![compatibilité éditeur](https://fastapi.tiangolo.com/img/vscode-completion.png)
+![compatibilité IDE](https://fastapi.tiangolo.com/img/vscode-completion.png)
 
 Pour un exemple plus complet comprenant plus de fonctionnalités, voir le <a href="https://fastapi.tiangolo.com/fr/tutorial/">Tutoriel - Guide utilisateur</a>.
 
-**Alerte spoiler** : le tutoriel - guide utilisateur inclut :
+**Spoiler alert** : le tutoriel - guide utilisateur inclut :
 
-* Déclaration de **paramètres** provenant d'autres emplacements comme : **en-têtes**, **cookies**, **champs de formulaire** et **fichiers**.
-* Comment définir des **contraintes de validation** comme `maximum_length` ou `regex`.
-* Un système **<abbr title="aussi connu sous le nom de composants, ressources, fournisseurs, services, injectables">d'injection de dépendances</abbr>** très puissant et facile à utiliser.
-* Sécurité et authentification, y compris la prise en charge de **OAuth2** avec des **JWT tokens** et l'authentification **HTTP Basic**.
-* Des techniques plus avancées (mais tout aussi faciles) pour déclarer des **modèles JSON profondément imbriqués** (grâce à Pydantic).
-* Intégration **GraphQL** avec <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> et d'autres bibliothèques.
-* De nombreuses fonctionnalités supplémentaires (grâce à Starlette) comme :
+* Déclaration de **paramètres** provenant d'autres endroits différents comme : **<abbr title="en anglais : headers">en-têtes</abbr>.**, **cookies**, **champs de formulaire** et **fichiers**.
+* L'utilisation de **contraintes de validation** comme `maximum_length` ou `regex`.
+* Un **<abbr title="aussi connu sous le nom de composants, ressources, fournisseurs, services, injectables">système d'injection de dépendance </abbr>** très puissant et facile à utiliser .
+* Sécurité et authentification, y compris la prise en charge de **OAuth2** avec les **<abbr title="en anglais : JWT tokens">jetons <abbr title="JSON Web Tokens">JWT</abbr></abbr>** et l'authentification **HTTP Basic**.
+* Des techniques plus avancées (mais tout aussi faciles) pour déclarer les **modèles <abbr title="JavaScript Object Notation">JSON</abbr> profondément imbriqués** (grâce à Pydantic).
+* Intégration de **GraphQL** avec <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> et d'autres bibliothèques.
+* D'obtenir de nombreuses fonctionnalités supplémentaires (grâce à  Starlette) comme :
     * **WebSockets**
-    * des tests extrêmement faciles basés sur HTTPX et `pytest`
-    * **CORS**
+    * de tester le code très facilement avec `requests` et `pytest`
+    * **<abbr title="Cross-Origin Resource Sharing">CORS</abbr>**
     * **Cookie Sessions**
     * ... et plus encore.
 
-### Déployer votre application (optionnel) { #deploy-your-app-optional }
+## Performance
 
-Vous pouvez, si vous le souhaitez, déployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, allez vous inscrire sur la liste d'attente si ce n'est pas déjà fait. 🚀
-
-Si vous avez déjà un compte **FastAPI Cloud** (nous vous avons invité depuis la liste d'attente 😉), vous pouvez déployer votre application avec une seule commande.
-
-Avant de déployer, assurez-vous d'être connecté :
-
-<div class="termy">
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-</div>
-
-Puis déployez votre application :
-
-<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>
-
-C'est tout ! Vous pouvez maintenant accéder à votre application à cette URL. ✨
-
-#### À propos de FastAPI Cloud { #about-fastapi-cloud }
-
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** est construit par le même auteur et la même équipe derrière **FastAPI**.
-
-Il simplifie le processus de **construction**, de **déploiement** et **d'accès** à une API avec un effort minimal.
-
-Il apporte la même **expérience développeur** de la création d'applications avec FastAPI au **déploiement** dans le cloud. 🎉
-
-FastAPI Cloud est le principal sponsor et financeur des projets open source *FastAPI and friends*. ✨
-
-#### Déployer sur d'autres fournisseurs cloud { #deploy-to-other-cloud-providers }
-
-FastAPI est open source et basé sur des standards. Vous pouvez déployer des applications FastAPI sur n'importe quel fournisseur cloud de votre choix.
-
-Suivez les guides de votre fournisseur cloud pour y déployer des applications FastAPI. 🤓
-
-## Performance { #performance }
-
-Les benchmarks TechEmpower indépendants montrent que les applications **FastAPI** s'exécutant sous Uvicorn sont <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">parmi les frameworks Python les plus rapides</a>, juste derrière Starlette et Uvicorn eux-mêmes (utilisés en interne par FastAPI). (*)
+Les benchmarks TechEmpower indépendants montrent que les applications **FastAPI** s'exécutant sous Uvicorn sont <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"> parmi les frameworks existants en Python les plus rapides </a>, juste derrière Starlette et Uvicorn (utilisés en interne par FastAPI). (*)
 
 Pour en savoir plus, consultez la section <a href="https://fastapi.tiangolo.com/fr/benchmarks/" class="internal-link" target="_blank">Benchmarks</a>.
 
-## Dépendances { #dependencies }
+## Dépendances facultatives
 
-FastAPI dépend de Pydantic et Starlette.
+Utilisées par Pydantic:
 
-### Dépendances `standard` { #standard-dependencies }
-
-Lorsque vous installez FastAPI avec `pip install "fastapi[standard]"`, il inclut le groupe `standard` de dépendances optionnelles :
-
-Utilisées par Pydantic :
-
-* <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email-validator</code></a> - pour la validation des adresses e-mail.
+* <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email-validator</code></a> - pour la validation des adresses email.
 
 Utilisées par Starlette :
 
-* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Obligatoire si vous souhaitez utiliser le `TestClient`.
+* <a href="https://requests.readthedocs.io" target="_blank"><code>requests</code></a> - Obligatoire si vous souhaitez utiliser `TestClient`.
 * <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Obligatoire si vous souhaitez utiliser la configuration de template par défaut.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Obligatoire si vous souhaitez prendre en charge l’<abbr title="convertir la chaîne issue d'une requête HTTP en données Python">« parsing »</abbr> de formulaires avec `request.form()`.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Obligatoire si vous souhaitez supporter le <abbr title="convertit la chaine de caractère d'une requête HTTP en donnée Python">"décodage"</abbr> de formulaire avec `request.form()`.
+* <a href="https://pythonhosted.org/itsdangerous/" target="_blank"><code>itsdangerous</code></a> - Obligatoire pour la prise en charge de `SessionMiddleware`.
+* <a href="https://pyyaml.org/wiki/PyYAMLDocumentation" target="_blank"><code>pyyaml</code></a> - Obligatoire pour le support `SchemaGenerator` de Starlette (vous n'en avez probablement pas besoin avec FastAPI).
 
-Utilisées par FastAPI :
+Utilisées par FastAPI / Starlette :
 
-* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - pour le serveur qui charge et sert votre application. Cela inclut `uvicorn[standard]`, qui comprend certaines dépendances (par ex. `uvloop`) nécessaires pour une haute performance.
-* `fastapi-cli[standard]` - pour fournir la commande `fastapi`.
-    * Cela inclut `fastapi-cloud-cli`, qui vous permet de déployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
-
-### Sans les dépendances `standard` { #without-standard-dependencies }
-
-Si vous ne souhaitez pas inclure les dépendances optionnelles `standard`, vous pouvez installer avec `pip install fastapi` au lieu de `pip install "fastapi[standard]"`.
-
-### Sans `fastapi-cloud-cli` { #without-fastapi-cloud-cli }
-
-Si vous souhaitez installer FastAPI avec les dépendances standard mais sans `fastapi-cloud-cli`, vous pouvez installer avec `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
-
-### Dépendances optionnelles supplémentaires { #additional-optional-dependencies }
-
-Il existe des dépendances supplémentaires que vous pourriez vouloir installer.
-
-Dépendances optionnelles supplémentaires pour Pydantic :
-
-* <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - pour la gestion des paramètres.
-* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - pour des types supplémentaires à utiliser avec Pydantic.
-
-Dépendances optionnelles supplémentaires pour FastAPI :
-
-* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Obligatoire si vous souhaitez utiliser `ORJSONResponse`.
+* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - Pour le serveur qui charge et sert votre application.
+* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - Obligatoire si vous voulez utiliser `ORJSONResponse`.
 * <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - Obligatoire si vous souhaitez utiliser `UJSONResponse`.
 
-## Licence { #license }
+Vous pouvez tout installer avec `pip install fastapi[all]`.
+
+## Licence
 
 Ce projet est soumis aux termes de la licence MIT.

docs/fr/docs/learn/index.md

@@ -1,5 +1,5 @@
-# Apprendre { #learn }
+# Apprendre
 
 Voici les sections introductives et les tutoriels pour apprendre **FastAPI**.
 
-Vous pouvez considérer ceci comme un **livre**, un **cours**, la **méthode officielle** et recommandée pour apprendre FastAPI. 😎
+Vous pouvez considérer ceci comme un **manuel**, un **cours**, la **méthode officielle** et recommandée pour appréhender FastAPI. 😎

docs/fr/docs/project-generation.md

@@ -1,28 +1,84 @@
-# Modèle Full Stack FastAPI { #full-stack-fastapi-template }
+# Génération de projets - Modèle
 
-Les modèles, bien qu'ils soient généralement livrés avec une configuration spécifique, sont conçus pour être flexibles et personnalisables. Cela vous permet de les modifier et de les adapter aux exigences de votre projet, ce qui en fait un excellent point de départ. 🏁
+Vous pouvez utiliser un générateur de projet pour commencer, qui réalisera pour vous la mise en place de bases côté architecture globale, sécurité, base de données et premières routes d'API.
 
-Vous pouvez utiliser ce modèle pour démarrer, car il inclut une grande partie de la configuration initiale, la sécurité, la base de données et quelques endpoints d'API déjà prêts pour vous.
+Un générateur de projet fera toujours une mise en place très subjective que vous devriez modifier et adapter suivant vos besoins, mais cela reste un bon point de départ pour vos projets.
 
-Dépôt GitHub : <a href="https://github.com/tiangolo/full-stack-fastapi-template" class="external-link" target="_blank">Modèle Full Stack FastAPI</a>
+## Full Stack FastAPI PostgreSQL
 
-## Modèle Full Stack FastAPI - Pile technologique et fonctionnalités { #full-stack-fastapi-template-technology-stack-and-features }
+GitHub : <a href="https://github.com/tiangolo/full-stack-fastapi-postgresql" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-fastapi-postgresql</a>
 
-- ⚡ [**FastAPI**](https://fastapi.tiangolo.com/fr) pour l'API backend Python.
-  - 🧰 [SQLModel](https://sqlmodel.tiangolo.com) pour les interactions avec la base de données SQL en Python (ORM).
-  - 🔍 [Pydantic](https://docs.pydantic.dev), utilisé par FastAPI, pour la validation des données et la gestion des paramètres.
-  - 💾 [PostgreSQL](https://www.postgresql.org) comme base de données SQL.
-- 🚀 [React](https://react.dev) pour le frontend.
-  - 💃 Utilisation de TypeScript, des hooks, de Vite et d'autres éléments d'un stack frontend moderne.
-  - 🎨 [Tailwind CSS](https://tailwindcss.com) et [shadcn/ui](https://ui.shadcn.com) pour les composants frontend.
-  - 🤖 Un client frontend généré automatiquement.
-  - 🧪 [Playwright](https://playwright.dev) pour les tests de bout en bout.
-  - 🦇 Prise en charge du mode sombre.
-- 🐋 [Docker Compose](https://www.docker.com) pour le développement et la production.
-- 🔒 Hachage sécurisé des mots de passe par défaut.
-- 🔑 Authentification JWT (JSON Web Token).
-- 📫 Récupération de mot de passe par e-mail.
-- ✅ Tests avec [Pytest](https://pytest.org).
-- 📞 [Traefik](https://traefik.io) comme proxy inverse / répartiteur de charge.
-- 🚢 Instructions de déploiement avec Docker Compose, y compris la configuration d'un proxy Traefik frontal pour gérer les certificats HTTPS automatiques.
-- 🏭 CI (intégration continue) et CD (déploiement continu) basés sur GitHub Actions.
+### Full Stack FastAPI PostgreSQL - Fonctionnalités
+
+* Intégration **Docker** complète (basée sur Docker).
+* Déploiement Docker en mode <a href="https://docs.docker.com/engine/swarm/" class="external-link" target="_blank">Swarm</a>
+* Intégration **Docker Compose** et optimisation pour développement local.
+* Serveur web Python **prêt au déploiement** utilisant Uvicorn et Gunicorn.
+* Backend Python <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">**FastAPI**</a> :
+    * **Rapide** : Très hautes performances, comparables à **NodeJS** ou **Go** (grâce à Starlette et Pydantic).
+    * **Intuitif** : Excellent support des éditeurs. <abbr title="aussi appelée auto-complétion, autocomplétion, IntelliSense...">Complétion</abbr> partout. Moins de temps passé à déboguer.
+    * **Facile** : Fait pour être facile à utiliser et apprendre. Moins de temps passé à lire de la documentation.
+    * **Concis** : Minimise la duplication de code. Plusieurs fonctionnalités à chaque déclaration de paramètre.
+    * **Robuste** : Obtenez du code prêt pour être utilisé en production. Avec de la documentation automatique interactive.
+    * **Basé sur des normes** : Basé sur (et totalement compatible avec) les normes ouvertes pour les APIs : <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> et <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+    * <a href="https://fastapi.tiangolo.com/features/" class="external-link" target="_blank">**Et bien d'autres fonctionnalités**</a> comme la validation automatique, la sérialisation, l'authentification avec OAuth2 JWT tokens, etc.
+* Hashage de **mots de passe sécurisé** par défaut.
+* Authentification par **jetons JWT**.
+* Modèles **SQLAlchemy** (indépendants des extensions Flask, afin qu'ils puissent être utilisés directement avec des *workers* Celery).
+* Modèle de démarrages basiques pour les utilisateurs (à modifier et supprimer au besoin).
+* Migrations **Alembic**.
+* **CORS** (partage des ressources entre origines multiples, ou *Cross Origin Resource Sharing*).
+* *Worker* **Celery** pouvant importer et utiliser les modèles et le code du reste du backend.
+* Tests du backend REST basés sur **Pytest**, intégrés dans Docker, pour que vous puissiez tester toutes les interactions de l'API indépendamment de la base de données. Étant exécutés dans Docker, les tests peuvent utiliser un nouvel entrepôt de données créé de zéro à chaque fois (vous pouvez donc utiliser ElasticSearch, MongoDB, CouchDB, etc. et juste tester que l'API fonctionne).
+* Intégration Python facile avec **Jupyter Kernels** pour le développement à distance ou intra-Docker avec des extensions comme Atom Hydrogen ou Visual Studio Code Jupyter.
+* Frontend **Vue** :
+    * Généré avec Vue CLI.
+    * Gestion de l'**Authentification JWT**.
+    * Page de connexion.
+    * Après la connexion, page de tableau de bord principal.
+    * Tableau de bord principal avec création et modification d'utilisateurs.
+    * Modification de ses propres caractéristiques utilisateur.
+    * **Vuex**.
+    * **Vue-router**.
+    * **Vuetify** pour de magnifiques composants *material design*.
+    * **TypeScript**.
+    * Serveur Docker basé sur **Nginx** (configuré pour être facilement manipulé avec Vue-router).
+    * Utilisation de *Docker multi-stage building*, pour ne pas avoir besoin de sauvegarder ou *commit* du code compilé.
+    * Tests frontend exécutés à la compilation (pouvant être désactivés).
+    * Fait aussi modulable que possible, pour pouvoir fonctionner comme tel, tout en pouvant être utilisé qu'en partie grâce à Vue CLI.
+* **PGAdmin** pour les bases de données PostgreSQL, facilement modifiable pour utiliser PHPMYAdmin ou MySQL.
+* **Flower** pour la surveillance de tâches Celery.
+* Équilibrage de charge entre le frontend et le backend avec **Traefik**, afin de pouvoir avoir les deux sur le même domaine, séparés par chemins, mais servis par différents conteneurs.
+* Intégration Traefik, comprenant la génération automatique de certificat **HTTPS** Let's Encrypt.
+* GitLab **CI** (intégration continue), comprenant des tests pour le frontend et le backend.
+
+## Full Stack FastAPI Couchbase
+
+GitHub : <a href="https://github.com/tiangolo/full-stack-fastapi-couchbase" class="external-link" target="_blank">https://github.com/tiangolo/full-stack-fastapi-couchbase</a>
+
+⚠️ **ATTENTION** ⚠️
+
+Si vous démarrez un nouveau projet de zéro, allez voir les alternatives au début de cette page.
+
+Par exemple, le générateur de projet <a href="https://github.com/tiangolo/full-stack-fastapi-postgresql" class="external-link" target="_blank">Full Stack FastAPI PostgreSQL</a>  peut être une meilleure alternative, étant activement maintenu et utilisé et comprenant toutes les nouvelles fonctionnalités et améliorations.
+
+Vous êtes toujours libre d'utiliser le générateur basé sur Couchbase si vous le voulez, cela devrait probablement fonctionner correctement, et si vous avez déjà un projet généré en utilisant ce dernier, cela devrait fonctionner aussi (et vous l'avez déjà probablement mis à jour suivant vos besoins).
+
+Vous pouvez en apprendre plus dans la documentation du dépôt GithHub.
+
+## Full Stack FastAPI MongoDB
+
+...viendra surement plus tard, suivant le temps que j'ai.  😅 🎉
+
+## Modèles d'apprentissage automatique avec spaCy et FastAPI
+
+GitHub : <a href="https://github.com/microsoft/cookiecutter-spacy-fastapi" class="external-link" target="_blank">https://github.com/microsoft/cookiecutter-spacy-fastapi</a>
+
+## Modèles d'apprentissage automatique avec spaCy et FastAPI - Fonctionnalités
+
+* Intégration d'un modèle NER **spaCy**.
+* Formatage de requête pour **Azure Cognitive Search**.
+* Serveur Python web **prêt à utiliser en production** utilisant Uvicorn et Gunicorn.
+* Déploiement CI/CD Kubernetes pour **Azure DevOps** (AKS).
+* **Multilangues**. Choisissez facilement l'une des langues intégrées à spaCy durant la mise en place du projet.
+* **Facilement généralisable** à d'autres bibliothèques similaires (Pytorch, Tensorflow), et non juste spaCy.

docs/fr/docs/python-types.md

@@ -1,68 +1,70 @@
-# Introduction aux types Python { #python-types-intro }
+# Introduction aux Types Python
 
-Python prend en charge des « type hints » (aussi appelées « annotations de type ») facultatives.
+Python supporte des annotations de type (ou *type hints*) optionnelles.
 
-Ces « type hints » ou annotations sont une syntaxe spéciale qui permet de déclarer le <abbr title="par exemple : str, int, float, bool">type</abbr> d'une variable.
+Ces annotations de type constituent une syntaxe spéciale qui permet de déclarer le <abbr title="par exemple : str, int, float, bool">type</abbr> d'une variable.
 
-En déclarant les types de vos variables, les éditeurs et outils peuvent vous offrir un meilleur support.
+En déclarant les types de vos variables, cela permet aux différents outils comme les éditeurs de texte d'offrir un meilleur support.
 
-Ceci est un **tutoriel rapide / rappel** à propos des annotations de type Python. Il couvre uniquement le minimum nécessaire pour les utiliser avec **FastAPI** ... ce qui est en réalité très peu.
+Ce chapitre n'est qu'un **tutoriel rapide / rappel** sur les annotations de type Python.
+Seulement le minimum nécessaire pour les utiliser avec **FastAPI** sera couvert... ce qui est en réalité très peu.
 
-**FastAPI** est totalement basé sur ces annotations de type, elles lui donnent de nombreux avantages et bénéfices.
+**FastAPI** est totalement basé sur ces annotations de type, qui lui donnent de nombreux avantages.
 
-Mais même si vous n'utilisez jamais **FastAPI**, vous auriez intérêt à en apprendre un peu à leur sujet.
+Mais même si vous n'utilisez pas ou n'utiliserez jamais **FastAPI**, vous pourriez bénéficier d'apprendre quelques choses sur ces dernières.
 
-/// note | Remarque
+/// note
 
-Si vous êtes un expert Python, et que vous savez déjà tout sur les annotations de type, passez au chapitre suivant.
+Si vous êtes un expert Python, et que vous savez déjà **tout** sur les annotations de type, passez au chapitre suivant.
 
 ///
 
-## Motivation { #motivation }
+## Motivations
 
-Commençons par un exemple simple :
+Prenons un exemple simple :
 
-{* ../../docs_src/python_types/tutorial001_py39.py *}
+{*../../docs_src/python_types/tutorial001.py*}
 
-Exécuter ce programme affiche :
+Exécuter ce programe affiche :
 
 ```
 John Doe
 ```
 
-La fonction fait ce qui suit :
+La fonction :
 
 * Prend un `first_name` et un `last_name`.
-* Convertit la première lettre de chacun en majuscule avec `title()`.
-* <abbr title="Les met ensemble, en un seul. Avec le contenu de l'un après l'autre.">Concatène</abbr> ces deux valeurs avec un espace au milieu.
+* Convertit la première lettre de chaque paramètre en majuscules grâce à `title()`.
+* Concatène les résultats avec un espace entre les deux.
 
-{* ../../docs_src/python_types/tutorial001_py39.py hl[2] *}
+{*../../docs_src/python_types/tutorial001.py hl[2] *}
 
-### Modifier le code { #edit-it }
+### Limitations
 
 C'est un programme très simple.
 
 Mais maintenant imaginez que vous l'écriviez de zéro.
 
-À un certain moment, vous auriez commencé la définition de la fonction, vous aviez les paramètres prêts ...
+À un certain point vous auriez commencé la définition de la fonction, vous aviez les paramètres prêts.
 
-Mais ensuite vous devez appeler « cette méthode qui convertit la première lettre en majuscule ».
+Mais vous aviez besoin de "cette méthode qui convertit la première lettre en majuscule".
 
-Était-ce `upper` ? Était-ce `uppercase` ? `first_uppercase` ? `capitalize` ?
+Était-ce `upper` ? `uppercase` ? `first_uppercase` ? `capitalize` ?
 
-Vous essayez alors avec l'ami de toujours des programmeurs, l'autocomplétion de l'éditeur.
+Vous essayez donc d'utiliser le vieil ami du programmeur, l'auto-complétion de l'éditeur.
 
-Vous tapez le premier paramètre de la fonction, `first_name`, puis un point (`.`) et appuyez sur `Ctrl+Espace` pour déclencher l'autocomplétion.
+Vous écrivez le premier paramètre, `first_name`, puis un point (`.`) et appuyez sur `Ctrl+Espace` pour déclencher l'auto-complétion.
 
-Mais, malheureusement, vous n'obtenez rien d'utile :
+Mais malheureusement, rien d'utile n'en résulte :
 
 <img src="/img/python-types/image01.png">
 
-### Ajouter des types { #add-types }
+### Ajouter des types
 
 Modifions une seule ligne de la version précédente.
 
-Nous allons changer exactement ce fragment, les paramètres de la fonction, de :
+Nous allons changer seulement cet extrait, les paramètres de la fonction, de :
+
 
 ```Python
     first_name, last_name
@@ -76,389 +78,222 @@ Nous allons changer exactement ce fragment, les paramètres de la fonction, de :
 
 C'est tout.
 
-Ce sont les « annotations de type » :
+Ce sont des annotations de types :
 
-{* ../../docs_src/python_types/tutorial002_py39.py hl[1] *}
+{*../../docs_src/python_types/tutorial002.py hl[1] *}
 
-Ce n'est pas la même chose que de déclarer des valeurs par défaut, ce qui serait :
+À ne pas confondre avec la déclaration de valeurs par défaut comme ici :
 
 ```Python
     first_name="john", last_name="doe"
 ```
 
-C'est différent.
+C'est une chose différente.
 
-Nous utilisons des deux-points (`:`), pas des signes égal (`=`).
+On utilise un deux-points (`:`), et pas un égal (`=`).
 
-Et ajouter des annotations de type ne change normalement pas ce qui se passe par rapport à ce qui se passerait sans elles.
+Et ajouter des annotations de types ne crée normalement pas de différence avec le comportement qui aurait eu lieu si elles n'étaient pas là.
 
-Mais maintenant, imaginez que vous êtes à nouveau en train de créer cette fonction, mais avec des annotations de type.
+Maintenant, imaginez que vous êtes en train de créer cette fonction, mais avec des annotations de type cette fois.
 
-Au même moment, vous essayez de déclencher l'autocomplétion avec `Ctrl+Espace` et vous voyez :
+Au même moment que durant l'exemple précédent, vous essayez de déclencher l'auto-complétion et vous voyez :
 
 <img src="/img/python-types/image02.png">
 
-Avec cela, vous pouvez faire défiler en voyant les options, jusqu'à trouver celle qui « vous dit quelque chose » :
+Vous pouvez donc dérouler les options jusqu'à trouver la méthode à laquelle vous pensiez.
 
 <img src="/img/python-types/image03.png">
 
-## Plus de motivation { #more-motivation }
+## Plus de motivations
 
-Regardez cette fonction, elle a déjà des annotations de type :
+Cette fonction possède déjà des annotations de type :
 
-{* ../../docs_src/python_types/tutorial003_py39.py hl[1] *}
+{*../../docs_src/python_types/tutorial003.py hl[1] *}
 
-Comme l'éditeur connaît les types des variables, vous n'obtenez pas seulement l'autocomplétion, vous obtenez aussi des vérifications d'erreurs :
+Comme l'éditeur connaît le type des variables, vous n'avez pas seulement l'auto-complétion, mais aussi de la détection d'erreurs :
 
 <img src="/img/python-types/image04.png">
 
-Vous savez maintenant qu'il faut corriger, convertir `age` en chaîne avec `str(age)` :
+Maintenant que vous avez connaissance du problème, convertissez `age` en <abbr title="string">chaîne de caractères</abbr> grâce à `str(age)` :
 
-{* ../../docs_src/python_types/tutorial004_py39.py hl[2] *}
+{*../../docs_src/python_types/tutorial004.py hl[2] *}
 
-## Déclarer des types { #declaring-types }
+## Déclarer des types
 
-Vous venez de voir l'endroit principal pour déclarer des annotations de type : dans les paramètres des fonctions.
+Vous venez de voir là où les types sont généralement déclarés : dans les paramètres de fonctions.
 
-C'est aussi l'endroit principal où vous les utiliserez avec **FastAPI**.
+C'est aussi ici que vous les utiliseriez avec **FastAPI**.
 
-### Types simples { #simple-types }
+### Types simples
 
-Vous pouvez déclarer tous les types standards de Python, pas seulement `str`.
+Vous pouvez déclarer tous les types  de Python, pas seulement `str`.
 
-Vous pouvez utiliser, par exemple :
+Comme par exemple :
 
 * `int`
 * `float`
 * `bool`
 * `bytes`
 
-{* ../../docs_src/python_types/tutorial005_py39.py hl[1] *}
+{*../../docs_src/python_types/tutorial005.py hl[1] *}
 
-### Types génériques avec paramètres de type { #generic-types-with-type-parameters }
+### Types génériques avec des paramètres de types
 
-Il existe certaines structures de données qui peuvent contenir d'autres valeurs, comme `dict`, `list`, `set` et `tuple`. Et les valeurs internes peuvent aussi avoir leur propre type.
+Il existe certaines structures de données qui contiennent d'autres valeurs, comme `dict`, `list`, `set` et `tuple`. Et les valeurs internes peuvent elles aussi avoir leurs propres types.
 
-Ces types qui ont des types internes sont appelés types « génériques ». Et il est possible de les déclarer, même avec leurs types internes.
+Pour déclarer ces types et les types internes, on utilise le module standard de Python `typing`.
 
-Pour déclarer ces types et les types internes, vous pouvez utiliser le module standard Python `typing`. Il existe spécifiquement pour prendre en charge ces annotations de type.
+Il existe spécialement pour supporter ces annotations de types.
 
-#### Versions plus récentes de Python { #newer-versions-of-python }
+#### `List`
 
-La syntaxe utilisant `typing` est compatible avec toutes les versions, de Python 3.6 aux plus récentes, y compris Python 3.9, Python 3.10, etc.
+Par exemple, définissons une variable comme `list` de `str`.
 
-Au fur et à mesure que Python évolue, les versions plus récentes apportent un meilleur support pour ces annotations de type et dans de nombreux cas vous n'aurez même pas besoin d'importer et d'utiliser le module `typing` pour les déclarer.
+Importez `List` (avec un `L` majuscule) depuis `typing`.
 
-Si vous pouvez choisir une version plus récente de Python pour votre projet, vous pourrez profiter de cette simplicité supplémentaire.
+{*../../docs_src/python_types/tutorial006.py hl[1] *}
 
-Dans toute la documentation, il y a des exemples compatibles avec chaque version de Python (lorsqu'il y a une différence).
+Déclarez la variable, en utilisant la syntaxe des deux-points (`:`).
 
-Par exemple « Python 3.6+ » signifie que c'est compatible avec Python 3.6 ou supérieur (y compris 3.7, 3.8, 3.9, 3.10, etc.). Et « Python 3.9+ » signifie que c'est compatible avec Python 3.9 ou supérieur (y compris 3.10, etc).
+Et comme type, mettez `List`.
 
-Si vous pouvez utiliser les dernières versions de Python, utilisez les exemples pour la dernière version, ils auront la meilleure et la plus simple syntaxe, par exemple, « Python 3.10+ ».
+Les listes étant un type contenant des types internes, mettez ces derniers entre crochets (`[`, `]`) :
 
-#### Liste { #list }
+{*../../docs_src/python_types/tutorial006.py hl[4] *}
 
-Par exemple, définissons une variable comme une `list` de `str`.
+/// tip | Astuce
 
-Déclarez la variable, en utilisant la même syntaxe avec deux-points (`:`).
+Ces types internes entre crochets sont appelés des "paramètres de type".
 
-Comme type, mettez `list`.
-
-Comme la liste est un type qui contient des types internes, mettez-les entre crochets :
-
-{* ../../docs_src/python_types/tutorial006_py39.py hl[1] *}
-
-/// info
-
-Ces types internes entre crochets sont appelés « paramètres de type ».
-
-Dans ce cas, `str` est le paramètre de type passé à `list`.
+Ici, `str` est un paramètre de type passé à `List`.
 
 ///
 
-Cela signifie : « la variable `items` est une `list`, et chacun des éléments de cette liste est un `str` ».
+Ce qui signifie : "la variable `items` est une `list`, et chacun de ses éléments a pour type `str`.
 
-En faisant cela, votre éditeur peut vous fournir de l'aide même pendant le traitement des éléments de la liste :
+En faisant cela, votre éditeur pourra vous aider, même pendant que vous traitez des éléments de la liste.
 
 <img src="/img/python-types/image05.png">
 
 Sans types, c'est presque impossible à réaliser.
 
-Remarquez que la variable `item` est l'un des éléments de la liste `items`.
+Vous remarquerez que la variable `item` n'est qu'un des éléments de la list `items`.
 
-Et pourtant, l'éditeur sait que c'est un `str` et fournit le support approprié.
+Et pourtant, l'éditeur sait qu'elle est de type `str` et pourra donc vous aider à l'utiliser.
 
-#### Tuple et Set { #tuple-and-set }
+#### `Tuple` et `Set`
 
-Vous feriez la même chose pour déclarer des `tuple` et des `set` :
+C'est le même fonctionnement pour déclarer un `tuple` ou un `set` :
 
-{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}
+{*../../docs_src/python_types/tutorial007.py hl[1,4] *}
 
-Cela signifie :
+Dans cet exemple :
 
-* La variable `items_t` est un `tuple` avec 3 éléments, un `int`, un autre `int`, et un `str`.
+* La variable `items_t` est un `tuple` avec 3 éléments, un `int`, un deuxième `int`, et un `str`.
 * La variable `items_s` est un `set`, et chacun de ses éléments est de type `bytes`.
 
-#### Dict { #dict }
+#### `Dict`
 
-Pour définir un `dict`, vous passez 2 paramètres de type, séparés par des virgules.
+Pour définir un `dict`, il faut lui passer 2 paramètres, séparés par une virgule (`,`).
 
-Le premier paramètre de type est pour les clés du `dict`.
+Le premier paramètre de type est pour les clés et le second pour les valeurs du dictionnaire (`dict`).
 
-Le second paramètre de type est pour les valeurs du `dict` :
+{*../../docs_src/python_types/tutorial008.py hl[1,4] *}
 
-{* ../../docs_src/python_types/tutorial008_py39.py hl[1] *}
+Dans cet exemple :
 
-Cela signifie :
+* La variable `prices` est de type `dict` :
+    * Les clés de ce dictionnaire sont de type `str`.
+    * Les valeurs de ce dictionnaire sont de type `float`.
 
-* La variable `prices` est un `dict` :
-    * Les clés de ce `dict` sont de type `str` (disons, le nom de chaque article).
-    * Les valeurs de ce `dict` sont de type `float` (disons, le prix de chaque article).
+#### `Optional`
 
-#### Union { #union }
+Vous pouvez aussi utiliser `Optional` pour déclarer qu'une variable a un type, comme `str` mais qu'il est "optionnel" signifiant qu'il pourrait aussi être `None`.
 
-Vous pouvez déclarer qu'une variable peut être de plusieurs types, par exemple, un `int` ou un `str`.
+{*../../docs_src/python_types/tutorial009.py hl[1,4] *}
 
-Dans Python 3.6 et supérieur (y compris Python 3.10), vous pouvez utiliser le type `Union` de `typing` et mettre entre crochets les types possibles à accepter.
+Utiliser `Optional[str]` plutôt que `str` permettra à l'éditeur de vous aider à détecter les erreurs où vous supposeriez qu'une valeur est toujours de type `str`, alors qu'elle pourrait aussi être `None`.
 
-Dans Python 3.10, il existe aussi une nouvelle syntaxe où vous pouvez mettre les types possibles séparés par une <abbr title='aussi appelé « opérateur OU bit à bit », mais ce sens n’est pas pertinent ici'>barre verticale (`|`)</abbr>.
+#### Types génériques
 
-//// tab | Python 3.10+
+Les types qui peuvent contenir des paramètres de types entre crochets, comme :
 
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial008b_py310.py!}
-```
-
-////
-
-//// tab | Python 3.9+
-
-```Python hl_lines="1  4"
-{!> ../../docs_src/python_types/tutorial008b_py39.py!}
-```
-
-////
-
-Dans les deux cas, cela signifie que `item` peut être un `int` ou un `str`.
-
-#### Possiblement `None` { #possibly-none }
-
-Vous pouvez déclarer qu'une valeur peut avoir un type, comme `str`, mais qu'elle peut aussi être `None`.
-
-Dans Python 3.6 et supérieur (y compris Python 3.10), vous pouvez le déclarer en important et en utilisant `Optional` depuis le module `typing`.
-
-```Python hl_lines="1  4"
-{!../../docs_src/python_types/tutorial009_py39.py!}
-```
-
-Utiliser `Optional[str]` au lieu de simplement `str` permettra à l'éditeur de vous aider à détecter des erreurs où vous supposeriez qu'une valeur est toujours un `str`, alors qu'elle pourrait en fait aussi être `None`.
-
-`Optional[Something]` est en réalité un raccourci pour `Union[Something, None]`, ils sont équivalents.
-
-Cela signifie aussi que dans Python 3.10, vous pouvez utiliser `Something | None` :
-
-//// tab | Python 3.10+
-
-```Python hl_lines="1"
-{!> ../../docs_src/python_types/tutorial009_py310.py!}
-```
-
-////
-
-//// tab | Python 3.9+
-
-```Python hl_lines="1  4"
-{!> ../../docs_src/python_types/tutorial009_py39.py!}
-```
-
-////
-
-//// tab | Python 3.9+ alternative
-
-```Python hl_lines="1  4"
-{!> ../../docs_src/python_types/tutorial009b_py39.py!}
-```
-
-////
-
-#### Utiliser `Union` ou `Optional` { #using-union-or-optional }
-
-Si vous utilisez une version de Python inférieure à 3.10, voici un conseil de mon point de vue très **subjectif** :
-
-* 🚨 Évitez d'utiliser `Optional[SomeType]`
-* À la place ✨ **utilisez `Union[SomeType, None]`** ✨.
-
-Les deux sont équivalents et sous le capot ce sont les mêmes, mais je recommanderais `Union` plutôt que `Optional` parce que le mot « facultatif » semble impliquer que la valeur est optionnelle, alors que cela signifie en fait « elle peut être `None` », même si elle n'est pas facultative et est toujours requise.
-
-Je pense que `Union[SomeType, None]` est plus explicite sur ce que cela signifie.
-
-Il ne s'agit que des mots et des noms. Mais ces mots peuvent influencer la manière dont vous et vos coéquipiers pensez au code.
-
-Par exemple, prenons cette fonction :
-
-{* ../../docs_src/python_types/tutorial009c_py39.py hl[1,4] *}
-
-Le paramètre `name` est défini comme `Optional[str]`, mais il n'est pas facultatif, vous ne pouvez pas appeler la fonction sans le paramètre :
-
-```Python
-say_hi()  # Oh non, cela lève une erreur ! 😱
-```
-
-Le paramètre `name` est toujours requis (pas « optionnel ») parce qu'il n'a pas de valeur par défaut. Néanmoins, `name` accepte `None` comme valeur :
-
-```Python
-say_hi(name=None)  # Cela fonctionne, None est valide 🎉
-```
-
-La bonne nouvelle est que, dès que vous êtes sur Python 3.10, vous n'avez plus à vous en soucier, car vous pourrez simplement utiliser `|` pour définir des unions de types :
-
-{* ../../docs_src/python_types/tutorial009c_py310.py hl[1,4] *}
-
-Et alors vous n'aurez plus à vous soucier de noms comme `Optional` et `Union`. 😎
-
-#### Types génériques { #generic-types }
-
-Ces types qui prennent des paramètres de type entre crochets sont appelés des **types génériques** ou **Generics**, par exemple :
-
-//// tab | Python 3.10+
-
-Vous pouvez utiliser les mêmes types intégrés comme génériques (avec des crochets et des types à l'intérieur) :
-
-* `list`
-* `tuple`
-* `set`
-* `dict`
-
-Et, comme avec les versions précédentes de Python, depuis le module `typing` :
-
-* `Union`
+* `List`
+* `Tuple`
+* `Set`
+* `Dict`
 * `Optional`
-* ... et d'autres.
+* ...et d'autres.
 
-Dans Python 3.10, comme alternative à l'utilisation des génériques `Union` et `Optional`, vous pouvez utiliser la <abbr title='aussi appelé « opérateur OU bit à bit », mais ce sens n’est pas pertinent ici'>barre verticale (`|`)</abbr> pour déclarer des unions de types, c'est bien mieux et plus simple.
+sont appelés des **types génériques** ou **Generics**.
 
-////
-
-//// tab | Python 3.9+
-
-Vous pouvez utiliser les mêmes types intégrés comme génériques (avec des crochets et des types à l'intérieur) :
-
-* `list`
-* `tuple`
-* `set`
-* `dict`
-
-Et des génériques depuis le module `typing` :
-
-* `Union`
-* `Optional`
-* ... et d'autres.
-
-////
-
-### Classes en tant que types { #classes-as-types }
+### Classes en tant que types
 
 Vous pouvez aussi déclarer une classe comme type d'une variable.
 
-Disons que vous avez une classe `Person`, avec un nom :
+Disons que vous avez une classe `Person`, avec une variable `name` :
+
+{*../../docs_src/python_types/tutorial010.py hl[1:3] *}
 
-{* ../../docs_src/python_types/tutorial010_py39.py hl[1:3] *}
 
 Vous pouvez ensuite déclarer une variable de type `Person` :
 
-{* ../../docs_src/python_types/tutorial010_py39.py hl[6] *}
+{*../../docs_src/python_types/tutorial010.py hl[6] *}
 
-Et là encore, vous obtenez tout le support de l'éditeur :
+Et vous aurez accès, encore une fois, au support complet offert par l'éditeur :
 
 <img src="/img/python-types/image06.png">
 
-Remarquez que cela signifie « `one_person` est une instance de la classe `Person` ».
-
-Cela ne signifie pas « `one_person` est la classe appelée `Person` ».
-
-## Modèles Pydantic { #pydantic-models }
+## Les modèles Pydantic
 
 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> est une bibliothèque Python pour effectuer de la validation de données.
 
-Vous déclarez la « forme » de la donnée sous forme de classes avec des attributs.
+Vous déclarez la forme de la donnée avec des classes et des attributs.
 
-Et chaque attribut a un type.
+Chaque attribut possède un type.
 
-Ensuite, vous créez une instance de cette classe avec certaines valeurs et elle validera les valeurs, les convertira dans le type approprié (le cas échéant) et vous donnera un objet avec toutes les données.
+Puis vous créez une instance de cette classe avec certaines valeurs et **Pydantic** validera les valeurs, les convertira dans le type adéquat (si c'est nécessaire et possible) et vous donnera un objet avec toute la donnée.
 
-Et vous obtenez tout le support de l'éditeur avec cet objet résultant.
+Ainsi, votre éditeur vous offrira un support adapté pour l'objet résultant.
 
-Un exemple tiré de la documentation officielle de Pydantic :
+Extrait de la documentation officielle de **Pydantic** :
 
-{* ../../docs_src/python_types/tutorial011_py310.py *}
+{*../../docs_src/python_types/tutorial011.py*}
 
 /// info
 
-Pour en savoir plus à propos de <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic, consultez sa documentation</a>.
+Pour en savoir plus à propos de <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic, allez jeter un coup d'oeil à sa documentation</a>.
 
 ///
 
-**FastAPI** est entièrement basé sur Pydantic.
+**FastAPI** est basé entièrement sur **Pydantic**.
 
-Vous verrez beaucoup plus de tout cela en pratique dans le [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
+Vous verrez bien plus d'exemples de son utilisation dans [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
 
-/// tip | Astuce
+## Les annotations de type dans **FastAPI**
 
-Pydantic a un comportement spécial lorsque vous utilisez `Optional` ou `Union[Something, None]` sans valeur par défaut, vous pouvez en lire davantage dans la documentation de Pydantic à propos des <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">champs Optionals requis</a>.
+**FastAPI** utilise ces annotations pour faire différentes choses.
 
-///
+Avec **FastAPI**, vous déclarez des paramètres grâce aux annotations de types et vous obtenez :
 
-## Annotations de type avec métadonnées { #type-hints-with-metadata-annotations }
+* **du support de l'éditeur**
+* **de la vérification de types**
 
-Python dispose également d'une fonctionnalité qui permet de mettre des **<abbr title="Données sur les données, dans ce cas, des informations sur le type, p. ex. une description.">métadonnées</abbr> supplémentaires** dans ces annotations de type en utilisant `Annotated`.
+...et **FastAPI** utilise ces mêmes déclarations pour :
 
-Depuis Python 3.9, `Annotated` fait partie de la bibliothèque standard, vous pouvez donc l'importer depuis `typing`.
-
-{* ../../docs_src/python_types/tutorial013_py39.py hl[1,4] *}
-
-Python lui-même ne fait rien avec ce `Annotated`. Et pour les éditeurs et autres outils, le type est toujours `str`.
-
-Mais vous pouvez utiliser cet espace dans `Annotated` pour fournir à **FastAPI** des métadonnées supplémentaires sur la façon dont vous voulez que votre application se comporte.
-
-L'important à retenir est que le premier paramètre de type que vous passez à `Annotated` est le type réel. Le reste n'est que des métadonnées pour d'autres outils.
-
-Pour l'instant, vous avez juste besoin de savoir que `Annotated` existe, et que c'est du Python standard. 😎
-
-Plus tard, vous verrez à quel point cela peut être puissant.
-
-/// tip | Astuce
-
-Le fait que ce soit du Python standard signifie que vous bénéficierez toujours de la meilleure expérience développeur possible dans votre éditeur, avec les outils que vous utilisez pour analyser et refactoriser votre code, etc. ✨
-
-Et aussi que votre code sera très compatible avec de nombreux autres outils et bibliothèques Python. 🚀
-
-///
-
-## Annotations de type dans **FastAPI** { #type-hints-in-fastapi }
-
-**FastAPI** tire parti de ces annotations de type pour faire plusieurs choses.
-
-Avec **FastAPI**, vous déclarez des paramètres avec des annotations de type et vous obtenez :
-
-* **Du support de l'éditeur**.
-* **Des vérifications de types**.
-
-... et **FastAPI** utilise les mêmes déclarations pour :
-
-* **Définir des prérequis** : à partir des paramètres de chemin de la requête, des paramètres de requête, des en-têtes, des corps, des dépendances, etc.
-* **Convertir des données** : de la requête vers le type requis.
-* **Valider des données** : provenant de chaque requête :
-    * En générant des **erreurs automatiques** renvoyées au client lorsque la donnée est invalide.
+* **Définir les prérequis** : depuis les paramètres de chemins des requêtes, les entêtes, les corps, les dépendances, etc.
+* **Convertir des données** : depuis la requête vers les types requis.
+* **Valider des données** : venant de chaque requête :
+    * Générant automatiquement des **erreurs** renvoyées au client quand la donnée est invalide.
 * **Documenter** l'API avec OpenAPI :
-    * ce qui est ensuite utilisé par les interfaces utilisateur de documentation interactive automatiques.
+    * ce qui ensuite utilisé par les interfaces utilisateur automatiques de documentation interactive.
 
-Tout cela peut sembler abstrait. Ne vous inquiétez pas. Vous verrez tout cela en action dans le [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
+Tout cela peut paraître bien abstrait, mais ne vous inquiétez pas, vous verrez tout ça en pratique dans [Tutoriel - Guide utilisateur](tutorial/index.md){.internal-link target=_blank}.
 
-L'important est qu'en utilisant les types standards de Python, en un seul endroit (au lieu d'ajouter plus de classes, de décorateurs, etc.), **FastAPI** fera une grande partie du travail pour vous.
+Ce qu'il faut retenir c'est qu'en utilisant les types standard de Python, à un seul endroit (plutôt que d'ajouter plus de classes, de décorateurs, etc.), **FastAPI** fera une grande partie du travail pour vous.
 
 /// info
 
-Si vous avez déjà parcouru tout le tutoriel et êtes revenu pour en voir plus sur les types, une bonne ressource est <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">l'« aide-mémoire » de `mypy`</a>.
+Si vous avez déjà lu le tutoriel et êtes revenus ici pour voir plus sur les types, une bonne ressource est la <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">"cheat sheet" de `mypy`</a>.
 
 ///

docs/fr/docs/tutorial/background-tasks.md

@@ -1,4 +1,4 @@
-# Tâches d'arrière-plan { #background-tasks }
+# Tâches d'arrière-plan
 
 Vous pouvez définir des tâches d'arrière-plan qui seront exécutées après avoir retourné une réponse.
 
@@ -7,19 +7,20 @@ Ceci est utile pour les opérations qui doivent avoir lieu après une requête,
 Cela comprend, par exemple :
 
 * Les notifications par email envoyées après l'exécution d'une action :
-    * Étant donné que se connecter à un serveur et envoyer un email a tendance à être « lent » (plusieurs secondes), vous pouvez retourner la réponse directement et envoyer la notification en arrière-plan.
+    * Étant donné que se connecter à un serveur et envoyer un email a tendance à être «lent» (plusieurs secondes), vous pouvez retourner la réponse directement et envoyer la notification en arrière-plan.
 * Traiter des données :
-    * Par exemple, si vous recevez un fichier qui doit passer par un traitement lent, vous pouvez retourner une réponse « Accepted » (HTTP 202) puis faire le traitement en arrière-plan.
+    * Par exemple, si vous recevez un fichier qui doit passer par un traitement lent, vous pouvez retourner une réponse «Accepted» (HTTP 202) puis faire le traitement en arrière-plan.
 
-## Utiliser `BackgroundTasks` { #using-backgroundtasks }
 
-Pour commencer, importez `BackgroundTasks` et définissez un paramètre dans votre *fonction de chemin d'accès* avec `BackgroundTasks` comme type déclaré.
+## Utiliser `BackgroundTasks`
 
-{* ../../docs_src/background_tasks/tutorial001_py39.py hl[1,13] *}
+Pour commencer, importez `BackgroundTasks` et définissez un paramètre dans votre *fonction de chemin* avec `BackgroundTasks` comme type déclaré.
+
+{* ../../docs_src/background_tasks/tutorial001.py hl[1,13] *}
 
 **FastAPI** créera l'objet de type `BackgroundTasks` pour vous et le passera comme paramètre.
 
-## Créer une fonction de tâche { #create-a-task-function }
+## Créer une fonction de tâche
 
 Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.
 
@@ -29,13 +30,14 @@ Dans cet exemple, la fonction de tâche écrira dans un fichier (afin de simuler
 
 L'opération d'écriture n'utilisant ni `async` ni `await`, on définit la fonction avec un `def` normal.
 
-{* ../../docs_src/background_tasks/tutorial001_py39.py hl[6:9] *}
+{* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}
 
-## Ajouter une tâche d'arrière-plan { #add-the-background-task }
+## Ajouter une tâche d'arrière-plan
 
-Dans votre *fonction de chemin d'accès*, passez votre fonction de tâche à l'objet de type `BackgroundTasks` (`background_tasks` ici) grâce à la méthode `.add_task()` :
+Dans votre *fonction de chemin*, passez votre fonction de tâche à l'objet de type `BackgroundTasks` (`background_tasks` ici) grâce à la méthode `.add_task()` :
 
-{* ../../docs_src/background_tasks/tutorial001_py39.py hl[14] *}
+
+{* ../../docs_src/background_tasks/tutorial001.py hl[14] *}
 
 `.add_task()` reçoit comme arguments :
 
@@ -43,40 +45,40 @@ Dans votre *fonction de chemin d'accès*, passez votre fonction de tâche à l'o
 * Les arguments positionnels à passer à la fonction de tâche dans l'ordre (`email`).
 * Les arguments nommés à passer à la fonction de tâche (`message="some notification"`).
 
-## Injection de dépendances { #dependency-injection }
+## Injection de dépendances
 
-Utiliser `BackgroundTasks` fonctionne aussi avec le système d'injection de dépendances. Vous pouvez déclarer un paramètre de type `BackgroundTasks` à différents niveaux : dans une *fonction de chemin d'accès*, dans une dépendance (dependable), dans une sous-dépendance, etc.
+Utiliser `BackgroundTasks` fonctionne aussi avec le système d'injection de dépendances. Vous pouvez déclarer un paramètre de type `BackgroundTasks` à différents niveaux : dans une *fonction de chemin*, dans une dépendance, dans une sous-dépendance...
 
-**FastAPI** sait quoi faire dans chaque cas et comment réutiliser le même objet, afin que toutes les tâches d'arrière-plan soient fusionnées et que les tâches soient ensuite exécutées en arrière-plan :
+**FastAPI** sait quoi faire dans chaque cas et comment réutiliser le même objet, afin que tous les paramètres de type `BackgroundTasks` soient fusionnés et que les tâches soient exécutées en arrière-plan :
 
-{* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
+{* ../../docs_src/background_tasks/tutorial002.py hl[13,15,22,25] *}
 
 Dans cet exemple, les messages seront écrits dans le fichier `log.txt` après que la réponse soit envoyée.
 
-S'il y avait un paramètre de requête dans la requête, alors il sera écrit dans le journal via une tâche d'arrière-plan.
+S'il y avait une `query` (paramètre nommé `q`) dans la requête, alors elle sera écrite dans `log.txt` via une tâche d'arrière-plan.
 
-Et ensuite une autre tâche d'arrière-plan (générée dans la *fonction de chemin d'accès*) écrira un message comprenant le paramètre de chemin `email`.
+Et ensuite une autre tâche d'arrière-plan (générée dans les paramètres de la *la fonction de chemin*) écrira un message dans `log.txt` comprenant le paramètre de chemin `email`.
 
-## Détails techniques { #technical-details }
+## Détails techniques
 
 La classe `BackgroundTasks` provient directement de <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">`starlette.background`</a>.
 
 Elle est importée/incluse directement dans **FastAPI** pour que vous puissiez l'importer depuis `fastapi` et éviter d'importer accidentellement `BackgroundTask` (sans `s` à la fin) depuis `starlette.background`.
 
-En utilisant seulement `BackgroundTasks` (et non `BackgroundTask`), il est possible de l'utiliser en tant que paramètre de *fonction de chemin d'accès* et de laisser **FastAPI** gérer le reste pour vous, comme en utilisant l'objet `Request` directement.
+En utilisant seulement `BackgroundTasks` (et non `BackgroundTask`), il est possible de l'utiliser en tant que paramètre de *fonction de chemin* et de laisser **FastAPI** gérer le reste pour vous, comme en utilisant l'objet `Request` directement.
 
 Il est tout de même possible d'utiliser `BackgroundTask` seul dans **FastAPI**, mais dans ce cas il faut créer l'objet dans le code et renvoyer une `Response` Starlette l'incluant.
 
-Plus de détails sont disponibles dans <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">la documentation officielle de Starlette sur les tâches d'arrière-plan</a>.
+Plus de détails sont disponibles dans <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">la documentation officielle de Starlette sur les tâches d'arrière-plan</a> (via leurs classes `BackgroundTasks`et `BackgroundTask`).
 
-## Avertissement { #caveat }
+## Avertissement
 
 Si vous avez besoin de réaliser des traitements lourds en tâche d'arrière-plan et que vous n'avez pas besoin que ces traitements aient lieu dans le même process (par exemple, pas besoin de partager la mémoire, les variables, etc.), il peut s'avérer profitable d'utiliser des outils plus importants tels que <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.
 
-Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de message, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans différents process, et surtout, sur plusieurs serveurs.
+Ces outils nécessitent généralement des configurations plus complexes ainsi qu'un gestionnaire de queue de message, comme RabbitMQ ou Redis, mais ils permettent d'exécuter des tâches d'arrière-plan dans différents process, et potentiellement, sur plusieurs serveurs.
 
 Mais si vous avez besoin d'accéder aux variables et objets de la même application **FastAPI**, ou si vous avez besoin d'effectuer de petites tâches d'arrière-plan (comme envoyer des notifications par email), vous pouvez simplement vous contenter d'utiliser `BackgroundTasks`.
 
-## Résumé { #recap }
+## Résumé
 
-Importez et utilisez `BackgroundTasks` grâce aux paramètres de *fonction de chemin d'accès* et les dépendances pour ajouter des tâches d'arrière-plan.
+Importez et utilisez `BackgroundTasks` grâce aux paramètres de *fonction de chemin* et les dépendances pour ajouter des tâches d'arrière-plan.

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

@@ -1,24 +1,24 @@
-# Body - Paramètres multiples { #body-multiple-parameters }
+# Body - Paramètres multiples
 
-Maintenant que nous avons vu comment utiliser `Path` et `Query`, voyons des usages plus avancés des déclarations de paramètres du corps de la requête.
+Maintenant que nous avons vu comment manipuler `Path` et `Query`, voyons comment faire pour le corps d'une requête, communément désigné par le terme anglais "body".
 
-## Mélanger les paramètres `Path`, `Query` et body { #mix-path-query-and-body-parameters }
+## Mélanger les paramètres `Path`, `Query` et body
 
-Tout d'abord, sachez que vous pouvez mélanger librement les déclarations des paramètres `Path`, `Query` et du body, **FastAPI** saura quoi faire.
+Tout d'abord, sachez que vous pouvez mélanger les déclarations des paramètres `Path`, `Query` et body, **FastAPI** saura quoi faire.
 
-Et vous pouvez également déclarer des paramètres du body comme étant optionnels, en leur assignant une valeur par défaut à `None` :
+Vous pouvez également déclarer des paramètres body comme étant optionnels, en leur assignant une valeur par défaut à `None` :
 
 {* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
 
-/// note | Remarque
+/// note
 
-Notez que, dans ce cas, l'élément `item` récupéré depuis le body est optionnel. Comme sa valeur par défaut est `None`.
+Notez que, dans ce cas, le paramètre `item` provenant du `Body` est optionnel (sa valeur par défaut est `None`).
 
 ///
 
-## Paramètres multiples du body { #multiple-body-parameters }
+## Paramètres multiples du body
 
-Dans l'exemple précédent, les chemins d'accès attendraient un body JSON avec les attributs d'un `Item`, par exemple :
+Dans l'exemple précédent, les opérations de routage attendaient un body JSON avec les attributs d'un `Item`, par exemple :
 
 ```JSON
 {
@@ -29,13 +29,13 @@ Dans l'exemple précédent, les chemins d'accès attendraient un body JSON avec
 }
 ```
 
-Mais vous pouvez également déclarer plusieurs paramètres provenant du body, par exemple `item` et `user` :
+Mais vous pouvez également déclarer plusieurs paramètres provenant de body, par exemple `item` et `user` simultanément :
 
 {* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
 
-Dans ce cas, **FastAPI** détectera qu'il y a plus d'un paramètre du body dans la fonction (il y a deux paramètres qui sont des modèles Pydantic).
+Dans ce cas, **FastAPI** détectera qu'il y a plus d'un paramètre dans le body (chacun correspondant à un modèle Pydantic).
 
-Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le body, et s'attendra à recevoir un body semblable à :
+Il utilisera alors les noms des paramètres comme clés, et s'attendra à recevoir quelque chose de semblable à :
 
 ```JSON
 {
@@ -52,25 +52,25 @@ Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le
 }
 ```
 
-/// note | Remarque
+/// note
 
-Notez que, bien que `item` ait été déclaré de la même manière qu'auparavant, il est désormais attendu à l'intérieur du body sous la clé `item`.
+"Notez que, bien que nous ayons déclaré le paramètre `item` de la même manière que précédemment, il est maintenant associé à la clé `item` dans le corps de la requête."`.
 
 ///
 
-**FastAPI** effectuera la conversion automatique depuis la requête, de sorte que le paramètre `item` reçoive son contenu spécifique, et de même pour `user`.
+**FastAPI** effectue la conversion de la requête de façon transparente, de sorte que les objets `item` et `user` se trouvent correctement définis.
 
-Il effectuera la validation des données composées, et les documentera ainsi pour le schéma OpenAPI et la documentation automatique.
+Il effectue également la validation des données (même imbriquées les unes dans les autres), et permet de les documenter correctement (schéma OpenAPI et documentation auto-générée).
 
-## Valeurs singulières dans le body { #singular-values-in-body }
+## Valeurs scalaires dans le body
 
-De la même façon qu'il existe `Query` et `Path` pour définir des données supplémentaires pour les paramètres de requête et de chemin, **FastAPI** fournit un équivalent `Body`.
+De la même façon qu'il existe `Query` et `Path` pour définir des données supplémentaires pour les paramètres query et path, **FastAPI** fournit un équivalent `Body`.
 
-Par exemple, en étendant le modèle précédent, vous pourriez décider d'avoir une autre clé `importance` dans le même body, en plus de `item` et `user`.
+Par exemple, en étendant le modèle précédent, vous pouvez vouloir ajouter un paramètre `importance` dans le même body, en plus des paramètres `item` et `user`.
 
-Si vous le déclarez tel quel, comme c'est une valeur singulière, **FastAPI** supposera qu'il s'agit d'un paramètre de requête.
+Si vous le déclarez tel quel, comme c'est une valeur [scalaire](https://docs.github.com/fr/graphql/reference/scalars), **FastAPI** supposera qu'il s'agit d'un paramètre de requête (`Query`).
 
-Mais vous pouvez indiquer à **FastAPI** de la traiter comme une autre clé du body en utilisant `Body` :
+Mais vous pouvez indiquer à **FastAPI** de la traiter comme une variable de body en utilisant `Body` :
 
 {* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}
 
@@ -92,51 +92,51 @@ Dans ce cas, **FastAPI** s'attendra à un body semblable à :
 }
 ```
 
-Encore une fois, il convertira les types de données, validera, documentera, etc.
+Encore une fois, cela convertira les types de données, les validera, permettra de générer la documentation, etc...
 
-## Paramètres multiples du body et paramètres de requête { #multiple-body-params-and-query }
+## Paramètres multiples body et query
 
-Bien entendu, vous pouvez également déclarer des paramètres de requête supplémentaires quand vous en avez besoin, en plus de tout paramètre du body.
+Bien entendu, vous pouvez déclarer autant de paramètres que vous le souhaitez, en plus des paramètres body déjà déclarés.
 
-Comme, par défaut, les valeurs singulières sont interprétées comme des paramètres de requête, vous n'avez pas besoin d'ajouter explicitement `Query`, vous pouvez simplement écrire :
-
-```Python
-q: str | None = None
-```
-
-Ou en Python 3.9 :
+Par défaut, les valeurs [scalaires](https://docs.github.com/fr/graphql/reference/scalars) sont interprétées comme des paramètres query, donc inutile d'ajouter explicitement `Query`. Vous pouvez juste écrire :
 
 ```Python
 q: Union[str, None] = None
 ```
 
+Ou bien, en Python 3.10 et supérieur :
+
+```Python
+q: str | None = None
+```
+
 Par exemple :
 
-{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
+{* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[27] *}
 
 /// info
 
-`Body` possède également les mêmes paramètres supplémentaires de validation et de métadonnées que `Query`, `Path` et d'autres que vous verrez plus tard.
+`Body` possède les mêmes paramètres de validation additionnels et de gestion des métadonnées que `Query` et `Path`, ainsi que d'autres que nous verrons plus tard.
 
 ///
 
-## Intégrer un seul paramètre du body { #embed-a-single-body-parameter }
+## Inclure un paramètre imbriqué dans le body
 
-Supposons que vous n'ayez qu'un seul paramètre `item` dans le body, provenant d'un modèle Pydantic `Item`.
+Disons que vous avez seulement un paramètre `item` dans le body, correspondant à un modèle Pydantic `Item`.
 
-Par défaut, **FastAPI** attendra alors son contenu directement.
+Par défaut, **FastAPI** attendra sa déclaration directement dans le body.
 
-Mais si vous voulez qu'il attende un JSON avec une clé `item` contenant le contenu du modèle, comme lorsqu'on déclare des paramètres supplémentaires du body, vous pouvez utiliser le paramètre spécial `embed` de `Body` :
+Cependant, si vous souhaitez qu'il interprête correctement un JSON avec une clé `item` associée au contenu du modèle, comme cela serait le cas si vous déclariez des paramètres body additionnels, vous pouvez utiliser le paramètre spécial `embed` de `Body` :
 
 ```Python
 item: Item = Body(embed=True)
 ```
 
-comme dans :
+Voici un exemple complet :
 
 {* ../../docs_src/body_multiple_params/tutorial005_an_py310.py hl[17] *}
 
-Dans ce cas **FastAPI** s'attendra à un body semblable à :
+Dans ce cas **FastAPI** attendra un body semblable à :
 
 ```JSON hl_lines="2"
 {
@@ -160,12 +160,12 @@ au lieu de :
 }
 ```
 
-## Récapitulatif { #recap }
+## Pour résumer
 
-Vous pouvez ajouter plusieurs paramètres du body à votre fonction de chemin d'accès, même si une requête ne peut avoir qu'un seul body.
+Vous pouvez ajouter plusieurs paramètres body dans votre fonction de routage, même si une requête ne peut avoir qu'un seul body.
 
-Mais **FastAPI** s'en chargera, vous fournira les bonnes données dans votre fonction, et validera et documentera le schéma correct dans le chemin d'accès.
+Cependant, **FastAPI** se chargera de faire opérer sa magie, afin de toujours fournir à votre fonction des données correctes, les validera et documentera le schéma associé.
 
-Vous pouvez également déclarer des valeurs singulières à recevoir dans le body.
+Vous pouvez également déclarer des valeurs [scalaires](https://docs.github.com/fr/graphql/reference/scalars) à recevoir dans le body.
 
-Et vous pouvez indiquer à **FastAPI** d'intégrer le body sous une clé même lorsqu'un seul paramètre est déclaré.
+Et vous pouvez indiquer à **FastAPI** d'inclure le body dans une autre variable, même lorsqu'un seul paramètre est déclaré.

docs/fr/docs/tutorial/body.md

@@ -1,10 +1,10 @@
-# Corps de la requête { #request-body }
+# Corps de la requête
 
 Quand vous avez besoin d'envoyer de la donnée depuis un client (comme un navigateur) vers votre API, vous l'envoyez en tant que **corps de requête**.
 
 Le corps d'une **requête** est de la donnée envoyée par le client à votre API. Le corps d'une **réponse** est la donnée envoyée par votre API au client.
 
-Votre API aura presque toujours à envoyer un corps de **réponse**. Mais un client n'a pas toujours à envoyer un **corps de requête** : parfois il demande seulement un chemin, peut-être avec quelques paramètres de requête, mais n'envoie pas de corps.
+Votre API aura presque toujours à envoyer un corps de **réponse**. Mais un client n'a pas toujours à envoyer un corps de **requête**.
 
 Pour déclarer un corps de **requête**, on utilise les modèles de <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> en profitant de tous leurs avantages et fonctionnalités.
 
@@ -18,23 +18,23 @@ Ceci étant découragé, la documentation interactive générée par Swagger UI
 
 ///
 
-## Importer le `BaseModel` de Pydantic { #import-pydantics-basemodel }
+## Importez le `BaseModel` de Pydantic
 
 Commencez par importer la classe `BaseModel` du module `pydantic` :
 
-{* ../../docs_src/body/tutorial001_py310.py hl[2] *}
+{* ../../docs_src/body/tutorial001.py hl[4] *}
 
-## Créer votre modèle de données { #create-your-data-model }
+## Créez votre modèle de données
 
 Déclarez ensuite votre modèle de données en tant que classe qui hérite de `BaseModel`.
 
 Utilisez les types Python standard pour tous les attributs :
 
-{* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
+{* ../../docs_src/body/tutorial001.py hl[7:11] *}
 
-Tout comme pour la déclaration de paramètres de requête, quand un attribut de modèle a une valeur par défaut, il n'est pas nécessaire. Sinon, cet attribut doit être renseigné dans le corps de la requête. Utilisez `None` pour le rendre simplement optionnel.
+Tout comme pour la déclaration de paramètres de requête, quand un attribut de modèle a une valeur par défaut, il n'est pas nécessaire. Sinon, cet attribut doit être renseigné dans le corps de la requête. Pour rendre ce champ optionnel simplement, utilisez `None` comme valeur par défaut.
 
-Par exemple, le modèle ci-dessus déclare un JSON « `object` » (ou `dict` Python) tel que :
+Par exemple, le modèle ci-dessus déclare un "objet" JSON (ou `dict` Python) tel que :
 
 ```JSON
 {
@@ -45,7 +45,7 @@ Par exemple, le modèle ci-dessus déclare un JSON « `object` » (ou `dict` P
 }
 ```
 
-... `description` et `tax` étant des attributs optionnels (avec `None` comme valeur par défaut), ce JSON « `object` » serait aussi valide :
+...`description` et `tax` étant des attributs optionnels (avec `None` comme valeur par défaut), cet "objet" JSON serait aussi valide :
 
 ```JSON
 {
@@ -54,28 +54,28 @@ Par exemple, le modèle ci-dessus déclare un JSON « `object` » (ou `dict` P
 }
 ```
 
-## Le déclarer comme paramètre { #declare-it-as-a-parameter }
+## Déclarez-le comme paramètre
 
 Pour l'ajouter à votre *opération de chemin*, déclarez-le comme vous déclareriez des paramètres de chemin ou de requête :
 
-{* ../../docs_src/body/tutorial001_py310.py hl[16] *}
+{* ../../docs_src/body/tutorial001.py hl[18] *}
 
-... et déclarez que son type est le modèle que vous avez créé : `Item`.
+...et déclarez que son type est le modèle que vous avez créé : `Item`.
 
-## Résultats { #results }
+## Résultats
 
 En utilisant uniquement les déclarations de type Python, **FastAPI** réussit à :
 
 * Lire le contenu de la requête en tant que JSON.
 * Convertir les types correspondants (si nécessaire).
 * Valider la donnée.
-    * Si la donnée est invalide, une erreur propre et claire sera renvoyée, indiquant exactement où et quelle était la donnée incorrecte.
+    * Si la donnée est invalide, une erreur propre et claire sera renvoyée, indiquant exactement où était la donnée incorrecte.
 * Passer la donnée reçue dans le paramètre `item`.
-    * Ce paramètre ayant été déclaré dans la fonction comme étant de type `Item`, vous aurez aussi tout le support offert par l'éditeur (autocomplétion, etc.) pour tous les attributs de ce paramètre et les types de ces attributs.
-* Générer des définitions <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> pour votre modèle ; vous pouvez également les utiliser partout ailleurs si cela a du sens pour votre projet.
-* Ces schémas participeront à la constitution du schéma généré OpenAPI, et seront utilisés par les documentations automatiques <abbr title="User Interfaces - Interfaces utilisateur">UIs</abbr>.
+    * Ce paramètre ayant été déclaré dans la fonction comme étant de type `Item`, vous aurez aussi tout le support offert par l'éditeur (auto-complétion, etc.) pour tous les attributs de ce paramètre et les types de ces attributs.
+* Générer des définitions <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> pour votre modèle, qui peuvent être utilisées où vous en avez besoin dans votre projet ensuite.
+* Ces schémas participeront à la constitution du schéma généré OpenAPI, et seront donc utilisés par les documentations automatiquement générées.
 
-## Documentation automatique { #automatic-docs }
+## Documentation automatique
 
 Les schémas JSON de vos modèles seront intégrés au schéma OpenAPI global de votre application, et seront donc affichés dans la documentation interactive de l'API :
 
@@ -85,63 +85,63 @@ Et seront aussi utilisés dans chaque *opération de chemin* de la documentation
 
 <img src="/img/tutorial/body/image02.png">
 
-## Support de l'éditeur { #editor-support }
+## Support de l'éditeur
 
-Dans votre éditeur, vous aurez des annotations de type et de l'autocomplétion partout dans votre fonction (ce qui n'aurait pas été le cas si vous aviez reçu un `dict` plutôt qu'un modèle Pydantic) :
+Dans votre éditeur, vous aurez des annotations de types et de l'auto-complétion partout dans votre fonction (ce qui n'aurait pas été le cas si vous aviez utilisé un classique `dict` plutôt qu'un modèle Pydantic) :
 
 <img src="/img/tutorial/body/image03.png">
 
-Et vous obtenez aussi des vérifications d'erreurs pour les opérations de types incorrectes :
+Et vous obtenez aussi de la vérification d'erreur pour les opérations incorrectes de types :
 
 <img src="/img/tutorial/body/image04.png">
 
 Ce n'est pas un hasard, ce framework entier a été bâti avec ce design comme objectif.
 
-Et cela a été rigoureusement testé durant la phase de design, avant toute implémentation, pour vous assurer que cela fonctionnerait avec tous les éditeurs.
+Et cela a été rigoureusement testé durant la phase de design, avant toute implémentation, pour s'assurer que cela fonctionnerait avec tous les éditeurs.
 
 Des changements sur Pydantic ont même été faits pour supporter cela.
 
-Les captures d'écran précédentes ont été prises sur <a href="https://code.visualstudio.com" class="external-link" target="_blank">Visual Studio Code</a>.
+Les captures d'écrans précédentes ont été prises sur <a href="https://code.visualstudio.com" class="external-link" target="_blank">Visual Studio Code</a>.
 
-Mais vous auriez le même support de l'éditeur avec <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> et la majorité des autres éditeurs de code Python :
+Mais vous auriez le même support de l'éditeur avec <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> et la majorité des autres éditeurs de code Python.
 
 <img src="/img/tutorial/body/image05.png">
 
 /// tip | Astuce
 
-Si vous utilisez <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> comme éditeur, vous pouvez utiliser le plug-in <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a>.
+Si vous utilisez <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> comme éditeur, vous pouvez utiliser le Plugin <a href="https://github.com/koxudaxi/pydantic-pycharm-plugin/" class="external-link" target="_blank">Pydantic PyCharm Plugin</a>.
 
 Ce qui améliore le support pour les modèles Pydantic avec :
 
-* de l'autocomplétion
+* de l'auto-complétion
 * des vérifications de type
-* du « refactoring » (ou remaniement de code)
+* du "refactoring" (ou remaniement de code)
 * de la recherche
-* des inspections
+* de l'inspection
 
 ///
 
-## Utiliser le modèle { #use-the-model }
+## Utilisez le modèle
 
 Dans la fonction, vous pouvez accéder à tous les attributs de l'objet du modèle directement :
 
-{* ../../docs_src/body/tutorial002_py310.py *}
+{* ../../docs_src/body/tutorial002.py hl[21] *}
 
-## Corps de la requête + paramètres de chemin { #request-body-path-parameters }
+## Corps de la requête + paramètres de chemin
 
 Vous pouvez déclarer des paramètres de chemin et un corps de requête pour la même *opération de chemin*.
 
 **FastAPI** est capable de reconnaître que les paramètres de la fonction qui correspondent aux paramètres de chemin doivent être **récupérés depuis le chemin**, et que les paramètres de fonctions déclarés comme modèles Pydantic devraient être **récupérés depuis le corps de la requête**.
 
-{* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
+{* ../../docs_src/body/tutorial003.py hl[17:18] *}
 
-## Corps de la requête + paramètres de chemin et de requête { #request-body-path-query-parameters }
+## Corps de la requête + paramètres de chemin et de requête
 
 Vous pouvez aussi déclarer un **corps**, et des paramètres de **chemin** et de **requête** dans la même *opération de chemin*.
 
 **FastAPI** saura reconnaître chacun d'entre eux et récupérer la bonne donnée au bon endroit.
 
-{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
+{* ../../docs_src/body/tutorial004.py hl[18] *}
 
 Les paramètres de la fonction seront reconnus comme tel :
 
@@ -149,16 +149,14 @@ Les paramètres de la fonction seront reconnus comme tel :
 * Si le paramètre est d'un **type singulier** (comme `int`, `float`, `str`, `bool`, etc.), il sera interprété comme un paramètre de **requête**.
 * Si le paramètre est déclaré comme ayant pour type un **modèle Pydantic**, il sera interprété comme faisant partie du **corps** de la requête.
 
-/// note | Remarque
+/// note
 
-**FastAPI** saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `= None`.
+**FastAPI** saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `=None`.
 
-L'annotation de type `str | None` (Python 3.10+) ou `Union` dans `Union[str, None]` (Python 3.9+) n'est pas utilisée par **FastAPI** pour déterminer que la valeur n'est pas requise, il le saura parce qu'elle a une valeur par défaut `= None`.
-
-Mais ajouter ces annotations de type permettra à votre éditeur de vous offrir un meilleur support et de détecter des erreurs.
+Le type `Optional` dans `Optional[str]` n'est pas utilisé par **FastAPI**, mais sera utile à votre éditeur pour améliorer le support offert par ce dernier et détecter plus facilement des erreurs de type.
 
 ///
 
-## Sans Pydantic { #without-pydantic }
+## Sans Pydantic
 
-Si vous ne voulez pas utiliser des modèles Pydantic, vous pouvez aussi utiliser des paramètres de **Body**. Pour cela, allez voir la documentation sur [Corps de la requête - Paramètres multiples : Valeurs singulières dans le corps](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Si vous ne voulez pas utiliser des modèles Pydantic, vous pouvez aussi utiliser des paramètres de **Corps**. Pour cela, allez voir la partie de la documentation sur  [Corps de la requête - Paramètres multiples](body-multiple-params.md){.internal-link target=_blank}.

docs/fr/docs/tutorial/debugging.md

@@ -1,14 +1,14 @@
-# <abbr title="En anglais: Debugging">Débogage</abbr> { #debugging }
+# <abbr title="En anglais: Debugging">Débogage</abbr>
 
 Vous pouvez connecter le <abbr title="En anglais: debugger">débogueur</abbr> dans votre éditeur, par exemple avec Visual Studio Code ou PyCharm.
 
-## Appeler `uvicorn` { #call-uvicorn }
+## Faites appel à `uvicorn`
 
 Dans votre application FastAPI, importez et exécutez directement `uvicorn` :
 
-{* ../../docs_src/debugging/tutorial001_py39.py hl[1,15] *}
+{* ../../docs_src/debugging/tutorial001.py hl[1,15] *}
 
-### À propos de `__name__ == "__main__"` { #about-name-main }
+### À propos de `__name__ == "__main__"`
 
 Le but principal de `__name__ == "__main__"` est d'avoir du code qui est exécuté lorsque votre fichier est appelé avec :
 
@@ -26,7 +26,7 @@ mais qui n'est pas appelé lorsqu'un autre fichier l'importe, comme dans :
 from myapp import app
 ```
 
-#### Pour davantage de détails { #more-details }
+#### Pour davantage de détails
 
 Imaginons que votre fichier s'appelle `myapp.py`.
 
@@ -78,7 +78,7 @@ Pour plus d'informations, consultez <a href="https://docs.python.org/3/library/_
 
 ///
 
-## Exécuter votre code avec votre <abbr title="En anglais: debugger">débogueur</abbr> { #run-your-code-with-your-debugger }
+## Exécutez votre code avec votre <abbr title="En anglais: debugger">débogueur</abbr>
 
 Parce que vous exécutez le serveur Uvicorn directement depuis votre code, vous pouvez appeler votre programme Python (votre application FastAPI) directement depuis le <abbr title="En anglais: debugger">débogueur</abbr>.
 
@@ -86,10 +86,10 @@ Parce que vous exécutez le serveur Uvicorn directement depuis votre code, vous
 
 Par exemple, dans Visual Studio Code, vous pouvez :
 
-- Allez dans le panneau « Debug ».
-- « Add configuration... ».
-- Sélectionnez « Python ».
-- Lancez le <abbr title="En anglais: debugger">débogueur</abbr> avec l'option « Python: Current File (Integrated Terminal) ».
+- Cliquer sur l'onglet "Debug" de la barre d'activités de Visual Studio Code.
+- "Add configuration...".
+- Sélectionnez "Python".
+- Lancez le <abbr title="En anglais: debugger">débogueur</abbr> avec l'option "`Python: Current File (Integrated Terminal)`".
 
 Il démarrera alors le serveur avec votre code **FastAPI**, s'arrêtera à vos points d'arrêt, etc.
 
@@ -101,8 +101,8 @@ Voici à quoi cela pourrait ressembler :
 
 Si vous utilisez Pycharm, vous pouvez :
 
-- Ouvrez le menu « Run ».
-- Sélectionnez l'option « Debug... ».
+- Ouvrir le menu "Run".
+- Sélectionnez l'option "Debug...".
 - Un menu contextuel s'affiche alors.
 - Sélectionnez le fichier à déboguer (dans ce cas, `main.py`).
 

docs/fr/docs/tutorial/first-steps.md

@@ -1,122 +1,107 @@
-# Démarrage { #first-steps }
+# Démarrage
 
-Le fichier **FastAPI** le plus simple possible pourrait ressembler à ceci :
+Le fichier **FastAPI** le plus simple possible pourrait ressembler à cela  :
 
-{* ../../docs_src/first_steps/tutorial001_py39.py *}
+{* ../../docs_src/first_steps/tutorial001.py *}
 
-Copiez cela dans un fichier `main.py`.
+Copiez ce code dans un fichier nommé `main.py`.
 
-Démarrez le serveur en direct :
+Démarrez le serveur :
 
 <div class="termy">
 
 ```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+$ uvicorn main:app --reload
 
-  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
-
-             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>
-
-   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
-             the following code:
-
-             <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>
-
-      <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://127.0.0.1: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://127.0.0.1:8000/docs</u></font>
-
-      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
-             <b>fastapi run</b>
-
-             Logs:
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
-             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
-             to quit<b>)</b>
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</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>  Application startup complete.
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+<span style="color: green;">INFO</span>:     Started reloader process [28720]
+<span style="color: green;">INFO</span>:     Started server process [28722]
+<span style="color: green;">INFO</span>:     Waiting for application startup.
+<span style="color: green;">INFO</span>:     Application startup complete.
 ```
 
 </div>
 
-Dans la sortie, il y a une ligne semblable à :
+/// note
+
+La commande `uvicorn main:app` fait référence à :
+
+* `main` : le fichier `main.py` (le module Python).
+* `app` : l'objet créé dans `main.py` via la ligne `app = FastAPI()`.
+* `--reload` : l'option disant à uvicorn de redémarrer le serveur à chaque changement du code. À ne pas utiliser en production !
+
+///
+
+Vous devriez voir dans la console, une ligne semblable à la suivante :
 
 ```hl_lines="4"
 INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
-Cette ligne montre l’URL où votre application est servie, sur votre machine locale.
+Cette ligne montre l'URL par laquelle l'app est actuellement accessible, sur votre machine locale.
 
-### Vérifiez { #check-it }
+### Allez voir le résultat
 
-Ouvrez votre navigateur à l’adresse <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
+Ouvrez votre navigateur à l'adresse <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a>.
 
-Vous verrez la réponse JSON suivante :
+Vous obtiendrez cette réponse JSON :
 
 ```JSON
 {"message": "Hello World"}
 ```
 
-### Documentation interactive de l’API { #interactive-api-docs }
+### Documentation interactive de l'API
 
-Allez maintenant sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Rendez-vous sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
-Vous verrez la documentation interactive de l’API générée automatiquement (fournie par <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
+Vous verrez la documentation interactive de l'API générée automatiquement (via <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a>) :
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Documentation alternative de l’API { #alternative-api-docs }
+### Documentation alternative
 
-Et maintenant, allez sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
+Ensuite, rendez-vous sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-Vous verrez la documentation automatique alternative (fournie par <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
+Vous y verrez la documentation alternative (via <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>) :
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-### OpenAPI { #openapi }
+### OpenAPI
 
-**FastAPI** génère un « schéma » contenant toute votre API en utilisant le standard **OpenAPI** pour définir des API.
+**FastAPI** génère un "schéma" contenant toute votre API dans le standard de définition d'API **OpenAPI**.
 
-#### « Schéma » { #schema }
+#### "Schéma"
 
-Un « schéma » est une définition ou une description de quelque chose. Pas le code qui l’implémente, mais uniquement une description abstraite.
+Un "schéma" est une définition ou une description de quelque chose. Pas le code qui l'implémente, uniquement une description abstraite.
 
-#### « Schéma » d’API { #api-schema }
+#### "Schéma" d'API
 
 Ici, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> est une spécification qui dicte comment définir le schéma de votre API.
 
-Cette définition de schéma inclut les chemins de votre API, les paramètres possibles qu’ils prennent, etc.
+Le schéma inclut les chemins de votre API, les paramètres potentiels de chaque chemin, etc.
 
-#### « Schéma » de données { #data-schema }
+#### "Schéma" de données
 
-Le terme « schéma » peut également faire référence à la forme d’une donnée, comme un contenu JSON.
+Le terme "schéma" peut aussi faire référence à la forme de la donnée, comme un contenu JSON.
 
-Dans ce cas, cela désignerait les attributs JSON, ainsi que leurs types, etc.
+Dans ce cas, cela signifierait les attributs JSON, ainsi que les types de ces attributs, etc.
 
-#### OpenAPI et JSON Schema { #openapi-and-json-schema }
+#### OpenAPI et JSON Schema
 
-OpenAPI définit un schéma d’API pour votre API. Et ce schéma inclut des définitions (ou « schémas ») des données envoyées et reçues par votre API en utilisant **JSON Schema**, le standard pour les schémas de données JSON.
+**OpenAPI** définit un schéma d'API pour votre API. Il inclut des définitions (ou "schémas") de la donnée envoyée et reçue par votre API en utilisant **JSON Schema**, le standard des schémas de données JSON.
 
-#### Voir le `openapi.json` { #check-the-openapi-json }
+#### Allez voir `openapi.json`
 
-Si vous êtes curieux de voir à quoi ressemble le schéma OpenAPI brut, FastAPI génère automatiquement un JSON (schéma) avec les descriptions de toute votre API.
+Si vous êtes curieux d'à quoi ressemble le schéma brut **OpenAPI**, **FastAPI** génère automatiquement un (schéma) JSON avec les descriptions de toute votre API.
 
-Vous pouvez le voir directement à l’adresse : <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
+Vous pouvez le voir directement à cette adresse : <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
+
+Le schéma devrait ressembler à ceci :
 
-Il affichera un JSON commençant par quelque chose comme :
 
 ```JSON
 {
-    "openapi": "3.1.0",
+    "openapi": "3.0.2",
     "info": {
         "title": "FastAPI",
         "version": "0.1.0"
@@ -135,87 +120,79 @@ Il affichera un JSON commençant par quelque chose comme :
 ...
 ```
 
-#### À quoi sert OpenAPI { #what-is-openapi-for }
+#### À quoi sert OpenAPI
 
-Le schéma OpenAPI est ce qui alimente les deux systèmes de documentation interactive inclus.
+Le schéma **OpenAPI** est ce qui alimente les deux systèmes de documentation interactive.
 
-Et il existe des dizaines d’alternatives, toutes basées sur OpenAPI. Vous pourriez facilement ajouter n’importe laquelle de ces alternatives à votre application construite avec **FastAPI**.
+Et il existe des dizaines d'alternatives, toutes basées sur **OpenAPI**. Vous pourriez facilement ajouter n'importe laquelle de ces alternatives à votre application **FastAPI**.
 
-Vous pourriez également l’utiliser pour générer du code automatiquement, pour les clients qui communiquent avec votre API. Par exemple, des applications frontend, mobiles ou IoT.
+Vous pourriez aussi l'utiliser pour générer du code automatiquement, pour les clients qui communiquent avec votre API. Comme par exemple, des applications frontend, mobiles ou IOT.
 
-### Déployer votre application (optionnel) { #deploy-your-app-optional }
+## Récapitulatif, étape par étape
 
-Vous pouvez, si vous le souhaitez, déployer votre application FastAPI sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, allez rejoindre la liste d’attente si ce n’est pas déjà fait. 🚀
+### Étape 1 : import `FastAPI`
 
-Si vous avez déjà un compte **FastAPI Cloud** (nous vous avons invité depuis la liste d’attente 😉), vous pouvez déployer votre application avec une seule commande.
+{* ../../docs_src/first_steps/tutorial001.py hl[1] *}
 
-Avant de déployer, vous devez vous assurer que vous êtes connecté :
-
-<div class="termy">
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-</div>
-
-Puis déployez votre application :
-
-<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>
-
-C’est tout ! Vous pouvez maintenant accéder à votre application à cette URL. ✨
-
-## Récapitulatif, étape par étape { #recap-step-by-step }
-
-### Étape 1 : importer `FastAPI` { #step-1-import-fastapi }
-
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[1] *}
-
-`FastAPI` est une classe Python qui fournit toutes les fonctionnalités nécessaires à votre API.
+`FastAPI` est une classe Python qui fournit toutes les fonctionnalités nécessaires au lancement de votre API.
 
 /// note | Détails techniques
 
-`FastAPI` est une classe qui hérite directement de `Starlette`.
+`FastAPI` est une classe héritant directement de `Starlette`.
 
-Vous pouvez donc aussi utiliser toutes les fonctionnalités de <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> avec `FastAPI`.
+Vous pouvez donc aussi utiliser toutes les fonctionnalités de <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> depuis `FastAPI`.
 
 ///
 
-### Étape 2 : créer une « instance » `FastAPI` { #step-2-create-a-fastapi-instance }
+### Étape 2 : créer une "instance" `FastAPI`
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[3] *}
+{* ../../docs_src/first_steps/tutorial001.py hl[3] *}
 
-Ici, la variable `app` sera une « instance » de la classe `FastAPI`.
+Ici la variable `app` sera une "instance" de la classe `FastAPI`.
 
-Ce sera le point principal d’interaction pour créer toute votre API.
+Ce sera le point principal d'interaction pour créer toute votre API.
 
-### Étape 3 : créer un « chemin d’accès » { #step-3-create-a-path-operation }
+Cette `app` est la même que celle à laquelle fait référence `uvicorn` dans la commande :
 
-#### Chemin { #path }
+<div class="termy">
 
-« Chemin » fait ici référence à la dernière partie de l’URL à partir du premier `/`.
+```console
+$ uvicorn main:app --reload
 
-Donc, dans une URL telle que :
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+Si vous créez votre app avec :
+
+{* ../../docs_src/first_steps/tutorial002.py hl[3] *}
+
+Et la mettez dans un fichier `main.py`, alors vous appelleriez `uvicorn` avec :
+
+<div class="termy">
+
+```console
+$ uvicorn main:my_awesome_api --reload
+
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+</div>
+
+### Étape 3: créer une *opération de chemin*
+
+#### Chemin
+
+Chemin, ou "path" fait référence ici à la dernière partie de l'URL démarrant au premier `/`.
+
+Donc, dans un URL tel que :
 
 ```
 https://example.com/items/foo
 ```
 
-... le chemin serait :
+...le "path" serait :
 
 ```
 /items/foo
@@ -223,67 +200,66 @@ https://example.com/items/foo
 
 /// info
 
-Un « chemin » est aussi couramment appelé « endpoint » ou « route ».
+Un chemin, ou "path" est aussi souvent appelé route ou "endpoint".
 
 ///
 
-Lors de la création d’une API, le « chemin » est la manière principale de séparer les « préoccupations » et les « ressources ».
+#### Opération
 
-#### Opération { #operation }
+"Opération" fait référence à une des "méthodes" HTTP.
 
-« Opération » fait ici référence à l’une des « méthodes » HTTP.
-
-L’une de :
+Une de :
 
 * `POST`
 * `GET`
 * `PUT`
 * `DELETE`
 
-... et les plus exotiques :
+...ou une des plus exotiques :
 
 * `OPTIONS`
 * `HEAD`
 * `PATCH`
 * `TRACE`
 
-Dans le protocole HTTP, vous pouvez communiquer avec chaque chemin en utilisant une (ou plusieurs) de ces « méthodes ».
+Dans le protocol HTTP, vous pouvez communiquer avec chaque chemin en utilisant une (ou plus) de ces "méthodes".
 
 ---
 
-En construisant des APIs, vous utilisez normalement ces méthodes HTTP spécifiques pour effectuer une action précise.
+En construisant des APIs, vous utilisez généralement ces méthodes HTTP spécifiques pour effectuer une action précise.
 
-En général, vous utilisez :
+Généralement vous utilisez :
 
-* `POST` : pour créer des données.
-* `GET` : pour lire des données.
-* `PUT` : pour mettre à jour des données.
-* `DELETE` : pour supprimer des données.
+* `POST` : pour créer de la donnée.
+* `GET` : pour lire de la donnée.
+* `PUT` : pour mettre à jour de la donnée.
+* `DELETE` : pour supprimer de la donnée.
 
-Donc, dans OpenAPI, chacune des méthodes HTTP est appelée une « opération ».
+Donc, dans **OpenAPI**, chaque méthode HTTP est appelée une "opération".
 
-Nous allons donc aussi les appeler « opérations ».
+Nous allons donc aussi appeler ces dernières des "**opérations**".
 
-#### Définir un « décorateur de chemin d’accès » { #define-a-path-operation-decorator }
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[6] *}
+#### Définir un *décorateur d'opération de chemin*
 
-Le `@app.get("/")` indique à **FastAPI** que la fonction juste en dessous est chargée de gérer les requêtes qui vont vers :
+{* ../../docs_src/first_steps/tutorial001.py hl[6] *}
+
+Le `@app.get("/")` dit à **FastAPI** que la fonction en dessous est chargée de gérer les requêtes qui vont sur :
 
 * le chemin `/`
-* en utilisant une <abbr title="une méthode HTTP GET"><code>get</code> opération</abbr>
+* en utilisant une <abbr title="une méthode GET HTTP">opération <code>get</code></abbr>
 
 /// info | `@décorateur` Info
 
-Cette syntaxe `@something` en Python est appelée un « décorateur ».
+Cette syntaxe `@something` en Python est appelée un "décorateur".
 
-Vous la mettez au-dessus d’une fonction. Comme un joli chapeau décoratif (j’imagine que c’est de là que vient le terme 🤷🏻‍♂).
+Vous la mettez au dessus d'une fonction. Comme un joli chapeau décoratif (j'imagine que ce terme vient de là 🤷🏻‍♂).
 
-Un « décorateur » prend la fonction en dessous et fait quelque chose avec.
+Un "décorateur" prend la fonction en dessous et en fait quelque chose.
 
-Dans notre cas, ce décorateur indique à **FastAPI** que la fonction en dessous correspond au **chemin** `/` avec une **opération** `get`.
+Dans notre cas, ce décorateur dit à **FastAPI** que la fonction en dessous correspond au **chemin** `/` avec l'**opération** `get`.
 
-C’est le « décorateur de chemin d’accès ».
+C'est le "**décorateur d'opération de chemin**".
 
 ///
 
@@ -293,7 +269,7 @@ Vous pouvez aussi utiliser les autres opérations :
 * `@app.put()`
 * `@app.delete()`
 
-Ainsi que les plus exotiques :
+Tout comme celles les plus exotiques :
 
 * `@app.options()`
 * `@app.head()`
@@ -302,79 +278,58 @@ Ainsi que les plus exotiques :
 
 /// tip | Astuce
 
-Vous êtes libre d’utiliser chaque opération (méthode HTTP) comme vous le souhaitez.
+Vous êtes libres d'utiliser chaque opération (méthode HTTP) comme vous le désirez.
 
-**FastAPI** n’impose aucune signification spécifique.
+**FastAPI** n'impose pas de sens spécifique à chacune d'elle.
 
-Les informations ici sont présentées comme des lignes directrices, pas comme une obligation.
+Les informations qui sont présentées ici forment une directive générale, pas des obligations.
 
-Par exemple, lorsque vous utilisez GraphQL, vous effectuez normalement toutes les actions en utilisant uniquement des opérations `POST`.
+Par exemple, quand l'on utilise **GraphQL**, toutes les actions sont effectuées en utilisant uniquement des opérations `POST`.
 
 ///
 
-### Étape 4 : définir la **fonction de chemin d’accès** { #step-4-define-the-path-operation-function }
+### Étape 4 : définir la **fonction de chemin**.
 
-Voici notre « fonction de chemin d’accès » :
+Voici notre "**fonction de chemin**" (ou fonction d'opération de chemin) :
 
 * **chemin** : `/`.
 * **opération** : `get`.
-* **fonction** : la fonction sous le « décorateur » (sous `@app.get("/")`).
+* **fonction** : la fonction sous le "décorateur" (sous `@app.get("/")`).
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial001.py hl[7] *}
 
-C’est une fonction Python.
+C'est une fonction Python.
 
-Elle sera appelée par **FastAPI** chaque fois qu’il recevra une requête vers l’URL « / » en utilisant une opération `GET`.
+Elle sera appelée par **FastAPI** quand une requête sur l'URL `/` sera reçue via une opération `GET`.
 
-Dans ce cas, c’est une fonction `async`.
+Ici, c'est une fonction asynchrone (définie avec `async def`).
 
 ---
 
-Vous pouvez aussi la définir comme une fonction normale au lieu de `async def` :
+Vous pourriez aussi la définir comme une fonction classique plutôt qu'avec `async def` :
 
-{* ../../docs_src/first_steps/tutorial003_py39.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial003.py hl[7] *}
 
 /// note
 
-Si vous ne connaissez pas la différence, consultez [Asynchrone : « Pressé ? »](../async.md#in-a-hurry){.internal-link target=_blank}.
+Si vous ne connaissez pas la différence, allez voir la section [Concurrence : *"Vous êtes pressés ?"*](../async.md#vous-etes-presses){.internal-link target=_blank}.
 
 ///
 
-### Étape 5 : retourner le contenu { #step-5-return-the-content }
+### Étape 5 : retourner le contenu
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[8] *}
+{* ../../docs_src/first_steps/tutorial001.py hl[8] *}
 
-Vous pouvez retourner un `dict`, une `list`, des valeurs uniques comme `str`, `int`, etc.
+Vous pouvez retourner un dictionnaire (`dict`), une liste (`list`), des valeurs seules comme des chaines de caractères (`str`) et des entiers (`int`), etc.
 
-Vous pouvez également retourner des modèles Pydantic (vous en verrez plus à ce sujet plus tard).
+Vous pouvez aussi retourner des models **Pydantic** (qui seront détaillés plus tard).
 
-Il existe de nombreux autres objets et modèles qui seront automatiquement convertis en JSON (y compris des ORM, etc.). Essayez d’utiliser vos favoris, il est fort probable qu’ils soient déjà pris en charge.
+Il y a de nombreux autres objets et modèles qui seront automatiquement convertis en JSON. Essayez d'utiliser vos favoris, il est fort probable qu'ils soient déjà supportés.
 
-### Étape 6 : le déployer { #step-6-deploy-it }
-
-Déployez votre application sur **<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** avec une seule commande : `fastapi deploy`. 🎉
-
-#### À propos de FastAPI Cloud { #about-fastapi-cloud }
-
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>** est construit par le même auteur et l’équipe derrière **FastAPI**.
-
-Il simplifie le processus de **construction**, de **déploiement** et d’**accès** à une API avec un minimum d’effort.
-
-Il apporte la même **expérience développeur** de création d’applications avec FastAPI au **déploiement** dans le cloud. 🎉
-
-FastAPI Cloud est le sponsor principal et le financeur des projets open source *FastAPI and friends*. ✨
-
-#### Déployer sur d’autres fournisseurs cloud { #deploy-to-other-cloud-providers }
-
-FastAPI est open source et basé sur des standards. Vous pouvez déployer des applications FastAPI chez n’importe quel fournisseur cloud de votre choix.
-
-Suivez les guides de votre fournisseur cloud pour y déployer des applications FastAPI. 🤓
-
-## Récapitulatif { #recap }
+## Récapitulatif
 
 * Importez `FastAPI`.
-* Créez une instance `app`.
-* Écrivez un **décorateur de chemin d’accès** avec des décorateurs comme `@app.get("/")`.
-* Définissez une **fonction de chemin d’accès** ; par exemple, `def root(): ...`.
-* Exécutez le serveur de développement avec la commande `fastapi dev`.
-* Déployez éventuellement votre application avec `fastapi deploy`.
+* Créez une instance d'`app`.
+* Ajoutez une **décorateur d'opération de chemin** (tel que `@app.get("/")`).
+* Ajoutez une **fonction de chemin** (telle que `def root(): ...` comme ci-dessus).
+* Lancez le serveur de développement (avec `uvicorn main:app --reload`).

docs/fr/docs/tutorial/index.md

@@ -1,53 +1,29 @@
-# Tutoriel - Guide utilisateur { #tutorial-user-guide }
+# Tutoriel - Guide utilisateur - Introduction
 
 Ce tutoriel vous montre comment utiliser **FastAPI** avec la plupart de ses fonctionnalités, étape par étape.
 
-Chaque section s'appuie progressivement sur les précédentes, mais elle est structurée de manière à séparer les sujets, afin que vous puissiez aller directement à l'un d'entre eux pour répondre à vos besoins spécifiques d'API.
+Chaque section s'appuie progressivement sur les précédentes, mais elle est structurée de manière à séparer les sujets, afin que vous puissiez aller directement à l'un d'entre eux pour résoudre vos besoins spécifiques en matière d'API.
 
-Il est également conçu pour servir de référence ultérieure, afin que vous puissiez revenir voir exactement ce dont vous avez besoin.
+Il est également conçu pour fonctionner comme une référence future.
 
-## Exécuter le code { #run-the-code }
+Vous pouvez donc revenir et voir exactement ce dont vous avez besoin.
+
+## Exécuter le code
 
 Tous les blocs de code peuvent être copiés et utilisés directement (il s'agit en fait de fichiers Python testés).
 
-Pour exécuter l'un de ces exemples, copiez le code dans un fichier `main.py`, et démarrez `fastapi dev` avec :
+Pour exécuter l'un de ces exemples, copiez le code dans un fichier `main.py`, et commencez `uvicorn` avec :
 
 <div class="termy">
 
 ```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+$ uvicorn main:app --reload
 
-  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
-
-             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>
-
-   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
-             the following code:
-
-             <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>
-
-      <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://127.0.0.1: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://127.0.0.1:8000/docs</u></font>
-
-      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
-             <b>fastapi run</b>
-
-             Logs:
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
-             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C
-             to quit<b>)</b>
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</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>  Application startup complete.
+<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+<span style="color: green;">INFO</span>:     Started reloader process [28720]
+<span style="color: green;">INFO</span>:     Started server process [28722]
+<span style="color: green;">INFO</span>:     Waiting for application startup.
+<span style="color: green;">INFO</span>:     Application startup complete.
 ```
 
 </div>
@@ -58,33 +34,45 @@ L'utiliser dans votre éditeur est ce qui vous montre vraiment les avantages de
 
 ---
 
-## Installer FastAPI { #install-fastapi }
+## Installer FastAPI
 
 La première étape consiste à installer FastAPI.
 
-Assurez-vous de créer un [environnement virtuel](../virtual-environments.md){.internal-link target=_blank}, de l'activer, puis **d'installer FastAPI** :
+Pour le tutoriel, vous voudrez peut-être l'installer avec toutes les dépendances et fonctionnalités optionnelles :
 
 <div class="termy">
 
 ```console
-$ pip install "fastapi[standard]"
+$ pip install fastapi[all]
 
 ---> 100%
 ```
 
 </div>
 
-/// note | Remarque
+... qui comprend également `uvicorn`, que vous pouvez utiliser comme serveur pour exécuter votre code.
 
-Lorsque vous installez avec `pip install "fastapi[standard]"` cela inclut des dépendances standard optionnelles par défaut, y compris `fastapi-cloud-cli`, qui vous permet de déployer sur <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
+/// note
 
-Si vous ne souhaitez pas avoir ces dépendances optionnelles, vous pouvez à la place installer `pip install fastapi`.
+Vous pouvez également l'installer pièce par pièce.
 
-Si vous souhaitez installer les dépendances standard mais sans `fastapi-cloud-cli`, vous pouvez installer avec `pip install "fastapi[standard-no-fastapi-cloud-cli]"`.
+C'est ce que vous feriez probablement une fois que vous voudrez déployer votre application en production :
+
+```
+pip install fastapi
+```
+
+Installez également `uvicorn` pour qu'il fonctionne comme serveur :
+
+```
+pip install uvicorn
+```
+
+Et la même chose pour chacune des dépendances facultatives que vous voulez utiliser.
 
 ///
 
-## Guide d'utilisation avancé { #advanced-user-guide }
+## Guide utilisateur avancé
 
 Il existe également un **Guide d'utilisation avancé** que vous pouvez lire plus tard après ce **Tutoriel - Guide d'utilisation**.
 

docs/fr/docs/tutorial/path-params-numeric-validations.md

@@ -1,8 +1,8 @@
-# Paramètres de chemin et validations numériques { #path-parameters-and-numeric-validations }
+# Paramètres de chemin et validations numériques
 
 De la même façon que vous pouvez déclarer plus de validations et de métadonnées pour les paramètres de requête avec `Query`, vous pouvez déclarer le même type de validations et de métadonnées pour les paramètres de chemin avec `Path`.
 
-## Importer `Path` { #import-path }
+## Importer Path
 
 Tout d'abord, importez `Path` de `fastapi`, et importez `Annotated` :
 
@@ -14,11 +14,11 @@ FastAPI a ajouté le support pour `Annotated` (et a commencé à le recommander)
 
 Si vous avez une version plus ancienne, vous obtiendrez des erreurs en essayant d'utiliser `Annotated`.
 
-Assurez-vous de [Mettre à niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} à la version 0.95.1 à minima avant d'utiliser `Annotated`.
+Assurez-vous de [Mettre à jour la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} à la version 0.95.1 à minima avant d'utiliser `Annotated`.
 
 ///
 
-## Déclarer des métadonnées { #declare-metadata }
+## Déclarer des métadonnées
 
 Vous pouvez déclarer les mêmes paramètres que pour `Query`.
 
@@ -26,15 +26,15 @@ Par exemple, pour déclarer une valeur de métadonnée `title` pour le paramètr
 
 {* ../../docs_src/path_params_numeric_validations/tutorial001_an_py310.py hl[10] *}
 
-/// note | Remarque
+/// note
 
 Un paramètre de chemin est toujours requis car il doit faire partie du chemin. Même si vous l'avez déclaré avec `None` ou défini une valeur par défaut, cela ne changerait rien, il serait toujours requis.
 
 ///
 
-## Ordonner les paramètres comme vous le souhaitez { #order-the-parameters-as-you-need }
+## Ordonnez les paramètres comme vous le souhaitez
 
-/// tip | Astuce
+/// tip
 
 Ce n'est probablement pas aussi important ou nécessaire si vous utilisez `Annotated`.
 
@@ -46,7 +46,7 @@ Et vous n'avez pas besoin de déclarer autre chose pour ce paramètre, donc vous
 
 Mais vous avez toujours besoin d'utiliser `Path` pour le paramètre de chemin `item_id`. Et vous ne voulez pas utiliser `Annotated` pour une raison quelconque.
 
-Python se plaindra si vous mettez une valeur avec une « valeur par défaut » avant une valeur qui n'a pas de « valeur par défaut ».
+Python se plaindra si vous mettez une valeur avec une "défaut" avant une valeur qui n'a pas de "défaut".
 
 Mais vous pouvez les réorganiser, et avoir la valeur sans défaut (le paramètre de requête `q`) en premier.
 
@@ -54,15 +54,15 @@ Cela n'a pas d'importance pour **FastAPI**. Il détectera les paramètres par le
 
 Ainsi, vous pouvez déclarer votre fonction comme suit :
 
-{* ../../docs_src/path_params_numeric_validations/tutorial002_py39.py hl[7] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial002.py hl[7] *}
 
 Mais gardez à l'esprit que si vous utilisez `Annotated`, vous n'aurez pas ce problème, cela n'aura pas d'importance car vous n'utilisez pas les valeurs par défaut des paramètres de fonction pour `Query()` ou `Path()`.
 
-{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py *}
+{* ../../docs_src/path_params_numeric_validations/tutorial002_an_py39.py hl[10] *}
 
-## Ordonner les paramètres comme vous le souhaitez, astuces { #order-the-parameters-as-you-need-tricks }
+## Ordonnez les paramètres comme vous le souhaitez (astuces)
 
-/// tip | Astuce
+/// tip
 
 Ce n'est probablement pas aussi important ou nécessaire si vous utilisez `Annotated`.
 
@@ -77,29 +77,38 @@ Si vous voulez :
 * les avoir dans un ordre différent
 * ne pas utiliser `Annotated`
 
-... Python a une petite syntaxe spéciale pour cela.
+...Python a une petite syntaxe spéciale pour cela.
 
 Passez `*`, comme premier paramètre de la fonction.
 
 Python ne fera rien avec ce `*`, mais il saura que tous les paramètres suivants doivent être appelés comme arguments "mots-clés" (paires clé-valeur), également connus sous le nom de <abbr title="De : K-ey W-ord Arg-uments"><code>kwargs</code></abbr>. Même s'ils n'ont pas de valeur par défaut.
 
-{* ../../docs_src/path_params_numeric_validations/tutorial003_py39.py hl[7] *}
+{* ../../docs_src/path_params_numeric_validations/tutorial003.py hl[7] *}
 
-### Mieux avec `Annotated` { #better-with-annotated }
+# Avec `Annotated`
 
 Gardez à l'esprit que si vous utilisez `Annotated`, comme vous n'utilisez pas les valeurs par défaut des paramètres de fonction, vous n'aurez pas ce problème, et vous n'aurez probablement pas besoin d'utiliser `*`.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial003_an_py39.py hl[10] *}
 
-## Validations numériques : supérieur ou égal { #number-validations-greater-than-or-equal }
+## Validations numériques : supérieur ou égal
 
 Avec `Query` et `Path` (et d'autres que vous verrez plus tard) vous pouvez déclarer des contraintes numériques.
 
-Ici, avec `ge=1`, `item_id` devra être un nombre entier « `g`reater than or `e`qual » à `1`.
+Ici, avec `ge=1`, `item_id` devra être un nombre entier "`g`reater than or `e`qual" à `1`.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
 
-## Validations numériques : supérieur et inférieur ou égal { #number-validations-greater-than-and-less-than-or-equal }
+## Validations numériques : supérieur ou égal et inférieur ou égal
+
+La même chose s'applique pour :
+
+* `gt` : `g`reater `t`han
+* `le` : `l`ess than or `e`qual
+
+{* ../../docs_src/path_params_numeric_validations/tutorial004_an_py39.py hl[10] *}
+
+## Validations numériques : supérieur et inférieur ou égal
 
 La même chose s'applique pour :
 
@@ -108,7 +117,7 @@ La même chose s'applique pour :
 
 {* ../../docs_src/path_params_numeric_validations/tutorial005_an_py39.py hl[10] *}
 
-## Validations numériques : flottants, supérieur et inférieur { #number-validations-floats-greater-than-and-less-than }
+## Validations numériques : flottants, supérieur et inférieur
 
 Les validations numériques fonctionnent également pour les valeurs `float`.
 
@@ -120,7 +129,7 @@ Et la même chose pour <abbr title="less than"><code>lt</code></abbr>.
 
 {* ../../docs_src/path_params_numeric_validations/tutorial006_an_py39.py hl[13] *}
 
-## Pour résumer { #recap }
+## Pour résumer
 
 Avec `Query`, `Path` (et d'autres que vous verrez plus tard) vous pouvez déclarer des métadonnées et des validations de chaînes de la même manière qu'avec les [Paramètres de requête et validations de chaînes](query-params-str-validations.md){.internal-link target=_blank}.
 

docs/fr/docs/tutorial/path-params.md

@@ -1,196 +1,205 @@
-# Paramètres de chemin { #path-parameters }
+# Paramètres de chemin
 
-Vous pouvez déclarer des « paramètres » ou « variables » de chemin avec la même syntaxe utilisée par les chaînes de format Python :
+Vous pouvez déclarer des "paramètres" ou "variables" de chemin avec la même syntaxe que celle utilisée par le
+<a href="https://docs.python.org/fr/3/library/string.html#format-string-syntax" class="external-link" target="_blank">formatage de chaîne Python</a> :
 
-{* ../../docs_src/path_params/tutorial001_py39.py hl[6:7] *}
 
-La valeur du paramètre de chemin `item_id` sera transmise à votre fonction dans l'argument `item_id`.
+{* ../../docs_src/path_params/tutorial001.py hl[6:7] *}
 
-Donc, si vous exécutez cet exemple et allez sur <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, vous verrez comme réponse :
+La valeur du paramètre `item_id` sera transmise à la fonction dans l'argument `item_id`.
+
+Donc, si vous exécutez cet exemple et allez sur <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>,
+vous verrez comme réponse :
 
 ```JSON
 {"item_id":"foo"}
 ```
 
-## Paramètres de chemin typés { #path-parameters-with-types }
+## Paramètres de chemin typés
 
-Vous pouvez déclarer le type d'un paramètre de chemin dans la fonction, en utilisant les annotations de type Python standard :
+Vous pouvez déclarer le type d'un paramètre de chemin dans la fonction, en utilisant les annotations de type Python :
 
-{* ../../docs_src/path_params/tutorial002_py39.py hl[7] *}
+
+{* ../../docs_src/path_params/tutorial002.py hl[7] *}
 
 Ici, `item_id` est déclaré comme `int`.
 
-/// check | Vérifications
+/// check | vérifier
 
-Cela vous apporte la prise en charge par l'éditeur dans votre fonction, avec vérifications d'erreurs, autocomplétion, etc.
+Ceci vous permettra d'obtenir des fonctionnalités de l'éditeur dans votre fonction, telles
+que des vérifications d'erreur, de l'auto-complétion, etc.
 
 ///
 
-## <abbr title="également appelé : sérialisation, parsing, marshalling">Conversion</abbr> de données { #data-conversion }
+## <abbr title="aussi appelé sérialisation, ou parfois parsing ou marshalling en anglais">Conversion</abbr> de données
 
-Si vous exécutez cet exemple et ouvrez votre navigateur sur <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, vous verrez comme réponse :
+Si vous exécutez cet exemple et allez sur <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a>, vous aurez comme réponse :
 
 ```JSON
 {"item_id":3}
 ```
 
-/// check | Vérifications
+/// check | vérifier
 
-Remarquez que la valeur reçue par votre fonction (et renvoyée) est `3`, en tant qu'entier (`int`) Python, pas la chaîne de caractères « 3 ».
+Comme vous l'avez remarqué, la valeur reçue par la fonction (et renvoyée ensuite) est `3`,
+en tant qu'entier (`int`) Python, pas la chaîne de caractères (`string`) `"3"`.
 
-Ainsi, avec cette déclaration de type, **FastAPI** vous fournit automatiquement le <abbr title="conversion de la chaîne de caractères provenant d'une requête HTTP en données Python">« parsing »</abbr> de la requête.
+Grâce aux déclarations de types, **FastAPI** fournit du
+<abbr title="conversion de la chaîne de caractères venant de la requête HTTP en données Python">"parsing"</abbr> automatique.
 
 ///
 
-## Validation de données { #data-validation }
+## Validation de données
 
-Mais si vous allez dans le navigateur sur <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, vous verrez une belle erreur HTTP :
+Si vous allez sur <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a>, vous aurez une belle erreur HTTP :
 
 ```JSON
 {
-  "detail": [
-    {
-      "type": "int_parsing",
-      "loc": [
-        "path",
-        "item_id"
-      ],
-      "msg": "Input should be a valid integer, unable to parse string as an integer",
-      "input": "foo"
-    }
-  ]
+    "detail": [
+        {
+            "loc": [
+                "path",
+                "item_id"
+            ],
+            "msg": "value is not a valid integer",
+            "type": "type_error.integer"
+        }
+    ]
 }
 ```
 
-car le paramètre de chemin `item_id` a pour valeur « foo », qui n'est pas un `int`.
+car le paramètre de chemin `item_id` possède comme valeur `"foo"`, qui ne peut pas être convertie en entier (`int`).
 
-La même erreur apparaîtrait si vous fournissiez un `float` au lieu d'un `int`, comme ici : <a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>
+La même erreur se produira si vous passez un nombre flottant (`float`) et non un entier, comme ici
+<a href="http://127.0.0.1:8000/items/4.2" class="external-link" target="_blank">http://127.0.0.1:8000/items/4.2</a>.
 
-/// check | Vérifications
 
-Ainsi, avec la même déclaration de type Python, **FastAPI** vous fournit la validation de données.
+/// check | vérifier
 
-Remarquez que l'erreur indique clairement l'endroit exact où la validation n'a pas réussi.
+Donc, avec ces mêmes déclarations de type Python, **FastAPI** vous fournit de la validation de données.
 
-C'est incroyablement utile lors du développement et du débogage du code qui interagit avec votre API.
+Notez que l'erreur mentionne le point exact où la validation n'a pas réussi.
+
+Ce qui est incroyablement utile au moment de développer et débugger du code qui interagit avec votre API.
 
 ///
 
-## Documentation { #documentation }
+## Documentation
 
-Et lorsque vous ouvrez votre navigateur sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, vous verrez une documentation d'API automatique et interactive comme :
+Et quand vous vous rendez sur <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>, vous verrez la
+documentation générée automatiquement et interactive :
 
 <img src="/img/tutorial/path-params/image01.png">
 
-/// check | Vérifications
+/// info
 
-À nouveau, simplement avec cette même déclaration de type Python, **FastAPI** vous fournit une documentation interactive automatique (intégrant Swagger UI).
+À nouveau, en utilisant uniquement les déclarations de type Python, **FastAPI** vous fournit automatiquement une documentation interactive (via Swagger UI).
 
-Remarquez que le paramètre de chemin est déclaré comme entier.
+On voit bien dans la documentation que `item_id` est déclaré comme entier.
 
 ///
 
-## Les avantages d'une norme, documentation alternative { #standards-based-benefits-alternative-documentation }
+## Les avantages d'avoir une documentation basée sur une norme, et la documentation alternative.
 
-Et comme le schéma généré suit la norme <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a>, il existe de nombreux outils compatibles.
+Le schéma généré suivant la norme <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.0.2.md" class="external-link" target="_blank">OpenAPI</a>,
+il existe de nombreux outils compatibles.
 
-Grâce à cela, **FastAPI** fournit lui-même une documentation d'API alternative (utilisant ReDoc), accessible sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> :
+Grâce à cela, **FastAPI** lui-même fournit une documentation alternative (utilisant ReDoc), qui peut être lue
+sur <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> :
 
 <img src="/img/tutorial/path-params/image02.png">
 
-De la même façon, il existe de nombreux outils compatibles, y compris des outils de génération de code pour de nombreux langages.
+De la même façon, il existe bien d'autres outils compatibles, y compris des outils de génération de code
+pour de nombreux langages.
 
-## Pydantic { #pydantic }
+## Pydantic
 
-Toute la validation de données est effectuée sous le capot par <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, vous en bénéficiez donc pleinement. Vous savez ainsi que vous êtes entre de bonnes mains.
+Toute la validation de données est effectué en arrière-plan avec <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>,
+dont vous bénéficierez de tous les avantages. Vous savez donc que vous êtes entre de bonnes mains.
 
-Vous pouvez utiliser les mêmes déclarations de type avec `str`, `float`, `bool` et de nombreux autres types de données complexes.
+## L'ordre importe
 
-Plusieurs d'entre eux sont explorés dans les prochains chapitres du tutoriel.
+Quand vous créez des *fonctions de chemins*, vous pouvez vous retrouver dans une situation où vous avez un chemin fixe.
 
-## L'ordre importe { #order-matters }
+Tel que `/users/me`, disons pour récupérer les données sur l'utilisateur actuel.
 
-Quand vous créez des *chemins d'accès*, vous pouvez vous retrouver dans une situation avec un chemin fixe.
+Et vous avez un second chemin : `/users/{user_id}` pour récupérer de la donnée sur un utilisateur spécifique grâce à son identifiant d'utilisateur
 
-Par exemple `/users/me`, disons pour récupérer les données de l'utilisateur actuel.
+Les *fonctions de chemin* étant évaluées dans l'ordre, il faut s'assurer que la fonction correspondant à `/users/me` est déclarée avant celle de `/users/{user_id}` :
 
-Et vous pouvez aussi avoir un chemin `/users/{user_id}` pour récupérer des données sur un utilisateur spécifique grâce à un identifiant d'utilisateur.
+{* ../../docs_src/path_params/tutorial003.py hl[6,11] *}
 
-Comme les *chemins d'accès* sont évalués dans l'ordre, vous devez vous assurer que le chemin `/users/me` est déclaré avant celui de `/users/{user_id}` :
+Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, la fonction "croyant" qu'elle a reçu un paramètre `user_id` avec pour valeur `"me"`.
 
-{* ../../docs_src/path_params/tutorial003_py39.py hl[6,11] *}
+## Valeurs prédéfinies
 
-Sinon, le chemin `/users/{user_id}` correspondrait aussi à `/users/me`, « pensant » qu'il reçoit un paramètre `user_id` avec la valeur « me ».
+Si vous avez une *fonction de chemin* qui reçoit un *paramètre de chemin*, mais que vous voulez que les valeurs possibles des paramètres soient prédéfinies, vous pouvez utiliser les <abbr title="Enumeration">`Enum`</abbr> de Python.
 
-De même, vous ne pouvez pas redéfinir un chemin d'accès :
+### Création d'un `Enum`
 
-{* ../../docs_src/path_params/tutorial003b_py39.py hl[6,11] *}
+Importez `Enum` et créez une sous-classe qui hérite de `str` et `Enum`.
 
-Le premier sera toujours utilisé puisque le chemin correspond en premier.
+En héritant de `str` la documentation sera capable de savoir que les valeurs doivent être de type `string` et pourra donc afficher cette `Enum` correctement.
 
-## Valeurs prédéfinies { #predefined-values }
+Créez ensuite des attributs de classe avec des valeurs fixes, qui seront les valeurs autorisées pour cette énumération.
 
-Si vous avez un *chemin d'accès* qui reçoit un *paramètre de chemin*, mais que vous voulez que les valeurs possibles de ce *paramètre de chemin* soient prédéfinies, vous pouvez utiliser une <abbr title="Enumeration">`Enum`</abbr> Python standard.
+{* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *}
 
-### Créer une classe `Enum` { #create-an-enum-class }
+/// info
 
-Importez `Enum` et créez une sous-classe qui hérite de `str` et de `Enum`.
-
-En héritant de `str`, la documentation de l'API saura que les valeurs doivent être de type `string` et pourra donc s'afficher correctement.
-
-Créez ensuite des attributs de classe avec des valeurs fixes, qui seront les valeurs valides disponibles :
-
-{* ../../docs_src/path_params/tutorial005_py39.py hl[1,6:9] *}
-
-/// tip | Astuce
-
-Si vous vous demandez, « AlexNet », « ResNet » et « LeNet » sont juste des noms de <abbr title="Techniquement, architectures de modèles de Deep Learning">modèles</abbr> de Machine Learning.
+<a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">Les énumérations (ou enums) sont disponibles en Python</a> depuis la version 3.4.
 
 ///
 
-### Déclarer un paramètre de chemin { #declare-a-path-parameter }
+/// tip | Astuce
 
-Créez ensuite un *paramètre de chemin* avec une annotation de type utilisant la classe d'énumération que vous avez créée (`ModelName`) :
+Pour ceux qui se demandent, "AlexNet", "ResNet", et "LeNet" sont juste des noms de <abbr title="Techniquement, des architectures de modèles">modèles</abbr> de Machine Learning.
 
-{* ../../docs_src/path_params/tutorial005_py39.py hl[16] *}
+///
 
-### Consulter la documentation { #check-the-docs }
+### Déclarer un paramètre de chemin
 
-Comme les valeurs disponibles pour le *paramètre de chemin* sont prédéfinies, la documentation interactive peut les afficher clairement :
+Créez ensuite un *paramètre de chemin* avec une annotation de type désignant l'énumération créée précédemment (`ModelName`) :
+
+{* ../../docs_src/path_params/tutorial005.py hl[16] *}
+
+### Documentation
+
+Les valeurs disponibles pour le *paramètre de chemin* sont bien prédéfinies, la documentation les affiche correctement :
 
 <img src="/img/tutorial/path-params/image03.png">
 
-### Travailler avec les *énumérations* Python { #working-with-python-enumerations }
+### Manipuler les *énumérations* Python
 
-La valeur du *paramètre de chemin* sera un *membre d'énumération*.
+La valeur du *paramètre de chemin* sera un des "membres" de l'énumération.
 
-#### Comparer des *membres d'énumération* { #compare-enumeration-members }
+#### Comparer les *membres d'énumération*
 
-Vous pouvez le comparer avec le *membre d'énumération* dans votre enum `ModelName` :
+Vous pouvez comparer ce paramètre avec les membres de votre énumération `ModelName` :
 
-{* ../../docs_src/path_params/tutorial005_py39.py hl[17] *}
+{* ../../docs_src/path_params/tutorial005.py hl[17] *}
 
-#### Obtenir la *valeur de l'énumération* { #get-the-enumeration-value }
+#### Récupérer la *valeur de l'énumération*
 
-Vous pouvez obtenir la valeur réelle (une `str` dans ce cas) avec `model_name.value`, ou en général, `votre_membre_d_enum.value` :
+Vous pouvez obtenir la valeur réel d'un membre (une chaîne de caractères ici), avec `model_name.value`, ou en général, `votre_membre_d'enum.value` :
 
-{* ../../docs_src/path_params/tutorial005_py39.py hl[20] *}
+{* ../../docs_src/path_params/tutorial005.py hl[20] *}
 
 /// tip | Astuce
 
-Vous pouvez aussi accéder à la valeur « lenet » avec `ModelName.lenet.value`.
+Vous pouvez aussi accéder la valeur `"lenet"` avec `ModelName.lenet.value`.
 
 ///
 
-#### Retourner des *membres d'énumération* { #return-enumeration-members }
+#### Retourner des *membres d'énumération*
 
-Vous pouvez retourner des *membres d'énumération* depuis votre *chemin d'accès*, même imbriqués dans un corps JSON (par ex. un `dict`).
+Vous pouvez retourner des *membres d'énumération* dans vos *fonctions de chemin*, même imbriquée dans un JSON (e.g. un `dict`).
 
-Ils seront convertis vers leurs valeurs correspondantes (des chaînes de caractères ici) avant d'être renvoyés au client :
+Ils seront convertis vers leurs valeurs correspondantes (chaînes de caractères ici) avant d'être transmis au client :
 
-{* ../../docs_src/path_params/tutorial005_py39.py hl[18,21,23] *}
+{* ../../docs_src/path_params/tutorial005.py hl[18,21,23] *}
 
-Dans votre client, vous recevrez une réponse JSON comme :
+Le client recevra une réponse JSON comme celle-ci :
 
 ```JSON
 {
@@ -199,53 +208,53 @@ Dans votre client, vous recevrez une réponse JSON comme :
 }
 ```
 
-## Paramètres de chemin contenant des chemins { #path-parameters-containing-paths }
+## Paramètres de chemin contenant des chemins
 
-Disons que vous avez un *chemin d'accès* avec un chemin `/files/{file_path}`.
+Disons que vous avez une *fonction de chemin* liée au chemin `/files/{file_path}`.
 
-Mais vous avez besoin que `file_path` lui-même contienne un *chemin*, comme `home/johndoe/myfile.txt`.
+Mais que `file_path` lui-même doit contenir un *chemin*, comme `home/johndoe/myfile.txt` par exemple.
 
-Ainsi, l'URL pour ce fichier serait : `/files/home/johndoe/myfile.txt`.
+Donc, l'URL pour ce fichier pourrait être : `/files/home/johndoe/myfile.txt`.
 
-### Support d'OpenAPI { #openapi-support }
+### Support d'OpenAPI
 
-OpenAPI ne prend pas en charge une manière de déclarer un *paramètre de chemin* contenant un *chemin* à l'intérieur, car cela peut conduire à des scénarios difficiles à tester et à définir.
+OpenAPI ne supporte pas de manière de déclarer un paramètre de chemin contenant un *chemin*, cela pouvant causer des scénarios difficiles à tester et définir.
 
-Néanmoins, vous pouvez toujours le faire dans **FastAPI**, en utilisant l'un des outils internes de Starlette.
+Néanmoins, cela reste faisable dans **FastAPI**, via les outils internes de Starlette.
 
-Et la documentation fonctionnera quand même, même si aucune indication supplémentaire ne sera ajoutée pour dire que le paramètre doit contenir un chemin.
+Et la documentation fonctionne quand même, bien qu'aucune section ne soit ajoutée pour dire que la paramètre devrait contenir un *chemin*.
 
-### Convertisseur de chemin { #path-convertor }
+### Convertisseur de *chemin*
 
-En utilisant une option directement depuis Starlette, vous pouvez déclarer un *paramètre de chemin* contenant un *chemin* avec une URL comme :
+En utilisant une option de Starlette directement, vous pouvez déclarer un *paramètre de chemin* contenant un *chemin* avec une URL comme :
 
 ```
 /files/{file_path:path}
 ```
 
-Dans ce cas, le nom du paramètre est `file_path`, et la dernière partie, `:path`, indique que le paramètre doit correspondre à n'importe quel *chemin*.
+Dans ce cas, le nom du paramètre est `file_path`, et la dernière partie, `:path`, indique à Starlette que le paramètre devrait correspondre à un *chemin*.
 
-Vous pouvez donc l'utiliser ainsi :
+Vous pouvez donc l'utilisez comme tel :
 
-{* ../../docs_src/path_params/tutorial004_py39.py hl[6] *}
+{* ../../docs_src/path_params/tutorial004.py hl[6] *}
 
 /// tip | Astuce
 
-Vous pourriez avoir besoin que le paramètre contienne `/home/johndoe/myfile.txt`, avec un slash initial (`/`).
+Vous pourriez avoir besoin que le paramètre contienne `/home/johndoe/myfile.txt`, avec un slash au début (`/`).
 
 Dans ce cas, l'URL serait : `/files//home/johndoe/myfile.txt`, avec un double slash (`//`) entre `files` et `home`.
 
 ///
 
-## Récapitulatif { #recap }
+## Récapitulatif
 
-Avec **FastAPI**, en utilisant des déclarations de type Python courtes, intuitives et standard, vous obtenez :
+Avec **FastAPI**, en utilisant les déclarations de type rapides, intuitives et standards de Python, vous bénéficiez de :
 
-* Support de l'éditeur : vérifications d'erreurs, autocomplétion, etc.
-* Données « <abbr title="conversion de la chaîne de caractères provenant d'une requête HTTP en données Python">parsing</abbr> »
-* Validation de données
-* Annotations d'API et documentation automatique
+* Support de l'éditeur : vérification d'erreurs, auto-complétion, etc.
+* <abbr title="conversion de la chaîne de caractères venant de la requête HTTP en données Python">"Parsing"</abbr> de données.
+* Validation de données.
+* Annotations d'API et documentation automatique.
 
-Et vous n'avez besoin de les déclarer qu'une seule fois.
+Et vous n'avez besoin de le déclarer qu'une fois.
 
-C'est probablement l'avantage visible principal de **FastAPI** comparé aux autres frameworks (outre les performances pures).
+C'est probablement l'avantage visible principal de **FastAPI** comparé aux autres *frameworks* (outre les performances pures).

docs/fr/docs/tutorial/query-params-str-validations.md

@@ -1,273 +1,166 @@
-# Paramètres de requête et validations de chaînes de caractères { #query-parameters-and-string-validations }
+# Paramètres de requête et validations de chaînes de caractères
 
-**FastAPI** vous permet de déclarer des informations et des validations supplémentaires pour vos paramètres.
+**FastAPI** vous permet de déclarer des informations et des validateurs additionnels pour vos paramètres de requêtes.
 
-Prenons cette application comme exemple :
+Commençons avec cette application pour exemple :
 
-{* ../../docs_src/query_params_str_validations/tutorial001_py310.py hl[7] *}
+{* ../../docs_src/query_params_str_validations/tutorial001.py hl[9] *}
 
-Le paramètre de requête `q` est de type `str | None`, cela signifie qu’il est de type `str` mais peut aussi être `None`, et en effet, la valeur par défaut est `None`, donc FastAPI saura qu’il n’est pas requis.
+Le paramètre de requête `q` a pour type `Union[str, None]` (ou `str | None` en Python 3.10), signifiant qu'il est de type `str` mais pourrait aussi être égal à `None`, et bien sûr, la valeur par défaut est `None`, donc **FastAPI** saura qu'il n'est pas requis.
 
-/// note | Remarque
+/// note
 
-FastAPI saura que la valeur de `q` n’est pas requise grâce à la valeur par défaut `= None`.
+**FastAPI** saura que la valeur de `q` n'est pas requise grâce à la valeur par défaut `= None`.
 
-Avoir `str | None` permettra à votre éditeur de vous offrir un meilleur support et de détecter les erreurs.
+Le `Union` dans `Union[str, None]` permettra à votre éditeur de vous offrir un meilleur support et de détecter les erreurs.
 
 ///
 
-## Validation additionnelle { #additional-validation }
+## Validation additionnelle
 
-Nous allons imposer que, même si `q` est optionnel, dès qu’il est fourni, **sa longueur n’excède pas 50 caractères**.
+Nous allons imposer que bien que `q` soit un paramètre optionnel, dès qu'il est fourni, **sa longueur n'excède pas 50 caractères**.
 
-### Importer `Query` et `Annotated` { #import-query-and-annotated }
+## Importer `Query`
 
-Pour ce faire, importez d’abord :
+Pour cela, importez d'abord `Query` depuis `fastapi` :
 
-- `Query` depuis `fastapi`
-- `Annotated` depuis `typing`
+{* ../../docs_src/query_params_str_validations/tutorial002.py hl[3] *}
 
-{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[1,3] *}
+## Utiliser `Query` comme valeur par défaut
 
-/// info
+Construisez ensuite la valeur par défaut de votre paramètre avec `Query`, en choisissant 50 comme `max_length` :
 
-FastAPI a ajouté la prise en charge de `Annotated` (et a commencé à le recommander) dans la version 0.95.0.
+{* ../../docs_src/query_params_str_validations/tutorial002.py hl[9] *}
 
-Si vous avez une version plus ancienne, vous obtiendrez des erreurs en essayant d’utiliser `Annotated`.
+Comme nous devons remplacer la valeur par défaut `None` dans la fonction par `Query()`, nous pouvons maintenant définir la valeur par défaut avec le paramètre `Query(default=None)`, il sert le même objectif qui est de définir cette valeur par défaut.
 
-Assurez-vous de [mettre à niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} vers au moins 0.95.1 avant d’utiliser `Annotated`.
-
-///
-
-## Utiliser `Annotated` dans le type pour le paramètre `q` { #use-annotated-in-the-type-for-the-q-parameter }
-
-Vous vous souvenez que je vous ai dit plus tôt que `Annotated` peut être utilisé pour ajouter des métadonnées à vos paramètres dans l’[Introduction aux types Python](../python-types.md#type-hints-with-metadata-annotations){.internal-link target=_blank} ?
-
-C’est le moment de l’utiliser avec FastAPI. 🚀
-
-Nous avions cette annotation de type :
-
-//// tab | Python 3.10+
+Donc :
 
 ```Python
-q: str | None = None
+q: Union[str, None] = Query(default=None)
 ```
 
-////
-
-//// tab | Python 3.9+
+... rend le paramètre optionnel, et est donc équivalent à :
 
 ```Python
 q: Union[str, None] = None
 ```
 
-////
+Mais déclare explicitement `q` comme étant un paramètre de requête.
 
-Ce que nous allons faire, c’est l’englober avec `Annotated`, de sorte que cela devienne :
+/// info
 
-//// tab | Python 3.10+
+Gardez à l'esprit que la partie la plus importante pour rendre un paramètre optionnel est :
 
 ```Python
-q: Annotated[str | None] = None
+= None
 ```
 
-////
-
-//// tab | Python 3.9+
+ou :
 
 ```Python
-q: Annotated[Union[str, None]] = None
+= Query(None)
 ```
 
-////
+et utilisera ce `None` pour détecter que ce paramètre de requête **n'est pas requis**.
 
-Les deux versions signifient la même chose, `q` est un paramètre qui peut être une `str` ou `None`, et par défaut, c’est `None`.
-
-Passons maintenant aux choses amusantes. 🎉
-
-## Ajouter `Query` à `Annotated` dans le paramètre `q` { #add-query-to-annotated-in-the-q-parameter }
-
-Maintenant que nous avons cet `Annotated` dans lequel nous pouvons mettre plus d’informations (dans ce cas une validation supplémentaire), ajoutez `Query` à l’intérieur de `Annotated`, et définissez le paramètre `max_length` à `50` :
-
-{* ../../docs_src/query_params_str_validations/tutorial002_an_py310.py hl[9] *}
-
-Remarquez que la valeur par défaut est toujours `None`, donc le paramètre est toujours optionnel.
-
-Mais maintenant, avec `Query(max_length=50)` à l’intérieur de `Annotated`, nous indiquons à FastAPI que nous voulons **une validation supplémentaire** pour cette valeur, nous voulons qu’elle ait au maximum 50 caractères. 😎
-
-/// tip | Astuce
-
-Ici nous utilisons `Query()` parce qu’il s’agit d’un **paramètre de requête**. Plus tard nous verrons d’autres comme `Path()`, `Body()`, `Header()` et `Cookie()`, qui acceptent également les mêmes arguments que `Query()`.
+Le `Union[str, None]` est uniquement là pour permettre à votre éditeur un meilleur support.
 
 ///
 
-FastAPI va maintenant :
+Ensuite, nous pouvons passer d'autres paramètres à `Query`. Dans cet exemple, le paramètre `max_length` qui s'applique aux chaînes de caractères :
 
-- **Valider** les données en s’assurant que la longueur maximale est de 50 caractères
-- Afficher une **erreur claire** au client quand les données ne sont pas valides
-- **Documenter** le paramètre dans la *chemin d'accès* du schéma OpenAPI (il apparaîtra donc dans l’**interface de documentation automatique**)
+```Python
+q: Union[str, None] = Query(default=None, max_length=50)
+```
 
-## Alternative (ancienne) : `Query` comme valeur par défaut { #alternative-old-query-as-the-default-value }
+Cela va valider les données, montrer une erreur claire si ces dernières ne sont pas valides, et documenter le paramètre dans le schéma `OpenAPI` de cette *path operation*.
 
-Les versions précédentes de FastAPI (avant <abbr title="avant 2023-03">0.95.0</abbr>) exigeaient d’utiliser `Query` comme valeur par défaut de votre paramètre, au lieu de le mettre dans `Annotated`. Il y a de fortes chances que vous voyiez du code qui l’utilise encore, je vais donc vous l’expliquer.
+## Rajouter plus de validation
 
-/// tip | Astuce
+Vous pouvez aussi rajouter un second paramètre `min_length` :
 
-Pour du nouveau code et dès que possible, utilisez `Annotated` comme expliqué ci-dessus. Il y a de multiples avantages (expliqués ci-dessous) et aucun inconvénient. 🍰
+{* ../../docs_src/query_params_str_validations/tutorial003.py hl[9] *}
+
+## Ajouter des validations par expressions régulières
+
+On peut définir une <abbr title="Une expression régulière, regex ou regexp est une suite de caractères qui définit un pattern de correspondance pour les chaînes de caractères.">expression régulière</abbr> à laquelle le paramètre doit correspondre :
+
+{* ../../docs_src/query_params_str_validations/tutorial004.py hl[10] *}
+
+Cette expression régulière vérifie que la valeur passée comme paramètre :
+
+* `^` : commence avec les caractères qui suivent, avec aucun caractère avant ceux-là.
+* `fixedquery` : a pour valeur exacte `fixedquery`.
+* `$` : se termine directement ensuite, n'a pas d'autres caractères après `fixedquery`.
+
+Si vous vous sentez perdu avec le concept d'**expression régulière**, pas d'inquiétudes. Il s'agit d'une notion difficile pour beaucoup, et l'on peut déjà réussir à faire beaucoup sans jamais avoir à les manipuler.
+
+Mais si vous décidez d'apprendre à les utiliser, sachez qu'ensuite vous pouvez les utiliser directement dans **FastAPI**.
+
+## Valeurs par défaut
+
+De la même façon que vous pouvez passer `None` comme premier argument pour l'utiliser comme valeur par défaut, vous pouvez passer d'autres valeurs.
+
+Disons que vous déclarez le paramètre `q` comme ayant une longueur minimale de `3`, et une valeur par défaut étant `"fixedquery"` :
+
+{* ../../docs_src/query_params_str_validations/tutorial005.py hl[7] *}
+
+/// note | Rappel
+
+Avoir une valeur par défaut rend le paramètre optionnel.
 
 ///
 
-Voici comment vous utiliseriez `Query()` comme valeur par défaut du paramètre de votre fonction, en définissant le paramètre `max_length` à 50 :
+## Rendre ce paramètre requis
 
-{* ../../docs_src/query_params_str_validations/tutorial002_py310.py hl[7] *}
-
-Comme, dans ce cas (sans utiliser `Annotated`), nous devons remplacer la valeur par défaut `None` dans la fonction par `Query()`, nous devons maintenant définir la valeur par défaut avec le paramètre `Query(default=None)`, cela sert le même objectif de définir cette valeur par défaut (au moins pour FastAPI).
-
-Donc :
-
-```Python
-q: str | None = Query(default=None)
-```
-
-... rend le paramètre optionnel, avec une valeur par défaut de `None`, comme :
-
-```Python
-q: str | None = None
-```
-
-Mais la version avec `Query` le déclare explicitement comme étant un paramètre de requête.
-
-Ensuite, nous pouvons passer plus de paramètres à `Query`. Dans ce cas, le paramètre `max_length` qui s’applique aux chaînes de caractères :
-
-```Python
-q: str | None = Query(default=None, max_length=50)
-```
-
-Cela validera les données, affichera une erreur claire lorsque les données ne sont pas valides et documentera le paramètre dans la *chemin d'accès* du schéma OpenAPI.
-
-### `Query` comme valeur par défaut ou dans `Annotated` { #query-as-the-default-value-or-in-annotated }
-
-Gardez à l’esprit qu’en utilisant `Query` à l’intérieur de `Annotated`, vous ne pouvez pas utiliser le paramètre `default` de `Query`.
-
-Utilisez à la place la valeur par défaut réelle du paramètre de fonction. Sinon, ce serait incohérent.
-
-Par exemple, ceci n’est pas autorisé :
-
-```Python
-q: Annotated[str, Query(default="rick")] = "morty"
-```
-
-... parce qu’il n’est pas clair si la valeur par défaut doit être « rick » ou « morty ».
-
-Donc, vous utiliseriez (de préférence) :
-
-```Python
-q: Annotated[str, Query()] = "rick"
-```
-
-... ou dans des bases de code plus anciennes, vous trouverez :
-
-```Python
-q: str = Query(default="rick")
-```
-
-### Avantages de `Annotated` { #advantages-of-annotated }
-
-**L’utilisation de `Annotated` est recommandée** plutôt que la valeur par défaut dans les paramètres de fonction, c’est **mieux** pour plusieurs raisons. 🤓
-
-La valeur **par défaut** du **paramètre de fonction** est la **vraie valeur par défaut**, c’est plus intuitif en Python en général. 😌
-
-Vous pouvez **appeler** cette même fonction dans **d’autres endroits** sans FastAPI, et elle **fonctionnera comme prévu**. S’il y a un paramètre **requis** (sans valeur par défaut), votre **éditeur** vous le signalera avec une erreur, **Python** se plaindra aussi si vous l’exécutez sans passer le paramètre requis.
-
-Quand vous n’utilisez pas `Annotated` et utilisez à la place l’**ancienne** méthode avec la **valeur par défaut**, si vous appelez cette fonction sans FastAPI dans **d’autres endroits**, vous devez **penser** à passer les arguments à la fonction pour qu’elle fonctionne correctement, sinon les valeurs seront différentes de ce que vous attendez (par ex. `QueryInfo` ou quelque chose de similaire au lieu d’une `str`). Et votre éditeur ne se plaindra pas, et Python ne se plaindra pas en exécutant cette fonction, seulement quand les opérations internes échoueront.
-
-Comme `Annotated` peut avoir plus d’une annotation de métadonnées, vous pouvez maintenant même utiliser la même fonction avec d’autres outils, comme <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">Typer</a>. 🚀
-
-## Ajouter plus de validations { #add-more-validations }
-
-Vous pouvez également ajouter un paramètre `min_length` :
-
-{* ../../docs_src/query_params_str_validations/tutorial003_an_py310.py hl[10] *}
-
-## Ajouter des expressions régulières { #add-regular-expressions }
-
-Vous pouvez définir un `pattern` d’<abbr title="Une expression régulière, regex ou regexp, est une suite de caractères qui définit un motif de recherche pour les chaînes de caractères.">expression régulière</abbr> auquel le paramètre doit correspondre :
-
-{* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
-
-Ce pattern d’expression régulière spécifique vérifie que la valeur reçue pour le paramètre :
-
-- `^` : commence avec les caractères qui suivent, n’a pas de caractères avant.
-- `fixedquery` : a exactement la valeur `fixedquery`.
-- `$` : se termine là, n’a pas d’autres caractères après `fixedquery`.
-
-Si vous vous sentez perdu avec toutes ces idées d’**« expression régulière »**, pas d’inquiétude. C’est un sujet difficile pour beaucoup. Vous pouvez déjà faire beaucoup de choses sans avoir besoin d’expressions régulières.
-
-Désormais, vous savez que, lorsque vous en aurez besoin, vous pourrez les utiliser dans **FastAPI**.
-
-## Valeurs par défaut { #default-values }
-
-Vous pouvez, bien sûr, utiliser des valeurs par défaut autres que `None`.
-
-Disons que vous voulez déclarer le paramètre de requête `q` avec un `min_length` de `3`, et avec une valeur par défaut de « fixedquery » :
-
-{* ../../docs_src/query_params_str_validations/tutorial005_an_py39.py hl[9] *}
-
-/// note | Remarque
-
-Avoir une valeur par défaut de n’importe quel type, y compris `None`, rend le paramètre optionnel (non requis).
-
-///
-
-## Paramètres requis { #required-parameters }
-
-Quand nous n’avons pas besoin de déclarer plus de validations ou de métadonnées, nous pouvons rendre le paramètre de requête `q` requis en n’indiquant simplement pas de valeur par défaut, comme :
+Quand on ne déclare ni validation, ni métadonnée, on peut rendre le paramètre `q` requis en ne lui déclarant juste aucune valeur par défaut :
 
 ```Python
 q: str
 ```
 
-au lieu de :
+à la place de :
 
 ```Python
-q: str | None = None
+q: Union[str, None] = None
 ```
 
-Mais maintenant nous le déclarons avec `Query`, par exemple ainsi :
+Mais maintenant, on déclare `q` avec `Query`, comme ceci :
 
 ```Python
-q: Annotated[str | None, Query(min_length=3)] = None
+q: Union[str, None] = Query(default=None, min_length=3)
 ```
 
-Donc, lorsque vous avez besoin de déclarer une valeur comme requise tout en utilisant `Query`, vous pouvez simplement ne pas déclarer de valeur par défaut :
+Donc pour déclarer une valeur comme requise tout en utilisant `Query`, il faut utiliser `...` comme premier argument :
 
-{* ../../docs_src/query_params_str_validations/tutorial006_an_py39.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial006.py hl[7] *}
 
-### Requis, peut valoir `None` { #required-can-be-none }
+/// info
 
-Vous pouvez déclarer qu’un paramètre accepte `None`, mais qu’il est tout de même requis. Cela obligerait les clients à envoyer une valeur, même si la valeur est `None`.
+Si vous n'avez jamais vu ce `...` auparavant : c'est une des constantes natives de Python <a href="https://docs.python.org/fr/3/library/constants.html#Ellipsis" class="external-link" target="_blank">appelée "Ellipsis"</a>.
 
-Pour ce faire, vous pouvez déclarer que `None` est un type valide tout en ne déclarant pas de valeur par défaut :
+///
 
-{* ../../docs_src/query_params_str_validations/tutorial006c_an_py310.py hl[9] *}
+Cela indiquera à **FastAPI** que la présence de ce paramètre est obligatoire.
 
-## Liste de paramètres de requête / valeurs multiples { #query-parameter-list-multiple-values }
+## Liste de paramètres / valeurs multiples via Query
 
-Quand vous définissez un paramètre de requête explicitement avec `Query`, vous pouvez aussi déclarer qu’il reçoit une liste de valeurs, autrement dit, qu’il reçoit des valeurs multiples.
+Quand on définit un paramètre de requête explicitement avec `Query` on peut aussi déclarer qu'il reçoit une liste de valeur, ou des "valeurs multiples".
 
-Par exemple, pour déclarer un paramètre de requête `q` qui peut apparaître plusieurs fois dans l’URL, vous pouvez écrire :
+Par exemple, pour déclarer un paramètre de requête `q` qui peut apparaître plusieurs fois dans une URL, on écrit :
 
-{* ../../docs_src/query_params_str_validations/tutorial011_an_py310.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial011.py hl[9] *}
 
-Ensuite, avec une URL comme :
+Ce qui fait qu'avec une URL comme :
 
 ```
 http://localhost:8000/items/?q=foo&q=bar
 ```
 
-vous recevriez les valeurs des multiples paramètres de requête `q` (`foo` et `bar`) dans une `list` Python à l’intérieur de votre fonction de *chemin d'accès*, dans le *paramètre de fonction* `q`.
+vous recevriez les valeurs des multiples paramètres de requête `q` (`foo` et `bar`) dans une `list` Python au sein de votre fonction de **path operation**, dans le paramètre de fonction `q`.
 
-Donc, la réponse pour cette URL serait :
+Donc la réponse de cette URL serait :
 
 ```JSON
 {
@@ -280,19 +173,19 @@ Donc, la réponse pour cette URL serait :
 
 /// tip | Astuce
 
-Pour déclarer un paramètre de requête avec un type `list`, comme dans l’exemple ci-dessus, vous devez explicitement utiliser `Query`, sinon il serait interprété comme faisant partie du corps de la requête.
+Pour déclarer un paramètre de requête de type `list`, comme dans l'exemple ci-dessus, il faut explicitement utiliser `Query`, sinon cela sera interprété comme faisant partie du corps de la requête.
 
 ///
 
-L’interface de documentation interactive de l’API sera mise à jour en conséquence, pour autoriser plusieurs valeurs :
+La documentation sera donc mise à jour automatiquement pour autoriser plusieurs valeurs :
 
 <img src="/img/tutorial/query-params-str-validations/image02.png">
 
-### Liste de paramètres de requête / valeurs multiples avec valeurs par défaut { #query-parameter-list-multiple-values-with-defaults }
+### Combiner liste de paramètres et valeurs par défaut
 
-Vous pouvez également définir une `list` de valeurs par défaut si aucune n’est fournie :
+Et l'on peut aussi définir une liste de valeurs par défaut si aucune n'est fournie :
 
-{* ../../docs_src/query_params_str_validations/tutorial012_an_py39.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial012.py hl[9] *}
 
 Si vous allez à :
 
@@ -300,7 +193,9 @@ Si vous allez à :
 http://localhost:8000/items/
 ```
 
-la valeur par défaut de `q` sera : `["foo", "bar"]` et votre réponse sera :
+la valeur par défaut de `q` sera : `["foo", "bar"]`
+
+et la réponse sera :
 
 ```JSON
 {
@@ -311,163 +206,93 @@ la valeur par défaut de `q` sera : `["foo", "bar"]` et votre réponse sera :
 }
 ```
 
-#### Utiliser simplement `list` { #using-just-list }
+#### Utiliser `list`
 
-Vous pouvez aussi utiliser `list` directement au lieu de `list[str]` :
+Il est aussi possible d'utiliser directement `list` plutôt que `List[str]` :
 
-{* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial013.py hl[7] *}
 
-/// note | Remarque
+/// note
 
-Gardez à l’esprit que dans ce cas, FastAPI ne vérifiera pas le contenu de la liste.
+Dans ce cas-là, **FastAPI** ne vérifiera pas le contenu de la liste.
 
-Par exemple, `list[int]` vérifierait (et documenterait) que le contenu de la liste est composé d’entiers. Mais un simple `list` ne le ferait pas.
+Par exemple, `List[int]` vérifiera (et documentera) que la liste est bien entièrement composée d'entiers. Alors qu'un simple `list` ne ferait pas cette vérification.
 
 ///
 
-## Déclarer plus de métadonnées { #declare-more-metadata }
+## Déclarer des métadonnées supplémentaires
 
-Vous pouvez ajouter plus d’informations à propos du paramètre.
+On peut aussi ajouter plus d'informations sur le paramètre.
 
-Ces informations seront incluses dans l’OpenAPI généré et utilisées par les interfaces de documentation et les outils externes.
+Ces informations seront incluses dans le schéma `OpenAPI` généré et utilisées par la documentation interactive ou les outils externes utilisés.
 
-/// note | Remarque
+/// note
 
-Gardez à l’esprit que différents outils peuvent avoir des niveaux de prise en charge d’OpenAPI différents.
+Gardez en tête que les outils externes utilisés ne supportent pas forcément tous parfaitement OpenAPI.
 
-Certains d’entre eux pourraient ne pas encore afficher toutes les informations supplémentaires déclarées, bien que, dans la plupart des cas, la fonctionnalité manquante soit déjà prévue au développement.
+Il se peut donc que certains d'entre eux n'utilisent pas toutes les métadonnées que vous avez déclarées pour le moment, bien que dans la plupart des cas, les fonctionnalités manquantes ont prévu d'être implémentées.
 
 ///
 
 Vous pouvez ajouter un `title` :
 
-{* ../../docs_src/query_params_str_validations/tutorial007_an_py310.py hl[10] *}
+{* ../../docs_src/query_params_str_validations/tutorial007.py hl[10] *}
 
 Et une `description` :
 
-{* ../../docs_src/query_params_str_validations/tutorial008_an_py310.py hl[14] *}
+{* ../../docs_src/query_params_str_validations/tutorial008.py hl[13] *}
 
-## Paramètres avec alias { #alias-parameters }
+## Alias de paramètres
 
-Imaginez que vous vouliez que le paramètre soit `item-query`.
+Imaginez que vous vouliez que votre paramètre se nomme `item-query`.
 
-Comme dans :
+Comme dans la requête :
 
 ```
 http://127.0.0.1:8000/items/?item-query=foobaritems
 ```
 
-Mais `item-query` n’est pas un nom de variable Python valide.
+Mais `item-query` n'est pas un nom de variable valide en Python.
 
-Le plus proche serait `item_query`.
+Le nom le plus proche serait `item_query`.
 
-Mais vous avez quand même besoin que ce soit exactement `item-query` ...
+Mais vous avez vraiment envie que ce soit exactement `item-query`...
 
-Vous pouvez alors déclarer un `alias`, et cet alias sera utilisé pour trouver la valeur du paramètre :
+Pour cela vous pouvez déclarer un `alias`, et cet alias est ce qui sera utilisé pour trouver la valeur du paramètre :
 
-{* ../../docs_src/query_params_str_validations/tutorial009_an_py310.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial009.py hl[9] *}
 
-## Déprécier des paramètres { #deprecating-parameters }
+## Déprécier des paramètres
 
-Disons que vous n’aimez plus ce paramètre.
+Disons que vous ne vouliez plus utiliser ce paramètre désormais.
 
-Vous devez le laisser là quelque temps car des clients l’utilisent, mais vous voulez que les documents l’affichent clairement comme <abbr title="obsolète, recommandé de ne pas l’utiliser">déprécié</abbr>.
+Il faut qu'il continue à exister pendant un certain temps car vos clients l'utilisent, mais vous voulez que la documentation mentionne clairement que ce paramètre est <abbr title="obsolète, recommandé de ne pas l'utiliser">déprécié</abbr>.
 
-Passez alors le paramètre `deprecated=True` à `Query` :
+On utilise alors l'argument `deprecated=True` de `Query` :
 
-{* ../../docs_src/query_params_str_validations/tutorial010_an_py310.py hl[19] *}
+{* ../../docs_src/query_params_str_validations/tutorial010.py hl[18] *}
 
-Les documents l’afficheront ainsi :
+La documentation le présentera comme il suit :
 
 <img src="/img/tutorial/query-params-str-validations/image01.png">
 
-## Exclure des paramètres d’OpenAPI { #exclude-parameters-from-openapi }
+## Pour résumer
 
-Pour exclure un paramètre de requête du schéma OpenAPI généré (et donc, des systèmes de documentation automatiques), définissez le paramètre `include_in_schema` de `Query` à `False` :
+Il est possible d'ajouter des validateurs et métadonnées pour vos paramètres.
 
-{* ../../docs_src/query_params_str_validations/tutorial014_an_py310.py hl[10] *}
+Validateurs et métadonnées génériques:
 
-## Validation personnalisée { #custom-validation }
+* `alias`
+* `title`
+* `description`
+* `deprecated`
 
-Il peut y avoir des cas où vous devez faire une **validation personnalisée** qui ne peut pas être réalisée avec les paramètres montrés ci-dessus.
+Validateurs spécifiques aux chaînes de caractères :
 
-Dans ces cas, vous pouvez utiliser une **fonction de validation personnalisée** qui est appliquée après la validation normale (par ex. après avoir validé que la valeur est une `str`).
+* `min_length`
+* `max_length`
+* `regex`
 
-Vous pouvez y parvenir en utilisant <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-after-validator" class="external-link" target="_blank">`AfterValidator` de Pydantic</a> à l’intérieur de `Annotated`.
+Parmi ces exemples, vous avez pu voir comment déclarer des validateurs pour les chaînes de caractères.
 
-/// tip | Astuce
-
-Pydantic a aussi <a href="https://docs.pydantic.dev/latest/concepts/validators/#field-before-validator" class="external-link" target="_blank">`BeforeValidator`</a> et d’autres. 🤓
-
-///
-
-Par exemple, ce validateur personnalisé vérifie que l’ID d’item commence par `isbn-` pour un numéro de livre <abbr title="International Standard Book Number - Numéro international normalisé du livre">ISBN</abbr> ou par `imdb-` pour un ID d’URL de film <abbr title="IMDB (Internet Movie Database) est un site web contenant des informations sur les films">IMDB</abbr> :
-
-{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
-
-/// info
-
-C’est disponible avec Pydantic version 2 ou supérieure. 😎
-
-///
-
-/// tip | Astuce
-
-Si vous devez faire un type de validation qui nécessite de communiquer avec un **composant externe**, comme une base de données ou une autre API, vous devez plutôt utiliser les **Dépendances de FastAPI**, vous en apprendrez davantage plus tard.
-
-Ces validateurs personnalisés sont destinés aux éléments qui peuvent être vérifiés **uniquement** avec les **mêmes données** fournies dans la requête.
-
-///
-
-### Comprendre ce code { #understand-that-code }
-
-Le point important est simplement d’utiliser **`AfterValidator` avec une fonction à l’intérieur de `Annotated`**. N’hésitez pas à passer cette partie. 🤸
-
----
-
-Mais si vous êtes curieux de cet exemple de code spécifique et que vous êtes toujours partant, voici quelques détails supplémentaires.
-
-#### Chaîne avec `value.startswith()` { #string-with-value-startswith }
-
-Avez-vous remarqué ? Une chaîne utilisant `value.startswith()` peut prendre un tuple, et elle vérifiera chaque valeur du tuple :
-
-{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
-
-#### Un élément aléatoire { #a-random-item }
-
-Avec `data.items()` nous obtenons un <abbr title="Quelque chose que l’on peut itérer avec une boucle for, comme une liste, un set, etc.">objet itérable</abbr> avec des tuples contenant la clé et la valeur pour chaque élément du dictionnaire.
-
-Nous convertissons cet objet itérable en une `list` propre avec `list(data.items())`.
-
-Ensuite, avec `random.choice()` nous pouvons obtenir une **valeur aléatoire** depuis la liste, nous obtenons donc un tuple `(id, name)`. Ce sera quelque chose comme `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
-
-Puis nous **affectons ces deux valeurs** du tuple aux variables `id` et `name`.
-
-Ainsi, si l’utilisateur n’a pas fourni d’ID d’item, il recevra quand même une suggestion aléatoire.
-
-... nous faisons tout cela en **une seule ligne simple**. 🤯 Vous n’adorez pas Python ? 🐍
-
-{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
-
-## Récapitulatif { #recap }
-
-Vous pouvez déclarer des validations et des métadonnées supplémentaires pour vos paramètres.
-
-Validations et métadonnées génériques :
-
-- `alias`
-- `title`
-- `description`
-- `deprecated`
-
-Validations spécifiques aux chaînes :
-
-- `min_length`
-- `max_length`
-- `pattern`
-
-Validations personnalisées avec `AfterValidator`.
-
-Dans ces exemples, vous avez vu comment déclarer des validations pour des valeurs `str`.
-
-Voyez les prochains chapitres pour apprendre à déclarer des validations pour d’autres types, comme les nombres.
+Dans les prochains chapitres, vous verrez comment déclarer des validateurs pour d'autres types, comme les nombres.

docs/fr/docs/tutorial/query-params.md

@@ -1,10 +1,10 @@
-# Paramètres de requête { #query-parameters }
+# Paramètres de requête
 
-Quand vous déclarez d'autres paramètres de fonction qui ne font pas partie des paramètres de chemin, ils sont automatiquement interprétés comme des paramètres de « query ».
+Quand vous déclarez des paramètres dans votre fonction de chemin qui ne font pas partie des paramètres indiqués dans le chemin associé, ces paramètres sont automatiquement considérés comme des paramètres de "requête".
 
-{* ../../docs_src/query_params/tutorial001_py39.py hl[9] *}
+{* ../../docs_src/query_params/tutorial001.py hl[9] *}
 
-La query est l'ensemble des paires clé-valeur placées après le `?` dans une URL, séparées par des caractères `&`.
+La partie appelée requête (ou **query**) dans une URL est l'ensemble des paires clés-valeurs placées après le `?` , séparées par des `&`.
 
 Par exemple, dans l'URL :
 
@@ -12,27 +12,27 @@ Par exemple, dans l'URL :
 http://127.0.0.1:8000/items/?skip=0&limit=10
 ```
 
-... les paramètres de requête sont :
+...les paramètres de requête sont :
 
-* `skip` : avec une valeur de `0`
+* `skip` : avec une valeur de`0`
 * `limit` : avec une valeur de `10`
 
-Comme ils font partie de l'URL, ce sont « naturellement » des chaînes de caractères.
+Faisant partie de l'URL, ces valeurs sont des chaînes de caractères (`str`).
 
-Mais lorsque vous les déclarez avec des types Python (dans l'exemple ci-dessus, en tant que `int`), ils sont convertis vers ce type et validés par rapport à celui-ci.
+Mais quand on les déclare avec des types Python (dans l'exemple précédent, en tant qu'`int`), elles sont converties dans les types renseignés.
 
-Tous les mêmes processus qui s'appliquaient aux paramètres de chemin s'appliquent aussi aux paramètres de requête :
+Toutes les fonctionnalités qui s'appliquent aux paramètres de chemin s'appliquent aussi aux paramètres de requête :
 
-* Prise en charge de l'éditeur (évidemment)
-* <abbr title="conversion de la chaîne provenant d'une requête HTTP en données Python">« parsing »</abbr> des données
-* Validation des données
-* Documentation automatique
+* Support de l'éditeur : vérification d'erreurs, auto-complétion, etc.
+* <abbr title="conversion de la chaîne de caractères venant de la requête HTTP en données Python">"Parsing"</abbr> de données.
+* Validation de données.
+* Annotations d'API et documentation automatique.
 
-## Valeurs par défaut { #defaults }
+## Valeurs par défaut
 
-Comme les paramètres de requête ne sont pas une partie fixe d'un chemin, ils peuvent être optionnels et avoir des valeurs par défaut.
+Les paramètres de requête ne sont pas une partie fixe d'un chemin, ils peuvent être optionnels et avoir des valeurs par défaut.
 
-Dans l'exemple ci-dessus, ils ont des valeurs par défaut `skip=0` et `limit=10`.
+Dans l'exemple ci-dessus, ils ont des valeurs par défaut qui sont `skip=0` et `limit=10`.
 
 Donc, accéder à l'URL :
 
@@ -40,44 +40,52 @@ Donc, accéder à l'URL :
 http://127.0.0.1:8000/items/
 ```
 
-serait équivalent à accéder à :
+serait équivalent à accéder à l'URL :
 
 ```
 http://127.0.0.1:8000/items/?skip=0&limit=10
 ```
 
-Mais si vous accédez, par exemple, à :
+Mais si vous accédez à, par exemple :
 
 ```
 http://127.0.0.1:8000/items/?skip=20
 ```
 
-Les valeurs des paramètres dans votre fonction seront :
+Les valeurs des paramètres de votre fonction seront :
 
-* `skip=20` : car vous l'avez défini dans l'URL
-* `limit=10` : car c'était la valeur par défaut
+* `skip=20` : car c'est la valeur déclarée dans l'URL.
+* `limit=10` : car `limit` n'a pas été déclaré dans l'URL, et que la valeur par défaut était `10`.
 
-## Paramètres optionnels { #optional-parameters }
+## Paramètres optionnels
 
-De la même façon, vous pouvez déclarer des paramètres de requête optionnels, en définissant leur valeur par défaut à `None` :
+De la même façon, vous pouvez définir des paramètres de requête comme optionnels, en leur donnant comme valeur par défaut `None` :
 
-{* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
+{* ../../docs_src/query_params/tutorial002.py hl[9] *}
 
-Dans ce cas, le paramètre de fonction `q` sera optionnel et vaudra `None` par défaut.
+Ici, le paramètre `q` sera optionnel, et aura `None` comme valeur par défaut.
 
-/// check | Vérifications
+/// check | Remarque
 
-Notez également que FastAPI est suffisamment intelligent pour remarquer que le paramètre de chemin `item_id` est un paramètre de chemin et que `q` ne l'est pas, c'est donc un paramètre de requête.
+On peut voir que **FastAPI** est capable de détecter que le paramètre de chemin `item_id` est un paramètre de chemin et que `q` n'en est pas un, c'est donc un paramètre de requête.
 
 ///
 
-## Conversion des types des paramètres de requête { #query-parameter-type-conversion }
+/// note
 
-Vous pouvez aussi déclarer des types `bool`, ils seront convertis :
+**FastAPI** saura que `q` est optionnel grâce au `=None`.
 
-{* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
+Le `Optional` dans `Optional[str]` n'est pas utilisé par **FastAPI** (**FastAPI** n'en utilisera que la partie `str`), mais il servira tout de même à votre éditeur de texte pour détecter des erreurs dans votre code.
 
-Dans ce cas, si vous allez sur :
+///
+
+## Conversion des types des paramètres de requête
+
+Vous pouvez aussi déclarer des paramètres de requête comme booléens (`bool`), **FastAPI** les convertira :
+
+{* ../../docs_src/query_params/tutorial003.py hl[9] *}
+
+Avec ce code, en allant sur :
 
 ```
 http://127.0.0.1:8000/items/foo?short=1
@@ -107,61 +115,60 @@ ou
 http://127.0.0.1:8000/items/foo?short=yes
 ```
 
-ou n'importe quelle autre variation de casse (tout en majuscules, uniquement la première lettre en majuscule, etc.), votre fonction verra le paramètre `short` avec une valeur `bool` à `True`. Sinon la valeur sera à `False`.
+ou n'importe quelle autre variation de casse (tout en majuscules, uniquement la première lettre en majuscule, etc.), votre fonction considérera le paramètre `short` comme ayant une valeur booléenne à `True`. Sinon la valeur sera à `False`.
 
-## Multiples paramètres de chemin et de requête { #multiple-path-and-query-parameters }
+## Multiples paramètres de chemin et de requête
 
-Vous pouvez déclarer plusieurs paramètres de chemin et paramètres de requête en même temps, FastAPI sait lequel est lequel.
+Vous pouvez déclarer plusieurs paramètres de chemin et paramètres de requête dans la même fonction, **FastAPI** saura comment les gérer.
 
 Et vous n'avez pas besoin de les déclarer dans un ordre spécifique.
 
-Ils seront détectés par leur nom :
+Ils seront détectés par leurs noms :
 
-{* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
+{* ../../docs_src/query_params/tutorial004.py hl[8,10] *}
 
-## Paramètres de requête requis { #required-query-parameters }
+## Paramètres de requête requis
 
-Quand vous déclarez une valeur par défaut pour des paramètres qui ne sont pas des paramètres de chemin (pour l'instant, nous n'avons vu que les paramètres de requête), alors ils ne sont pas requis.
+Quand vous déclarez une valeur par défaut pour un paramètre qui n'est pas un paramètre de chemin (actuellement, nous n'avons vu que les paramètres de requête), alors ce paramètre n'est pas requis.
 
-Si vous ne voulez pas leur donner de valeur spécifique mais simplement les rendre optionnels, définissez la valeur par défaut à `None`.
+Si vous ne voulez pas leur donner de valeur par défaut mais juste les rendre optionnels, utilisez `None` comme valeur par défaut.
 
-Mais si vous voulez rendre un paramètre de requête obligatoire, vous pouvez simplement ne déclarer aucune valeur par défaut :
+Mais si vous voulez rendre un paramètre de requête obligatoire, vous pouvez juste ne pas y affecter de valeur par défaut :
 
-{* ../../docs_src/query_params/tutorial005_py39.py hl[6:7] *}
+{* ../../docs_src/query_params/tutorial005.py hl[6:7] *}
 
-Ici, le paramètre de requête `needy` est un paramètre de requête requis de type `str`.
+Ici le paramètre `needy` est un paramètre requis (ou obligatoire) de type `str`.
 
-Si vous ouvrez dans votre navigateur une URL comme :
+Si vous ouvrez une URL comme :
 
 ```
 http://127.0.0.1:8000/items/foo-item
 ```
 
-... sans ajouter le paramètre requis `needy`, vous verrez une erreur comme :
+...sans ajouter le paramètre requis `needy`, vous aurez une erreur :
 
 ```JSON
 {
-  "detail": [
-    {
-      "type": "missing",
-      "loc": [
-        "query",
-        "needy"
-      ],
-      "msg": "Field required",
-      "input": null
-    }
-  ]
+    "detail": [
+        {
+            "loc": [
+                "query",
+                "needy"
+            ],
+            "msg": "field required",
+            "type": "value_error.missing"
+        }
+    ]
 }
 ```
 
-Comme `needy` est un paramètre requis, vous devez le définir dans l'URL :
+La présence de `needy` étant nécessaire, vous auriez besoin de l'insérer dans l'URL :
 
 ```
 http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
 ```
 
-... cela fonctionnerait :
+...ce qui fonctionnerait :
 
 ```JSON
 {
@@ -170,18 +177,18 @@ http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
 }
 ```
 
-Et bien sûr, vous pouvez définir certains paramètres comme requis, certains avec une valeur par défaut et certains entièrement optionnels :
+Et bien sur, vous pouvez définir certains paramètres comme requis, certains avec des valeurs par défaut et certains entièrement optionnels :
 
-{* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
+{* ../../docs_src/query_params/tutorial006.py hl[10] *}
 
-Dans ce cas, il y a 3 paramètres de requête :
+Ici, on a donc 3 paramètres de requête :
 
-* `needy`, un `str` requis.
-* `skip`, un `int` avec une valeur par défaut de `0`.
+* `needy`, requis et de type `str`.
+* `skip`, un `int` avec comme valeur par défaut `0`.
 * `limit`, un `int` optionnel.
 
 /// tip | Astuce
 
-Vous pourriez aussi utiliser des `Enum`s de la même façon qu'avec les [Paramètres de chemin](path-params.md#predefined-values){.internal-link target=_blank}.
+Vous pouvez utiliser les `Enum`s de la même façon qu'avec les [Paramètres de chemin](path-params.md#valeurs-predefinies){.internal-link target=_blank}.
 
 ///

docs/ko/docs/advanced/advanced-dependencies.md

@@ -79,13 +79,13 @@ checker(q="somequery")
 
 ### `yield`와 `scope`가 있는 의존성 { #dependencies-with-yield-and-scope }
 
-0.121.0 버전에서 FastAPI는 `Depends(scope="function")` 지원을 추가했습니다.
+0.121.0 버전에서 FastAPI는 `yield`가 있는 의존성에 대해 `Depends(scope="function")` 지원을 추가했습니다.
 
 `Depends(scope="function")`를 사용하면, `yield` 이후의 종료 코드는 *경로 처리 함수*가 끝난 직후(클라이언트에 응답이 반환되기 전)에 실행됩니다.
 
 그리고 `Depends(scope="request")`(기본값)를 사용하면, `yield` 이후의 종료 코드는 응답이 전송된 후에 실행됩니다.
 
-자세한 내용은 [`yield`가 있는 의존성 - 조기 종료와 `scope`](../tutorial/dependencies/dependencies-with-yield.md#early-exit-and-scope) 문서를 참고하세요.
+자세한 내용은 [Dependencies with `yield` - Early exit and `scope`](../tutorial/dependencies/dependencies-with-yield.md#early-exit-and-scope) 문서를 참고하세요.
 
 ### `yield`가 있는 의존성과 `StreamingResponse`, 기술 세부사항 { #dependencies-with-yield-and-streamingresponse-technical-details }
 
@@ -133,7 +133,7 @@ SQLModel(또는 SQLAlchemy)을 사용하면서 이런 특정 사용 사례가
 
 그러면 세션이 데이터베이스 연결을 해제하여, 다른 요청들이 이를 사용할 수 있게 됩니다.
 
-`yield`가 있는 의존성에서 조기 종료가 필요한 다른 사용 사례가 있다면, 여러분의 구체적인 사용 사례와 `yield`가 있는 의존성에 대한 조기 종료가 어떤 점에서 이득이 되는지를 포함해 <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussions 질문</a>을 생성해 주세요.
+`yield`가 있는 의존성에서 조기 종료가 필요한 다른 사용 사례가 있다면, 여러분의 구체적인 사용 사례와 `yield`가 있는 의존성에 대한 조기 종료가 어떤 점에서 이득이 되는지를 포함해 <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussion Question</a>을 생성해 주세요.
 
 `yield`가 있는 의존성에서 조기 종료에 대한 설득력 있는 사용 사례가 있다면, 조기 종료를 선택적으로 활성화할 수 있는 새로운 방법을 추가하는 것을 고려하겠습니다.
 
@@ -145,7 +145,7 @@ FastAPI 0.110.0 이전에는 `yield`가 있는 의존성을 사용한 다음 그
 
 ### 백그라운드 태스크와 `yield`가 있는 의존성, 기술 세부사항 { #background-tasks-and-dependencies-with-yield-technical-details }
 
-FastAPI 0.106.0 이전에는 `yield` 이후에 예외를 발생시키는 것이 불가능했습니다. `yield`가 있는 의존성의 종료 코드는 응답이 전송된 *후에* 실행되었기 때문에, [예외 핸들러](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}가 이미 실행된 뒤였습니다.
+FastAPI 0.106.0 이전에는 `yield` 이후에 예외를 발생시키는 것이 불가능했습니다. `yield`가 있는 의존성의 종료 코드는 응답이 전송된 *후에* 실행되었기 때문에, [Exception Handlers](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank}가 이미 실행된 뒤였습니다.
 
 이는 주로 백그라운드 태스크 안에서 의존성이 "yield"한 동일한 객체들을 사용할 수 있게 하기 위한 설계였습니다. 백그라운드 태스크가 끝난 뒤에 종료 코드가 실행되었기 때문입니다.
 

docs/ko/docs/advanced/wsgi.md

@@ -1,48 +1,32 @@
-# WSGI 포함하기 - Flask, Django 등 { #including-wsgi-flask-django-others }
+# WSGI 포함하기 - Flask, Django 그 외 { #including-wsgi-flask-django-others }
 
-[서브 애플리케이션 - 마운트](sub-applications.md){.internal-link target=_blank}, [프록시 뒤에서](behind-a-proxy.md){.internal-link target=_blank}에서 본 것처럼 WSGI 애플리케이션을 마운트할 수 있습니다.
+[서브 응용 프로그램 - 마운트](sub-applications.md){.internal-link target=_blank}, [프록시 뒤편에서](behind-a-proxy.md){.internal-link target=_blank}에서 보았듯이 WSGI 응용 프로그램들을 마운트 할 수 있습니다.
 
-이를 위해 `WSGIMiddleware`를 사용해 WSGI 애플리케이션(예: Flask, Django 등)을 감쌀 수 있습니다.
+이를 위해 `WSGIMiddleware`를 사용해 WSGI 응용 프로그램(예: Flask, Django 등)을 감쌀 수 있습니다.
 
 ## `WSGIMiddleware` 사용하기 { #using-wsgimiddleware }
 
-/// info | 정보
+`WSGIMiddleware`를 불러와야 합니다.
 
-이를 사용하려면 `a2wsgi`를 설치해야 합니다. 예: `pip install a2wsgi`
+그런 다음, WSGI(예: Flask) 응용 프로그램을 미들웨어로 포장합니다.
 
-///
+그 후, 해당 경로에 마운트합니다.
 
-`a2wsgi`에서 `WSGIMiddleware`를 import 해야 합니다.
-
-그런 다음, WSGI(예: Flask) 애플리케이션을 미들웨어로 감쌉니다.
-
-그리고 해당 경로에 마운트합니다.
-
-{* ../../docs_src/wsgi/tutorial001_py39.py hl[1,3,23] *}
-
-/// note | 참고
-
-이전에 `fastapi.middleware.wsgi`의 `WSGIMiddleware` 사용을 권장했지만 이제는 더 이상 권장되지 않습니다.
-
-대신 `a2wsgi` 패키지 사용을 권장합니다. 사용 방법은 동일합니다.
-
-단, `a2wsgi` 패키지가 설치되어 있고 `a2wsgi`에서 `WSGIMiddleware`를 올바르게 import 하는지만 확인하세요.
-
-///
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
 ## 확인하기 { #check-it }
 
-이제 `/v1/` 경로에 있는 모든 요청은 Flask 애플리케이션에서 처리됩니다.
+이제 `/v1/` 경로에 있는 모든 요청은 Flask 응용 프로그램에서 처리됩니다.
 
 그리고 나머지는 **FastAPI**에 의해 처리됩니다.
 
-실행하고 <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a>로 이동하면 Flask의 응답을 볼 수 있습니다:
+실행하면 <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a>으로 이동해서 Flask의 응답을 볼 수 있습니다:
 
 ```txt
 Hello, World from Flask!
 ```
 
-그리고 <a href="http://localhost:8000/v2" class="external-link" target="_blank">http://localhost:8000/v2</a>로 이동하면 **FastAPI**의 응답을 볼 수 있습니다:
+그리고 다음으로 이동하면 <a href="http://localhost:8000/v2" class="external-link" target="_blank">http://localhost:8000/v2</a> **FastAPI**의 응답을 볼 수 있습니다:
 
 ```JSON
 {

docs/ko/docs/deployment/docker.md

@@ -145,6 +145,8 @@ Successfully installed fastapi pydantic
 * 다음 내용으로 `main.py` 파일을 만듭니다:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -156,7 +158,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -243,14 +245,14 @@ Docker 지시어 <a href="https://docs.docker.com/reference/dockerfile/#cmd" cla
 ✅ **Exec** form:
 
 ```Dockerfile
-# ✅ 이렇게 하세요
+# ✅ Do this
 CMD ["fastapi", "run", "app/main.py", "--port", "80"]
 ```
 
 ⛔️ **Shell** form:
 
 ```Dockerfile
-# ⛔️ 이렇게 하지 마세요
+# ⛔️ Don't do this
 CMD fastapi run app/main.py --port 80
 ```
 
@@ -454,7 +456,7 @@ Traefik은 Docker, Kubernetes 등과 통합되어 있어, 이를 사용해 컨
 
 ## 복제 - 프로세스 개수 { #replication-number-of-processes }
 
-**Kubernetes**, Docker Swarm Mode, Nomad 등의 복잡한 시스템으로 여러 머신에 분산된 컨테이너를 관리하는 <abbr title="어떤 방식으로 연결되어 함께 동작하도록 구성된 머신의 그룹">클러스터</abbr>를 사용한다면, 각 컨테이너에서(**워커를 사용하는 Uvicorn** 같은) **프로세스 매니저**를 쓰는 대신, **클러스터 레벨**에서 **복제를 처리**하고 싶을 가능성이 큽니다.
+**Kubernetes**, Docker Swarm Mode, Nomad 등의 복잡한 시스템으로 여러 머신에 분산된 컨테이너를 관리하는 <abbr title="A group of machines that are configured to be connected and work together in some way.">cluster</abbr>를 사용한다면, 각 컨테이너에서(**워커를 사용하는 Uvicorn** 같은) **프로세스 매니저**를 쓰는 대신, **클러스터 레벨**에서 **복제를 처리**하고 싶을 가능성이 큽니다.
 
 Kubernetes 같은 분산 컨테이너 관리 시스템은 보통 들어오는 요청에 대한 **로드 밸런싱**을 지원하면서도, **컨테이너 복제**를 처리하는 통합된 방법을 가지고 있습니다. 모두 **클러스터 레벨**에서요.
 
@@ -578,7 +580,7 @@ Kubernetes를 사용한다면, 이는 아마도 <a href="https://kubernetes.io/d
 
 그리고 여러 워커가 필요하다면, `--workers` 커맨드 라인 옵션을 간단히 사용하면 됩니다.
 
-/// note | 기술 세부사항
+/// note Technical Details | 기술 세부사항
 
 이 Docker 이미지는 Uvicorn이 죽은 워커를 관리하고 재시작하는 기능을 지원하지 않던 시기에 만들어졌습니다. 그래서 Gunicorn과 Uvicorn을 함께 사용해야 했고, Gunicorn이 Uvicorn 워커 프로세스를 관리하고 재시작하도록 하기 위해 상당한 복잡성이 추가되었습니다.
 

docs/ko/docs/index.md

@@ -40,7 +40,7 @@ FastAPI는 현대적이고, 빠르며(고성능), 파이썬 표준 타입 힌트
 * **빠름**: (Starlette과 Pydantic 덕분에) **NodeJS** 및 **Go**와 대등할 정도로 매우 높은 성능. [사용 가능한 가장 빠른 파이썬 프레임워크 중 하나](#performance).
 * **빠른 코드 작성**: 약 200%에서 300%까지 기능 개발 속도 증가. *
 * **적은 버그**: 사람(개발자)에 의한 에러 약 40% 감소. *
-* **직관적**: 훌륭한 편집기 지원. 모든 곳에서 <abbr title="다른 말로는: auto-complete, autocompletion, IntelliSense">자동완성</abbr>. 적은 디버깅 시간.
+* **직관적**: 훌륭한 편집기 지원. 모든 곳에서 <abbr title="also known as auto-complete, autocompletion, IntelliSense">자동완성</abbr>. 적은 디버깅 시간.
 * **쉬움**: 쉽게 사용하고 배우도록 설계. 적은 문서 읽기 시간.
 * **짧음**: 코드 중복 최소화. 각 매개변수 선언의 여러 기능. 적은 버그.
 * **견고함**: 준비된 프로덕션 용 코드를 얻으십시오. 자동 대화형 문서와 함께.
@@ -127,7 +127,7 @@ FastAPI는 현대적이고, 빠르며(고성능), 파이썬 표준 타입 힌트
 
 <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>
 
-웹 API 대신 터미널에서 사용할 <abbr title="Command Line Interface - 커맨드 라인 인터페이스">CLI</abbr> 앱을 만들고 있다면, <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>를 확인해 보십시오.
+웹 API 대신 터미널에서 사용할 <abbr title="Command Line Interface">CLI</abbr> 앱을 만들고 있다면, <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>를 확인해 보십시오.
 
 **Typer**는 FastAPI의 동생입니다. 그리고 **CLI를 위한 FastAPI**가 되기 위해 생겼습니다. ⌨️ 🚀
 
@@ -161,6 +161,8 @@ $ pip install "fastapi[standard]"
 다음 내용으로 `main.py` 파일을 만드십시오:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -172,7 +174,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -181,7 +183,9 @@ def read_item(item_id: int, q: str | None = None):
 
 여러분의 코드가 `async` / `await`을 사용한다면, `async def`를 사용하십시오:
 
-```Python hl_lines="7  12"
+```Python hl_lines="9  14"
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -193,7 +197,7 @@ async def read_root():
 
 
 @app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -284,7 +288,9 @@ INFO:     Application startup complete.
 
 Pydantic 덕분에 표준 Python 타입을 사용해 본문을 선언합니다.
 
-```Python hl_lines="2  7-10 23-25"
+```Python hl_lines="4  9-12  25-27"
+from typing import Union
+
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -294,7 +300,7 @@ app = FastAPI()
 class Item(BaseModel):
     name: str
     price: float
-    is_offer: bool | None = None
+    is_offer: Union[bool, None] = None
 
 
 @app.get("/")
@@ -303,7 +309,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 
 
@@ -368,7 +374,7 @@ item: Item
 * 데이터 검증:
     * 데이터가 유효하지 않을 때 자동으로 생성하는 명확한 에러.
     * 깊이 중첩된 JSON 객체에 대한 유효성 검사.
-* 입력 데이터 <abbr title="다른 말로는: serialization, parsing, marshalling">변환</abbr>: 네트워크에서 파이썬 데이터 및 타입으로 전송. 읽을 수 있는 것들:
+* 입력 데이터 <abbr title="also known as: serialization, parsing, marshalling">변환</abbr>: 네트워크에서 파이썬 데이터 및 타입으로 전송. 읽을 수 있는 것들:
     * JSON.
     * 경로 매개변수.
     * 쿼리 매개변수.
@@ -376,7 +382,7 @@ item: Item
     * 헤더.
     * 폼(Forms).
     * 파일.
-* 출력 데이터 <abbr title="다른 말로는: serialization, parsing, marshalling">변환</abbr>: 파이썬 데이터 및 타입을 네트워크 데이터로 전환(JSON 형식으로):
+* 출력 데이터 <abbr title="also known as: serialization, parsing, marshalling">변환</abbr>: 파이썬 데이터 및 타입을 네트워크 데이터로 전환(JSON 형식으로):
     * 파이썬 타입 변환 (`str`, `int`, `float`, `bool`, `list`, 등).
     * `datetime` 객체.
     * `UUID` 객체.
@@ -439,7 +445,7 @@ item: Item
 
 * 서로 다른 장소에서 **매개변수** 선언: **헤더**, **쿠키**, **폼 필드** 그리고 **파일**.
 * `maximum_length` 또는 `regex`처럼 **유효성 제약**하는 방법.
-* 강력하고 사용하기 쉬운 **<abbr title="다른 말로는: components, resources, providers, services, injectables">의존성 주입</abbr>** 시스템.
+* 강력하고 사용하기 쉬운 **<abbr title="also known as components, resources, providers, services, injectables">의존성 주입</abbr>** 시스템.
 * **OAuth2** 지원을 포함한 **JWT tokens** 및 **HTTP Basic**을 갖는 보안과 인증.
 * (Pydantic 덕분에) **깊은 중첩 JSON 모델**을 선언하는데 더 진보한 (하지만 마찬가지로 쉬운) 기술.
 * <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> 및 기타 라이브러리와의 **GraphQL** 통합.

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

@@ -102,16 +102,15 @@
 
 기본적으로 단일 값은 쿼리 매개변수로 해석되므로, 명시적으로 `Query`를 추가할 필요 없이 이렇게 하면 됩니다:
 
-```Python
-q: str | None = None
-```
-
-또는 Python 3.9에서는:
-
 ```Python
 q: Union[str, None] = None
 ```
 
+또는 Python 3.10 이상에서는:
+
+```Python
+q: str | None = None
+```
 
 예를 들어:
 

docs/ko/docs/tutorial/path-operation-configuration.md

@@ -52,11 +52,11 @@
 
 `summary`와 `description`을 추가할 수 있습니다:
 
-{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
 ## 독스트링으로 만든 설명 { #description-from-docstring }
 
-설명은 보통 길어지고 여러 줄에 걸쳐있기 때문에, *경로 처리* 설명을 함수 <abbr title="문서화에 사용되는 함수 내부 첫 표현식의 여러 줄 문자열(어떤 변수에도 할당되지 않음)">docstring</abbr>에 선언할 수 있으며, **FastAPI**는 그곳에서 이를 읽습니다.
+설명은 보통 길어지고 여러 줄에 걸쳐있기 때문에, *경로 처리* 설명을 함수 <abbr title="a multi-line string as the first expression inside a function (not assigned to any variable) used for documentation – 문서화에 사용되는 함수 내부 첫 표현식의 여러 줄 문자열(어떤 변수에도 할당되지 않음)">docstring</abbr>에 선언할 수 있으며, **FastAPI**는 그곳에서 이를 읽습니다.
 
 독스트링에는 <a href="https://en.wikipedia.org/wiki/Markdown" class="external-link" target="_blank">Markdown</a>을 작성할 수 있으며, (독스트링의 들여쓰기를 고려하여) 올바르게 해석되고 표시됩니다.
 
@@ -70,7 +70,7 @@
 
 `response_description` 매개변수로 응답에 관한 설명을 명시할 수 있습니다:
 
-{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
 /// info | 정보
 
@@ -90,7 +90,7 @@ OpenAPI는 각 *경로 처리*가 응답에 관한 설명을 요구할 것을
 
 ## *경로 처리* 지원중단하기 { #deprecate-a-path-operation }
 
-*경로 처리*를 제거하지 않고 <abbr title="구식이며 사용하지 않는 것이 권장됨">deprecated</abbr>로 표시해야 한다면, `deprecated` 매개변수를 전달하면 됩니다:
+*경로 처리*를 제거하지 않고 <abbr title="obsolete, recommended not to use it – 구식이며 사용하지 않는 것이 권장됨">deprecated</abbr>로 표시해야 한다면, `deprecated` 매개변수를 전달하면 됩니다:
 
 {* ../../docs_src/path_operation_configuration/tutorial006_py39.py hl[16] *}
 

docs/pt/docs/advanced/advanced-dependencies.md

@@ -148,7 +148,7 @@ Antes do FastAPI 0.106.0, lançar exceções após o `yield` não era possível,
 
 Isso foi projetado assim principalmente para permitir o uso dos mesmos objetos "yielded" por dependências dentro de tarefas em segundo plano, porque o código de saída seria executado depois que as tarefas em segundo plano fossem concluídas.
 
-Isso foi alterado no FastAPI 0.106.0 com a intenção de não manter recursos enquanto se espera a response percorrer a rede.
+Isso foi alterado no FastAPI 0.106.0 com a intenção de não manter recursos enquanto se espera a resposta percorrer a rede.
 
 /// tip | Dica
 

docs/pt/docs/advanced/wsgi.md

@@ -6,29 +6,13 @@ Para isso, você pode utilizar o `WSGIMiddleware` para encapsular a sua aplicaç
 
 ## Usando `WSGIMiddleware` { #using-wsgimiddleware }
 
-/// info | Informação
-
-Isso requer instalar `a2wsgi`, por exemplo com `pip install a2wsgi`.
-
-///
-
-Você precisa importar o `WSGIMiddleware` de `a2wsgi`.
+Você precisa importar o `WSGIMiddleware`.
 
 Em seguida, encapsule a aplicação WSGI (e.g. Flask) com o middleware.
 
 E então monte isso sob um path.
 
-{* ../../docs_src/wsgi/tutorial001_py39.py hl[1,3,23] *}
-
-/// note | Nota
-
-Anteriormente, recomendava-se usar `WSGIMiddleware` de `fastapi.middleware.wsgi`, mas agora está descontinuado.
-
-É aconselhável usar o pacote `a2wsgi` em seu lugar. O uso permanece o mesmo.
-
-Apenas certifique-se de que o pacote `a2wsgi` está instalado e importe `WSGIMiddleware` corretamente de `a2wsgi`.
-
-///
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
 ## Confira { #check-it }
 

docs/pt/docs/deployment/docker.md

@@ -145,6 +145,8 @@ Há outros formatos e ferramentas para definir e instalar dependências de pacot
 * Crie um arquivo `main.py` com:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -156,7 +158,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -570,7 +572,7 @@ Se você tiver uma configuração simples, com um **único contêiner** que ent
 
 ### Imagem Docker base { #base-docker-image }
 
-Antes havia uma imagem oficial do FastAPI para Docker: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi-docker</a>. Mas agora ela está descontinuada. ⛔️
+Antes havia uma imagem oficial do FastAPI para Docker: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Mas agora ela está descontinuada. ⛔️
 
 Você provavelmente **não** deve usar essa imagem base do Docker (ou qualquer outra semelhante).
 

docs/pt/docs/index.md

@@ -33,7 +33,7 @@
 
 ---
 
-FastAPI é um moderno e rápido (alta performance) framework web para construção de APIs com Python, baseado nos type hints padrões do Python.
+FastAPI é um moderno e rápido (alta performance) _framework web_ para construção de APIs com Python, baseado nos _type hints_ padrões do Python.
 
 Os recursos chave são:
 
@@ -161,6 +161,8 @@ $ pip install "fastapi[standard]"
 Crie um arquivo `main.py` com:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -172,7 +174,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -181,7 +183,9 @@ def read_item(item_id: int, q: str | None = None):
 
 Se seu código utiliza `async` / `await`, use `async def`:
 
-```Python hl_lines="7  12"
+```Python hl_lines="9  14"
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -193,7 +197,7 @@ async def read_root():
 
 
 @app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -284,7 +288,9 @@ Agora modifique o arquivo `main.py` para receber um corpo de uma requisição `P
 
 Declare o corpo utilizando tipos padrão Python, graças ao Pydantic.
 
-```Python hl_lines="2  7-10 23-25"
+```Python hl_lines="4  9-12  25-27"
+from typing import Union
+
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -294,7 +300,7 @@ app = FastAPI()
 class Item(BaseModel):
     name: str
     price: float
-    is_offer: bool | None = None
+    is_offer: Union[bool, None] = None
 
 
 @app.get("/")
@@ -303,7 +309,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 
 
@@ -405,7 +411,7 @@ Voltando ao código do exemplo anterior, **FastAPI** irá:
 * Documentar tudo com OpenAPI, que poderá ser usado por:
     * Sistemas de documentação interativos.
     * Sistemas de clientes de geração de código automáticos, para muitas linguagens.
-* Fornecer diretamente 2 interfaces web de documentação interativa.
+* Fornecer diretamente 2 interfaces _web_ de documentação interativa.
 
 ---
 
@@ -504,7 +510,7 @@ Siga os tutoriais do seu provedor de nuvem para implantar aplicações FastAPI c
 
 ## Performance { #performance }
 
-Testes de performance da Independent TechEmpower mostram aplicações **FastAPI** rodando sob 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">um dos frameworks Python mais rápidos disponíveis</a>, somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
+Testes de performance da _Independent TechEmpower_ mostram aplicações **FastAPI** rodando sob 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">um dos _frameworks_ Python mais rápidos disponíveis</a>, somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
 
 Para entender mais sobre isso, veja a seção <a href="https://fastapi.tiangolo.com/pt/benchmarks/" class="internal-link" target="_blank">Comparações</a>.
 
@@ -524,7 +530,7 @@ Utilizado pelo Starlette:
 
 * <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Obrigatório caso você queira utilizar o `TestClient`.
 * <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Obrigatório se você quer utilizar a configuração padrão de templates.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Obrigatório se você deseja suporte a <abbr title="convertendo a string que vem de uma requisição HTTP em dados Python">"parsing"</abbr> de formulário, com `request.form()`.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Obrigatório se você deseja suporte a <abbr title="converting the string that comes from an HTTP request into Python data - convertendo a string que vem de uma requisição HTTP em dados Python">"parsing"</abbr> de formulário, com `request.form()`.
 
 Utilizado pelo FastAPI:
 

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

@@ -101,13 +101,13 @@ Obviamente, você também pode declarar parâmetros de consulta assim que você
 Dado que, por padrão, valores singulares são interpretados como parâmetros de consulta, você não precisa explicitamente adicionar uma `Query`, você pode somente:
 
 ```Python
-q: str | None = None
+q: Union[str, None] = None
 ```
 
-Ou em Python 3.9:
+Ou como em Python 3.10 e versões superiores:
 
 ```Python
-q: Union[str, None] = None
+q: str | None = None
 ```
 
 Por exemplo:

docs/pt/docs/tutorial/path-operation-configuration.md

@@ -52,7 +52,7 @@ Nestes casos, pode fazer sentido armazenar as tags em um `Enum`.
 
 Você pode adicionar um `summary` e uma `description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
 ## Descrição do docstring { #description-from-docstring }
 
@@ -70,7 +70,7 @@ Ela será usada nas documentações interativas:
 
 Você pode especificar a descrição da resposta com o parâmetro `response_description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
 /// info | Informação
 

docs/ru/docs/advanced/advanced-dependencies.md

@@ -48,7 +48,7 @@
 checker(q="somequery")
 ```
 
-…и передаст возвращённое значение как значение зависимости в параметр `fixed_content_included` нашей *функции-обработчика пути*:
+…и передаст возвращённое значение как значение зависимости в нашу *функцию-обработчике пути* в параметр `fixed_content_included`:
 
 {* ../../docs_src/dependencies/tutorial011_an_py39.py hl[22] *}
 

docs/ru/docs/advanced/wsgi.md

@@ -6,29 +6,13 @@
 
 ## Использование `WSGIMiddleware` { #using-wsgimiddleware }
 
-/// info | Информация
-
-Для этого требуется установить `a2wsgi`, например с помощью `pip install a2wsgi`.
-
-///
-
-Нужно импортировать `WSGIMiddleware` из `a2wsgi`.
+Нужно импортировать `WSGIMiddleware`.
 
 Затем оберните WSGI‑приложение (например, Flask) в middleware (Промежуточный слой).
 
 После этого смонтируйте его на путь.
 
-{* ../../docs_src/wsgi/tutorial001_py39.py hl[1,3,23] *}
-
-/// note | Примечание
-
-Ранее рекомендовалось использовать `WSGIMiddleware` из `fastapi.middleware.wsgi`, но теперь он помечен как устаревший.
-
-Вместо него рекомендуется использовать пакет `a2wsgi`. Использование остаётся таким же.
-
-Просто убедитесь, что пакет `a2wsgi` установлен, и импортируйте `WSGIMiddleware` из `a2wsgi`.
-
-///
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
 ## Проверьте { #check-it }
 

docs/ru/docs/deployment/docker.md

@@ -145,6 +145,8 @@ Successfully installed fastapi pydantic
 * Создайте файл `main.py` со следующим содержимым:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -156,7 +158,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 

docs/ru/docs/index.md

@@ -161,6 +161,8 @@ $ pip install "fastapi[standard]"
 Создайте файл `main.py` со следующим содержимым:
 
 ```Python
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -172,7 +174,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -181,7 +183,9 @@ def read_item(item_id: int, q: str | None = None):
 
 Если ваш код использует `async` / `await`, используйте `async def`:
 
-```Python hl_lines="7  12"
+```Python hl_lines="9  14"
+from typing import Union
+
 from fastapi import FastAPI
 
 app = FastAPI()
@@ -193,7 +197,7 @@ async def read_root():
 
 
 @app.get("/items/{item_id}")
-async def read_item(item_id: int, q: str | None = None):
+async def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 ```
 
@@ -284,7 +288,9 @@ INFO:     Application startup complete.
 
 Объявите тело запроса, используя стандартные типы Python, спасибо Pydantic.
 
-```Python hl_lines="2  7-10 23-25"
+```Python hl_lines="4  9-12  25-27"
+from typing import Union
+
 from fastapi import FastAPI
 from pydantic import BaseModel
 
@@ -294,7 +300,7 @@ app = FastAPI()
 class Item(BaseModel):
     name: str
     price: float
-    is_offer: bool | None = None
+    is_offer: Union[bool, None] = None
 
 
 @app.get("/")
@@ -303,7 +309,7 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: str | None = None):
+def read_item(item_id: int, q: Union[str, None] = None):
     return {"item_id": item_id, "q": q}
 
 

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

@@ -101,13 +101,13 @@
 Поскольку по умолчанию, отдельные значения интерпретируются как query-параметры, вам не нужно явно добавлять `Query`, вы можете просто сделать так:
 
 ```Python
-q: str | None = None
+q: Union[str, None] = None
 ```
 
-Или в Python 3.9:
+Или в Python 3.10 и выше:
 
 ```Python
-q: Union[str, None] = None
+q: str | None = None
 ```
 
 Например:
@@ -116,7 +116,7 @@ q: Union[str, None] = None
 
 /// info | Информация
 
-`Body` также имеет все те же дополнительные параметры валидации и метаданных, как у `Query`, `Path` и других, которые вы увидите позже.
+`Body` также имеет все те же дополнительные параметры валидации и метаданных, как у `Query`,`Path` и других, которые вы увидите позже.
 
 ///
 

docs/ru/docs/tutorial/path-operation-configuration.md

@@ -52,7 +52,7 @@
 
 Вы можете добавить параметры `summary` и `description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[17:18] *}
+{* ../../docs_src/path_operation_configuration/tutorial003_py310.py hl[18:19] *}
 
 ## Описание из строк документации { #description-from-docstring }
 
@@ -70,7 +70,7 @@
 
 Вы можете указать описание ответа с помощью параметра `response_description`:
 
-{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[18] *}
+{* ../../docs_src/path_operation_configuration/tutorial005_py310.py hl[19] *}
 
 /// info | Дополнительная информация
 
@@ -78,7 +78,7 @@
 
 ///
 
-/// check | Проверка
+/// check
 
 OpenAPI указывает, что каждой *операции пути* необходимо описание ответа.
 

docs/tr/docs/_llm-test.md

@@ -1,503 +0,0 @@
-# LLM test dosyası { #llm-test-file }
-
-Bu doküman, dokümantasyonu çeviren <abbr title="Large Language Model - Büyük Dil Modeli">LLM</abbr>'nin `scripts/translate.py` içindeki `general_prompt`'u ve `docs/{language code}/llm-prompt.md` içindeki dile özel prompt'u anlayıp anlamadığını test eder. Dile özel prompt, `general_prompt`'a eklenir.
-
-Buraya eklenen testler, dile özel prompt'ları tasarlayan herkes tarafından görülecektir.
-
-Şu şekilde kullanın:
-
-* Dile özel bir prompt bulundurun: `docs/{language code}/llm-prompt.md`.
-* Bu dokümanın hedeflediğiniz dile sıfırdan yeni bir çevirisini yapın (örneğin `translate.py` içindeki `translate-page` komutu). Bu, çeviriyi `docs/{language code}/docs/_llm-test.md` altında oluşturur.
-* Çeviride her şeyin yolunda olup olmadığını kontrol edin.
-* Gerekirse dile özel prompt'u, genel prompt'u veya İngilizce dokümanı iyileştirin.
-* Ardından çeviride kalan sorunları elle düzeltin; böylece iyi bir çeviri elde edin.
-* İyi çeviri yerindeyken yeniden çeviri yapın. İdeal sonuç, LLM'nin artık çeviride hiçbir değişiklik yapmamasıdır. Bu da genel prompt'un ve dile özel prompt'un olabilecek en iyi hâle geldiği anlamına gelir (bazen rastgele gibi görünen birkaç değişiklik yapabilir; çünkü <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">LLM'ler deterministik algoritmalar değildir</a>).
-
-Testler:
-
-## Code snippets { #code-snippets }
-
-//// tab | Test
-
-Bu bir code snippet: `foo`. Bu da başka bir code snippet: `bar`. Bir tane daha: `baz quux`.
-
-////
-
-//// tab | Bilgi
-
-Code snippet'lerin içeriği olduğu gibi bırakılmalıdır.
-
-`script/translate.py` içindeki genel prompt'ta `### Content of code snippets` bölümüne bakın.
-
-////
-
-## Alıntılar { #quotes }
-
-//// tab | Test
-
-Dün bir arkadaşım şunu yazdı: "If you spell incorrectly correctly, you have spelled it incorrectly". Ben de şunu yanıtladım: "Correct, but 'incorrectly' is incorrectly not '"incorrectly"'".
-
-/// note | Not
-
-LLM muhtemelen bunu yanlış çevirecektir. Yeniden çeviri yapıldığında düzeltilmiş çeviriyi koruyup korumadığı önemlidir.
-
-///
-
-////
-
-//// tab | Bilgi
-
-Prompt tasarlayan kişi, düz tırnakları tipografik tırnaklara dönüştürüp dönüştürmemeyi seçebilir. Olduğu gibi bırakmak da uygundur.
-
-Örneğin `docs/de/llm-prompt.md` içindeki `### Quotes` bölümüne bakın.
-
-////
-
-## Code snippet'lerde alıntılar { #quotes-in-code-snippets }
-
-//// tab | Test
-
-`pip install "foo[bar]"`
-
-Code snippet'lerde string literal örnekleri: `"this"`, `'that'`.
-
-Code snippet'lerde string literal için zor bir örnek: `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 | Bilgi
-
-... Ancak code snippet'lerin içindeki tırnaklar olduğu gibi kalmalıdır.
-
-////
-
-## Code block'lar { #code-blocks }
-
-//// tab | Test
-
-Bir Bash code örneği...
-
-```bash
-# Evrene bir selam yazdır
-echo "Hello universe"
-```
-
-...ve bir console code örneği...
-
-```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
-```
-
-...ve bir başka console code örneği...
-
-```console
-// "Code" adında bir dizin oluştur
-$ mkdir code
-// O dizine geç
-$ cd code
-```
-
-...ve bir Python code örneği...
-
-```Python
-wont_work()  # This won't work 😱
-works(foo="bar")  # This works 🎉
-```
-
-...ve hepsi bu.
-
-////
-
-//// tab | Bilgi
-
-Code block'ların içindeki code değiştirilmemelidir; tek istisna yorumlardır (comments).
-
-`script/translate.py` içindeki genel prompt'ta `### Content of code blocks` bölümüne bakın.
-
-////
-
-## Sekmeler ve renkli kutular { #tabs-and-colored-boxes }
-
-//// tab | Test
-
-/// info | Bilgi
-Some text
-///
-
-/// note | Not
-Some text
-///
-
-/// note | Teknik Detaylar
-Some text
-///
-
-/// check | Ek bilgi
-Some text
-///
-
-/// tip | İpucu
-Some text
-///
-
-/// warning | Uyarı
-Some text
-///
-
-/// danger | Tehlike
-Some text
-///
-
-////
-
-//// tab | Bilgi
-
-Sekmelerin ve `Info`/`Note`/`Warning`/vb. blokların başlığı, dikey çizgiden (`|`) sonra çeviri olarak eklenmelidir.
-
-`script/translate.py` içindeki genel prompt'ta `### Special blocks` ve `### Tab blocks` bölümlerine bakın.
-
-////
-
-## Web ve internal link'ler { #web-and-internal-links }
-
-//// tab | Test
-
-Link metni çevrilmelidir, link adresi değişmeden kalmalıdır:
-
-* [Yukarıdaki başlığa link](#code-snippets)
-* [Internal link](index.md#installation){.internal-link target=_blank}
-* <a href="https://sqlmodel.tiangolo.com/" class="external-link" target="_blank">External link</a>
-* <a href="https://fastapi.tiangolo.com/css/styles.css" class="external-link" target="_blank">Link to a style</a>
-* <a href="https://fastapi.tiangolo.com/js/logic.js" class="external-link" target="_blank">Link to a script</a>
-* <a href="https://fastapi.tiangolo.com/img/foo.jpg" class="external-link" target="_blank">Link to an image</a>
-
-Link metni çevrilmelidir, link adresi çeviriye işaret etmelidir:
-
-* <a href="https://fastapi.tiangolo.com/tr/" class="external-link" target="_blank">FastAPI link</a>
-
-////
-
-//// tab | Bilgi
-
-Link'ler çevrilmelidir, ancak adresleri değişmeden kalmalıdır. Bir istisna, FastAPI dokümantasyonunun sayfalarına verilen mutlak link'lerdir. Bu durumda link, çeviriye işaret etmelidir.
-
-`script/translate.py` içindeki genel prompt'ta `### Links` bölümüne bakın.
-
-////
-
-## HTML "abbr" öğeleri { #html-abbr-elements }
-
-//// tab | Test
-
-Burada HTML "abbr" öğeleriyle sarılmış bazı şeyler var (bazıları uydurma):
-
-### abbr tam bir ifade verir { #the-abbr-gives-a-full-phrase }
-
-* <abbr title="Getting Things Done - İşleri Bitirme">GTD</abbr>
-* <abbr title="less than - küçüktür"><code>lt</code></abbr>
-* <abbr title="XML Web Token - XML Web Token">XWT</abbr>
-* <abbr title="Parallel Server Gateway Interface - Paralel Sunucu Gateway Interface">PSGI</abbr>
-
-### abbr bir açıklama verir { #the-abbr-gives-an-explanation }
-
-* <abbr title="Bir şekilde birbirine bağlanacak ve birlikte çalışacak şekilde yapılandırılmış makinelerden oluşan bir grup.">cluster</abbr>
-* <abbr title="Girdi ve çıktı katmanları arasında çok sayıda gizli katman içeren yapay sinir ağlarını kullanan; böylece kapsamlı bir iç yapı geliştiren bir machine learning yöntemi">Deep Learning</abbr>
-
-### abbr tam bir ifade ve bir açıklama verir { #the-abbr-gives-a-full-phrase-and-an-explanation }
-
-* <abbr title="Mozilla Developer Network - Mozilla Geliştirici Ağı: Firefox ekibi tarafından yazılmış, geliştiricilere yönelik dokümantasyon">MDN</abbr>
-* <abbr title="Input/Output - Girdi/Çıktı: disk okuma ya da yazma, ağ iletişimi.">I/O</abbr>.
-
-////
-
-//// tab | Bilgi
-
-"abbr" öğelerinin "title" attribute'ları belirli talimatlara göre çevrilir.
-
-Çeviriler, LLM'nin kaldırmaması gereken kendi "abbr" öğelerini ekleyebilir. Örneğin İngilizce kelimeleri açıklamak için.
-
-`script/translate.py` içindeki genel prompt'ta `### HTML abbr elements` bölümüne bakın.
-
-////
-
-## Başlıklar { #headings }
-
-//// tab | Test
-
-### Bir web uygulaması geliştirin - bir öğretici { #develop-a-webapp-a-tutorial }
-
-Merhaba.
-
-### Type hint'ler ve -annotation'lar { #type-hints-and-annotations }
-
-Tekrar merhaba.
-
-### Super- ve subclass'lar { #super-and-subclasses }
-
-Tekrar merhaba.
-
-////
-
-//// tab | Bilgi
-
-Başlıklarla ilgili tek katı kural, LLM'nin süslü parantezler içindeki hash kısmını değiştirmemesidir; böylece link'ler bozulmaz.
-
-`script/translate.py` içindeki genel prompt'ta `### Headings` bölümüne bakın.
-
-Dile özel bazı talimatlar için örneğin `docs/de/llm-prompt.md` içindeki `### Headings` bölümüne bakın.
-
-////
-
-## Dokümanlarda kullanılan terimler { #terms-used-in-the-docs }
-
-//// tab | Test
-
-* siz
-* sizin
-
-* örn.
-* vb.
-
-* `foo` bir `int` olarak
-* `bar` bir `str` olarak
-* `baz` bir `list` olarak
-
-* Tutorial - Kullanıcı kılavuzu
-* İleri Düzey Kullanıcı Kılavuzu
-* SQLModel dokümanları
-* API dokümanları
-* otomatik dokümanlar
-
-* Veri Bilimi
-* Deep Learning
-* Machine Learning
-* Dependency Injection
-* HTTP Basic authentication
-* HTTP Digest
-* ISO formatı
-* JSON Schema standardı
-* JSON schema
-* schema tanımı
-* Password Flow
-* Mobil
-
-* deprecated
-* designed
-* invalid
-* on the fly
-* standard
-* default
-* case-sensitive
-* case-insensitive
-
-* uygulamayı serve etmek
-* sayfayı serve etmek
-
-* app
-* application
-
-* request
-* response
-* error response
-
-* path operation
-* path operation decorator
-* path operation function
-
-* body
-* request body
-* response body
-* JSON body
-* form body
-* file body
-* function body
-
-* parameter
-* body parameter
-* path parameter
-* query parameter
-* cookie parameter
-* header parameter
-* form parameter
-* function parameter
-
-* event
-* startup event
-* server'ın startup'ı
-* shutdown event
-* lifespan event
-
-* handler
-* event handler
-* exception handler
-* handle etmek
-
-* model
-* Pydantic model
-* data model
-* database model
-* form model
-* model object
-
-* class
-* base class
-* parent class
-* subclass
-* child class
-* sibling class
-* class method
-
-* header
-* headers
-* authorization header
-* `Authorization` header
-* forwarded header
-
-* dependency injection system
-* dependency
-* dependable
-* dependant
-
-* I/O bound
-* CPU bound
-* concurrency
-* parallelism
-* multiprocessing
-
-* env var
-* environment variable
-* `PATH`
-* `PATH` variable
-
-* authentication
-* authentication provider
-* authorization
-* authorization form
-* authorization provider
-* kullanıcı authenticate olur
-* sistem kullanıcıyı authenticate eder
-
-* CLI
-* command line interface
-
-* server
-* client
-
-* cloud provider
-* cloud service
-
-* geliştirme
-* geliştirme aşamaları
-
-* dict
-* dictionary
-* enumeration
-* enum
-* enum member
-
-* encoder
-* decoder
-* encode etmek
-* decode etmek
-
-* exception
-* raise etmek
-
-* expression
-* statement
-
-* frontend
-* backend
-
-* GitHub discussion
-* GitHub issue
-
-* performance
-* performance optimization
-
-* return type
-* return value
-
-* security
-* security scheme
-
-* task
-* background task
-* task function
-
-* template
-* template engine
-
-* type annotation
-* type hint
-
-* server worker
-* Uvicorn worker
-* Gunicorn Worker
-* worker process
-* worker class
-* workload
-
-* deployment
-* deploy etmek
-
-* SDK
-* software development kit
-
-* `APIRouter`
-* `requirements.txt`
-* Bearer Token
-* breaking change
-* bug
-* button
-* callable
-* code
-* commit
-* context manager
-* coroutine
-* database session
-* disk
-* domain
-* engine
-* fake X
-* HTTP GET method
-* item
-* library
-* lifespan
-* lock
-* middleware
-* mobile application
-* module
-* mounting
-* network
-* origin
-* override
-* payload
-* processor
-* property
-* proxy
-* pull request
-* query
-* RAM
-* remote machine
-* status code
-* string
-* tag
-* web framework
-* wildcard
-* return etmek
-* validate etmek
-
-////
-
-//// tab | Bilgi
-
-Bu, dokümanlarda görülen (çoğunlukla) teknik terimlerin eksiksiz ve normatif olmayan bir listesidir. Prompt tasarlayan kişi için, LLM'nin hangi terimlerde desteğe ihtiyaç duyduğunu anlamada yardımcı olabilir. Örneğin iyi bir çeviriyi sürekli daha zayıf bir çeviriye geri alıyorsa. Ya da sizin dilinizde bir terimi çekimlemekte (conjugating/declinating) zorlanıyorsa.
-
-Örneğin `docs/de/llm-prompt.md` içindeki `### List of English terms and their preferred German translations` bölümüne bakın.
-
-////

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

@@ -1,247 +0,0 @@
-# OpenAPI'de Ek Response'lar { #additional-responses-in-openapi }
-
-/// warning | Uyarı
-
-Bu konu oldukça ileri seviye bir konudur.
-
-**FastAPI**'ye yeni başlıyorsanız buna ihtiyaç duymayabilirsiniz.
-
-///
-
-Ek status code'lar, media type'lar, açıklamalar vb. ile ek response'lar tanımlayabilirsiniz.
-
-Bu ek response'lar OpenAPI şemasına dahil edilir; dolayısıyla API dokümanlarında da görünürler.
-
-Ancak bu ek response'lar için, status code'unuzu ve içeriğinizi vererek `JSONResponse` gibi bir `Response`'u doğrudan döndürdüğünüzden emin olmanız gerekir.
-
-## `model` ile Ek Response { #additional-response-with-model }
-
-*Path operation decorator*'larınıza `responses` adlı bir parametre geçebilirsiniz.
-
-Bu parametre bir `dict` alır: anahtarlar her response için status code'lardır (`200` gibi), değerler ise her birine ait bilgileri içeren başka `dict`'lerdir.
-
-Bu response `dict`'lerinin her birinde, `response_model`'e benzer şekilde bir Pydantic model içeren `model` anahtarı olabilir.
-
-**FastAPI** bu modeli alır, JSON Schema'sını üretir ve OpenAPI'de doğru yere ekler.
-
-Örneğin, `404` status code'u ve `Message` Pydantic model'i ile başka bir response tanımlamak için şunu yazabilirsiniz:
-
-{* ../../docs_src/additional_responses/tutorial001_py39.py hl[18,22] *}
-
-/// note | Not
-
-`JSONResponse`'u doğrudan döndürmeniz gerektiğini unutmayın.
-
-///
-
-/// info | Bilgi
-
-`model` anahtarı OpenAPI'nin bir parçası değildir.
-
-**FastAPI** buradaki Pydantic model'i alır, JSON Schema'yı üretir ve doğru yere yerleştirir.
-
-Doğru yer şurasıdır:
-
-* Değeri başka bir JSON nesnesi (`dict`) olan `content` anahtarının içinde:
-    * Media type anahtarı (örn. `application/json`) bulunur; bunun değeri başka bir JSON nesnesidir ve onun içinde:
-        * Değeri model'den gelen JSON Schema olan `schema` anahtarı vardır; doğru yer burasıdır.
-            * **FastAPI** bunu doğrudan gömmek yerine OpenAPI'deki başka bir yerde bulunan global JSON Schema'lara bir referans ekler. Böylece diğer uygulamalar ve client'lar bu JSON Schema'ları doğrudan kullanabilir, daha iyi code generation araçları sağlayabilir, vb.
-
-///
-
-Bu *path operation* için OpenAPI'de üretilen response'lar şöyle olur:
-
-```JSON hl_lines="3-12"
-{
-    "responses": {
-        "404": {
-            "description": "Additional Response",
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "$ref": "#/components/schemas/Message"
-                    }
-                }
-            }
-        },
-        "200": {
-            "description": "Successful Response",
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "$ref": "#/components/schemas/Item"
-                    }
-                }
-            }
-        },
-        "422": {
-            "description": "Validation Error",
-            "content": {
-                "application/json": {
-                    "schema": {
-                        "$ref": "#/components/schemas/HTTPValidationError"
-                    }
-                }
-            }
-        }
-    }
-}
-```
-
-Schema'lar OpenAPI şemasının içinde başka bir yere referanslanır:
-
-```JSON hl_lines="4-16"
-{
-    "components": {
-        "schemas": {
-            "Message": {
-                "title": "Message",
-                "required": [
-                    "message"
-                ],
-                "type": "object",
-                "properties": {
-                    "message": {
-                        "title": "Message",
-                        "type": "string"
-                    }
-                }
-            },
-            "Item": {
-                "title": "Item",
-                "required": [
-                    "id",
-                    "value"
-                ],
-                "type": "object",
-                "properties": {
-                    "id": {
-                        "title": "Id",
-                        "type": "string"
-                    },
-                    "value": {
-                        "title": "Value",
-                        "type": "string"
-                    }
-                }
-            },
-            "ValidationError": {
-                "title": "ValidationError",
-                "required": [
-                    "loc",
-                    "msg",
-                    "type"
-                ],
-                "type": "object",
-                "properties": {
-                    "loc": {
-                        "title": "Location",
-                        "type": "array",
-                        "items": {
-                            "type": "string"
-                        }
-                    },
-                    "msg": {
-                        "title": "Message",
-                        "type": "string"
-                    },
-                    "type": {
-                        "title": "Error Type",
-                        "type": "string"
-                    }
-                }
-            },
-            "HTTPValidationError": {
-                "title": "HTTPValidationError",
-                "type": "object",
-                "properties": {
-                    "detail": {
-                        "title": "Detail",
-                        "type": "array",
-                        "items": {
-                            "$ref": "#/components/schemas/ValidationError"
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-```
-
-## Ana Response İçin Ek Media Type'lar { #additional-media-types-for-the-main-response }
-
-Aynı `responses` parametresini, aynı ana response için farklı media type'lar eklemek amacıyla da kullanabilirsiniz.
-
-Örneğin, `image/png` için ek bir media type ekleyerek, *path operation*'ınızın bir JSON nesnesi (media type `application/json`) ya da bir PNG görseli döndürebildiğini belirtebilirsiniz:
-
-{* ../../docs_src/additional_responses/tutorial002_py310.py hl[17:22,26] *}
-
-/// note | Not
-
-Görseli `FileResponse` kullanarak doğrudan döndürmeniz gerektiğine dikkat edin.
-
-///
-
-/// info | Bilgi
-
-`responses` parametrenizde açıkça farklı bir media type belirtmediğiniz sürece FastAPI, response'un ana response class'ı ile aynı media type'a sahip olduğunu varsayar (varsayılan `application/json`).
-
-Ancak media type'ı `None` olan özel bir response class belirttiyseniz, FastAPI ilişkili bir model'i olan tüm ek response'lar için `application/json` kullanır.
-
-///
-
-## Bilgileri Birleştirme { #combining-information }
-
-`response_model`, `status_code` ve `responses` parametreleri dahil olmak üzere, response bilgilerini birden fazla yerden birleştirebilirsiniz.
-
-Varsayılan `200` status code'unu (ya da gerekiyorsa özel bir tane) kullanarak bir `response_model` tanımlayabilir, ardından aynı response için ek bilgileri `responses` içinde, doğrudan OpenAPI şemasına ekleyebilirsiniz.
-
-**FastAPI**, `responses` içindeki ek bilgileri korur ve model'inizin JSON Schema'sı ile birleştirir.
-
-Örneğin, Pydantic model kullanan ve özel bir `description` içeren `404` status code'lu bir response tanımlayabilirsiniz.
-
-Ayrıca `response_model`'inizi kullanan, ancak özel bir `example` içeren `200` status code'lu bir response da tanımlayabilirsiniz:
-
-{* ../../docs_src/additional_responses/tutorial003_py39.py hl[20:31] *}
-
-Bunların hepsi OpenAPI'nize birleştirilerek dahil edilir ve API dokümanlarında gösterilir:
-
-<img src="/img/tutorial/additional-responses/image01.png">
-
-## Ön Tanımlı Response'ları Özel Olanlarla Birleştirme { #combine-predefined-responses-and-custom-ones }
-
-Birçok *path operation* için geçerli olacak bazı ön tanımlı response'larınız olabilir; ancak bunları her *path operation*'ın ihtiyaç duyduğu özel response'larla birleştirmek isteyebilirsiniz.
-
-Bu durumlarda, Python'daki bir `dict`'i `**dict_to_unpack` ile "unpacking" tekniğini kullanabilirsiniz:
-
-```Python
-old_dict = {
-    "old key": "old value",
-    "second old key": "second old value",
-}
-new_dict = {**old_dict, "new key": "new value"}
-```
-
-Burada `new_dict`, `old_dict` içindeki tüm key-value çiftlerini ve buna ek olarak yeni key-value çiftini içerir:
-
-```Python
-{
-    "old key": "old value",
-    "second old key": "second old value",
-    "new key": "new value",
-}
-```
-
-Bu tekniği, *path operation*'larınızda bazı ön tanımlı response'ları yeniden kullanmak ve bunları ek özel response'larla birleştirmek için kullanabilirsiniz.
-
-Örneğin:
-
-{* ../../docs_src/additional_responses/tutorial004_py310.py hl[11:15,24] *}
-
-## OpenAPI Response'ları Hakkında Daha Fazla Bilgi { #more-information-about-openapi-responses }
-
-Response'ların içine tam olarak neleri dahil edebileceğinizi görmek için OpenAPI spesifikasyonundaki şu bölümlere bakabilirsiniz:
-
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#responses-object" class="external-link" target="_blank">OpenAPI Responses Object</a>, `Response Object`'i içerir.
-* <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#response-object" class="external-link" target="_blank">OpenAPI Response Object</a>, buradaki her şeyi `responses` parametreniz içinde, her bir response'un içine doğrudan ekleyebilirsiniz. Buna `description`, `headers`, `content` (bunun içinde farklı media type'lar ve JSON Schema'lar tanımlarsınız) ve `links` dahildir.

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

@@ -1,41 +0,0 @@
-# Ek Status Code'ları { #additional-status-codes }
-
-Varsayılan olarak **FastAPI**, response'ları bir `JSONResponse` kullanarak döndürür; *path operation*'ınızdan döndürdüğünüz içeriği bu `JSONResponse`'un içine yerleştirir.
-
-Varsayılan status code'u veya *path operation* içinde sizin belirlediğiniz status code'u kullanır.
-
-## Ek status code'ları { #additional-status-codes_1 }
-
-Ana status code'a ek olarak başka status code'lar da döndürmek istiyorsanız, `JSONResponse` gibi bir `Response`'u doğrudan döndürerek bunu yapabilirsiniz ve ek status code'u doğrudan orada ayarlarsınız.
-
-Örneğin, item'ları güncellemeye izin veren bir *path operation*'ınız olduğunu düşünelim; başarılı olduğunda 200 "OK" HTTP status code'unu döndürüyor olsun.
-
-Ancak yeni item'ları da kabul etmesini istiyorsunuz. Ve item daha önce yoksa, onu oluşturup 201 "Created" HTTP status code'unu döndürsün.
-
-Bunu yapmak için `JSONResponse` import edin ve içeriğinizi doğrudan onunla döndürün; istediğiniz `status_code`'u da ayarlayın:
-
-{* ../../docs_src/additional_status_codes/tutorial001_an_py310.py hl[4,25] *}
-
-/// warning | Uyarı
-
-Yukarıdaki örnekte olduğu gibi bir `Response`'u doğrudan döndürdüğünüzde, response aynen olduğu gibi döndürülür.
-
-Bir model ile serialize edilmez, vb.
-
-İçinde olmasını istediğiniz veriyi taşıdığından emin olun ve değerlerin geçerli JSON olduğundan emin olun (eğer `JSONResponse` kullanıyorsanız).
-
-///
-
-/// note | Teknik Detaylar
-
-`from starlette.responses import JSONResponse` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici olarak size kolaylık olsun diye `starlette.responses` içindekileri `fastapi.responses` altında da sunar. Ancak mevcut response'ların çoğu doğrudan Starlette'ten gelir. `status` için de aynı durum geçerlidir.
-
-///
-
-## OpenAPI ve API docs { #openapi-and-api-docs }
-
-Ek status code'ları ve response'ları doğrudan döndürürseniz, FastAPI sizin ne döndüreceğinizi önceden bilemeyeceği için bunlar OpenAPI şemasına (API docs) dahil edilmez.
-
-Ancak bunu kodunuzda şu şekilde dokümante edebilirsiniz: [Ek Response'lar](additional-responses.md){.internal-link target=_blank}.

docs/tr/docs/advanced/advanced-dependencies.md

@@ -1,163 +0,0 @@
-# Gelişmiş Dependency'ler { #advanced-dependencies }
-
-## Parametreli dependency'ler { #parameterized-dependencies }
-
-Şimdiye kadar gördüğümüz tüm dependency'ler sabit bir function ya da class idi.
-
-Ancak, birçok farklı function veya class tanımlamak zorunda kalmadan, dependency üzerinde bazı parametreler ayarlamak isteyebileceğiniz durumlar olabilir.
-
-Örneğin, query parametresi `q`'nun belirli bir sabit içeriği barındırıp barındırmadığını kontrol eden bir dependency istediğimizi düşünelim.
-
-Ama bu sabit içeriği parametreleştirebilmek istiyoruz.
-
-## "Callable" bir instance { #a-callable-instance }
-
-Python'da bir class'ın instance'ını "callable" yapmanın bir yolu vardır.
-
-Class'ın kendisini değil (zaten callable'dır), o class'ın bir instance'ını.
-
-Bunu yapmak için `__call__` adında bir method tanımlarız:
-
-{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[12] *}
-
-Bu durumda, ek parametreleri ve alt-dependency'leri kontrol etmek için **FastAPI**'nin kullanacağı şey bu `__call__` olacaktır; ayrıca daha sonra *path operation function* içindeki parametreye bir değer geçmek için çağrılacak olan da budur.
-
-## Instance'ı parametreleştirme { #parameterize-the-instance }
-
-Ve şimdi, dependency'yi "parametreleştirmek" için kullanacağımız instance parametrelerini tanımlamak üzere `__init__` kullanabiliriz:
-
-{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[9] *}
-
-Bu durumda **FastAPI**, `__init__` ile asla uğraşmaz veya onu önemsemez; onu doğrudan kendi kodumuzda kullanırız.
-
-## Bir instance oluşturma { #create-an-instance }
-
-Bu class'tan bir instance'ı şöyle oluşturabiliriz:
-
-{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[18] *}
-
-Böylece dependency'mizi "parametreleştirmiş" oluruz; artık içinde `"bar"` vardır ve bu değer `checker.fixed_content` attribute'u olarak durur.
-
-## Instance'ı dependency olarak kullanma { #use-the-instance-as-a-dependency }
-
-Sonra `Depends(FixedContentQueryChecker)` yerine `Depends(checker)` içinde bu `checker`'ı kullanabiliriz. Çünkü dependency, class'ın kendisi değil, `checker` instance'ıdır.
-
-Ve dependency çözülürken **FastAPI** bu `checker`'ı şöyle çağırır:
-
-```Python
-checker(q="somequery")
-```
-
-...ve bunun döndürdüğü her şeyi, *path operation function* içinde `fixed_content_included` parametresine dependency değeri olarak geçirir:
-
-{* ../../docs_src/dependencies/tutorial011_an_py39.py hl[22] *}
-
-/// tip | İpucu
-
-Bunların tamamı biraz yapay görünebilir. Ayrıca bunun nasıl faydalı olduğu da henüz çok net olmayabilir.
-
-Bu örnekler bilerek basit tutuldu; ama mekanizmanın nasıl çalıştığını gösteriyor.
-
-Security bölümlerinde, aynı şekilde implement edilmiş yardımcı function'lar bulunuyor.
-
-Buradaki her şeyi anladıysanız, security için kullanılan bu yardımcı araçların arka planda nasıl çalıştığını da zaten biliyorsunuz demektir.
-
-///
-
-## `yield`, `HTTPException`, `except` ve Background Tasks ile Dependency'ler { #dependencies-with-yield-httpexception-except-and-background-tasks }
-
-/// warning | Uyarı
-
-Büyük ihtimalle bu teknik detaylara ihtiyacınız yok.
-
-Bu detaylar, özellikle 0.121.0'dan eski bir FastAPI uygulamanız varsa ve `yield` kullanan dependency'lerle ilgili sorunlar yaşıyorsanız faydalıdır.
-
-///
-
-`yield` kullanan dependency'ler; farklı kullanım senaryolarını kapsamak ve bazı sorunları düzeltmek için zaman içinde evrildi. Aşağıda nelerin değiştiğinin bir özeti var.
-
-### `yield` ve `scope` ile dependency'ler { #dependencies-with-yield-and-scope }
-
-0.121.0 sürümünde FastAPI, `yield` kullanan dependency'ler için `Depends(scope="function")` desteğini ekledi.
-
-`Depends(scope="function")` kullanıldığında, `yield` sonrasındaki çıkış kodu, *path operation function* biter bitmez, response client'a geri gönderilmeden önce çalıştırılır.
-
-`Depends(scope="request")` (varsayılan) kullanıldığında ise `yield` sonrasındaki çıkış kodu, response gönderildikten sonra çalıştırılır.
-
-Daha fazlasını [Dependencies with `yield` - Early exit and `scope`](../tutorial/dependencies/dependencies-with-yield.md#early-exit-and-scope) dokümantasyonunda okuyabilirsiniz.
-
-### `yield` ve `StreamingResponse` ile dependency'ler, Teknik Detaylar { #dependencies-with-yield-and-streamingresponse-technical-details }
-
-FastAPI 0.118.0 öncesinde, `yield` kullanan bir dependency kullanırsanız, *path operation function* döndükten sonra ama response gönderilmeden hemen önce `yield` sonrasındaki çıkış kodu çalıştırılırdı.
-
-Amaç, response'un ağ üzerinden taşınmasını beklerken gereğinden uzun süre resource tutmaktan kaçınmaktı.
-
-Bu değişiklik aynı zamanda şunu da ifade ediyordu: `StreamingResponse` döndürürseniz, `yield` kullanan dependency'nin çıkış kodu zaten çalışmış olurdu.
-
-Örneğin, `yield` kullanan bir dependency içinde bir veritabanı session'ınız varsa, `StreamingResponse` veri stream ederken bu session'ı kullanamazdı; çünkü `yield` sonrasındaki çıkış kodunda session zaten kapatılmış olurdu.
-
-Bu davranış 0.118.0'da geri alındı ve `yield` sonrasındaki çıkış kodunun, response gönderildikten sonra çalıştırılması sağlandı.
-
-/// info | Bilgi
-
-Aşağıda göreceğiniz gibi, bu davranış 0.106.0 sürümünden önceki davranışa oldukça benzer; ancak köşe durumlar için çeşitli iyileştirmeler ve bug fix'ler içerir.
-
-///
-
-#### Erken Çıkış Kodu için Kullanım Senaryoları { #use-cases-with-early-exit-code }
-
-Bazı özel koşullardaki kullanım senaryoları, response gönderilmeden önce `yield` kullanan dependency'lerin çıkış kodunun çalıştırıldığı eski davranıştan fayda görebilir.
-
-Örneğin, `yield` kullanan bir dependency içinde yalnızca bir kullanıcıyı doğrulamak için veritabanı session'ı kullanan bir kodunuz olduğunu düşünün; ama bu session *path operation function* içinde bir daha hiç kullanılmıyor, yalnızca dependency içinde kullanılıyor **ve** response'un gönderilmesi uzun sürüyor. Mesela veriyi yavaş gönderen bir `StreamingResponse` var, ama herhangi bir nedenle veritabanını kullanmıyor.
-
-Bu durumda veritabanı session'ı, response tamamen gönderilene kadar elde tutulur. Ancak session kullanılmıyorsa, bunu elde tutmak gerekli değildir.
-
-Şöyle görünebilir:
-
-{* ../../docs_src/dependencies/tutorial013_an_py310.py *}
-
-`Session`'ın otomatik kapatılması olan çıkış kodu şurada:
-
-{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[19:21] *}
-
-...yavaş veri gönderen response'un gönderimi bittikten sonra çalıştırılır:
-
-{* ../../docs_src/dependencies/tutorial013_an_py310.py ln[30:38] hl[31:33] *}
-
-Ama `generate_stream()` veritabanı session'ını kullanmadığı için, response gönderilirken session'ı açık tutmak aslında gerekli değildir.
-
-SQLModel (veya SQLAlchemy) kullanarak bu spesifik senaryoya sahipseniz, session'a artık ihtiyacınız kalmadıktan sonra session'ı açıkça kapatabilirsiniz:
-
-{* ../../docs_src/dependencies/tutorial014_an_py310.py ln[24:28] hl[28] *}
-
-Böylece session veritabanı bağlantısını serbest bırakır ve diğer request'ler bunu kullanabilir.
-
-`yield` kullanan bir dependency'den erken çıkış gerektiren farklı bir kullanım senaryonuz varsa, lütfen kullanım senaryonuzla birlikte ve `yield` kullanan dependency'ler için erken kapatmadan neden fayda göreceğinizi açıklayarak bir <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussion Question</a> oluşturun.
-
-`yield` kullanan dependency'lerde erken kapatma için ikna edici kullanım senaryoları varsa, erken kapatmayı seçmeli (opt-in) hale getiren yeni bir yöntem eklemeyi düşünebilirim.
-
-### `yield` ve `except` ile dependency'ler, Teknik Detaylar { #dependencies-with-yield-and-except-technical-details }
-
-FastAPI 0.110.0 öncesinde, `yield` kullanan bir dependency kullanır, sonra o dependency içinde `except` ile bir exception yakalar ve exception'ı tekrar raise etmezseniz; exception otomatik olarak herhangi bir exception handler'a veya internal server error handler'a raise/forward edilirdi.
-
-Bu davranış 0.110.0 sürümünde değiştirildi. Amaç, handler olmayan (internal server errors) forward edilmiş exception'ların yönetilmemesinden kaynaklanan bellek tüketimini düzeltmek ve bunu normal Python kodunun davranışıyla tutarlı hale getirmekti.
-
-### Background Tasks ve `yield` ile dependency'ler, Teknik Detaylar { #background-tasks-and-dependencies-with-yield-technical-details }
-
-FastAPI 0.106.0 öncesinde, `yield` sonrasında exception raise etmek mümkün değildi; çünkü `yield` kullanan dependency'lerdeki çıkış kodu response gönderildikten *sonra* çalıştırılıyordu. Bu nedenle [Exception Handlers](../tutorial/handling-errors.md#install-custom-exception-handlers){.internal-link target=_blank} zaten çalışmış olurdu.
-
-Bu tasarımın ana sebeplerinden biri, background task'lerin içinde dependency'lerin "yield ettiği" aynı objeleri kullanmaya izin vermekti; çünkü çıkış kodu, background task'ler bittikten sonra çalıştırılıyordu.
-
-Bu davranış FastAPI 0.106.0'da, response'un ağ üzerinde taşınmasını beklerken resource tutmamak amacıyla değiştirildi.
-
-/// tip | İpucu
-
-Ek olarak, bir background task normalde ayrı ele alınması gereken bağımsız bir mantık setidir ve kendi resource'larına sahip olmalıdır (ör. kendi veritabanı bağlantısı).
-
-Bu şekilde muhtemelen daha temiz bir kod elde edersiniz.
-
-///
-
-Bu davranışa güvenerek kod yazdıysanız, artık background task'ler için resource'ları background task'in içinde oluşturmalı ve içeride yalnızca `yield` kullanan dependency'lerin resource'larına bağlı olmayan verileri kullanmalısınız.
-
-Örneğin, aynı veritabanı session'ını kullanmak yerine background task içinde yeni bir veritabanı session'ı oluşturur ve veritabanındaki objeleri bu yeni session ile alırsınız. Ardından, background task function'ına veritabanından gelen objeyi parametre olarak geçirmek yerine, o objenin ID'sini geçirir ve objeyi background task function'ı içinde yeniden elde edersiniz.

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

@@ -1,99 +0,0 @@
-# Async Testler { #async-tests }
-
-Sağlanan `TestClient` ile **FastAPI** uygulamalarınızı nasıl test edeceğinizi zaten gördünüz. Şimdiye kadar yalnızca senkron testler yazdık, yani `async` fonksiyonlar kullanmadan.
-
-Testlerinizde asenkron fonksiyonlar kullanabilmek faydalı olabilir; örneğin veritabanınızı asenkron olarak sorguluyorsanız. Diyelim ki FastAPI uygulamanıza request gönderilmesini test etmek ve ardından async bir veritabanı kütüphanesi kullanırken backend'in doğru veriyi veritabanına başarıyla yazdığını doğrulamak istiyorsunuz.
-
-Bunu nasıl çalıştırabileceğimize bir bakalım.
-
-## pytest.mark.anyio { #pytest-mark-anyio }
-
-Testlerimizde asenkron fonksiyonlar çağırmak istiyorsak, test fonksiyonlarımızın da asenkron olması gerekir. AnyIO bunun için güzel bir plugin sağlar; böylece bazı test fonksiyonlarının asenkron olarak çağrılacağını belirtebiliriz.
-
-## HTTPX { #httpx }
-
-**FastAPI** uygulamanız `async def` yerine normal `def` fonksiyonları kullanıyor olsa bile, altta yatan yapı hâlâ bir `async` uygulamadır.
-
-`TestClient`, standart pytest kullanarak normal `def` test fonksiyonlarınızın içinden asenkron FastAPI uygulamasını çağırmak için içeride bazı “sihirli” işlemler yapar. Ancak bu sihir, onu asenkron fonksiyonların içinde kullandığımızda artık çalışmaz. Testlerimizi asenkron çalıştırdığımızda, test fonksiyonlarımızın içinde `TestClient` kullanamayız.
-
-`TestClient`, <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> tabanlıdır ve neyse ki API'yi test etmek için HTTPX'i doğrudan kullanabiliriz.
-
-## Örnek { #example }
-
-Basit bir örnek için, [Bigger Applications](../tutorial/bigger-applications.md){.internal-link target=_blank} ve [Testing](../tutorial/testing.md){.internal-link target=_blank} bölümlerinde anlatılana benzer bir dosya yapısı düşünelim:
-
-```
-.
-├── app
-│   ├── __init__.py
-│   ├── main.py
-│   └── test_main.py
-```
-
-`main.py` dosyası şöyle olur:
-
-{* ../../docs_src/async_tests/app_a_py39/main.py *}
-
-`test_main.py` dosyasında `main.py` için testler yer alır, artık şöyle görünebilir:
-
-{* ../../docs_src/async_tests/app_a_py39/test_main.py *}
-
-## Çalıştırma { #run-it }
-
-Testlerinizi her zamanki gibi şu şekilde çalıştırabilirsiniz:
-
-<div class="termy">
-
-```console
-$ pytest
-
----> 100%
-```
-
-</div>
-
-## Detaylı Anlatım { #in-detail }
-
-`@pytest.mark.anyio` marker'ı, pytest'e bu test fonksiyonunun asenkron olarak çağrılması gerektiğini söyler:
-
-{* ../../docs_src/async_tests/app_a_py39/test_main.py hl[7] *}
-
-/// tip | İpucu
-
-Test fonksiyonu artık `TestClient` kullanırken eskiden olduğu gibi sadece `def` değil, `async def`.
-
-///
-
-Ardından app ile bir `AsyncClient` oluşturup `await` kullanarak ona async request'ler gönderebiliriz.
-
-{* ../../docs_src/async_tests/app_a_py39/test_main.py hl[9:12] *}
-
-Bu, şu kullanıma denktir:
-
-```Python
-response = client.get('/')
-```
-
-...ki daha önce request'leri `TestClient` ile bu şekilde gönderiyorduk.
-
-/// tip | İpucu
-
-Yeni `AsyncClient` ile async/await kullandığımızı unutmayın; request asenkron çalışır.
-
-///
-
-/// warning | Uyarı
-
-Uygulamanız lifespan event'lerine dayanıyorsa, `AsyncClient` bu event'leri tetiklemez. Tetiklendiklerinden emin olmak için <a href="https://github.com/florimondmanca/asgi-lifespan#usage" class="external-link" target="_blank">florimondmanca/asgi-lifespan</a> paketindeki `LifespanManager`'ı kullanın.
-
-///
-
-## Diğer Asenkron Fonksiyon Çağrıları { #other-asynchronous-function-calls }
-
-Test fonksiyonu artık asenkron olduğundan, testlerinizde FastAPI uygulamanıza request göndermenin yanında başka `async` fonksiyonları da (çağırıp `await` ederek) kodunuzun başka yerlerinde yaptığınız gibi aynı şekilde kullanabilirsiniz.
-
-/// tip | İpucu
-
-Testlerinize asenkron fonksiyon çağrıları entegre ederken `RuntimeError: Task attached to a different loop` hatasıyla karşılaşırsanız (ör. <a href="https://stackoverflow.com/questions/41584243/runtimeerror-task-attached-to-a-different-loop" class="external-link" target="_blank">MongoDB'nin MotorClient</a> kullanımı), event loop gerektiren nesneleri yalnızca async fonksiyonların içinde oluşturmanız gerektiğini unutmayın; örneğin bir `@app.on_event("startup")` callback'i içinde.
-
-///

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

@@ -1,466 +0,0 @@
-# Proxy Arkasında Çalıştırma { #behind-a-proxy }
-
-Birçok durumda, FastAPI uygulamanızın önünde Traefik veya Nginx gibi bir **proxy** kullanırsınız.
-
-Bu proxy'ler HTTPS sertifikalarını ve diğer bazı işleri üstlenebilir.
-
-## Proxy Forwarded Header'ları { #proxy-forwarded-headers }
-
-Uygulamanızın önündeki bir **proxy**, request'leri **server**'ınıza göndermeden önce genelde bazı header'ları dinamik olarak ayarlar. Böylece server, request'in proxy tarafından **forward** edildiğini; domain dahil orijinal (public) URL'yi, HTTPS kullanıldığını vb. bilgileri anlayabilir.
-
-**Server** programı (örneğin **FastAPI CLI** üzerinden **Uvicorn**) bu header'ları yorumlayabilir ve ardından bu bilgiyi uygulamanıza aktarabilir.
-
-Ancak güvenlik nedeniyle, server güvenilir bir proxy arkasında olduğunu bilmediği için bu header'ları yorumlamaz.
-
-/// note | Teknik Detaylar
-
-Proxy header'ları şunlardır:
-
-* <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>
-
-///
-
-### Proxy Forwarded Header'larını Etkinleştirme { #enable-proxy-forwarded-headers }
-
-FastAPI CLI'yi `--forwarded-allow-ips` *CLI Option*'ı ile başlatıp, bu forwarded header'ları okumada güvenilecek IP adreslerini verebilirsiniz.
-
-Bunu `--forwarded-allow-ips="*"` olarak ayarlarsanız, gelen tüm IP'lere güvenir.
-
-**Server**'ınız güvenilir bir **proxy** arkasındaysa ve onunla sadece proxy konuşuyorsa, bu ayar server'ın o **proxy**'nin IP'si her neyse onu kabul etmesini sağlar.
-
-<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>
-
-### HTTPS ile Redirect'ler { #redirects-with-https }
-
-Örneğin `/items/` adında bir *path operation* tanımladığınızı düşünelim:
-
-{* ../../docs_src/behind_a_proxy/tutorial001_01_py39.py hl[6] *}
-
-Client `/items`'a gitmeye çalışırsa, varsayılan olarak `/items/`'a redirect edilir.
-
-Ancak *CLI Option* `--forwarded-allow-ips` ayarlanmadan önce, `http://localhost:8000/items/`'a redirect edebilir.
-
-Oysa uygulamanız `https://mysuperapp.com` üzerinde host ediliyor olabilir ve redirect'in `https://mysuperapp.com/items/` olması gerekir.
-
-Artık `--proxy-headers` ayarını yaparak FastAPI'nin doğru adrese redirect edebilmesini sağlarsınız. 😎
-
-```
-https://mysuperapp.com/items/
-```
-
-/// tip | İpucu
-
-HTTPS hakkında daha fazla bilgi için [HTTPS Hakkında](../deployment/https.md){.internal-link target=_blank} rehberine bakın.
-
-///
-
-### Proxy Forwarded Header'ları Nasıl Çalışır { #how-proxy-forwarded-headers-work }
-
-**Proxy**'nin, client ile **application server** arasında forwarded header'ları nasıl eklediğini gösteren görsel bir temsil:
-
-```mermaid
-sequenceDiagram
-    participant Client
-    participant Proxy as Proxy/Load Balancer
-    participant Server as FastAPI Server
-
-    Client->>Proxy: HTTPS Request<br/>Host: mysuperapp.com<br/>Path: /items
-
-    Note over Proxy: Proxy adds forwarded headers
-
-    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: Server interprets headers<br/>(if --forwarded-allow-ips is set)
-
-    Server->>Proxy: HTTP Response<br/>with correct HTTPS URLs
-
-    Proxy->>Client: HTTPS Response
-```
-
-**Proxy**, orijinal client request'ini araya girerek (intercept) alır ve request'i **application server**'a iletmeden önce özel *forwarded* header'ları (`X-Forwarded-*`) ekler.
-
-Bu header'lar, aksi halde kaybolacak olan orijinal request bilgilerini korur:
-
-* **X-Forwarded-For**: Orijinal client'ın IP adresi
-* **X-Forwarded-Proto**: Orijinal protokol (`https`)
-* **X-Forwarded-Host**: Orijinal host (`mysuperapp.com`)
-
-**FastAPI CLI** `--forwarded-allow-ips` ile yapılandırıldığında bu header'lara güvenir ve örneğin redirect'lerde doğru URL'leri üretmek için bunları kullanır.
-
-## Path Prefix'i Kırpılan (Stripped) Bir Proxy { #proxy-with-a-stripped-path-prefix }
-
-Uygulamanıza bir path prefix ekleyen bir proxy'niz olabilir.
-
-Bu durumlarda uygulamanızı yapılandırmak için `root_path` kullanabilirsiniz.
-
-`root_path`, FastAPI'nin (Starlette üzerinden) üzerine kurulduğu ASGI spesifikasyonunun sağladığı bir mekanizmadır.
-
-`root_path` bu özel senaryoları yönetmek için kullanılır.
-
-Ayrıca sub-application mount ederken de içeride kullanılır.
-
-Path prefix'i kırpılan bir proxy kullanmak, şu anlama gelir: Kodunuzda `/app` altında bir path tanımlarsınız; ancak üstte bir katman (proxy) ekleyip **FastAPI** uygulamanızı `/api/v1` gibi bir path'in altına koyarsınız.
-
-Bu durumda, orijinal `/app` path'i aslında `/api/v1/app` altında servis edilir.
-
-Kodunuzun tamamı sadece `/app` varmış gibi yazılmış olsa bile.
-
-{* ../../docs_src/behind_a_proxy/tutorial001_py39.py hl[6] *}
-
-Proxy, request'i app server'a (muhtemelen FastAPI CLI üzerinden Uvicorn) iletmeden önce **path prefix**'i anlık olarak **"kırpar"** (strip). Böylece uygulamanız hâlâ `/app` altında servis ediliyormuş gibi davranır ve tüm kodunuzu `/api/v1` prefix'ini içerecek şekilde güncellemeniz gerekmez.
-
-Buraya kadar her şey normal çalışır.
-
-Ancak entegre doküman arayüzünü (frontend) açtığınızda, OpenAPI şemasını `/api/v1/openapi.json` yerine `/openapi.json` üzerinden almayı bekler.
-
-Dolayısıyla tarayıcıda çalışan frontend `/openapi.json`'a erişmeye çalışır ve OpenAPI şemasını alamaz.
-
-Çünkü uygulamamız proxy arkasında `/api/v1` path prefix'i ile çalışmaktadır; frontend'in OpenAPI şemasını `/api/v1/openapi.json` üzerinden çekmesi gerekir.
-
-```mermaid
-graph LR
-
-browser("Browser")
-proxy["Proxy on http://0.0.0.0:9999/api/v1/app"]
-server["Server on http://127.0.0.1:8000/app"]
-
-browser --> proxy
-proxy --> server
-```
-
-/// tip | İpucu
-
-`0.0.0.0` IP'si, genelde programın ilgili makine/server üzerindeki tüm kullanılabilir IP'lerde dinlediği anlamına gelir.
-
-///
-
-Docs UI'nin, bu API `server`'ının (proxy arkasında) `/api/v1` altında bulunduğunu belirtmek için OpenAPI şemasına da ihtiyacı olur. Örneğin:
-
-```JSON hl_lines="4-8"
-{
-    "openapi": "3.1.0",
-    // More stuff here
-    "servers": [
-        {
-            "url": "/api/v1"
-        }
-    ],
-    "paths": {
-            // More stuff here
-    }
-}
-```
-
-Bu örnekte "Proxy", **Traefik** gibi bir şey olabilir. Server da FastAPI uygulamanızı çalıştıran (Uvicorn'lu) FastAPI CLI olabilir.
-
-### `root_path` Sağlama { #providing-the-root-path }
-
-Bunu yapmak için `--root-path` komut satırı seçeneğini şöyle kullanabilirsiniz:
-
-<div class="termy">
-
-```console
-$ 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>
-
-Hypercorn kullanıyorsanız, onda da `--root-path` seçeneği vardır.
-
-/// note | Teknik Detaylar
-
-ASGI spesifikasyonu bu kullanım senaryosu için bir `root_path` tanımlar.
-
-`--root-path` komut satırı seçeneği de bu `root_path`'i sağlar.
-
-///
-
-### Mevcut `root_path`'i Kontrol Etme { #checking-the-current-root-path }
-
-Uygulamanızın her request için kullandığı mevcut `root_path` değerini alabilirsiniz; bu değer ASGI spesifikasyonunun bir parçası olan `scope` dict'inin içindedir.
-
-Burada sadece göstermek için bunu mesaja dahil ediyoruz.
-
-{* ../../docs_src/behind_a_proxy/tutorial001_py39.py hl[8] *}
-
-Ardından Uvicorn'u şu şekilde başlatırsanız:
-
-<div class="termy">
-
-```console
-$ 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>
-
-Response şöyle bir şey olur:
-
-```JSON
-{
-    "message": "Hello World",
-    "root_path": "/api/v1"
-}
-```
-
-### FastAPI Uygulamasında `root_path` Ayarlama { #setting-the-root-path-in-the-fastapi-app }
-
-Alternatif olarak, `--root-path` gibi bir komut satırı seçeneği (veya muadili) sağlayamıyorsanız, FastAPI uygulamanızı oluştururken `root_path` parametresini ayarlayabilirsiniz:
-
-{* ../../docs_src/behind_a_proxy/tutorial002_py39.py hl[3] *}
-
-`FastAPI`'ye `root_path` vermek, Uvicorn veya Hypercorn'a `--root-path` komut satırı seçeneğini vermekle eşdeğerdir.
-
-### `root_path` Hakkında { #about-root-path }
-
-Şunu unutmayın: Server (Uvicorn) bu `root_path`'i, uygulamaya iletmek dışında başka bir amaçla kullanmaz.
-
-Ancak tarayıcınızla <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a> adresine giderseniz normal response'u görürsünüz:
-
-```JSON
-{
-    "message": "Hello World",
-    "root_path": "/api/v1"
-}
-```
-
-Yani `http://127.0.0.1:8000/api/v1/app` üzerinden erişilmeyi beklemez.
-
-Uvicorn, proxy'nin Uvicorn'a `http://127.0.0.1:8000/app` üzerinden erişmesini bekler; bunun üstüne ekstra `/api/v1` prefix'ini eklemek proxy'nin sorumluluğudur.
-
-## Stripped Path Prefix Kullanan Proxy'ler Hakkında { #about-proxies-with-a-stripped-path-prefix }
-
-Stripped path prefix kullanan bir proxy, yapılandırma yöntemlerinden yalnızca biridir.
-
-Birçok durumda varsayılan davranış, proxy'nin stripped path prefix kullanmaması olacaktır.
-
-Böyle bir durumda (stripped path prefix olmadan), proxy `https://myawesomeapp.com` gibi bir yerde dinler; tarayıcı `https://myawesomeapp.com/api/v1/app`'e giderse ve sizin server'ınız (ör. Uvicorn) `http://127.0.0.1:8000` üzerinde dinliyorsa, proxy (stripped path prefix olmadan) Uvicorn'a aynı path ile erişir: `http://127.0.0.1:8000/api/v1/app`.
-
-## Traefik ile Local Olarak Test Etme { #testing-locally-with-traefik }
-
-<a href="https://docs.traefik.io/" class="external-link" target="_blank">Traefik</a> kullanarak, stripped path prefix'li deneyi local'de kolayca çalıştırabilirsiniz.
-
-<a href="https://github.com/containous/traefik/releases" class="external-link" target="_blank">Traefik'i indirin</a>; tek bir binary'dir, sıkıştırılmış dosyayı çıkarıp doğrudan terminalden çalıştırabilirsiniz.
-
-Ardından `traefik.toml` adında bir dosya oluşturup şunu yazın:
-
-```TOML hl_lines="3"
-[entryPoints]
-  [entryPoints.http]
-    address = ":9999"
-
-[providers]
-  [providers.file]
-    filename = "routes.toml"
-```
-
-Bu, Traefik'e 9999 portunda dinlemesini ve `routes.toml` adlı başka bir dosyayı kullanmasını söyler.
-
-/// tip | İpucu
-
-Standart HTTP portu 80 yerine 9999 portunu kullanıyoruz; böylece admin (`sudo`) yetkileriyle çalıştırmanız gerekmez.
-
-///
-
-Şimdi diğer dosyayı, `routes.toml`'u oluşturun:
-
-```TOML hl_lines="5  12  20"
-[http]
-  [http.middlewares]
-
-    [http.middlewares.api-stripprefix.stripPrefix]
-      prefixes = ["/api/v1"]
-
-  [http.routers]
-
-    [http.routers.app-http]
-      entryPoints = ["http"]
-      service = "app"
-      rule = "PathPrefix(`/api/v1`)"
-      middlewares = ["api-stripprefix"]
-
-  [http.services]
-
-    [http.services.app]
-      [http.services.app.loadBalancer]
-        [[http.services.app.loadBalancer.servers]]
-          url = "http://127.0.0.1:8000"
-```
-
-Bu dosya, Traefik'i `/api/v1` path prefix'ini kullanacak şekilde yapılandırır.
-
-Ardından Traefik, request'leri `http://127.0.0.1:8000` üzerinde çalışan Uvicorn'unuza yönlendirir.
-
-Şimdi Traefik'i başlatın:
-
-<div class="termy">
-
-```console
-$ ./traefik --configFile=traefik.toml
-
-INFO[0000] Configuration loaded from file: /home/user/awesomeapi/traefik.toml
-```
-
-</div>
-
-Ve şimdi uygulamanızı `--root-path` seçeneğiyle başlatın:
-
-<div class="termy">
-
-```console
-$ 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>
-
-### Response'ları Kontrol Edin { #check-the-responses }
-
-Şimdi Uvicorn'un portundaki URL'ye giderseniz: <a href="http://127.0.0.1:8000/app" class="external-link" target="_blank">http://127.0.0.1:8000/app</a>, normal response'u görürsünüz:
-
-```JSON
-{
-    "message": "Hello World",
-    "root_path": "/api/v1"
-}
-```
-
-/// tip | İpucu
-
-`http://127.0.0.1:8000/app` üzerinden erişiyor olsanız bile, `root_path` değerinin `--root-path` seçeneğinden alınıp `/api/v1` olarak gösterildiğine dikkat edin.
-
-///
-
-Şimdi de Traefik'in portundaki URL'yi, path prefix ile birlikte açın: <a href="http://127.0.0.1:9999/api/v1/app" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/app</a>.
-
-Aynı response'u alırız:
-
-```JSON
-{
-    "message": "Hello World",
-    "root_path": "/api/v1"
-}
-```
-
-ama bu sefer proxy'nin sağladığı prefix path olan `/api/v1` ile gelen URL'de.
-
-Elbette buradaki fikir, herkesin uygulamaya proxy üzerinden erişmesidir; dolayısıyla `/api/v1` path prefix'li sürüm "doğru" olandır.
-
-Uvicorn'un doğrudan sunduğu, path prefix olmayan sürüm (`http://127.0.0.1:8000/app`) ise sadece _proxy_'nin (Traefik) erişmesi için kullanılmalıdır.
-
-Bu da Proxy'nin (Traefik) path prefix'i nasıl kullandığını ve server'ın (Uvicorn) `--root-path` seçeneğinden gelen `root_path`'i nasıl kullandığını gösterir.
-
-### Docs UI'yi Kontrol Edin { #check-the-docs-ui }
-
-Şimdi işin eğlenceli kısmı. ✨
-
-Uygulamaya erişmenin "resmi" yolu, tanımladığımız path prefix ile proxy üzerinden erişmektir. Bu yüzden beklendiği gibi, Uvicorn'un doğrudan servis ettiği docs UI'yi URL'de path prefix olmadan açarsanız çalışmaz; çünkü proxy üzerinden erişileceğini varsayar.
-
-Şuradan kontrol edebilirsiniz: <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>:
-
-<img src="/img/tutorial/behind-a-proxy/image01.png">
-
-Ancak docs UI'yi proxy üzerinden, `9999` portuyla, `/api/v1/docs` altında "resmi" URL'den açarsak doğru çalışır! 🎉
-
-Şuradan kontrol edebilirsiniz: <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a>:
-
-<img src="/img/tutorial/behind-a-proxy/image02.png">
-
-Tam istediğimiz gibi. ✔️
-
-Bunun nedeni, FastAPI'nin OpenAPI içinde varsayılan `server`'ı, `root_path` tarafından verilen URL ile oluşturmak için bu `root_path`'i kullanmasıdır.
-
-## Ek `server`'lar { #additional-servers }
-
-/// warning | Uyarı
-
-Bu daha ileri seviye bir kullanım senaryosudur. İsterseniz atlayabilirsiniz.
-
-///
-
-Varsayılan olarak **FastAPI**, OpenAPI şemasında `root_path` için bir `server` oluşturur.
-
-Ancak başka alternatif `servers` da sağlayabilirsiniz; örneğin *aynı* docs UI'nin hem staging hem de production ortamıyla etkileşime girmesini istiyorsanız.
-
-Özel bir `servers` listesi verirseniz ve bir `root_path` varsa (çünkü API'niz proxy arkasındadır), **FastAPI** bu `root_path` ile bir "server"ı listenin başına ekler.
-
-Örneğin:
-
-{* ../../docs_src/behind_a_proxy/tutorial003_py39.py hl[4:7] *}
-
-Şöyle bir OpenAPI şeması üretir:
-
-```JSON hl_lines="5-7"
-{
-    "openapi": "3.1.0",
-    // More stuff here
-    "servers": [
-        {
-            "url": "/api/v1"
-        },
-        {
-            "url": "https://stag.example.com",
-            "description": "Staging environment"
-        },
-        {
-            "url": "https://prod.example.com",
-            "description": "Production environment"
-        }
-    ],
-    "paths": {
-            // More stuff here
-    }
-}
-```
-
-/// tip | İpucu
-
-`url` değeri `/api/v1` olan, `root_path`'ten alınmış otomatik üretilen server'a dikkat edin.
-
-///
-
-Docs UI'de, <a href="http://127.0.0.1:9999/api/v1/docs" class="external-link" target="_blank">http://127.0.0.1:9999/api/v1/docs</a> adresinde şöyle görünür:
-
-<img src="/img/tutorial/behind-a-proxy/image03.png">
-
-/// tip | İpucu
-
-Docs UI, seçtiğiniz server ile etkileşime girer.
-
-///
-
-/// note | Teknik Detaylar
-
-OpenAPI spesifikasyonunda `servers` özelliği opsiyoneldir.
-
-`servers` parametresini belirtmezseniz ve `root_path` `/` ile aynıysa, üretilen OpenAPI şemasında `servers` özelliği varsayılan olarak tamamen çıkarılır; bu da `url` değeri `/` olan tek bir server ile eşdeğerdir.
-
-///
-
-### `root_path`'ten Otomatik `server` Eklenmesini Kapatma { #disable-automatic-server-from-root-path }
-
-**FastAPI**'nin `root_path` kullanarak otomatik bir server eklemesini istemiyorsanız, `root_path_in_servers=False` parametresini kullanabilirsiniz:
-
-{* ../../docs_src/behind_a_proxy/tutorial004_py39.py hl[9] *}
-
-Böylece OpenAPI şemasına dahil etmez.
-
-## Bir Sub-Application Mount Etme { #mounting-a-sub-application }
-
-Bir sub-application'ı ( [Sub Applications - Mounts](sub-applications.md){.internal-link target=_blank} bölümünde anlatıldığı gibi) mount etmeniz gerekiyorsa ve aynı zamanda `root_path` ile bir proxy kullanıyorsanız, bunu beklendiği gibi normal şekilde yapabilirsiniz.
-
-FastAPI içeride `root_path`'i akıllıca kullanır; dolayısıyla doğrudan çalışır. ✨

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

@@ -1,312 +0,0 @@
-# Özel Response - HTML, Stream, File ve Diğerleri { #custom-response-html-stream-file-others }
-
-Varsayılan olarak **FastAPI**, response'ları `JSONResponse` kullanarak döndürür.
-
-Bunu, [Doğrudan bir Response döndür](response-directly.md){.internal-link target=_blank} bölümünde gördüğünüz gibi doğrudan bir `Response` döndürerek geçersiz kılabilirsiniz.
-
-Ancak doğrudan bir `Response` döndürürseniz (veya `JSONResponse` gibi herhangi bir alt sınıfını), veri otomatik olarak dönüştürülmez (bir `response_model` tanımlamış olsanız bile) ve dokümantasyon da otomatik üretilmez (örneğin, üretilen OpenAPI’nin parçası olarak HTTP header `Content-Type` içindeki ilgili "media type" dahil edilmez).
-
-Bununla birlikte, *path operation decorator* içinde `response_class` parametresini kullanarak hangi `Response`’un (örn. herhangi bir `Response` alt sınıfı) kullanılacağını da ilan edebilirsiniz.
-
-*path operation function*’ınızdan döndürdüğünüz içerik, o `Response`’un içine yerleştirilir.
-
-Ve eğer bu `Response` ( `JSONResponse` ve `UJSONResponse`’ta olduğu gibi) bir JSON media type’a (`application/json`) sahipse, döndürdüğünüz veri; *path operation decorator* içinde tanımladığınız herhangi bir Pydantic `response_model` ile otomatik olarak dönüştürülür (ve filtrelenir).
-
-/// note | Not
-
-Media type’ı olmayan bir response class kullanırsanız, FastAPI response’unuzun content içermediğini varsayar; bu yüzden ürettiği OpenAPI dokümanında response formatını dokümante etmez.
-
-///
-
-## `ORJSONResponse` Kullan { #use-orjsonresponse }
-
-Örneğin performansı sıkıştırmaya çalışıyorsanız, <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> kurup kullanabilir ve response’u `ORJSONResponse` olarak ayarlayabilirsiniz.
-
-Kullanmak istediğiniz `Response` class’ını (alt sınıfını) import edin ve *path operation decorator* içinde tanımlayın.
-
-Büyük response'larda, doğrudan bir `Response` döndürmek bir dictionary döndürmekten çok daha hızlıdır.
-
-Çünkü varsayılan olarak FastAPI, içindeki her item’ı inceleyip JSON olarak serialize edilebilir olduğundan emin olur; tutorial’da anlatılan aynı [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank} mekanizmasını kullanır. Bu da örneğin veritabanı modelleri gibi **keyfi objeleri** döndürebilmenizi sağlar.
-
-Ancak döndürdüğünüz içeriğin **JSON ile serialize edilebilir** olduğundan eminseniz, onu doğrudan response class’ına verebilir ve FastAPI’nin response class’ına vermeden önce dönüş içeriğinizi `jsonable_encoder` içinden geçirirken oluşturacağı ek yükten kaçınabilirsiniz.
-
-{* ../../docs_src/custom_response/tutorial001b_py39.py hl[2,7] *}
-
-/// info | Bilgi
-
-`response_class` parametresi, response’un "media type"’ını tanımlamak için de kullanılır.
-
-Bu durumda HTTP header `Content-Type`, `application/json` olarak ayarlanır.
-
-Ve OpenAPI’de de bu şekilde dokümante edilir.
-
-///
-
-/// tip | İpucu
-
-`ORJSONResponse` yalnızca FastAPI’de vardır, Starlette’te yoktur.
-
-///
-
-## HTML Response { #html-response }
-
-**FastAPI**’den doğrudan HTML içeren bir response döndürmek için `HTMLResponse` kullanın.
-
-* `HTMLResponse` import edin.
-* *path operation decorator*’ınızın `response_class` parametresi olarak `HTMLResponse` verin.
-
-{* ../../docs_src/custom_response/tutorial002_py39.py hl[2,7] *}
-
-/// info | Bilgi
-
-`response_class` parametresi, response’un "media type"’ını tanımlamak için de kullanılır.
-
-Bu durumda HTTP header `Content-Type`, `text/html` olarak ayarlanır.
-
-Ve OpenAPI’de de bu şekilde dokümante edilir.
-
-///
-
-### Bir `Response` Döndür { #return-a-response }
-
-[Doğrudan bir Response döndür](response-directly.md){.internal-link target=_blank} bölümünde görüldüğü gibi, *path operation* içinde doğrudan bir response döndürerek response’u override edebilirsiniz.
-
-Yukarıdaki örneğin aynısı, bu sefer bir `HTMLResponse` döndürerek, şöyle görünebilir:
-
-{* ../../docs_src/custom_response/tutorial003_py39.py hl[2,7,19] *}
-
-/// warning | Uyarı
-
-*path operation function*’ınızın doğrudan döndürdüğü bir `Response`, OpenAPI’de dokümante edilmez (örneğin `Content-Type` dokümante edilmez) ve otomatik interaktif dokümanlarda görünmez.
-
-///
-
-/// info | Bilgi
-
-Elbette gerçek `Content-Type` header’ı, status code vb. değerler, döndürdüğünüz `Response` objesinden gelir.
-
-///
-
-### OpenAPI’de Dokümante Et ve `Response`’u Override Et { #document-in-openapi-and-override-response }
-
-Response’u fonksiyonun içinden override etmek ama aynı zamanda OpenAPI’de "media type"’ı dokümante etmek istiyorsanız, `response_class` parametresini kullanıp ayrıca bir `Response` objesi döndürebilirsiniz.
-
-Bu durumda `response_class` sadece OpenAPI *path operation*’ını dokümante etmek için kullanılır; sizin `Response`’unuz ise olduğu gibi kullanılır.
-
-#### Doğrudan bir `HTMLResponse` Döndür { #return-an-htmlresponse-directly }
-
-Örneğin şöyle bir şey olabilir:
-
-{* ../../docs_src/custom_response/tutorial004_py39.py hl[7,21,23] *}
-
-Bu örnekte `generate_html_response()` fonksiyonu, HTML’i bir `str` olarak döndürmek yerine zaten bir `Response` üretip döndürmektedir.
-
-`generate_html_response()` çağrısının sonucunu döndürerek, varsayılan **FastAPI** davranışını override edecek bir `Response` döndürmüş olursunuz.
-
-Ama `response_class` içinde `HTMLResponse` da verdiğiniz için **FastAPI**, bunu OpenAPI’de ve interaktif dokümanlarda `text/html` ile HTML olarak nasıl dokümante edeceğini bilir:
-
-<img src="/img/tutorial/custom-response/image01.png">
-
-## Mevcut Response'lar { #available-responses }
-
-Mevcut response'lardan bazıları aşağıdadır.
-
-Unutmayın: `Response` ile başka herhangi bir şeyi döndürebilir, hatta özel bir alt sınıf da oluşturabilirsiniz.
-
-/// note | Teknik Detaylar
-
-`from starlette.responses import HTMLResponse` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici için kolaylık olsun diye `starlette.responses` içindekileri `fastapi.responses` olarak da sağlar. Ancak mevcut response'ların çoğu doğrudan Starlette’ten gelir.
-
-///
-
-### `Response` { #response }
-
-Ana `Response` class’ıdır; diğer tüm response'lar bundan türetilir.
-
-Bunu doğrudan döndürebilirsiniz.
-
-Şu parametreleri kabul eder:
-
-* `content` - Bir `str` veya `bytes`.
-* `status_code` - Bir `int` HTTP status code.
-* `headers` - String’lerden oluşan bir `dict`.
-* `media_type` - Media type’ı veren bir `str`. Örn. `"text/html"`.
-
-FastAPI (aslında Starlette) otomatik olarak bir Content-Length header’ı ekler. Ayrıca `media_type`’a göre bir Content-Type header’ı ekler ve text türleri için sona bir charset ekler.
-
-{* ../../docs_src/response_directly/tutorial002_py39.py hl[1,18] *}
-
-### `HTMLResponse` { #htmlresponse }
-
-Yukarıda okuduğunuz gibi, bir miktar text veya bytes alır ve HTML response döndürür.
-
-### `PlainTextResponse` { #plaintextresponse }
-
-Bir miktar text veya bytes alır ve düz metin response döndürür.
-
-{* ../../docs_src/custom_response/tutorial005_py39.py hl[2,7,9] *}
-
-### `JSONResponse` { #jsonresponse }
-
-Bir miktar veri alır ve `application/json` olarak encode edilmiş bir response döndürür.
-
-Yukarıda okuduğunuz gibi, **FastAPI**’de varsayılan response budur.
-
-### `ORJSONResponse` { #orjsonresponse }
-
-Yukarıda okuduğunuz gibi <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> kullanan hızlı bir alternatif JSON response.
-
-/// info | Bilgi
-
-Bunun için `orjson` kurulmalıdır; örneğin `pip install orjson`.
-
-///
-
-### `UJSONResponse` { #ujsonresponse }
-
-<a href="https://github.com/ultrajson/ultrajson" class="external-link" target="_blank">`ujson`</a> kullanan alternatif bir JSON response.
-
-/// info | Bilgi
-
-Bunun için `ujson` kurulmalıdır; örneğin `pip install ujson`.
-
-///
-
-/// warning | Uyarı
-
-`ujson`, bazı edge-case’leri ele alma konusunda Python’un built-in implementasyonu kadar dikkatli değildir.
-
-///
-
-{* ../../docs_src/custom_response/tutorial001_py39.py hl[2,7] *}
-
-/// tip | İpucu
-
-`ORJSONResponse` daha hızlı bir alternatif olabilir.
-
-///
-
-### `RedirectResponse` { #redirectresponse }
-
-HTTP redirect döndürür. Varsayılan olarak 307 status code (Temporary Redirect) kullanır.
-
-`RedirectResponse`’u doğrudan döndürebilirsiniz:
-
-{* ../../docs_src/custom_response/tutorial006_py39.py hl[2,9] *}
-
----
-
-Veya `response_class` parametresi içinde kullanabilirsiniz:
-
-{* ../../docs_src/custom_response/tutorial006b_py39.py hl[2,7,9] *}
-
-Bunu yaparsanız, *path operation* function’ınızdan doğrudan URL döndürebilirsiniz.
-
-Bu durumda kullanılan `status_code`, `RedirectResponse` için varsayılan olan `307` olur.
-
----
-
-Ayrıca `status_code` parametresini `response_class` parametresiyle birlikte kullanabilirsiniz:
-
-{* ../../docs_src/custom_response/tutorial006c_py39.py hl[2,7,9] *}
-
-### `StreamingResponse` { #streamingresponse }
-
-Bir async generator veya normal generator/iterator alır ve response body’yi stream eder.
-
-{* ../../docs_src/custom_response/tutorial007_py39.py hl[2,14] *}
-
-#### `StreamingResponse`’u file-like objelerle kullanma { #using-streamingresponse-with-file-like-objects }
-
-Bir <a href="https://docs.python.org/3/glossary.html#term-file-like-object" class="external-link" target="_blank">file-like</a> objeniz varsa (örn. `open()`’ın döndürdüğü obje), o file-like obje üzerinde iterate eden bir generator function oluşturabilirsiniz.
-
-Böylece önce hepsini memory’ye okumak zorunda kalmazsınız; bu generator function’ı `StreamingResponse`’a verip döndürebilirsiniz.
-
-Buna cloud storage ile etkileşime giren, video işleyen ve benzeri birçok kütüphane dahildir.
-
-{* ../../docs_src/custom_response/tutorial008_py39.py hl[2,10:12,14] *}
-
-1. Bu generator function’dır. İçinde `yield` ifadeleri olduğu için "generator function" denir.
-2. Bir `with` bloğu kullanarak, generator function bittiğinde file-like objenin kapandığından emin oluruz. Yani response göndermeyi bitirdikten sonra kapanır.
-3. Bu `yield from`, fonksiyona `file_like` isimli şeyi iterate etmesini söyler. Ardından iterate edilen her parça için, o parçayı bu generator function’dan (`iterfile`) geliyormuş gibi yield eder.
-
-    Yani, içerdeki "üretme" (generating) işini başka bir şeye devreden bir generator function’dır.
-
-    Bunu bu şekilde yaptığımızda `with` bloğu içinde tutabilir ve böylece iş bitince file-like objenin kapanmasını garanti edebiliriz.
-
-/// tip | İpucu
-
-Burada `async` ve `await` desteklemeyen standart `open()` kullandığımız için path operation’ı normal `def` ile tanımlarız.
-
-///
-
-### `FileResponse` { #fileresponse }
-
-Asenkron olarak bir dosyayı response olarak stream eder.
-
-Diğer response türlerine göre instantiate ederken farklı argümanlar alır:
-
-* `path` - Stream edilecek dosyanın dosya path'i.
-* `headers` - Eklenecek özel header’lar; dictionary olarak.
-* `media_type` - Media type’ı veren string. Ayarlanmazsa, dosya adı veya path kullanılarak media type tahmin edilir.
-* `filename` - Ayarlanırsa response içindeki `Content-Disposition`’a dahil edilir.
-
-File response'ları uygun `Content-Length`, `Last-Modified` ve `ETag` header’larını içerir.
-
-{* ../../docs_src/custom_response/tutorial009_py39.py hl[2,10] *}
-
-`response_class` parametresini de kullanabilirsiniz:
-
-{* ../../docs_src/custom_response/tutorial009b_py39.py hl[2,8,10] *}
-
-Bu durumda *path operation* function’ınızdan doğrudan dosya path'ini döndürebilirsiniz.
-
-## Özel response class { #custom-response-class }
-
-`Response`’dan türeterek kendi özel response class’ınızı oluşturabilir ve kullanabilirsiniz.
-
-Örneğin, dahil gelen `ORJSONResponse` class’ında kullanılmayan bazı özel ayarlarla <a href="https://github.com/ijl/orjson" class="external-link" target="_blank">`orjson`</a> kullanmak istediğinizi varsayalım.
-
-Diyelim ki girintili ve biçimlendirilmiş JSON döndürmek istiyorsunuz; bunun için `orjson.OPT_INDENT_2` seçeneğini kullanmak istiyorsunuz.
-
-Bir `CustomORJSONResponse` oluşturabilirsiniz. Burada yapmanız gereken temel şey, content’i `bytes` olarak döndüren bir `Response.render(content)` metodu yazmaktır:
-
-{* ../../docs_src/custom_response/tutorial009c_py39.py hl[9:14,17] *}
-
-Artık şunu döndürmek yerine:
-
-```json
-{"message": "Hello World"}
-```
-
-...bu response şunu döndürür:
-
-```json
-{
-  "message": "Hello World"
-}
-```
-
-Elbette JSON’u formatlamaktan çok daha iyi şekillerde bundan faydalanabilirsiniz. 😉
-
-## Varsayılan response class { #default-response-class }
-
-Bir **FastAPI** class instance’ı veya bir `APIRouter` oluştururken, varsayılan olarak hangi response class’ının kullanılacağını belirtebilirsiniz.
-
-Bunu tanımlayan parametre `default_response_class`’tır.
-
-Aşağıdaki örnekte **FastAPI**, tüm *path operations* için varsayılan olarak `JSONResponse` yerine `ORJSONResponse` kullanır.
-
-{* ../../docs_src/custom_response/tutorial010_py39.py hl[2,4] *}
-
-/// tip | İpucu
-
-Daha önce olduğu gibi, *path operations* içinde `response_class`’ı yine override edebilirsiniz.
-
-///
-
-## Ek dokümantasyon { #additional-documentation }
-
-OpenAPI’de media type’ı ve daha birçok detayı `responses` kullanarak da tanımlayabilirsiniz: [OpenAPI’de Ek Response'lar](additional-responses.md){.internal-link target=_blank}.

docs/tr/docs/advanced/dataclasses.md

@@ -1,95 +0,0 @@
-# Dataclass Kullanımı { #using-dataclasses }
-
-FastAPI, **Pydantic** üzerine inşa edilmiştir ve request/response tanımlamak için Pydantic model'lerini nasıl kullanacağınızı gösteriyordum.
-
-Ancak FastAPI, <a href="https://docs.python.org/3/library/dataclasses.html" class="external-link" target="_blank">`dataclasses`</a> kullanmayı da aynı şekilde destekler:
-
-{* ../../docs_src/dataclasses_/tutorial001_py310.py hl[1,6:11,18:19] *}
-
-Bu destek hâlâ **Pydantic** sayesinde vardır; çünkü Pydantic, <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/#use-of-stdlib-dataclasses-with-basemodel" class="external-link" target="_blank">`dataclasses` için dahili destek</a> sunar.
-
-Yani yukarıdaki kod Pydantic'i doğrudan kullanmasa bile, FastAPI bu standart dataclass'ları Pydantic'in kendi dataclass biçimine dönüştürmek için Pydantic'i kullanmaktadır.
-
-Ve elbette aynı özellikleri destekler:
-
-* veri doğrulama (data validation)
-* veri serileştirme (data serialization)
-* veri dokümantasyonu (data documentation), vb.
-
-Bu, Pydantic model'lerinde olduğu gibi çalışır. Aslında arka planda da aynı şekilde, Pydantic kullanılarak yapılır.
-
-/// info | Bilgi
-
-Dataclass'ların, Pydantic model'lerinin yapabildiği her şeyi yapamadığını unutmayın.
-
-Bu yüzden yine de Pydantic model'lerini kullanmanız gerekebilir.
-
-Ancak elinizde zaten bir sürü dataclass varsa, bunları FastAPI ile bir web API'yi beslemek için kullanmak güzel bir numaradır. 🤓
-
-///
-
-## `response_model` İçinde Dataclass'lar { #dataclasses-in-response-model }
-
-`response_model` parametresinde `dataclasses` da kullanabilirsiniz:
-
-{* ../../docs_src/dataclasses_/tutorial002_py310.py hl[1,6:12,18] *}
-
-Dataclass otomatik olarak bir Pydantic dataclass'ına dönüştürülür.
-
-Bu sayede şeması API docs kullanıcı arayüzünde görünür:
-
-<img src="/img/tutorial/dataclasses/image01.png">
-
-## İç İçe Veri Yapılarında Dataclass'lar { #dataclasses-in-nested-data-structures }
-
-İç içe veri yapıları oluşturmak için `dataclasses` ile diğer type annotation'ları da birleştirebilirsiniz.
-
-Bazı durumlarda yine de Pydantic'in `dataclasses` sürümünü kullanmanız gerekebilir. Örneğin, otomatik oluşturulan API dokümantasyonunda hata alıyorsanız.
-
-Bu durumda standart `dataclasses` yerine, drop-in replacement olan `pydantic.dataclasses` kullanabilirsiniz:
-
-{* ../../docs_src/dataclasses_/tutorial003_py310.py hl[1,4,7:10,13:16,22:24,27] *}
-
-1. `field` hâlâ standart `dataclasses` içinden import edilir.
-
-2. `pydantic.dataclasses`, `dataclasses` için bir drop-in replacement'tır.
-
-3. `Author` dataclass'ı, `Item` dataclass'larından oluşan bir liste içerir.
-
-4. `Author` dataclass'ı, `response_model` parametresi olarak kullanılır.
-
-5. Request body olarak dataclass'larla birlikte diğer standart type annotation'ları da kullanabilirsiniz.
-
-    Bu örnekte, `Item` dataclass'larından oluşan bir listedir.
-
-6. Burada `items` içeren bir dictionary döndürüyoruz; `items` bir dataclass listesi.
-
-    FastAPI, veriyi JSON'a <abbr title="converting the data to a format that can be transmitted - veriyi aktarılabilir bir formata dönüştürme">serializing</abbr> etmeyi yine başarır.
-
-7. Burada `response_model`, `Author` dataclass'larından oluşan bir listenin type annotation'ını kullanıyor.
-
-    Yine `dataclasses` ile standart type annotation'ları birleştirebilirsiniz.
-
-8. Bu *path operation function*, `async def` yerine normal `def` kullanıyor.
-
-    Her zaman olduğu gibi, FastAPI'de ihtiyaca göre `def` ve `async def`’i birlikte kullanabilirsiniz.
-
-    Hangisini ne zaman kullanmanız gerektiğine dair hızlı bir hatırlatma isterseniz, [`async` ve `await`](../async.md#in-a-hurry){.internal-link target=_blank} dokümanındaki _"In a hurry?"_ bölümüne bakın.
-
-9. Bu *path operation function* dataclass döndürmüyor (isterse döndürebilir), onun yerine dahili verilerle bir dictionary listesi döndürüyor.
-
-    FastAPI, response'u dönüştürmek için (dataclass'ları içeren) `response_model` parametresini kullanacaktır.
-
-Karmaşık veri yapıları oluşturmak için `dataclasses` ile diğer type annotation'ları pek çok farklı kombinasyonda birleştirebilirsiniz.
-
-Daha spesifik ayrıntılar için yukarıdaki kod içi annotation ipuçlarına bakın.
-
-## Daha Fazla Öğrenin { #learn-more }
-
-`dataclasses`'ı diğer Pydantic model'leriyle de birleştirebilir, onlardan kalıtım alabilir, kendi model'lerinize dahil edebilirsiniz, vb.
-
-Daha fazlası için <a href="https://docs.pydantic.dev/latest/concepts/dataclasses/" class="external-link" target="_blank">Pydantic'in dataclasses dokümantasyonuna</a> bakın.
-
-## Sürüm { #version }
-
-Bu özellik FastAPI `0.67.0` sürümünden beri mevcuttur. 🔖

docs/tr/docs/advanced/events.md

@@ -1,165 +0,0 @@
-# Lifespan Olayları { #lifespan-events }
-
-Uygulama **başlamadan** önce çalıştırılması gereken mantığı (kodu) tanımlayabilirsiniz. Bu, bu kodun **bir kez**, uygulama **request almaya başlamadan önce** çalıştırılacağı anlamına gelir.
-
-Benzer şekilde, uygulama **kapanırken** çalıştırılması gereken mantığı (kodu) da tanımlayabilirsiniz. Bu durumda bu kod, muhtemelen **çok sayıda request** işlendi **sonra**, **bir kez** çalıştırılır.
-
-Bu kod, uygulama request almaya **başlamadan** önce ve request’leri işlemeyi **bitirdikten** hemen sonra çalıştığı için, uygulamanın tüm **lifespan**’ını (birazdan "lifespan" kelimesi önemli olacak 😉) kapsar.
-
-Bu yaklaşım, tüm uygulama boyunca kullanacağınız ve request’ler arasında **paylaşılan** **resource**’ları kurmak ve/veya sonrasında bunları **temizlemek** için çok faydalıdır. Örneğin bir veritabanı connection pool’u ya da paylaşılan bir machine learning modelini yüklemek gibi.
-
-## Kullanım Senaryosu { #use-case }
-
-Önce bir **kullanım senaryosu** örneğiyle başlayalım, sonra bunu bununla nasıl çözeceğimize bakalım.
-
-Request’leri işlemek için kullanmak istediğiniz bazı **machine learning modelleriniz** olduğunu hayal edelim. 🤖
-
-Aynı modeller request’ler arasında paylaşılır; yani request başına bir model, kullanıcı başına bir model vb. gibi değil.
-
-Modeli yüklemenin, diskten çok fazla **data** okunması gerektiği için **oldukça uzun sürebildiğini** düşünelim. Dolayısıyla bunu her request için yapmak istemezsiniz.
-
-Modeli modülün/dosyanın en üst seviyesinde yükleyebilirdiniz; ancak bu, basit bir otomatik test çalıştırdığınızda bile **modelin yükleneceği** anlamına gelir. Böyle olunca test, kodun bağımsız bir kısmını çalıştırabilmek için önce modelin yüklenmesini beklemek zorunda kalır ve **yavaş** olur.
-
-Burada çözeceğimiz şey bu: modeli request’ler işlenmeden önce yükleyelim, ama kod yüklenirken değil; yalnızca uygulama request almaya başlamadan hemen önce.
-
-## Lifespan { #lifespan }
-
-Bu *startup* ve *shutdown* mantığını, `FastAPI` uygulamasının `lifespan` parametresi ve bir "context manager" kullanarak tanımlayabilirsiniz (bunun ne olduğunu birazdan göstereceğim).
-
-Önce bir örnekle başlayıp sonra ayrıntılarına bakalım.
-
-Aşağıdaki gibi `yield` kullanan async bir `lifespan()` fonksiyonu oluşturuyoruz:
-
-{* ../../docs_src/events/tutorial003_py39.py hl[16,19] *}
-
-Burada, `yield` öncesinde (sahte) model fonksiyonunu machine learning modellerini içeren dictionary’e koyarak, modeli yükleme gibi maliyetli bir *startup* işlemini simüle ediyoruz. Bu kod, *startup* sırasında, uygulama **request almaya başlamadan önce** çalıştırılır.
-
-Ardından `yield`’den hemen sonra modeli bellekten kaldırıyoruz (unload). Bu kod, uygulama **request’leri işlemeyi bitirdikten sonra**, *shutdown*’dan hemen önce çalıştırılır. Örneğin memory veya GPU gibi resource’ları serbest bırakabilir.
-
-/// tip | İpucu
-
-`shutdown`, uygulamayı **durdurduğunuzda** gerçekleşir.
-
-Belki yeni bir sürüm başlatmanız gerekiyordur, ya da çalıştırmaktan sıkılmışsınızdır. 🤷
-
-///
-
-### Lifespan fonksiyonu { #lifespan-function }
-
-Dikkat edilmesi gereken ilk şey, `yield` içeren async bir fonksiyon tanımlıyor olmamız. Bu, `yield` kullanan Dependencies’e oldukça benzer.
-
-{* ../../docs_src/events/tutorial003_py39.py hl[14:19] *}
-
-Fonksiyonun `yield`’den önceki kısmı, uygulama başlamadan **önce** çalışır.
-
-`yield`’den sonraki kısım ise, uygulama işini bitirdikten **sonra** çalışır.
-
-### Async Context Manager { #async-context-manager }
-
-Bakarsanız, fonksiyon `@asynccontextmanager` ile dekore edilmiş.
-
-Bu da fonksiyonu "**async context manager**" denen şeye dönüştürür.
-
-{* ../../docs_src/events/tutorial003_py39.py hl[1,13] *}
-
-Python’da **context manager**, `with` ifadesi içinde kullanabildiğiniz bir yapıdır. Örneğin `open()` bir context manager olarak kullanılabilir:
-
-```Python
-with open("file.txt") as file:
-    file.read()
-```
-
-Python’ın güncel sürümlerinde bir de **async context manager** vardır. Bunu `async with` ile kullanırsınız:
-
-```Python
-async with lifespan(app):
-    await do_stuff()
-```
-
-Yukarıdaki gibi bir context manager veya async context manager oluşturduğunuzda, yaptığı şey şudur: `with` bloğuna girmeden önce `yield`’den önceki kodu çalıştırır, `with` bloğundan çıktıktan sonra da `yield`’den sonraki kodu çalıştırır.
-
-Yukarıdaki kod örneğimizde bunu doğrudan kullanmıyoruz; bunun yerine FastAPI’ye veriyoruz ki o kullansın.
-
-`FastAPI` uygulamasının `lifespan` parametresi bir **async context manager** alır; dolayısıyla oluşturduğumuz yeni `lifespan` async context manager’ını buraya geçebiliriz.
-
-{* ../../docs_src/events/tutorial003_py39.py hl[22] *}
-
-## Alternatif Events (kullanımdan kaldırıldı) { #alternative-events-deprecated }
-
-/// warning | Uyarı
-
-*startup* ve *shutdown* işlemlerini yönetmenin önerilen yolu, yukarıda anlatıldığı gibi `FastAPI` uygulamasının `lifespan` parametresini kullanmaktır. Bir `lifespan` parametresi sağlarsanız, `startup` ve `shutdown` event handler’ları artık çağrılmaz. Ya tamamen `lifespan` ya da tamamen events; ikisi birden değil.
-
-Muhtemelen bu bölümü atlayabilirsiniz.
-
-///
-
-*startup* ve *shutdown* sırasında çalıştırılacak bu mantığı tanımlamanın alternatif bir yolu daha vardır.
-
-Uygulama başlamadan önce veya uygulama kapanırken çalıştırılması gereken event handler’ları (fonksiyonları) tanımlayabilirsiniz.
-
-Bu fonksiyonlar `async def` ile veya normal `def` ile tanımlanabilir.
-
-### `startup` eventi { #startup-event }
-
-Uygulama başlamadan önce çalıştırılacak bir fonksiyon eklemek için, `"startup"` event’i ile tanımlayın:
-
-{* ../../docs_src/events/tutorial001_py39.py hl[8] *}
-
-Bu durumda `startup` event handler fonksiyonu, "database" öğesini (sadece bir `dict`) bazı değerlerle başlatır.
-
-Birden fazla event handler fonksiyonu ekleyebilirsiniz.
-
-Ve tüm `startup` event handler’ları tamamlanmadan uygulamanız request almaya başlamaz.
-
-### `shutdown` eventi { #shutdown-event }
-
-Uygulama kapanırken çalıştırılacak bir fonksiyon eklemek için, `"shutdown"` event’i ile tanımlayın:
-
-{* ../../docs_src/events/tutorial002_py39.py hl[6] *}
-
-Burada `shutdown` event handler fonksiyonu, `log.txt` dosyasına `"Application shutdown"` satırını yazar.
-
-/// info | Bilgi
-
-`open()` fonksiyonunda `mode="a"` "append" anlamına gelir; yani satır, önceki içeriği silmeden dosyada ne varsa onun sonuna eklenir.
-
-///
-
-/// tip | İpucu
-
-Dikkat edin, bu örnekte bir dosyayla etkileşen standart Python `open()` fonksiyonunu kullanıyoruz.
-
-Dolayısıyla disk’e yazılmasını beklemeyi gerektiren I/O (input/output) söz konusu.
-
-Ancak `open()` `async` ve `await` kullanmaz.
-
-Bu yüzden event handler fonksiyonunu `async def` yerine standart `def` ile tanımlarız.
-
-///
-
-### `startup` ve `shutdown` birlikte { #startup-and-shutdown-together }
-
-*startup* ve *shutdown* mantığınızın birbiriyle bağlantılı olma ihtimali yüksektir; bir şeyi başlatıp sonra bitirmek, bir resource edinip sonra serbest bırakmak vb. isteyebilirsiniz.
-
-Bunu, ortak mantık veya değişken paylaşmayan ayrı fonksiyonlarda yapmak daha zordur; çünkü değerleri global değişkenlerde tutmanız veya benzer numaralar yapmanız gerekir.
-
-Bu nedenle artık bunun yerine, yukarıda açıklandığı gibi `lifespan` kullanmanız önerilmektedir.
-
-## Teknik Detaylar { #technical-details }
-
-Meraklı nerd’ler için küçük bir teknik detay. 🤓
-
-Altta, ASGI teknik spesifikasyonunda bu, <a href="https://asgi.readthedocs.io/en/latest/specs/lifespan.html" class="external-link" target="_blank">Lifespan Protocol</a>’ün bir parçasıdır ve `startup` ile `shutdown` adında event’ler tanımlar.
-
-/// info | Bilgi
-
-Starlette `lifespan` handler’ları hakkında daha fazlasını <a href="https://www.starlette.dev/lifespan/" class="external-link" target="_blank">Starlette's Lifespan docs</a> içinde okuyabilirsiniz.
-
-Ayrıca kodunuzun başka bölgelerinde de kullanılabilecek lifespan state’i nasıl yöneteceğinizi de kapsar.
-
-///
-
-## Alt Uygulamalar { #sub-applications }
-
-🚨 Unutmayın: Bu lifespan event’leri (`startup` ve `shutdown`) yalnızca ana uygulama için çalıştırılır; [Alt Uygulamalar - Mounts](sub-applications.md){.internal-link target=_blank} için çalıştırılmaz.

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

@@ -1,208 +0,0 @@
-# SDK Üretme { #generating-sdks }
-
-**FastAPI**, **OpenAPI** spesifikasyonunu temel aldığı için API'leri birçok aracın anlayabildiği standart bir formatta tanımlanabilir.
-
-Bu sayede güncel **dokümantasyon**, birden fazla dilde istemci kütüphaneleri (<abbr title="Software Development Kits - Yazılım Geliştirme Kitleri">**SDKs**</abbr>) ve kodunuzla senkron kalan **test** veya **otomasyon iş akışları** üretmek kolaylaşır.
-
-Bu rehberde, FastAPI backend'iniz için bir **TypeScript SDK** üretmeyi öğreneceksiniz.
-
-## Açık Kaynak SDK Üreteçleri { #open-source-sdk-generators }
-
-Esnek bir seçenek olan <a href="https://openapi-generator.tech/" class="external-link" target="_blank">OpenAPI Generator</a>, **birçok programlama dilini** destekler ve OpenAPI spesifikasyonunuzdan SDK üretebilir.
-
-**TypeScript client**'lar için <a href="https://heyapi.dev/" class="external-link" target="_blank">Hey API</a>, TypeScript ekosistemi için özel olarak tasarlanmış, optimize bir deneyim sunan bir çözümdür.
-
-Daha fazla SDK üretecini <a href="https://openapi.tools/#sdk" class="external-link" target="_blank">OpenAPI.Tools</a> üzerinde keşfedebilirsiniz.
-
-/// tip | İpucu
-
-FastAPI otomatik olarak **OpenAPI 3.1** spesifikasyonları üretir; bu yüzden kullanacağınız aracın bu sürümü desteklemesi gerekir.
-
-///
-
-## FastAPI Sponsorlarından SDK Üreteçleri { #sdk-generators-from-fastapi-sponsors }
-
-Bu bölüm, FastAPI'yi sponsorlayan şirketlerin sunduğu **yatırım destekli** ve **şirket destekli** çözümleri öne çıkarır. Bu ürünler, yüksek kaliteli üretilen SDK'ların üzerine **ek özellikler** ve **entegrasyonlar** sağlar.
-
-✨ [**FastAPI'ye sponsor olarak**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨ bu şirketler, framework'ün ve **ekosisteminin** sağlıklı ve **sürdürülebilir** kalmasına yardımcı olur.
-
-Sponsor olmaları aynı zamanda FastAPI **topluluğuna** (size) güçlü bir bağlılığı da gösterir; yalnızca **iyi bir hizmet** sunmayı değil, aynı zamanda **güçlü ve gelişen bir framework** olan FastAPI'yi desteklemeyi de önemsediklerini gösterir. 🙇
-
-Örneğin şunları deneyebilirsiniz:
-
-* <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.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>
-
-Bu çözümlerin bazıları açık kaynak olabilir veya ücretsiz katman sunabilir; yani finansal bir taahhüt olmadan deneyebilirsiniz. Başka ticari SDK üreteçleri de vardır ve internette bulunabilir. 🤓
-
-## TypeScript SDK Oluşturma { #create-a-typescript-sdk }
-
-Basit bir FastAPI uygulamasıyla başlayalım:
-
-{* ../../docs_src/generate_clients/tutorial001_py39.py hl[7:9,12:13,16:17,21] *}
-
-*Path operation*'ların, request payload ve response payload için kullandıkları modelleri `Item` ve `ResponseMessage` modelleriyle tanımladıklarına dikkat edin.
-
-### API Dokümanları { #api-docs }
-
-`/docs` adresine giderseniz, request'lerde gönderilecek ve response'larda alınacak veriler için **schema**'ları içerdiğini görürsünüz:
-
-<img src="/img/tutorial/generate-clients/image01.png">
-
-Bu schema'ları görebilirsiniz, çünkü uygulamada modellerle birlikte tanımlandılar.
-
-Bu bilgi uygulamanın **OpenAPI schema**'sında bulunur ve sonrasında API dokümanlarında gösterilir.
-
-OpenAPI'ye dahil edilen, modellerden gelen bu bilginin aynısı **client code üretmek** için kullanılabilir.
-
-### Hey API { #hey-api }
-
-Modelleri olan bir FastAPI uygulamamız olduğunda, Hey API ile bir TypeScript client üretebiliriz. Bunu yapmanın en hızlı yolu npx kullanmaktır.
-
-```sh
-npx @hey-api/openapi-ts -i http://localhost:8000/openapi.json -o src/client
-```
-
-Bu komut `./src/client` içine bir TypeScript SDK üretecektir.
-
-Web sitelerinde <a href="https://heyapi.dev/openapi-ts/get-started" class="external-link" target="_blank">`@hey-api/openapi-ts` kurulumunu</a> öğrenebilir ve <a href="https://heyapi.dev/openapi-ts/output" class="external-link" target="_blank">üretilen çıktıyı</a> inceleyebilirsiniz.
-
-### SDK'yı Kullanma { #using-the-sdk }
-
-Artık client code'u import edip kullanabilirsiniz. Şuna benzer görünebilir; method'lar için otomatik tamamlama aldığınıza dikkat edin:
-
-<img src="/img/tutorial/generate-clients/image02.png">
-
-Ayrıca gönderilecek payload için de otomatik tamamlama alırsınız:
-
-<img src="/img/tutorial/generate-clients/image03.png">
-
-/// tip | İpucu
-
-`name` ve `price` için otomatik tamamlamaya dikkat edin; bunlar FastAPI uygulamasında, `Item` modelinde tanımlanmıştı.
-
-///
-
-Gönderdiğiniz veriler için satır içi hatalar (inline errors) da alırsınız:
-
-<img src="/img/tutorial/generate-clients/image04.png">
-
-Response objesi de otomatik tamamlama sunacaktır:
-
-<img src="/img/tutorial/generate-clients/image05.png">
-
-## Tag'lerle FastAPI Uygulaması { #fastapi-app-with-tags }
-
-Birçok durumda FastAPI uygulamanız daha büyük olacaktır ve farklı *path operation* gruplarını ayırmak için muhtemelen tag'leri kullanacaksınız.
-
-Örneğin **items** için bir bölüm, **users** için başka bir bölüm olabilir ve bunları tag'lerle ayırabilirsiniz:
-
-{* ../../docs_src/generate_clients/tutorial002_py39.py hl[21,26,34] *}
-
-### Tag'lerle TypeScript Client Üretme { #generate-a-typescript-client-with-tags }
-
-Tag'leri kullanan bir FastAPI uygulaması için client ürettiğinizde, genelde client code da tag'lere göre ayrılır.
-
-Bu sayede client code tarafında her şey doğru şekilde sıralanır ve gruplandırılır:
-
-<img src="/img/tutorial/generate-clients/image06.png">
-
-Bu örnekte şunlar var:
-
-* `ItemsService`
-* `UsersService`
-
-### Client Method İsimleri { #client-method-names }
-
-Şu an üretilen `createItemItemsPost` gibi method isimleri çok temiz görünmüyor:
-
-```TypeScript
-ItemsService.createItemItemsPost({name: "Plumbus", price: 5})
-```
-
-...çünkü client üreteci, her *path operation* için OpenAPI'nin dahili **operation ID** değerini kullanır.
-
-OpenAPI, her operation ID'nin tüm *path operation*'lar arasında benzersiz olmasını ister. Bu yüzden FastAPI; operation ID'yi benzersiz tutabilmek için **function adı**, **path** ve **HTTP method/operation** bilgilerini birleştirerek üretir.
-
-Ancak bunu bir sonraki adımda nasıl iyileştirebileceğinizi göstereceğim. 🤓
-
-## Özel Operation ID'ler ve Daha İyi Method İsimleri { #custom-operation-ids-and-better-method-names }
-
-Bu operation ID'lerin **üretilme** şeklini **değiştirerek**, client'larda daha basit **method isimleri** elde edebilirsiniz.
-
-Bu durumda, her operation ID'nin **benzersiz** olduğundan başka bir şekilde emin olmanız gerekir.
-
-Örneğin, her *path operation*'ın bir tag'i olmasını sağlayabilir ve operation ID'yi **tag** ve *path operation* **adı**na (function adı) göre üretebilirsiniz.
-
-### Benzersiz ID Üreten Özel Fonksiyon { #custom-generate-unique-id-function }
-
-FastAPI, her *path operation* için bir **unique ID** kullanır. Bu ID, **operation ID** için ve ayrıca request/response'lar için gerekebilecek özel model isimleri için de kullanılır.
-
-Bu fonksiyonu özelleştirebilirsiniz. Bir `APIRoute` alır ve string döndürür.
-
-Örneğin burada ilk tag'i (muhtemelen tek tag'iniz olur) ve *path operation* adını (function adı) kullanıyor.
-
-Sonrasında bu özel fonksiyonu `generate_unique_id_function` parametresiyle **FastAPI**'ye geçebilirsiniz:
-
-{* ../../docs_src/generate_clients/tutorial003_py39.py hl[6:7,10] *}
-
-### Özel Operation ID'lerle TypeScript Client Üretme { #generate-a-typescript-client-with-custom-operation-ids }
-
-Artık client'ı tekrar üretirseniz, geliştirilmiş method isimlerini göreceksiniz:
-
-<img src="/img/tutorial/generate-clients/image07.png">
-
-Gördüğünüz gibi method isimleri artık önce tag'i, sonra function adını içeriyor; URL path'i ve HTTP operation bilgisini artık taşımıyor.
-
-### Client Üretecine Vermeden Önce OpenAPI Spesifikasyonunu Ön İşlemek { #preprocess-the-openapi-specification-for-the-client-generator }
-
-Üretilen kodda hâlâ bazı **tekrarlanan bilgiler** var.
-
-Bu method'un **items** ile ilişkili olduğunu zaten biliyoruz; çünkü bu kelime `ItemsService` içinde var (tag'den geliyor). Ama method adında da tag adı önek olarak duruyor. 😕
-
-OpenAPI genelinde muhtemelen bunu korumak isteriz; çünkü operation ID'lerin **benzersiz** olmasını sağlar.
-
-Ancak üretilen client için, client'ları üretmeden hemen önce OpenAPI operation ID'lerini **değiştirip**, method isimlerini daha hoş ve **temiz** hale getirebiliriz.
-
-OpenAPI JSON'u `openapi.json` diye bir dosyaya indirip, şu tarz bir script ile **öndeki tag'i kaldırabiliriz**:
-
-{* ../../docs_src/generate_clients/tutorial004_py39.py *}
-
-//// tab | Node.js
-
-```Javascript
-{!> ../../docs_src/generate_clients/tutorial004.js!}
-```
-
-////
-
-Bununla operation ID'ler `items-get_items` gibi değerlerden sadece `get_items` olacak şekilde yeniden adlandırılır; böylece client üreteci daha basit method isimleri üretebilir.
-
-### Ön İşlenmiş OpenAPI ile TypeScript Client Üretme { #generate-a-typescript-client-with-the-preprocessed-openapi }
-
-Sonuç artık bir `openapi.json` dosyasında olduğuna göre, input konumunu güncellemeniz gerekir:
-
-```sh
-npx @hey-api/openapi-ts -i ./openapi.json -o src/client
-```
-
-Yeni client'ı ürettikten sonra, tüm **otomatik tamamlama**, **satır içi hatalar**, vb. ile birlikte **temiz method isimleri** elde edersiniz:
-
-<img src="/img/tutorial/generate-clients/image08.png">
-
-## Faydalar { #benefits }
-
-Otomatik üretilen client'ları kullanınca şu alanlarda **otomatik tamamlama** elde edersiniz:
-
-* Method'lar.
-* Body'deki request payload'ları, query parametreleri, vb.
-* Response payload'ları.
-
-Ayrıca her şey için **satır içi hatalar** (inline errors) da olur.
-
-Backend kodunu her güncellediğinizde ve frontend'i **yeniden ürettiğinizde**, yeni *path operation*'lar method olarak eklenir, eskileri kaldırılır ve diğer değişiklikler de üretilen koda yansır. 🤓
-
-Bu, bir şey değiştiğinde client code'a otomatik olarak **yansıyacağı** anlamına gelir. Ayrıca client'ı **build** ettiğinizde, kullanılan verilerde bir **uyuşmazlık** (mismatch) varsa hata alırsınız.
-
-Böylece üretimde son kullanıcılara hata yansımasını beklemek ve sonra sorunun nerede olduğunu debug etmeye çalışmak yerine, geliştirme sürecinin çok erken aşamalarında **birçok hatayı tespit edersiniz**. ✨

docs/tr/docs/advanced/middleware.md

@@ -1,97 +0,0 @@
-# İleri Seviye Middleware { #advanced-middleware }
-
-Ana tutorial'da uygulamanıza [Özel Middleware](../tutorial/middleware.md){.internal-link target=_blank} eklemeyi gördünüz.
-
-Ardından [`CORSMiddleware` ile CORS'u yönetmeyi](../tutorial/cors.md){.internal-link target=_blank} de okudunuz.
-
-Bu bölümde diğer middleware'leri nasıl kullanacağımıza bakacağız.
-
-## ASGI middleware'leri ekleme { #adding-asgi-middlewares }
-
-**FastAPI**, Starlette üzerine kurulu olduğu ve <abbr title="Asynchronous Server Gateway Interface - Asenkron Sunucu Ağ Geçidi Arayüzü">ASGI</abbr> spesifikasyonunu uyguladığı için, herhangi bir ASGI middleware'ini kullanabilirsiniz.
-
-Bir middleware'in çalışması için özellikle FastAPI ya da Starlette için yazılmış olması gerekmez; ASGI spec'ine uyduğu sürece yeterlidir.
-
-Genel olarak ASGI middleware'leri, ilk argüman olarak bir ASGI app almayı bekleyen class'lar olur.
-
-Dolayısıyla üçüncü taraf ASGI middleware'lerinin dokümantasyonunda muhtemelen şöyle bir şey yapmanızı söylerler:
-
-```Python
-from unicorn import UnicornMiddleware
-
-app = SomeASGIApp()
-
-new_app = UnicornMiddleware(app, some_config="rainbow")
-```
-
-Ancak FastAPI (aslında Starlette) bunu yapmanın daha basit bir yolunu sunar; böylece dahili middleware'ler server hatalarını doğru şekilde ele alır ve özel exception handler'lar düzgün çalışır.
-
-Bunun için `app.add_middleware()` kullanırsınız (CORS örneğindeki gibi).
-
-```Python
-from fastapi import FastAPI
-from unicorn import UnicornMiddleware
-
-app = FastAPI()
-
-app.add_middleware(UnicornMiddleware, some_config="rainbow")
-```
-
-`app.add_middleware()` ilk argüman olarak bir middleware class'ı alır ve middleware'e aktarılacak ek argümanları da kabul eder.
-
-## Entegre middleware'ler { #integrated-middlewares }
-
-**FastAPI**, yaygın kullanım senaryoları için birkaç middleware içerir; şimdi bunları nasıl kullanacağımıza bakacağız.
-
-/// note | Teknik Detaylar
-
-Bir sonraki örneklerde `from starlette.middleware.something import SomethingMiddleware` kullanmanız da mümkündür.
-
-**FastAPI**, size (geliştirici olarak) kolaylık olsun diye `fastapi.middleware` içinde bazı middleware'leri sağlar. Ancak mevcut middleware'lerin çoğu doğrudan Starlette'ten gelir.
-
-///
-
-## `HTTPSRedirectMiddleware` { #httpsredirectmiddleware }
-
-Gelen tüm request'lerin `https` veya `wss` olmasını zorunlu kılar.
-
-`http` veya `ws` olarak gelen herhangi bir request, bunun yerine güvenli şemaya redirect edilir.
-
-{* ../../docs_src/advanced_middleware/tutorial001_py39.py hl[2,6] *}
-
-## `TrustedHostMiddleware` { #trustedhostmiddleware }
-
-HTTP Host Header saldırılarına karşı korunmak için, gelen tüm request'lerde `Host` header'ının doğru ayarlanmış olmasını zorunlu kılar.
-
-{* ../../docs_src/advanced_middleware/tutorial002_py39.py hl[2,6:8] *}
-
-Aşağıdaki argümanlar desteklenir:
-
-* `allowed_hosts` - Hostname olarak izin verilmesi gereken domain adlarının listesi. `*.example.com` gibi wildcard domain'ler subdomain eşleştirmesi için desteklenir. Herhangi bir hostname'e izin vermek için `allowed_hosts=["*"]` kullanın veya middleware'i hiç eklemeyin.
-* `www_redirect` - True olarak ayarlanırsa, izin verilen host'ların www olmayan sürümlerine gelen request'ler www sürümlerine redirect edilir. Varsayılanı `True`'dur.
-
-Gelen bir request doğru şekilde doğrulanmazsa `400` response gönderilir.
-
-## `GZipMiddleware` { #gzipmiddleware }
-
-`Accept-Encoding` header'ında `"gzip"` içeren herhangi bir request için GZip response'larını yönetir.
-
-Middleware hem standart hem de streaming response'ları ele alır.
-
-{* ../../docs_src/advanced_middleware/tutorial003_py39.py hl[2,6] *}
-
-Aşağıdaki argümanlar desteklenir:
-
-* `minimum_size` - Bayt cinsinden bu minimum boyuttan küçük response'lara GZip uygulama. Varsayılanı `500`'dür.
-* `compresslevel` - GZip sıkıştırması sırasında kullanılır. 1 ile 9 arasında bir tamsayıdır. Varsayılanı `9`'dur. Daha düşük değer daha hızlı sıkıştırma ama daha büyük dosya boyutları üretir; daha yüksek değer daha yavaş sıkıştırma ama daha küçük dosya boyutları üretir.
-
-## Diğer middleware'ler { #other-middlewares }
-
-Başka birçok ASGI middleware'i vardır.
-
-Örneğin:
-
-* <a href="https://github.com/encode/uvicorn/blob/master/uvicorn/middleware/proxy_headers.py" class="external-link" target="_blank">Uvicorn'un `ProxyHeadersMiddleware`'i</a>
-* <a href="https://github.com/florimondmanca/msgpack-asgi" class="external-link" target="_blank">MessagePack</a>
-
-Diğer mevcut middleware'leri görmek için <a href="https://www.starlette.dev/middleware/" class="external-link" target="_blank">Starlette'in Middleware dokümanlarına</a> ve <a href="https://github.com/florimondmanca/awesome-asgi" class="external-link" target="_blank">ASGI Awesome List</a> listesine bakın.

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

@@ -1,186 +0,0 @@
-# OpenAPI Callback'leri { #openapi-callbacks }
-
-Başka biri tarafından (muhtemelen API'nizi *kullanacak* olan aynı geliştirici tarafından) oluşturulmuş bir *external API*'ye request tetikleyebilen bir *path operation* ile bir API oluşturabilirsiniz.
-
-API uygulamanızın *external API*'yi çağırdığı sırada gerçekleşen sürece "callback" denir. Çünkü dış geliştiricinin yazdığı yazılım API'nize bir request gönderir ve ardından API'niz *geri çağrı* yaparak (*call back*), bir *external API*'ye request gönderir (muhtemelen aynı geliştiricinin oluşturduğu).
-
-Bu durumda, o external API'nin nasıl görünmesi *gerektiğini* dokümante etmek isteyebilirsiniz. Hangi *path operation*'a sahip olmalı, hangi body'yi beklemeli, hangi response'u döndürmeli, vb.
-
-## Callback'leri olan bir uygulama { #an-app-with-callbacks }
-
-Bunların hepsine bir örnekle bakalım.
-
-Fatura oluşturmayı sağlayan bir uygulama geliştirdiğinizi düşünün.
-
-Bu faturaların `id`, `title` (opsiyonel), `customer` ve `total` alanları olacak.
-
-API'nizin kullanıcısı (external bir geliştirici) API'nizde bir POST request ile fatura oluşturacak.
-
-Sonra API'niz (varsayalım ki):
-
-* Faturayı external geliştiricinin bir müşterisine gönderir.
-* Parayı tahsil eder.
-* API kullanıcısına (external geliştiriciye) tekrar bir bildirim gönderir.
-    * Bu, external geliştiricinin sağladığı bir *external API*'ye (*sizin API'nizden*) bir POST request gönderilerek yapılır (işte bu "callback"tir).
-
-## Normal **FastAPI** uygulaması { #the-normal-fastapi-app }
-
-Önce callback eklemeden önce normal API uygulamasının nasıl görüneceğine bakalım.
-
-Bir `Invoice` body alacak bir *path operation*'ı ve callback için URL'yi taşıyacak `callback_url` adlı bir query parametresi olacak.
-
-Bu kısım oldukça standart; kodun çoğu muhtemelen size zaten tanıdık gelecektir:
-
-{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[7:11,34:51] *}
-
-/// tip | İpucu
-
-`callback_url` query parametresi, Pydantic'in <a href="https://docs.pydantic.dev/latest/api/networks/" class="external-link" target="_blank">Url</a> tipini kullanır.
-
-///
-
-Tek yeni şey, *path operation decorator*'ına argüman olarak verilen `callbacks=invoices_callback_router.routes`. Bunun ne olduğuna şimdi bakacağız.
-
-## Callback'i dokümante etmek { #documenting-the-callback }
-
-Callback'in gerçek kodu, büyük ölçüde sizin API uygulamanıza bağlıdır.
-
-Ve bir uygulamadan diğerine oldukça değişebilir.
-
-Sadece bir-iki satır kod bile olabilir, örneğin:
-
-```Python
-callback_url = "https://example.com/api/v1/invoices/events/"
-httpx.post(callback_url, json={"description": "Invoice paid", "paid": True})
-```
-
-Ancak callback'in belki de en önemli kısmı, API'nizin kullanıcısının (external geliştiricinin) *external API*'yi doğru şekilde uyguladığından emin olmaktır; çünkü *sizin API'niz* callback'in request body'sinde belirli veriler gönderecektir, vb.
-
-Dolayısıyla sıradaki adım olarak, *sizin API'nizden* callback almak için o *external API*'nin nasıl görünmesi gerektiğini dokümante eden kodu ekleyeceğiz.
-
-Bu dokümantasyon, API'nizde `/docs` altındaki Swagger UI'da görünecek ve external geliştiricilere *external API*'yi nasıl inşa edeceklerini gösterecek.
-
-Bu örnek callback'in kendisini implemente etmiyor (o zaten tek satır kod olabilir), sadece dokümantasyon kısmını ekliyor.
-
-/// tip | İpucu
-
-Gerçek callback, sadece bir HTTP request'tir.
-
-Callback'i kendiniz implemente ederken <a href="https://www.python-httpx.org" class="external-link" target="_blank">HTTPX</a> veya <a href="https://requests.readthedocs.io/" class="external-link" target="_blank">Requests</a> gibi bir şey kullanabilirsiniz.
-
-///
-
-## Callback dokümantasyon kodunu yazın { #write-the-callback-documentation-code }
-
-Bu kod uygulamanızda çalıştırılmayacak; sadece o *external API*'nin nasıl görünmesi gerektiğini *dokümante etmek* için gerekiyor.
-
-Ancak **FastAPI** ile bir API için otomatik dokümantasyonu kolayca nasıl üreteceğinizi zaten biliyorsunuz.
-
-O halde aynı bilgiyi kullanarak, *external API*'nin nasıl görünmesi gerektiğini dokümante edeceğiz... external API'nin implemente etmesi gereken *path operation*'ları oluşturarak (API'nizin çağıracağı olanlar).
-
-/// tip | İpucu
-
-Bir callback'i dokümante eden kodu yazarken, kendinizi *external geliştirici* olarak hayal etmek faydalı olabilir. Ve şu anda *sizin API'nizi* değil, *external API*'yi implemente ettiğinizi düşünün.
-
-Bu bakış açısını (external geliştiricinin bakış açısını) geçici olarak benimsemek; parametreleri nereye koyacağınızı, body için Pydantic modelini, response için modelini vb. external API tarafında nasıl tasarlayacağınızı daha net hale getirebilir.
-
-///
-
-### Bir callback `APIRouter` oluşturun { #create-a-callback-apirouter }
-
-Önce bir veya daha fazla callback içerecek yeni bir `APIRouter` oluşturun.
-
-{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[1,23] *}
-
-### Callback *path operation*'ını oluşturun { #create-the-callback-path-operation }
-
-Callback *path operation*'ını oluşturmak için, yukarıda oluşturduğunuz aynı `APIRouter`'ı kullanın.
-
-Normal bir FastAPI *path operation*'ı gibi görünmelidir:
-
-* Muhtemelen alması gereken body'nin bir deklarasyonu olmalı, örn. `body: InvoiceEvent`.
-* Ayrıca döndürmesi gereken response'un deklarasyonu da olabilir, örn. `response_model=InvoiceEventReceived`.
-
-{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[14:16,19:20,26:30] *}
-
-Normal bir *path operation*'dan 2 temel farkı vardır:
-
-* Gerçek bir koda ihtiyaç duymaz; çünkü uygulamanız bu kodu asla çağırmayacak. Bu yalnızca *external API*'yi dokümante etmek için kullanılır. Yani fonksiyon sadece `pass` içerebilir.
-* *path*, bir <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">OpenAPI 3 expression</a> (aşağıda daha fazlası) içerebilir; böylece parametreler ve *sizin API'nize* gönderilen orijinal request'in bazı parçalarıyla değişkenler kullanılabilir.
-
-### Callback path ifadesi { #the-callback-path-expression }
-
-Callback *path*'i, *sizin API'nize* gönderilen orijinal request'in bazı parçalarını içerebilen bir <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md#key-expression" class="external-link" target="_blank">OpenAPI 3 expression</a> barındırabilir.
-
-Bu örnekte, bu bir `str`:
-
-```Python
-"{$callback_url}/invoices/{$request.body.id}"
-```
-
-Yani API'nizin kullanıcısı (external geliştirici) *sizin API'nize* şu adrese bir request gönderirse:
-
-```
-https://yourapi.com/invoices/?callback_url=https://www.external.org/events
-```
-
-ve JSON body şu şekilde olursa:
-
-```JSON
-{
-    "id": "2expen51ve",
-    "customer": "Mr. Richie Rich",
-    "total": "9999"
-}
-```
-
-o zaman *sizin API'niz* faturayı işleyecek ve daha sonra bir noktada `callback_url`'ye (yani *external API*'ye) bir callback request gönderecek:
-
-```
-https://www.external.org/events/invoices/2expen51ve
-```
-
-ve JSON body yaklaşık şöyle bir şey içerecek:
-
-```JSON
-{
-    "description": "Payment celebration",
-    "paid": true
-}
-```
-
-ve o *external API*'den şu gibi bir JSON body içeren response bekleyecek:
-
-```JSON
-{
-    "ok": true
-}
-```
-
-/// tip | İpucu
-
-Callback URL'sinin, `callback_url` içindeki query parametresi olarak alınan URL'yi (`https://www.external.org/events`) ve ayrıca JSON body'nin içindeki fatura `id`'sini (`2expen51ve`) birlikte kullandığına dikkat edin.
-
-///
-
-### Callback router'ını ekleyin { #add-the-callback-router }
-
-Bu noktada, yukarıda oluşturduğunuz callback router'ında gerekli callback *path operation*'ları (external geliştiricinin *external API*'de implemente etmesi gerekenler) hazır.
-
-Şimdi *sizin API'nizin path operation decorator*'ında `callbacks` parametresini kullanarak, callback router'ının `.routes` attribute'unu (bu aslında route/*path operation*'lardan oluşan bir `list`) geçin:
-
-{* ../../docs_src/openapi_callbacks/tutorial001_py310.py hl[33] *}
-
-/// tip | İpucu
-
-`callback=` içine router'ın kendisini (`invoices_callback_router`) değil, `invoices_callback_router.routes` şeklinde `.routes` attribute'unu verdiğinize dikkat edin.
-
-///
-
-### Dokümanları kontrol edin { #check-the-docs }
-
-Artık uygulamanızı başlatıp <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresine gidebilirsiniz.
-
-*Path operation*'ınız için, *external API*'nin nasıl görünmesi gerektiğini gösteren bir "Callbacks" bölümünü içeren dokümanları göreceksiniz:
-
-<img src="/img/tutorial/openapi-callbacks/image01.png">

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

@@ -1,55 +0,0 @@
-# OpenAPI Webhook'lar { #openapi-webhooks }
-
-Bazı durumlarda, API'nizi kullanan **kullanıcılara** uygulamanızın *onların* uygulamasını (request göndererek) bazı verilerle çağırabileceğini; genellikle bir tür **event** hakkında **bildirim** yapmak için kullanacağını söylemek istersiniz.
-
-Bu da şunu ifade eder: Kullanıcılarınızın API'nize request göndermesi şeklindeki normal akış yerine, request'i **sizin API'niz** (veya uygulamanız) **onların sistemine** (onların API'sine, onların uygulamasına) **gönderebilir**.
-
-Buna genellikle **webhook** denir.
-
-## Webhook adımları { #webhooks-steps }
-
-Süreç genellikle şöyledir: Kodunuzda göndereceğiniz mesajın ne olduğunu, yani request'in **body**'sini **siz tanımlarsınız**.
-
-Ayrıca uygulamanızın bu request'leri veya event'leri hangi **anlarda** göndereceğini de bir şekilde tanımlarsınız.
-
-Ve **kullanıcılarınız** da bir şekilde (örneğin bir web dashboard üzerinden) uygulamanızın bu request'leri göndermesi gereken **URL**'yi tanımlar.
-
-Webhook'lar için URL'lerin nasıl kaydedileceğine dair tüm **mantık** ve bu request'leri gerçekten gönderen kod tamamen size bağlıdır. Bunu **kendi kodunuzda** istediğiniz gibi yazarsınız.
-
-## **FastAPI** ve OpenAPI ile webhook'ları dokümante etmek { #documenting-webhooks-with-fastapi-and-openapi }
-
-**FastAPI** ile OpenAPI kullanarak bu webhook'ların adlarını, uygulamanızın gönderebileceği HTTP operation türlerini (örn. `POST`, `PUT`, vb.) ve uygulamanızın göndereceği request **body**'lerini tanımlayabilirsiniz.
-
-Bu, kullanıcılarınızın **webhook** request'lerinizi alacak şekilde **API'lerini implement etmesini** çok daha kolaylaştırabilir; hatta kendi API kodlarının bir kısmını otomatik üretebilirler.
-
-/// info | Bilgi
-
-Webhook'lar OpenAPI 3.1.0 ve üzeri sürümlerde mevcuttur; FastAPI `0.99.0` ve üzeri tarafından desteklenir.
-
-///
-
-## Webhook'ları olan bir uygulama { #an-app-with-webhooks }
-
-Bir **FastAPI** uygulaması oluşturduğunuzda, *webhook*'ları tanımlamak için kullanabileceğiniz bir `webhooks` attribute'u vardır; *path operation* tanımlar gibi, örneğin `@app.webhooks.post()` ile.
-
-{* ../../docs_src/openapi_webhooks/tutorial001_py39.py hl[9:13,36:53] *}
-
-Tanımladığınız webhook'lar **OpenAPI** şemasında ve otomatik **docs UI**'da yer alır.
-
-/// info | Bilgi
-
-`app.webhooks` nesnesi aslında sadece bir `APIRouter`'dır; uygulamanızı birden fazla dosya ile yapılandırırken kullanacağınız türün aynısıdır.
-
-///
-
-Dikkat edin: Webhook'larda aslında bir *path* (ör. `/items/`) deklare etmiyorsunuz; oraya verdiğiniz metin sadece webhook'un bir **identifier**'ıdır (event'in adı). Örneğin `@app.webhooks.post("new-subscription")` içinde webhook adı `new-subscription`'dır.
-
-Bunun nedeni, webhook request'ini almak istedikleri gerçek **URL path**'i **kullanıcılarınızın** başka bir şekilde (örn. bir web dashboard üzerinden) tanımlamasının beklenmesidir.
-
-### Dokümanları kontrol edin { #check-the-docs }
-
-Şimdi uygulamanızı başlatıp <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresine gidin.
-
-Dokümanlarınızda normal *path operation*'ları ve artık bazı **webhook**'ları da göreceksiniz:
-
-<img src="/img/tutorial/openapi-webhooks/image01.png">

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

@@ -1,172 +0,0 @@
-# Path Operation İleri Düzey Yapılandırma { #path-operation-advanced-configuration }
-
-## OpenAPI operationId { #openapi-operationid }
-
-/// warning | Uyarı
-
-OpenAPI konusunda "uzman" değilseniz, muhtemelen buna ihtiyacınız yok.
-
-///
-
-*path operation*’ınızda kullanılacak OpenAPI `operationId` değerini `operation_id` parametresiyle ayarlayabilirsiniz.
-
-Bunun her operation için benzersiz olduğundan emin olmanız gerekir.
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial001_py39.py hl[6] *}
-
-### operationId olarak *path operation function* adını kullanma { #using-the-path-operation-function-name-as-the-operationid }
-
-API’lerinizin function adlarını `operationId` olarak kullanmak istiyorsanız, hepsini dolaşıp her *path operation*’ın `operation_id` değerini `APIRoute.name` ile override edebilirsiniz.
-
-Bunu, tüm *path operation*’ları ekledikten sonra yapmalısınız.
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial002_py39.py hl[2, 12:21, 24] *}
-
-/// tip | İpucu
-
-`app.openapi()` fonksiyonunu manuel olarak çağırıyorsanız, bunu yapmadan önce `operationId`’leri güncellemelisiniz.
-
-///
-
-/// warning | Uyarı
-
-Bunu yaparsanız, her bir *path operation function*’ın adının benzersiz olduğundan emin olmanız gerekir.
-
-Farklı modüllerde (Python dosyalarında) olsalar bile.
-
-///
-
-## OpenAPI’den Hariç Tutma { #exclude-from-openapi }
-
-Bir *path operation*’ı üretilen OpenAPI şemasından (dolayısıyla otomatik dokümantasyon sistemlerinden) hariç tutmak için `include_in_schema` parametresini kullanın ve `False` yapın:
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial003_py39.py hl[6] *}
-
-## Docstring’den İleri Düzey Açıklama { #advanced-description-from-docstring }
-
-OpenAPI için, bir *path operation function*’ın docstring’inden kullanılacak satırları sınırlandırabilirsiniz.
-
-Bir `\f` (escape edilmiş "form feed" karakteri) eklerseniz, **FastAPI** OpenAPI için kullanılan çıktıyı bu noktada **keser**.
-
-Dokümantasyonda görünmez, ancak diğer araçlar (Sphinx gibi) geri kalan kısmı kullanabilir.
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
-
-## Ek Responses { #additional-responses }
-
-Muhtemelen bir *path operation* için `response_model` ve `status_code` tanımlamayı görmüşsünüzdür.
-
-Bu, bir *path operation*’ın ana response’u ile ilgili metadata’yı tanımlar.
-
-Ek response’ları; modelleri, status code’ları vb. ile birlikte ayrıca da tanımlayabilirsiniz.
-
-Dokümantasyonda bununla ilgili ayrı bir bölüm var; [OpenAPI’de Ek Responses](additional-responses.md){.internal-link target=_blank} sayfasından okuyabilirsiniz.
-
-## OpenAPI Extra { #openapi-extra }
-
-Uygulamanızda bir *path operation* tanımladığınızda, **FastAPI** OpenAPI şemasına dahil edilmek üzere o *path operation* ile ilgili metadata’yı otomatik olarak üretir.
-
-/// note | Teknik Detaylar
-
-OpenAPI spesifikasyonunda buna <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#operation-object" class="external-link" target="_blank">Operation Object</a> denir.
-
-///
-
-Bu, *path operation* hakkında tüm bilgileri içerir ve otomatik dokümantasyonu üretmek için kullanılır.
-
-`tags`, `parameters`, `requestBody`, `responses` vb. alanları içerir.
-
-Bu *path operation*’a özel OpenAPI şeması normalde **FastAPI** tarafından otomatik üretilir; ancak siz bunu genişletebilirsiniz.
-
-/// tip | İpucu
-
-Bu, düşük seviyeli bir genişletme noktasıdır.
-
-Yalnızca ek response’lar tanımlamanız gerekiyorsa, bunu yapmanın daha pratik yolu [OpenAPI’de Ek Responses](additional-responses.md){.internal-link target=_blank} kullanmaktır.
-
-///
-
-Bir *path operation* için OpenAPI şemasını `openapi_extra` parametresiyle genişletebilirsiniz.
-
-### OpenAPI Extensions { #openapi-extensions }
-
-Örneğin bu `openapi_extra`, [OpenAPI Extensions](https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.0.3.md#specificationExtensions) tanımlamak için faydalı olabilir:
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial005_py39.py hl[6] *}
-
-Otomatik API dokümanlarını açtığınızda, extension’ınız ilgili *path operation*’ın en altında görünür.
-
-<img src="/img/tutorial/path-operation-advanced-configuration/image01.png">
-
-Ayrıca ortaya çıkan OpenAPI’yi (API’nizde `/openapi.json`) görüntülerseniz, extension’ınızı ilgili *path operation*’ın bir parçası olarak orada da görürsünüz:
-
-```JSON hl_lines="22"
-{
-    "openapi": "3.1.0",
-    "info": {
-        "title": "FastAPI",
-        "version": "0.1.0"
-    },
-    "paths": {
-        "/items/": {
-            "get": {
-                "summary": "Read Items",
-                "operationId": "read_items_items__get",
-                "responses": {
-                    "200": {
-                        "description": "Successful Response",
-                        "content": {
-                            "application/json": {
-                                "schema": {}
-                            }
-                        }
-                    }
-                },
-                "x-aperture-labs-portal": "blue"
-            }
-        }
-    }
-}
-```
-
-### Özel OpenAPI *path operation* şeması { #custom-openapi-path-operation-schema }
-
-`openapi_extra` içindeki dictionary, *path operation* için otomatik üretilen OpenAPI şemasıyla derinlemesine (deep) birleştirilir.
-
-Böylece otomatik üretilen şemaya ek veri ekleyebilirsiniz.
-
-Örneğin, Pydantic ile FastAPI’nin otomatik özelliklerini kullanmadan request’i kendi kodunuzla okuyup doğrulamaya karar verebilirsiniz; ancak yine de OpenAPI şemasında request’i tanımlamak isteyebilirsiniz.
-
-Bunu `openapi_extra` ile yapabilirsiniz:
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial006_py39.py hl[19:36, 39:40] *}
-
-Bu örnekte herhangi bir Pydantic model tanımlamadık. Hatta request body JSON olarak <abbr title="converted from some plain format, like bytes, into Python objects - bytes gibi düz bir formattan Python nesnelerine dönüştürme">parsed</abbr> bile edilmiyor; doğrudan `bytes` olarak okunuyor ve `magic_data_reader()` fonksiyonu bunu bir şekilde parse etmekten sorumlu oluyor.
-
-Buna rağmen, request body için beklenen şemayı tanımlayabiliriz.
-
-### Özel OpenAPI content type { #custom-openapi-content-type }
-
-Aynı yöntemi kullanarak, Pydantic model ile JSON Schema’yı tanımlayıp bunu *path operation* için özel OpenAPI şeması bölümüne dahil edebilirsiniz.
-
-Ve bunu, request içindeki veri tipi JSON olmasa bile yapabilirsiniz.
-
-Örneğin bu uygulamada, FastAPI’nin Pydantic modellerinden JSON Schema çıkarmaya yönelik entegre işlevselliğini ve JSON için otomatik doğrulamayı kullanmıyoruz. Hatta request content type’ını JSON değil, YAML olarak tanımlıyoruz:
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
-
-Buna rağmen, varsayılan entegre işlevselliği kullanmasak da, YAML olarak almak istediğimiz veri için JSON Schema’yı manuel üretmek üzere bir Pydantic model kullanmaya devam ediyoruz.
-
-Ardından request’i doğrudan kullanıp body’yi `bytes` olarak çıkarıyoruz. Bu da FastAPI’nin request payload’ını JSON olarak parse etmeye çalışmayacağı anlamına gelir.
-
-Sonrasında kodumuzda bu YAML içeriğini doğrudan parse ediyor, ardından YAML içeriğini doğrulamak için yine aynı Pydantic modeli kullanıyoruz:
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
-
-/// tip | İpucu
-
-Burada aynı Pydantic modeli tekrar kullanıyoruz.
-
-Aynı şekilde, başka bir yöntemle de doğrulama yapabilirdik.
-
-///

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

@@ -1,31 +0,0 @@
-# Response - Status Code Değiştirme { #response-change-status-code }
-
-Muhtemelen daha önce varsayılan bir [Response Status Code](../tutorial/response-status-code.md){.internal-link target=_blank} ayarlayabileceğinizi okumuşsunuzdur.
-
-Ancak bazı durumlarda, varsayılandan farklı bir status code döndürmeniz gerekir.
-
-## Kullanım senaryosu { #use-case }
-
-Örneğin, varsayılan olarak "OK" `200` HTTP status code'u döndürmek istediğinizi düşünün.
-
-Ama veri mevcut değilse onu oluşturmak ve "CREATED" `201` HTTP status code'u döndürmek istiyorsunuz.
-
-Aynı zamanda, döndürdüğünüz veriyi bir `response_model` ile filtreleyip dönüştürebilmeyi de sürdürmek istiyorsunuz.
-
-Bu tür durumlarda bir `Response` parametresi kullanabilirsiniz.
-
-## Bir `Response` parametresi kullanın { #use-a-response-parameter }
-
-*Path operation function* içinde `Response` tipinde bir parametre tanımlayabilirsiniz (cookie ve header'lar için yapabildiğiniz gibi).
-
-Ardından bu *geçici (temporal)* `Response` nesnesi üzerinde `status_code` değerini ayarlayabilirsiniz.
-
-{* ../../docs_src/response_change_status_code/tutorial001_py39.py hl[1,9,12] *}
-
-Sonrasında, normalde yaptığınız gibi ihtiyacınız olan herhangi bir nesneyi döndürebilirsiniz (`dict`, bir veritabanı modeli, vb.).
-
-Ve eğer bir `response_model` tanımladıysanız, döndürdüğünüz nesneyi filtrelemek ve dönüştürmek için yine kullanılacaktır.
-
-**FastAPI**, status code'u (ayrıca cookie ve header'ları) bu *geçici (temporal)* response'tan alır ve `response_model` ile filtrelenmiş, sizin döndürdüğünüz değeri içeren nihai response'a yerleştirir.
-
-Ayrıca `Response` parametresini dependency'lerde de tanımlayıp status code'u orada ayarlayabilirsiniz. Ancak unutmayın, en son ayarlanan değer geçerli olur.

docs/tr/docs/advanced/response-cookies.md

@@ -1,51 +0,0 @@
-# Response Cookie'leri { #response-cookies }
-
-## Bir `Response` parametresi kullanın { #use-a-response-parameter }
-
-*Path operation function* içinde `Response` tipinde bir parametre tanımlayabilirsiniz.
-
-Ardından bu *geçici* response nesnesi üzerinde cookie'leri set edebilirsiniz.
-
-{* ../../docs_src/response_cookies/tutorial002_py39.py hl[1, 8:9] *}
-
-Sonrasında normalde yaptığınız gibi ihtiyaç duyduğunuz herhangi bir nesneyi döndürebilirsiniz (bir `dict`, bir veritabanı modeli vb.).
-
-Ayrıca bir `response_model` tanımladıysanız, döndürdüğünüz nesneyi filtrelemek ve dönüştürmek için yine kullanılacaktır.
-
-**FastAPI**, bu *geçici* response'u cookie'leri (ayrıca header'ları ve status code'u) çıkarmak için kullanır ve bunları, döndürdüğünüz değeri içeren nihai response'a ekler. Döndürdüğünüz değer, varsa `response_model` ile filtrelenmiş olur.
-
-`Response` parametresini dependency'lerde de tanımlayıp, onların içinde cookie (ve header) set edebilirsiniz.
-
-## Doğrudan bir `Response` döndürün { #return-a-response-directly }
-
-Kodunuzda doğrudan bir `Response` döndürürken de cookie oluşturabilirsiniz.
-
-Bunu yapmak için, [Doğrudan Response Döndürme](response-directly.md){.internal-link target=_blank} bölümünde anlatıldığı gibi bir response oluşturabilirsiniz.
-
-Sonra bunun içinde Cookie'leri set edin ve response'u döndürün:
-
-{* ../../docs_src/response_cookies/tutorial001_py39.py hl[10:12] *}
-
-/// tip | İpucu
-
-`Response` parametresini kullanmak yerine doğrudan bir response döndürürseniz, FastAPI onu olduğu gibi (doğrudan) döndürür.
-
-Bu yüzden, verinizin doğru tipte olduğundan emin olmanız gerekir. Örneğin `JSONResponse` döndürüyorsanız, verinin JSON ile uyumlu olması gerekir.
-
-Ayrıca `response_model` tarafından filtrelenmesi gereken bir veriyi göndermediğinizden de emin olun.
-
-///
-
-### Daha fazla bilgi { #more-info }
-
-/// note | Teknik Detaylar
-
-`from starlette.responses import Response` veya `from starlette.responses import JSONResponse` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici olarak size kolaylık olması için `fastapi.responses` içinde `starlette.responses` ile aynı response sınıflarını sunar. Ancak mevcut response'ların büyük kısmı doğrudan Starlette'ten gelir.
-
-Ve `Response`, header ve cookie set etmek için sık kullanıldığından, **FastAPI** bunu `fastapi.Response` olarak da sağlar.
-
-///
-
-Mevcut tüm parametreleri ve seçenekleri görmek için <a href="https://www.starlette.dev/responses/#set-cookie" class="external-link" target="_blank">Starlette dokümantasyonuna</a> bakın.

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

@@ -1,65 +0,0 @@
-# Doğrudan Bir Response Döndürme { #return-a-response-directly }
-
-**FastAPI** ile bir *path operation* oluşturduğunuzda, normalde ondan herhangi bir veri döndürebilirsiniz: bir `dict`, bir `list`, bir Pydantic model, bir veritabanı modeli vb.
-
-Varsayılan olarak **FastAPI**, döndürdüğünüz bu değeri [JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank} bölümünde anlatılan `jsonable_encoder` ile otomatik olarak JSON'a çevirir.
-
-Ardından perde arkasında, JSON-uyumlu bu veriyi (ör. bir `dict`) client'a response göndermek için kullanılacak bir `JSONResponse` içine yerleştirir.
-
-Ancak *path operation*'larınızdan doğrudan bir `JSONResponse` döndürebilirsiniz.
-
-Bu, örneğin özel header'lar veya cookie'ler döndürmek istediğinizde faydalı olabilir.
-
-## Bir `Response` Döndürme { #return-a-response }
-
-Aslında herhangi bir `Response` veya onun herhangi bir alt sınıfını döndürebilirsiniz.
-
-/// tip | İpucu
-
-`JSONResponse` zaten `Response`'un bir alt sınıfıdır.
-
-///
-
-Bir `Response` döndürdüğünüzde, **FastAPI** bunu olduğu gibi doğrudan iletir.
-
-Pydantic model'leriyle herhangi bir veri dönüşümü yapmaz, içeriği başka bir tipe çevirmez vb.
-
-Bu size ciddi bir esneklik sağlar. Herhangi bir veri türü döndürebilir, herhangi bir veri deklarasyonunu veya validasyonunu override edebilirsiniz.
-
-## Bir `Response` İçinde `jsonable_encoder` Kullanma { #using-the-jsonable-encoder-in-a-response }
-
-**FastAPI**, sizin döndürdüğünüz `Response` üzerinde hiçbir değişiklik yapmadığı için, içeriğinin gönderilmeye hazır olduğundan emin olmanız gerekir.
-
-Örneğin, bir Pydantic model'i, önce JSON-uyumlu tiplere çevrilmeden (`datetime`, `UUID` vb.) doğrudan bir `JSONResponse` içine koyamazsınız. Önce tüm veri tipleri JSON-uyumlu hale gelecek şekilde `dict`'e çevrilmesi gerekir.
-
-Bu gibi durumlarda, response'a vermeden önce verinizi dönüştürmek için `jsonable_encoder` kullanabilirsiniz:
-
-{* ../../docs_src/response_directly/tutorial001_py310.py hl[5:6,20:21] *}
-
-/// note | Teknik Detaylar
-
-`from starlette.responses import JSONResponse` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici olarak size kolaylık olması için `starlette.responses` içeriğini `fastapi.responses` üzerinden de sunar. Ancak mevcut response'ların çoğu doğrudan Starlette'tan gelir.
-
-///
-
-## Özel Bir `Response` Döndürme { #returning-a-custom-response }
-
-Yukarıdaki örnek ihtiyaç duyduğunuz tüm parçaları gösteriyor, ancak henüz çok kullanışlı değil. Çünkü `item`'ı zaten doğrudan döndürebilirdiniz ve **FastAPI** varsayılan olarak onu sizin için bir `JSONResponse` içine koyup `dict`'e çevirirdi vb.
-
-Şimdi bunu kullanarak nasıl özel bir response döndürebileceğinize bakalım.
-
-Diyelim ki <a href="https://en.wikipedia.org/wiki/XML" class="external-link" target="_blank">XML</a> response döndürmek istiyorsunuz.
-
-XML içeriğinizi bir string içine koyabilir, onu bir `Response` içine yerleştirip döndürebilirsiniz:
-
-{* ../../docs_src/response_directly/tutorial002_py39.py hl[1,18] *}
-
-## Notlar { #notes }
-
-Bir `Response`'u doğrudan döndürdüğünüzde, verisi otomatik olarak validate edilmez, dönüştürülmez (serialize edilmez) veya dokümante edilmez.
-
-Ancak yine de [Additional Responses in OpenAPI](additional-responses.md){.internal-link target=_blank} bölümünde anlatıldığı şekilde dokümante edebilirsiniz.
-
-İlerleyen bölümlerde, otomatik veri dönüşümü, dokümantasyon vb. özellikleri korurken bu özel `Response`'ları nasıl kullanıp declare edebileceğinizi göreceksiniz.

docs/tr/docs/advanced/response-headers.md

@@ -1,41 +0,0 @@
-# Response Header'ları { #response-headers }
-
-## Bir `Response` parametresi kullanın { #use-a-response-parameter }
-
-*Path operation function* içinde (cookie'lerde yapabildiğiniz gibi) tipi `Response` olan bir parametre tanımlayabilirsiniz.
-
-Sonra da bu *geçici* response nesnesi üzerinde header'ları ayarlayabilirsiniz.
-
-{* ../../docs_src/response_headers/tutorial002_py39.py hl[1, 7:8] *}
-
-Ardından normalde yaptığınız gibi ihtiyacınız olan herhangi bir nesneyi döndürebilirsiniz (bir `dict`, bir veritabanı modeli vb.).
-
-Eğer bir `response_model` tanımladıysanız, döndürdüğünüz nesneyi filtrelemek ve dönüştürmek için yine kullanılacaktır.
-
-**FastAPI**, header'ları (aynı şekilde cookie'leri ve status code'u) bu *geçici* response'dan alır ve döndürdüğünüz değeri (varsa bir `response_model` ile filtrelenmiş hâliyle) içeren nihai response'a ekler.
-
-`Response` parametresini dependency'lerde de tanımlayıp, onların içinde header (ve cookie) ayarlayabilirsiniz.
-
-## Doğrudan bir `Response` döndürün { #return-a-response-directly }
-
-Doğrudan bir `Response` döndürdüğünüzde de header ekleyebilirsiniz.
-
-[Bir Response'u Doğrudan Döndürün](response-directly.md){.internal-link target=_blank} bölümünde anlatıldığı gibi bir response oluşturun ve header'ları ek bir parametre olarak geçin:
-
-{* ../../docs_src/response_headers/tutorial001_py39.py hl[10:12] *}
-
-/// note | Teknik Detaylar
-
-`from starlette.responses import Response` veya `from starlette.responses import JSONResponse` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici olarak size kolaylık olsun diye `starlette.responses` içeriğini `fastapi.responses` olarak da sunar. Ancak mevcut response'ların çoğu doğrudan Starlette'ten gelir.
-
-Ayrıca `Response` header ve cookie ayarlamak için sık kullanıldığından, **FastAPI** bunu `fastapi.Response` altında da sağlar.
-
-///
-
-## Özel Header'lar { #custom-headers }
-
-Özel/proprietary header'ların <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers" class="external-link" target="_blank">`X-` prefix'i kullanılarak</a> eklenebileceğini unutmayın.
-
-Ancak tarayıcıdaki bir client'ın görebilmesini istediğiniz özel header'larınız varsa, bunları CORS ayarlarınıza eklemeniz gerekir ([CORS (Cross-Origin Resource Sharing)](../tutorial/cors.md){.internal-link target=_blank} bölümünde daha fazla bilgi), bunun için <a href="https://www.starlette.dev/middleware/#corsmiddleware" class="external-link" target="_blank">Starlette'in CORS dokümanında</a> açıklanan `expose_headers` parametresini kullanın.

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

@@ -1,107 +0,0 @@
-# HTTP Basic Auth { #http-basic-auth }
-
-En basit senaryolarda HTTP Basic Auth kullanabilirsiniz.
-
-HTTP Basic Auth’ta uygulama, içinde kullanıcı adı ve şifre bulunan bir header bekler.
-
-Eğer bunu almazsa HTTP 401 "Unauthorized" hatası döndürür.
-
-Ayrıca değeri `Basic` olan ve isteğe bağlı `realm` parametresi içerebilen `WWW-Authenticate` header’ını da döndürür.
-
-Bu da tarayıcıya, kullanıcı adı ve şifre için entegre giriş penceresini göstermesini söyler.
-
-Ardından kullanıcı adı ve şifreyi yazdığınızda tarayıcı bunları otomatik olarak header içinde gönderir.
-
-## Basit HTTP Basic Auth { #simple-http-basic-auth }
-
-* `HTTPBasic` ve `HTTPBasicCredentials` import edin.
-* `HTTPBasic` kullanarak bir "`security` scheme" oluşturun.
-* *path operation*’ınızda bir dependency ile bu `security`’yi kullanın.
-* Bu, `HTTPBasicCredentials` tipinde bir nesne döndürür:
-    * İçinde gönderilen `username` ve `password` bulunur.
-
-{* ../../docs_src/security/tutorial006_an_py39.py hl[4,8,12] *}
-
-URL’yi ilk kez açmaya çalıştığınızda (veya dokümanlardaki "Execute" butonuna tıkladığınızda) tarayıcı sizden kullanıcı adınızı ve şifrenizi ister:
-
-<img src="/img/tutorial/security/image12.png">
-
-## Kullanıcı adını kontrol edin { #check-the-username }
-
-Daha kapsamlı bir örneğe bakalım.
-
-Kullanıcı adı ve şifrenin doğru olup olmadığını kontrol etmek için bir dependency kullanın.
-
-Bunun için kullanıcı adı ve şifreyi kontrol ederken Python standart modülü olan <a href="https://docs.python.org/3/library/secrets.html" class="external-link" target="_blank">`secrets`</a>’i kullanın.
-
-`secrets.compare_digest()`; `bytes` ya da yalnızca ASCII karakterleri (İngilizce’deki karakterler) içeren bir `str` almalıdır. Bu da `Sebastián` içindeki `á` gibi karakterlerle çalışmayacağı anlamına gelir.
-
-Bunu yönetmek için önce `username` ve `password` değerlerini UTF-8 ile encode ederek `bytes`’a dönüştürürüz.
-
-Sonra `secrets.compare_digest()` kullanarak `credentials.username`’in `"stanleyjobson"` ve `credentials.password`’ün `"swordfish"` olduğundan emin olabiliriz.
-
-{* ../../docs_src/security/tutorial007_an_py39.py hl[1,12:24] *}
-
-Bu, kabaca şuna benzer olurdu:
-
-```Python
-if not (credentials.username == "stanleyjobson") or not (credentials.password == "swordfish"):
-    # Return some error
-    ...
-```
-
-Ancak `secrets.compare_digest()` kullanarak, "timing attacks" denilen bir saldırı türüne karşı güvenli olursunuz.
-
-### Timing Attacks { #timing-attacks }
-
-Peki "timing attack" nedir?
-
-Bazı saldırganların kullanıcı adı ve şifreyi tahmin etmeye çalıştığını düşünelim.
-
-Ve `johndoe` kullanıcı adı ve `love123` şifresi ile bir request gönderiyorlar.
-
-Uygulamanızdaki Python kodu o zaman kabaca şuna denk olur:
-
-```Python
-if "johndoe" == "stanleyjobson" and "love123" == "swordfish":
-    ...
-```
-
-Ancak Python, `johndoe` içindeki ilk `j` ile `stanleyjobson` içindeki ilk `s`’i karşılaştırdığı anda `False` döndürür; çünkü iki string’in aynı olmadığını zaten anlar ve "kalan harfleri karşılaştırmak için daha fazla hesaplama yapmaya gerek yok" diye düşünür. Uygulamanız da "Incorrect username or password" der.
-
-Sonra saldırganlar bu sefer `stanleyjobsox` kullanıcı adı ve `love123` şifresi ile dener.
-
-Uygulama kodunuz da şuna benzer bir şey yapar:
-
-```Python
-if "stanleyjobsox" == "stanleyjobson" and "love123" == "swordfish":
-    ...
-```
-
-Bu kez Python, iki string’in aynı olmadığını fark etmeden önce hem `stanleyjobsox` hem de `stanleyjobson` içinde `stanleyjobso` kısmının tamamını karşılaştırmak zorunda kalır. Bu nedenle "Incorrect username or password" yanıtını vermesi birkaç mikro saniye daha uzun sürer.
-
-#### Yanıt süresi saldırganlara yardımcı olur { #the-time-to-answer-helps-the-attackers }
-
-Bu noktada saldırganlar, server’ın "Incorrect username or password" response’unu göndermesinin birkaç mikro saniye daha uzun sürdüğünü fark ederek _bir şeyleri_ doğru yaptıklarını anlar; yani başlangıçtaki bazı harfler doğrudur.
-
-Sonra tekrar denerken, bunun `johndoe`’dan ziyade `stanleyjobsox`’a daha yakın bir şey olması gerektiğini bilerek devam edebilirler.
-
-#### "Profesyonel" bir saldırı { #a-professional-attack }
-
-Elbette saldırganlar bunu elle tek tek denemez; bunu yapan bir program yazarlar. Muhtemelen saniyede binlerce ya da milyonlarca test yaparlar ve her seferinde yalnızca bir doğru harf daha elde ederler.
-
-Böylece birkaç dakika ya da birkaç saat içinde doğru kullanıcı adı ve şifreyi, yanıt süresini kullanarak ve uygulamamızın "yardımıyla" tahmin etmiş olurlar.
-
-#### `secrets.compare_digest()` ile düzeltin { #fix-it-with-secrets-compare-digest }
-
-Ancak bizim kodumuzda `secrets.compare_digest()` kullanıyoruz.
-
-Kısacası, `stanleyjobsox` ile `stanleyjobson`’u karşılaştırmak için geçen süre, `johndoe` ile `stanleyjobson`’u karşılaştırmak için geçen süreyle aynı olur. Şifre için de aynı şekilde.
-
-Bu sayede uygulama kodunuzda `secrets.compare_digest()` kullanarak bu güvenlik saldırıları ailesine karşı güvenli olursunuz.
-
-### Hatayı döndürün { #return-the-error }
-
-Credential’ların hatalı olduğunu tespit ettikten sonra, 401 status code ile (credential verilmediğinde dönenle aynı) bir `HTTPException` döndürün ve tarayıcının giriş penceresini yeniden göstermesi için `WWW-Authenticate` header’ını ekleyin:
-
-{* ../../docs_src/security/tutorial007_an_py39.py hl[26:30] *}

docs/tr/docs/advanced/security/oauth2-scopes.md

@@ -1,274 +0,0 @@
-# OAuth2 scope'ları { #oauth2-scopes }
-
-OAuth2 scope'larını **FastAPI** ile doğrudan kullanabilirsiniz; sorunsuz çalışacak şekilde entegre edilmiştir.
-
-Bu sayede OAuth2 standardını takip eden, daha ince taneli bir izin sistemini OpenAPI uygulamanıza (ve API dokümanlarınıza) entegre edebilirsiniz.
-
-Scope'lu OAuth2; Facebook, Google, GitHub, Microsoft, X (Twitter) vb. birçok büyük kimlik doğrulama sağlayıcısının kullandığı mekanizmadır. Kullanıcı ve uygulamalara belirli izinler vermek için bunu kullanırlar.
-
-Facebook, Google, GitHub, Microsoft, X (Twitter) ile "giriş yaptığınızda", o uygulama scope'lu OAuth2 kullanıyor demektir.
-
-Bu bölümde, **FastAPI** uygulamanızda aynı scope'lu OAuth2 ile authentication ve authorization'ı nasıl yöneteceğinizi göreceksiniz.
-
-/// warning | Uyarı
-
-Bu bölüm az çok ileri seviye sayılır. Yeni başlıyorsanız atlayabilirsiniz.
-
-OAuth2 scope'larına mutlaka ihtiyacınız yok; authentication ve authorization'ı istediğiniz şekilde ele alabilirsiniz.
-
-Ancak scope'lu OAuth2, API'nize (OpenAPI ile) ve API dokümanlarınıza güzel biçimde entegre edilebilir.
-
-Buna rağmen, bu scope'ları (veya başka herhangi bir security/authorization gereksinimini) kodunuzda ihtiyaç duyduğunuz şekilde yine siz zorunlu kılarsınız.
-
-Birçok durumda scope'lu OAuth2 gereğinden fazla (overkill) olabilir.
-
-Ama ihtiyacınız olduğunu biliyorsanız ya da merak ediyorsanız okumaya devam edin.
-
-///
-
-## OAuth2 scope'ları ve OpenAPI { #oauth2-scopes-and-openapi }
-
-OAuth2 spesifikasyonu, "scope"ları boşluklarla ayrılmış string'lerden oluşan bir liste olarak tanımlar.
-
-Bu string'lerin her birinin içeriği herhangi bir formatta olabilir, ancak boşluk içermemelidir.
-
-Bu scope'lar "izinleri" temsil eder.
-
-OpenAPI'de (ör. API dokümanlarında) "security scheme" tanımlayabilirsiniz.
-
-Bu security scheme'lerden biri OAuth2 kullanıyorsa, scope'ları da tanımlayıp kullanabilirsiniz.
-
-Her bir "scope" sadece bir string'dir (boşluksuz).
-
-Genellikle belirli güvenlik izinlerini tanımlamak için kullanılır, örneğin:
-
-* `users:read` veya `users:write` sık görülen örneklerdir.
-* `instagram_basic` Facebook / Instagram tarafından kullanılır.
-* `https://www.googleapis.com/auth/drive` Google tarafından kullanılır.
-
-/// info | Bilgi
-
-OAuth2'de "scope", gereken belirli bir izni bildiren bir string'den ibarettir.
-
-`:` gibi başka karakterler içermesi ya da bir URL olması önemli değildir.
-
-Bu detaylar implementasyon'a bağlıdır.
-
-OAuth2 için bunlar sadece string'dir.
-
-///
-
-## Genel görünüm { #global-view }
-
-Önce, ana **Tutorial - User Guide** içindeki [Password (ve hashing) ile OAuth2, JWT token'lı Bearer](../../tutorial/security/oauth2-jwt.md){.internal-link target=_blank} örneklerinden, OAuth2 scope'larına geçince hangi kısımların değiştiğine hızlıca bakalım:
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[5,9,13,47,65,106,108:116,122:126,130:136,141,157] *}
-
-Şimdi bu değişiklikleri adım adım inceleyelim.
-
-## OAuth2 Security scheme { #oauth2-security-scheme }
-
-İlk değişiklik, artık OAuth2 security scheme'ini iki adet kullanılabilir scope ile tanımlamamız: `me` ve `items`.
-
-`scopes` parametresi; her scope'un key, açıklamasının ise value olduğu bir `dict` alır:
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[63:66] *}
-
-Bu scope'ları tanımladığımız için, login/authorize yaptığınızda API dokümanlarında görünecekler.
-
-Ve hangi scope'lara erişim vermek istediğinizi seçebileceksiniz: `me` ve `items`.
-
-Bu, Facebook/Google/GitHub vb. ile giriş yaparken izin verdiğinizde kullanılan mekanizmanın aynısıdır:
-
-<img src="/img/tutorial/security/image11.png">
-
-## Scope'lu JWT token { #jwt-token-with-scopes }
-
-Şimdi token *path operation*'ını, istenen scope'ları döndürecek şekilde değiştirin.
-
-Hâlâ aynı `OAuth2PasswordRequestForm` kullanılıyor. Bu form, request'te aldığı her scope için `str`'lerden oluşan bir `list` içeren `scopes` özelliğine sahiptir.
-
-Ve scope'ları JWT token'ın bir parçası olarak döndürüyoruz.
-
-/// danger | Uyarı
-
-Basitlik için burada, gelen scope'ları doğrudan token'a ekliyoruz.
-
-Ama uygulamanızda güvenlik açısından, yalnızca kullanıcının gerçekten sahip olabileceği scope'ları (veya sizin önceden tanımladıklarınızı) eklediğinizden emin olmalısınız.
-
-///
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[157] *}
-
-## *Path operation*'larda ve dependency'lerde scope tanımlama { #declare-scopes-in-path-operations-and-dependencies }
-
-Artık `/users/me/items/` için olan *path operation*'ın `items` scope'unu gerektirdiğini tanımlıyoruz.
-
-Bunun için `fastapi` içinden `Security` import edip kullanıyoruz.
-
-Dependency'leri (`Depends` gibi) tanımlamak için `Security` kullanabilirsiniz; fakat `Security`, ayrıca string'lerden oluşan bir scope listesi alan `scopes` parametresini de alır.
-
-Bu durumda `Security`'ye dependency fonksiyonu olarak `get_current_active_user` veriyoruz (`Depends` ile yaptığımız gibi).
-
-Ama ayrıca bir `list` olarak scope'ları da veriyoruz; burada tek bir scope var: `items` (daha fazla da olabilir).
-
-Ve `get_current_active_user` dependency fonksiyonu, sadece `Depends` ile değil `Security` ile de alt-dependency'ler tanımlayabilir. Kendi alt-dependency fonksiyonunu (`get_current_user`) ve daha fazla scope gereksinimini tanımlar.
-
-Bu örnekte `me` scope'unu gerektiriyor (birden fazla scope da isteyebilirdi).
-
-/// note | Not
-
-Farklı yerlerde farklı scope'lar eklemek zorunda değilsiniz.
-
-Burada, **FastAPI**'nin farklı seviyelerde tanımlanan scope'ları nasıl ele aldığını göstermek için böyle yapıyoruz.
-
-///
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[5,141,172] *}
-
-/// info | Teknik Detaylar
-
-`Security` aslında `Depends`'in bir alt sınıfıdır ve sadece birazdan göreceğimiz bir ek parametreye sahiptir.
-
-Ancak `Depends` yerine `Security` kullanınca **FastAPI**, security scope'larının tanımlanabileceğini bilir, bunları içeride kullanır ve API'yi OpenAPI ile dokümante eder.
-
-Fakat `fastapi` içinden `Query`, `Path`, `Depends`, `Security` vb. import ettiğiniz şeyler, aslında özel sınıflar döndüren fonksiyonlardır.
-
-///
-
-## `SecurityScopes` kullanımı { #use-securityscopes }
-
-Şimdi `get_current_user` dependency'sini güncelleyelim.
-
-Bu fonksiyon, yukarıdaki dependency'ler tarafından kullanılıyor.
-
-Burada, daha önce oluşturduğumuz aynı OAuth2 scheme'i dependency olarak tanımlıyoruz: `oauth2_scheme`.
-
-Bu dependency fonksiyonunun kendi içinde bir scope gereksinimi olmadığı için, `oauth2_scheme` ile `Depends` kullanabiliriz; security scope'larını belirtmemiz gerekmiyorsa `Security` kullanmak zorunda değiliz.
-
-Ayrıca `fastapi.security` içinden import edilen, `SecurityScopes` tipinde özel bir parametre tanımlıyoruz.
-
-Bu `SecurityScopes` sınıfı, `Request`'e benzer (`Request`, request nesnesini doğrudan almak için kullanılmıştı).
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[9,106] *}
-
-## `scopes`'ları kullanma { #use-the-scopes }
-
-`security_scopes` parametresi `SecurityScopes` tipinde olacaktır.
-
-Bu nesnenin `scopes` adlı bir özelliği vardır; bu liste, kendisinin ve bunu alt-dependency olarak kullanan tüm dependency'lerin gerektirdiği tüm scope'ları içerir. Yani tüm "dependant"lar... kafa karıştırıcı gelebilir; aşağıda tekrar açıklanıyor.
-
-`security_scopes` nesnesi (`SecurityScopes` sınıfından) ayrıca, bu scope'ları boşluklarla ayrılmış tek bir string olarak veren `scope_str` attribute'una sahiptir (bunu kullanacağız).
-
-Sonrasında birkaç farklı noktada tekrar kullanabileceğimiz (`raise` edebileceğimiz) bir `HTTPException` oluşturuyoruz.
-
-Bu exception içinde, gerekiyorsa, gerekli scope'ları boşlukla ayrılmış bir string olarak (`scope_str` ile) ekliyoruz. Bu scope'ları içeren string'i `WWW-Authenticate` header'ına koyuyoruz (spesifikasyonun bir parçası).
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[106,108:116] *}
-
-## `username` ve veri şeklinin doğrulanması { #verify-the-username-and-data-shape }
-
-Bir `username` aldığımızı doğruluyoruz ve scope'ları çıkarıyoruz.
-
-Ardından bu veriyi Pydantic model'i ile doğruluyoruz (`ValidationError` exception'ını yakalayarak). JWT token'ı okurken veya Pydantic ile veriyi doğrularken bir hata olursa, daha önce oluşturduğumuz `HTTPException`'ı fırlatıyoruz.
-
-Bunun için Pydantic model'i `TokenData`'yı, `scopes` adlı yeni bir özellik ekleyerek güncelliyoruz.
-
-Veriyi Pydantic ile doğrulayarak örneğin scope'ların tam olarak `str`'lerden oluşan bir `list` olduğunu ve `username`'in bir `str` olduğunu garanti edebiliriz.
-
-Aksi halde, örneğin bir `dict` veya başka bir şey gelebilir; bu da daha sonra uygulamanın bir yerinde kırılmaya yol açıp güvenlik riski oluşturabilir.
-
-Ayrıca bu `username` ile bir kullanıcı olduğunu doğruluyoruz; yoksa yine aynı exception'ı fırlatıyoruz.
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[47,117:129] *}
-
-## `scopes`'ların doğrulanması { #verify-the-scopes }
-
-Şimdi bu dependency'nin ve tüm dependant'ların ( *path operation*'lar dahil) gerektirdiği tüm scope'ların, alınan token'da sağlanan scope'lar içinde olup olmadığını doğruluyoruz; değilse `HTTPException` fırlatıyoruz.
-
-Bunun için, tüm bu scope'ları `str` olarak içeren bir `list` olan `security_scopes.scopes` kullanılır.
-
-{* ../../docs_src/security/tutorial005_an_py310.py hl[130:136] *}
-
-## Dependency ağacı ve scope'lar { #dependency-tree-and-scopes }
-
-Bu dependency ağacını ve scope'ları tekrar gözden geçirelim.
-
-`get_current_active_user` dependency'si, alt-dependency olarak `get_current_user`'ı kullandığı için, `get_current_active_user` üzerinde tanımlanan `"me"` scope'u, `get_current_user`'a geçirilen `security_scopes.scopes` içindeki gerekli scope listesine dahil edilir.
-
-*Path operation*'ın kendisi de `"items"` scope'unu tanımlar; bu da `get_current_user`'a geçirilen `security_scopes.scopes` listesinde yer alır.
-
-Dependency'lerin ve scope'ların hiyerarşisi şöyle görünür:
-
-* *Path operation* `read_own_items` şunlara sahiptir:
-    * Dependency ile gerekli scope'lar `["items"]`:
-    * `get_current_active_user`:
-        * `get_current_active_user` dependency fonksiyonu şunlara sahiptir:
-            * Dependency ile gerekli scope'lar `["me"]`:
-            * `get_current_user`:
-                * `get_current_user` dependency fonksiyonu şunlara sahiptir:
-                    * Kendisinin gerektirdiği scope yok.
-                    * `oauth2_scheme` kullanan bir dependency.
-                    * `SecurityScopes` tipinde bir `security_scopes` parametresi:
-                        * Bu `security_scopes` parametresinin `scopes` adlı bir özelliği vardır ve yukarıda tanımlanan tüm scope'ları içeren bir `list` taşır, yani:
-                            * *Path operation* `read_own_items` için `security_scopes.scopes` `["me", "items"]` içerir.
-                            * *Path operation* `read_users_me` için `security_scopes.scopes` `["me"]` içerir; çünkü bu scope `get_current_active_user` dependency'sinde tanımlanmıştır.
-                            * *Path operation* `read_system_status` için `security_scopes.scopes` `[]` (boş) olur; çünkü herhangi bir `Security` ile `scopes` tanımlamamıştır ve dependency'si olan `get_current_user` da `scopes` tanımlamaz.
-
-/// tip | İpucu
-
-Buradaki önemli ve "sihirli" nokta şu: `get_current_user`, her *path operation* için kontrol etmesi gereken farklı bir `scopes` listesi alır.
-
-Bu, belirli bir *path operation* için dependency ağacındaki her *path operation* ve her dependency üzerinde tanımlanan `scopes`'lara bağlıdır.
-
-///
-
-## `SecurityScopes` hakkında daha fazla detay { #more-details-about-securityscopes }
-
-`SecurityScopes`'u herhangi bir noktada ve birden fazla yerde kullanabilirsiniz; mutlaka "kök" dependency'de olmak zorunda değildir.
-
-Her zaman, **o spesifik** *path operation* ve **o spesifik** dependency ağacı için, mevcut `Security` dependency'lerinde ve tüm dependant'larda tanımlanan security scope'larını içerir.
-
-`SecurityScopes`, dependant'ların tanımladığı tüm scope'ları barındırdığı için, gereken scope'ların token'da olup olmadığını merkezi bir dependency fonksiyonunda doğrulayıp, farklı *path operation*'larda farklı scope gereksinimleri tanımlayabilirsiniz.
-
-Bu kontroller her *path operation* için bağımsız yapılır.
-
-## Deneyin { #check-it }
-
-API dokümanlarını açarsanız, authenticate olup hangi scope'ları authorize etmek istediğinizi seçebilirsiniz.
-
-<img src="/img/tutorial/security/image11.png">
-
-Hiç scope seçmezseniz "authenticated" olursunuz; ancak `/users/me/` veya `/users/me/items/`'e erişmeye çalıştığınızda, yeterli izniniz olmadığını söyleyen bir hata alırsınız. Yine de `/status/`'a erişebilirsiniz.
-
-`me` scope'unu seçip `items` scope'unu seçmezseniz `/users/me/`'a erişebilirsiniz ama `/users/me/items/`'e erişemezsiniz.
-
-Bu, bir üçüncü taraf uygulamanın, bir kullanıcı tarafından sağlanan token ile bu *path operation*'lardan birine erişmeye çalıştığında; kullanıcının uygulamaya kaç izin verdiğine bağlı olarak yaşayacağı durumdur.
-
-## Üçüncü taraf entegrasyonları hakkında { #about-third-party-integrations }
-
-Bu örnekte OAuth2 "password" flow'unu kullanıyoruz.
-
-Bu, kendi uygulamamıza giriş yaptığımız durumlar için uygundur; muhtemelen kendi frontend'imiz vardır.
-
-Çünkü `username` ve `password` alacağını bildiğimiz frontend'i biz kontrol ediyoruz, dolayısıyla güvenebiliriz.
-
-Ancak başkalarının bağlanacağı bir OAuth2 uygulaması geliştiriyorsanız (yani Facebook, Google, GitHub vb. gibi bir authentication provider muadili geliştiriyorsanız) diğer flow'lardan birini kullanmalısınız.
-
-En yaygını implicit flow'dur.
-
-En güvenlisi code flow'dur; ancak daha fazla adım gerektirdiği için implementasyonu daha karmaşıktır. Daha karmaşık olduğundan, birçok sağlayıcı implicit flow'yu önermeye yönelir.
-
-/// note | Not
-
-Her authentication provider'ın flow'ları markasının bir parçası yapmak için farklı şekilde adlandırması yaygındır.
-
-Ama sonuçta aynı OAuth2 standardını implement ediyorlar.
-
-///
-
-**FastAPI**, bu OAuth2 authentication flow'larının tamamı için `fastapi.security.oauth2` içinde yardımcı araçlar sunar.
-
-## Decorator `dependencies` içinde `Security` { #security-in-decorator-dependencies }
-
-Decorator'ın `dependencies` parametresinde bir `list` `Depends` tanımlayabildiğiniz gibi ( [Path operation decorator'larında Dependencies](../../tutorial/dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} bölümünde açıklandığı üzere), burada `scopes` ile birlikte `Security` de kullanabilirsiniz.

docs/tr/docs/advanced/settings.md

@@ -1,302 +0,0 @@
-# Ayarlar ve Ortam Değişkenleri { #settings-and-environment-variables }
-
-Birçok durumda uygulamanızın bazı harici ayarlara veya konfigürasyonlara ihtiyacı olabilir; örneğin secret key'ler, veritabanı kimlik bilgileri, e-posta servisleri için kimlik bilgileri vb.
-
-Bu ayarların çoğu değişkendir (değişebilir); örneğin veritabanı URL'leri. Ayrıca birçoğu hassas olabilir; örneğin secret'lar.
-
-Bu nedenle bunları, uygulama tarafından okunan environment variable'lar ile sağlamak yaygındır.
-
-/// tip | İpucu
-
-Environment variable'ları anlamak için [Environment Variables](../environment-variables.md){.internal-link target=_blank} dokümanını okuyabilirsiniz.
-
-///
-
-## Tipler ve doğrulama { #types-and-validation }
-
-Bu environment variable'lar yalnızca metin (string) taşıyabilir; çünkü Python'ın dışındadırlar ve diğer programlarla ve sistemin geri kalanıyla uyumlu olmaları gerekir (hatta Linux, Windows, macOS gibi farklı işletim sistemleriyle de).
-
-Bu da, Python içinde bir environment variable'dan okunan herhangi bir değerin `str` olacağı anlamına gelir; farklı bir tipe dönüştürme veya herhangi bir doğrulama işlemi kod içinde yapılmalıdır.
-
-## Pydantic `Settings` { #pydantic-settings }
-
-Neyse ki Pydantic, environment variable'lardan gelen bu ayarları yönetmek için <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/" class="external-link" target="_blank">Pydantic: Settings management</a> ile çok iyi bir yardımcı araç sunar.
-
-### `pydantic-settings`'i kurun { #install-pydantic-settings }
-
-Önce, [virtual environment](../virtual-environments.md){.internal-link target=_blank} oluşturduğunuzdan, aktive ettiğinizden emin olun ve ardından `pydantic-settings` paketini kurun:
-
-<div class="termy">
-
-```console
-$ pip install pydantic-settings
----> 100%
-```
-
-</div>
-
-Ayrıca `all` extras'ını şu şekilde kurduğunuzda da dahil gelir:
-
-<div class="termy">
-
-```console
-$ pip install "fastapi[all]"
----> 100%
-```
-
-</div>
-
-### `Settings` nesnesini oluşturun { #create-the-settings-object }
-
-Pydantic'ten `BaseSettings` import edin ve bir alt sınıf (sub-class) oluşturun; tıpkı bir Pydantic model'inde olduğu gibi.
-
-Pydantic model'lerinde olduğu gibi, type annotation'larla (ve gerekirse default değerlerle) class attribute'ları tanımlarsınız.
-
-Pydantic model'lerinde kullandığınız aynı doğrulama özelliklerini ve araçlarını burada da kullanabilirsiniz; örneğin farklı veri tipleri ve `Field()` ile ek doğrulamalar.
-
-{* ../../docs_src/settings/tutorial001_py39.py hl[2,5:8,11] *}
-
-/// tip | İpucu
-
-Hızlıca kopyalayıp yapıştırmak istiyorsanız bu örneği kullanmayın; aşağıdaki son örneği kullanın.
-
-///
-
-Ardından, bu `Settings` sınıfının bir instance'ını oluşturduğunuzda (bu örnekte `settings` nesnesi), Pydantic environment variable'ları büyük/küçük harfe duyarsız şekilde okur; yani büyük harfli `APP_NAME` değişkeni, yine de `app_name` attribute'u için okunur.
-
-Sonrasında veriyi dönüştürür ve doğrular. Böylece `settings` nesnesini kullandığınızda, tanımladığınız tiplerde verilere sahip olursunuz (örn. `items_per_user` bir `int` olur).
-
-### `settings`'i kullanın { #use-the-settings }
-
-Daha sonra uygulamanızda yeni `settings` nesnesini kullanabilirsiniz:
-
-{* ../../docs_src/settings/tutorial001_py39.py hl[18:20] *}
-
-### Server'ı çalıştırın { #run-the-server }
-
-Sonraki adımda server'ı çalıştırırken konfigürasyonları environment variable olarak geçersiniz; örneğin `ADMIN_EMAIL` ve `APP_NAME` şu şekilde ayarlanabilir:
-
-<div class="termy">
-
-```console
-$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-/// tip | İpucu
-
-Tek bir komut için birden fazla env var ayarlamak istiyorsanız aralarına boşluk koyun ve hepsini komuttan önce yazın.
-
-///
-
-Böylece `admin_email` ayarı `"deadpool@example.com"` olur.
-
-`app_name` `"ChimichangApp"` olur.
-
-`items_per_user` ise default değeri olan `50` olarak kalır.
-
-## Ayarları başka bir module'de tutma { #settings-in-another-module }
-
-[Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=_blank} bölümünde gördüğünüz gibi, bu ayarları başka bir module dosyasına koyabilirsiniz.
-
-Örneğin `config.py` adında bir dosyanız şu şekilde olabilir:
-
-{* ../../docs_src/settings/app01_py39/config.py *}
-
-Ve ardından bunu `main.py` dosyasında kullanabilirsiniz:
-
-{* ../../docs_src/settings/app01_py39/main.py hl[3,11:13] *}
-
-/// tip | İpucu
-
-[Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=_blank} bölümünde gördüğünüz gibi, ayrıca bir `__init__.py` dosyasına da ihtiyacınız olacak.
-
-///
-
-## Dependency içinde ayarlar { #settings-in-a-dependency }
-
-Bazı durumlarda, her yerde kullanılan global bir `settings` nesnesi yerine ayarları bir dependency üzerinden sağlamak faydalı olabilir.
-
-Bu özellikle test sırasında çok işe yarar; çünkü bir dependency'yi kendi özel ayarlarınızla override etmek çok kolaydır.
-
-### Config dosyası { #the-config-file }
-
-Bir önceki örnekten devam edersek, `config.py` dosyanız şöyle görünebilir:
-
-{* ../../docs_src/settings/app02_an_py39/config.py hl[10] *}
-
-Dikkat edin, artık default bir instance `settings = Settings()` oluşturmuyoruz.
-
-### Ana uygulama dosyası { #the-main-app-file }
-
-Şimdi, yeni bir `config.Settings()` döndüren bir dependency oluşturuyoruz.
-
-{* ../../docs_src/settings/app02_an_py39/main.py hl[6,12:13] *}
-
-/// tip | İpucu
-
-`@lru_cache` konusunu birazdan ele alacağız.
-
-Şimdilik `get_settings()`'in normal bir fonksiyon olduğunu varsayabilirsiniz.
-
-///
-
-Sonra bunu dependency olarak *path operation function*'dan talep edebilir ve ihtiyaç duyduğumuz her yerde kullanabiliriz.
-
-{* ../../docs_src/settings/app02_an_py39/main.py hl[17,19:21] *}
-
-### Ayarlar ve test { #settings-and-testing }
-
-Ardından, `get_settings` için bir dependency override oluşturarak test sırasında farklı bir settings nesnesi sağlamak çok kolay olur:
-
-{* ../../docs_src/settings/app02_an_py39/test_main.py hl[9:10,13,21] *}
-
-Dependency override içinde, yeni `Settings` nesnesini oluştururken `admin_email` için yeni bir değer ayarlarız ve sonra bu yeni nesneyi döndürürüz.
-
-Sonrasında bunun kullanıldığını test edebiliriz.
-
-## `.env` dosyası okuma { #reading-a-env-file }
-
-Çok sayıda ayarınız varsa ve bunlar farklı ortamlarda sık sık değişiyorsa, bunları bir dosyaya koyup, sanki environment variable'mış gibi o dosyadan okumak faydalı olabilir.
-
-Bu yaklaşım oldukça yaygındır ve bir adı vardır: Bu environment variable'lar genellikle `.env` adlı bir dosyaya konur ve bu dosyaya "dotenv" denir.
-
-/// tip | İpucu
-
-Nokta (`.`) ile başlayan dosyalar, Linux ve macOS gibi Unix-benzeri sistemlerde gizli dosyadır.
-
-Ancak dotenv dosyasının mutlaka bu dosya adına sahip olması gerekmez.
-
-///
-
-Pydantic, harici bir kütüphane kullanarak bu tür dosyalardan okuma desteğine sahiptir. Daha fazlası için: <a href="https://docs.pydantic.dev/latest/concepts/pydantic_settings/#dotenv-env-support" class="external-link" target="_blank">Pydantic Settings: Dotenv (.env) support</a>.
-
-/// tip | İpucu
-
-Bunun çalışması için `pip install python-dotenv` yapmanız gerekir.
-
-///
-
-### `.env` dosyası { #the-env-file }
-
-Şöyle bir `.env` dosyanız olabilir:
-
-```bash
-ADMIN_EMAIL="deadpool@example.com"
-APP_NAME="ChimichangApp"
-```
-
-### Ayarları `.env`'den okuyun { #read-settings-from-env }
-
-Ardından `config.py` dosyanızı şöyle güncelleyin:
-
-{* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
-
-/// tip | İpucu
-
-`model_config` attribute'u yalnızca Pydantic konfigürasyonu içindir. Daha fazlası için <a href="https://docs.pydantic.dev/latest/concepts/config/" class="external-link" target="_blank">Pydantic: Concepts: Configuration</a>.
-
-///
-
-Burada, Pydantic `Settings` sınıfınızın içinde `env_file` konfigürasyonunu tanımlar ve değer olarak kullanmak istediğimiz dotenv dosyasının dosya adını veririz.
-
-### `lru_cache` ile `Settings`'i yalnızca bir kez oluşturma { #creating-the-settings-only-once-with-lru-cache }
-
-Diskten dosya okumak normalde maliyetli (yavaş) bir işlemdir; bu yüzden muhtemelen bunu yalnızca bir kez yapıp aynı settings nesnesini tekrar kullanmak istersiniz. Her request için yeniden okumak istemezsiniz.
-
-Ancak her seferinde şunu yaptığımızda:
-
-```Python
-Settings()
-```
-
-yeni bir `Settings` nesnesi oluşturulur ve oluşturulurken `.env` dosyasını yeniden okur.
-
-Dependency fonksiyonu sadece şöyle olsaydı:
-
-```Python
-def get_settings():
-    return Settings()
-```
-
-bu nesneyi her request için oluştururduk ve `.env` dosyasını her request'te okurduk. ⚠️
-
-Fakat en üstte `@lru_cache` decorator'ünü kullandığımız için `Settings` nesnesi yalnızca bir kez, ilk çağrıldığı anda oluşturulur. ✔️
-
-{* ../../docs_src/settings/app03_an_py39/main.py hl[1,11] *}
-
-Sonraki request'lerde dependency'ler içinden `get_settings()` çağrıldığında, `get_settings()`'in iç kodu tekrar çalıştırılıp yeni bir `Settings` nesnesi yaratılmak yerine, ilk çağrıda döndürülen aynı nesne tekrar tekrar döndürülür.
-
-#### `lru_cache` Teknik Detayları { #lru-cache-technical-details }
-
-`@lru_cache`, decorator olarak uygulandığı fonksiyonu, her seferinde tekrar hesaplamak yerine ilk seferde döndürdüğü değeri döndürecek şekilde değiştirir; yani fonksiyon kodunu her çağrıda yeniden çalıştırmaz.
-
-Bu nedenle altındaki fonksiyon, argüman kombinasyonlarının her biri için bir kez çalıştırılır. Sonra bu argüman kombinasyonlarının her biri için döndürülmüş değerler, fonksiyon aynı argüman kombinasyonuyla çağrıldıkça tekrar tekrar kullanılır.
-
-Örneğin, şöyle bir fonksiyonunuz varsa:
-
-```Python
-@lru_cache
-def say_hi(name: str, salutation: str = "Ms."):
-    return f"Hello {salutation} {name}"
-```
-
-programınız şu şekilde çalışabilir:
-
-```mermaid
-sequenceDiagram
-
-participant code as Code
-participant function as say_hi()
-participant execute as Execute function
-
-    rect rgba(0, 255, 0, .1)
-        code ->> function: say_hi(name="Camila")
-        function ->> execute: execute function code
-        execute ->> code: return the result
-    end
-
-    rect rgba(0, 255, 255, .1)
-        code ->> function: say_hi(name="Camila")
-        function ->> code: return stored result
-    end
-
-    rect rgba(0, 255, 0, .1)
-        code ->> function: say_hi(name="Rick")
-        function ->> execute: execute function code
-        execute ->> code: return the result
-    end
-
-    rect rgba(0, 255, 0, .1)
-        code ->> function: say_hi(name="Rick", salutation="Mr.")
-        function ->> execute: execute function code
-        execute ->> code: return the result
-    end
-
-    rect rgba(0, 255, 255, .1)
-        code ->> function: say_hi(name="Rick")
-        function ->> code: return stored result
-    end
-
-    rect rgba(0, 255, 255, .1)
-        code ->> function: say_hi(name="Camila")
-        function ->> code: return stored result
-    end
-```
-
-Bizim `get_settings()` dependency'miz özelinde ise fonksiyon hiç argüman almaz; dolayısıyla her zaman aynı değeri döndürür.
-
-Bu şekilde, neredeyse global bir değişken gibi davranır. Ancak bir dependency fonksiyonu kullandığı için testte kolayca override edebiliriz.
-
-`@lru_cache`, Python standart kütüphanesinin bir parçası olan `functools` içindedir. Daha fazla bilgi için: <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">Python docs for `@lru_cache`</a>.
-
-## Özet { #recap }
-
-Uygulamanızın ayarlarını veya konfigürasyonlarını yönetmek için, Pydantic model'lerinin tüm gücüyle birlikte Pydantic Settings'i kullanabilirsiniz.
-
-* Dependency kullanarak test etmeyi basitleştirebilirsiniz.
-* Bununla `.env` dosyalarını kullanabilirsiniz.
-* `@lru_cache` kullanmak, dotenv dosyasını her request için tekrar tekrar okumayı engellerken, test sırasında override etmenize de izin verir.

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

@@ -1,67 +0,0 @@
-# Alt Uygulamalar - Mount İşlemi { #sub-applications-mounts }
-
-Kendi bağımsız OpenAPI şemaları ve kendi dokümantasyon arayüzleri olan iki bağımsız FastAPI uygulamasına ihtiyacınız varsa, bir ana uygulama oluşturup bir (veya daha fazla) alt uygulamayı "mount" edebilirsiniz.
-
-## Bir **FastAPI** uygulamasını mount etmek { #mounting-a-fastapi-application }
-
-"Mount" etmek, belirli bir path altında tamamen "bağımsız" bir uygulamayı eklemek anlamına gelir. Ardından o path’in altındaki her şeyi, alt uygulamada tanımlanan _path operation_’lar ile o alt uygulama yönetir.
-
-### Üst seviye uygulama { #top-level-application }
-
-Önce ana, üst seviye **FastAPI** uygulamasını ve onun *path operation*’larını oluşturun:
-
-{* ../../docs_src/sub_applications/tutorial001_py39.py hl[3, 6:8] *}
-
-### Alt uygulama { #sub-application }
-
-Sonra alt uygulamanızı ve onun *path operation*’larını oluşturun.
-
-Bu alt uygulama da standart bir FastAPI uygulamasıdır; ancak "mount" edilecek olan budur:
-
-{* ../../docs_src/sub_applications/tutorial001_py39.py hl[11, 14:16] *}
-
-### Alt uygulamayı mount edin { #mount-the-sub-application }
-
-Üst seviye uygulamanızda (`app`), alt uygulama `subapi`’yi mount edin.
-
-Bu örnekte `/subapi` path’ine mount edilecektir:
-
-{* ../../docs_src/sub_applications/tutorial001_py39.py hl[11, 19] *}
-
-### Otomatik API dokümanlarını kontrol edin { #check-the-automatic-api-docs }
-
-Şimdi dosyanızla birlikte `fastapi` komutunu çalıştırın:
-
-<div class="termy">
-
-```console
-$ fastapi dev main.py
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-Ardından <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresinden dokümanları açın.
-
-Ana uygulama için otomatik API dokümanlarını göreceksiniz; yalnızca onun kendi _path operation_’larını içerir:
-
-<img src="/img/tutorial/sub-applications/image01.png">
-
-Sonra alt uygulamanın dokümanlarını <a href="http://127.0.0.1:8000/subapi/docs" class="external-link" target="_blank">http://127.0.0.1:8000/subapi/docs</a> adresinden açın.
-
-Alt uygulama için otomatik API dokümanlarını göreceksiniz; yalnızca onun kendi _path operation_’larını içerir ve hepsi doğru alt-path öneki `/subapi` altında yer alır:
-
-<img src="/img/tutorial/sub-applications/image02.png">
-
-İki arayüzden herhangi biriyle etkileşime girmeyi denerseniz doğru şekilde çalıştıklarını görürsünüz; çünkü tarayıcı her bir uygulama ya da alt uygulama ile ayrı ayrı iletişim kurabilir.
-
-### Teknik Detaylar: `root_path` { #technical-details-root-path }
-
-Yukarıda anlatıldığı gibi bir alt uygulamayı mount ettiğinizde FastAPI, ASGI spesifikasyonundaki `root_path` adlı bir mekanizmayı kullanarak alt uygulamaya mount path’ini iletmeyi otomatik olarak yönetir.
-
-Bu sayede alt uygulama, dokümantasyon arayüzü için o path önekini kullanması gerektiğini bilir.
-
-Ayrıca alt uygulamanın kendi mount edilmiş alt uygulamaları da olabilir; FastAPI tüm bu `root_path`’leri otomatik olarak yönettiği için her şey doğru şekilde çalışır.
-
-`root_path` hakkında daha fazlasını ve bunu açıkça nasıl kullanacağınızı [Behind a Proxy](behind-a-proxy.md){.internal-link target=_blank} bölümünde öğreneceksiniz.

docs/tr/docs/advanced/templates.md

@@ -1,126 +0,0 @@
-# Şablonlar { #templates }
-
-**FastAPI** ile istediğiniz herhangi bir template engine'i kullanabilirsiniz.
-
-Yaygın bir tercih, Flask ve diğer araçların da kullandığı Jinja2'dir.
-
-Bunu kolayca yapılandırmak için, doğrudan **FastAPI** uygulamanızda kullanabileceğiniz yardımcı araçlar vardır (Starlette tarafından sağlanır).
-
-## Bağımlılıkları Yükleme { #install-dependencies }
-
-Bir [virtual environment](../virtual-environments.md){.internal-link target=_blank} oluşturduğunuzdan, etkinleştirdiğinizden ve `jinja2`'yi yüklediğinizden emin olun:
-
-<div class="termy">
-
-```console
-$ pip install jinja2
-
----> 100%
-```
-
-</div>
-
-## `Jinja2Templates` Kullanımı { #using-jinja2templates }
-
-* `Jinja2Templates`'ı içe aktarın.
-* Daha sonra tekrar kullanabileceğiniz bir `templates` nesnesi oluşturun.
-* Template döndürecek *path operation* içinde bir `Request` parametresi tanımlayın.
-* Oluşturduğunuz `templates` nesnesini kullanarak bir `TemplateResponse` render edip döndürün; template'in adını, request nesnesini ve Jinja2 template'i içinde kullanılacak anahtar-değer çiftlerini içeren bir "context" sözlüğünü (dict) iletin.
-
-{* ../../docs_src/templates/tutorial001_py39.py hl[4,11,15:18] *}
-
-/// note | Not
-
-FastAPI 0.108.0 ve Starlette 0.29.0 öncesinde, ilk parametre `name` idi.
-
-Ayrıca, daha önceki sürümlerde `request` nesnesi, Jinja2 için context içindeki anahtar-değer çiftlerinin bir parçası olarak geçirilirdi.
-
-///
-
-/// tip | İpucu
-
-`response_class=HTMLResponse` olarak tanımlarsanız doküman arayüzü (docs UI) response'un HTML olacağını anlayabilir.
-
-///
-
-/// note | Teknik Detaylar
-
-`from starlette.templating import Jinja2Templates` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici için kolaylık olması adına `starlette.templating` içeriğini `fastapi.templating` olarak da sunar. Ancak mevcut response'ların çoğu doğrudan Starlette'ten gelir. `Request` ve `StaticFiles` için de aynı durum geçerlidir.
-
-///
-
-## Template Yazma { #writing-templates }
-
-Ardından örneğin `templates/item.html` konumunda bir template yazabilirsiniz:
-
-```jinja hl_lines="7"
-{!../../docs_src/templates/templates/item.html!}
-```
-
-### Template Context Değerleri { #template-context-values }
-
-Şu HTML içeriğinde:
-
-{% raw %}
-
-```jinja
-Item ID: {{ id }}
-```
-
-{% endraw %}
-
-...gösterilecek olan `id`, sizin "context" olarak ilettiğiniz `dict` içinden alınır:
-
-```Python
-{"id": id}
-```
-
-Örneğin ID değeri `42` ise, şu şekilde render edilir:
-
-```html
-Item ID: 42
-```
-
-### Template `url_for` Argümanları { #template-url-for-arguments }
-
-Template içinde `url_for()` da kullanabilirsiniz; argüman olarak, *path operation function*'ınızın kullandığı argümanların aynısını alır.
-
-Dolayısıyla şu bölüm:
-
-{% raw %}
-
-```jinja
-<a href="{{ url_for('read_item', id=id) }}">
-```
-
-{% endraw %}
-
-...*path operation function* olan `read_item(id=id)` tarafından handle edilecek URL'nin aynısına bir link üretir.
-
-Örneğin ID değeri `42` ise, şu şekilde render edilir:
-
-```html
-<a href="/items/42">
-```
-
-## Template'ler ve statik dosyalar { #templates-and-static-files }
-
-Template içinde `url_for()` kullanabilir ve örneğin `name="static"` ile mount ettiğiniz `StaticFiles` ile birlikte kullanabilirsiniz.
-
-```jinja hl_lines="4"
-{!../../docs_src/templates/templates/item.html!}
-```
-
-Bu örnekte, şu şekilde `static/styles.css` konumundaki bir CSS dosyasına link verir:
-
-```CSS hl_lines="4"
-{!../../docs_src/templates/static/styles.css!}
-```
-
-Ve `StaticFiles` kullandığınız için, bu CSS dosyası **FastAPI** uygulamanız tarafından `/static/styles.css` URL'sinde otomatik olarak servis edilir.
-
-## Daha fazla detay { #more-details }
-
-Template'leri nasıl test edeceğiniz dahil daha fazla detay için <a href="https://www.starlette.dev/templates/" class="external-link" target="_blank">Starlette'in template dokümantasyonuna</a> bakın.

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

@@ -1,53 +0,0 @@
-# Override Kullanarak Dependency'leri Test Etme { #testing-dependencies-with-overrides }
-
-## Test Sırasında Dependency Override Etme { #overriding-dependencies-during-testing }
-
-Test yazarken bazı durumlarda bir dependency'yi override etmek isteyebilirsiniz.
-
-Orijinal dependency'nin (ve varsa tüm alt dependency'lerinin) çalışmasını istemezsiniz.
-
-Bunun yerine, yalnızca testler sırasında (hatta belki sadece belirli bazı testlerde) kullanılacak farklı bir dependency sağlarsınız; böylece orijinal dependency'nin ürettiği değerin kullanıldığı yerde, test için üretilen değeri kullanabilirsiniz.
-
-### Kullanım Senaryoları: Harici Servis { #use-cases-external-service }
-
-Örneğin, çağırmanız gereken harici bir authentication provider'ınız olabilir.
-
-Ona bir token gönderirsiniz ve o da authenticated bir user döndürür.
-
-Bu provider request başına ücret alıyor olabilir ve onu çağırmak, testlerde sabit bir mock user kullanmaya kıyasla daha fazla zaman alabilir.
-
-Muhtemelen harici provider'ı bir kez test etmek istersiniz; ancak çalışan her testte onu çağırmanız şart değildir.
-
-Bu durumda, o provider'ı çağıran dependency'yi override edebilir ve yalnızca testleriniz için mock user döndüren özel bir dependency kullanabilirsiniz.
-
-### `app.dependency_overrides` Attribute'ünü Kullanın { #use-the-app-dependency-overrides-attribute }
-
-Bu tür durumlar için **FastAPI** uygulamanızda `app.dependency_overrides` adında bir attribute bulunur; bu basit bir `dict`'tir.
-
-Test için bir dependency'yi override etmek istediğinizde, key olarak orijinal dependency'yi (bir function), value olarak da override edecek dependency'nizi (başka bir function) verirsiniz.
-
-Böylece **FastAPI**, orijinal dependency yerine bu override'ı çağırır.
-
-{* ../../docs_src/dependency_testing/tutorial001_an_py310.py hl[26:27,30] *}
-
-/// tip | İpucu
-
-**FastAPI** uygulamanızın herhangi bir yerinde kullanılan bir dependency için override tanımlayabilirsiniz.
-
-Orijinal dependency bir *path operation function* içinde, bir *path operation decorator* içinde (return value kullanmadığınız durumlarda), bir `.include_router()` çağrısında, vb. kullanılıyor olabilir.
-
-FastAPI yine de onu override edebilir.
-
-///
-
-Sonrasında override'larınızı (yani kaldırıp sıfırlamayı) `app.dependency_overrides` değerini boş bir `dict` yaparak gerçekleştirebilirsiniz:
-
-```Python
-app.dependency_overrides = {}
-```
-
-/// tip | İpucu
-
-Bir dependency'yi yalnızca bazı testler sırasında override etmek istiyorsanız, override'ı testin başında (test function'ının içinde) ayarlayıp testin sonunda (yine test function'ının sonunda) sıfırlayabilirsiniz.
-
-///

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

@@ -1,12 +0,0 @@
-# Event'leri Test Etme: lifespan ve startup - shutdown { #testing-events-lifespan-and-startup-shutdown }
-
-Test'lerinizde `lifespan`'ın çalışması gerektiğinde, `TestClient`'ı bir `with` ifadesiyle kullanabilirsiniz:
-
-{* ../../docs_src/app_testing/tutorial004_py39.py hl[9:15,18,27:28,30:32,41:43] *}
-
-
-Bu konuda daha fazla ayrıntıyı resmi Starlette dokümantasyon sitesindeki ["Running lifespan in tests in the official Starlette documentation site."](https://www.starlette.dev/lifespan/#running-lifespan-in-tests) bölümünde okuyabilirsiniz.
-
-Kullanımdan kaldırılmış `startup` ve `shutdown` event'leri için ise `TestClient`'ı aşağıdaki gibi kullanabilirsiniz:
-
-{* ../../docs_src/app_testing/tutorial003_py39.py hl[9:12,20:24] *}

docs/tr/docs/advanced/using-request-directly.md

@@ -1,56 +0,0 @@
-# Request'i Doğrudan Kullanmak { #using-the-request-directly }
-
-Şu ana kadar, ihtiyacınız olan request parçalarını tipleriyle birlikte tanımlıyordunuz.
-
-Verileri şuradan alarak:
-
-* path'ten parameter olarak.
-* Header'lardan.
-* Cookie'lerden.
-* vb.
-
-Bunu yaptığınızda **FastAPI**, bu verileri doğrular (validate eder), dönüştürür ve API'niz için dokümantasyonu otomatik olarak üretir.
-
-Ancak bazı durumlarda `Request` nesnesine doğrudan erişmeniz gerekebilir.
-
-## `Request` nesnesi hakkında detaylar { #details-about-the-request-object }
-
-**FastAPI** aslında altta **Starlette** çalıştırır ve üstüne çeşitli araçlardan oluşan bir katman ekler. Bu yüzden gerektiğinde Starlette'in <a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">`Request`</a> nesnesini doğrudan kullanabilirsiniz.
-
-Bu ayrıca şu anlama gelir: `Request` nesnesinden veriyi doğrudan alırsanız (örneğin body'yi okursanız) FastAPI bu veriyi doğrulamaz, dönüştürmez veya dokümante etmez (otomatik API arayüzü için OpenAPI ile).
-
-Buna rağmen normal şekilde tanımladığınız diğer herhangi bir parameter (örneğin Pydantic model ile body) yine doğrulanır, dönüştürülür, annotate edilir, vb.
-
-Ama bazı özel durumlarda `Request` nesnesini almak faydalıdır.
-
-## `Request` nesnesini doğrudan kullanın { #use-the-request-object-directly }
-
-*Path operation function* içinde client'ın IP adresini/host'unu almak istediğinizi düşünelim.
-
-Bunun için request'e doğrudan erişmeniz gerekir.
-
-{* ../../docs_src/using_request_directly/tutorial001_py39.py hl[1,7:8] *}
-
-Tipi `Request` olan bir *path operation function* parameter'ı tanımladığınızda **FastAPI**, o parameter'a `Request` nesnesini geçmesi gerektiğini anlar.
-
-/// tip | İpucu
-
-Bu örnekte, request parameter'ının yanında bir path parameter'ı da tanımladığımıza dikkat edin.
-
-Dolayısıyla path parameter'ı çıkarılır, doğrulanır, belirtilen tipe dönüştürülür ve OpenAPI ile annotate edilir.
-
-Aynı şekilde, diğer parameter'ları normal biçimde tanımlamaya devam edip buna ek olarak `Request` de alabilirsiniz.
-
-///
-
-## `Request` dokümantasyonu { #request-documentation }
-
-<a href="https://www.starlette.dev/requests/" class="external-link" target="_blank">Resmi Starlette dokümantasyon sitesinde `Request` nesnesiyle ilgili daha fazla detayı</a> okuyabilirsiniz.
-
-/// note | Teknik Detaylar
-
-`from starlette.requests import Request` de kullanabilirsiniz.
-
-**FastAPI** bunu size (geliştiriciye) kolaylık olsun diye doğrudan sunar. Ancak kendisi doğrudan Starlette'ten gelir.
-
-///

docs/tr/docs/advanced/websockets.md

@@ -1,186 +0,0 @@
-# WebSockets { #websockets }
-
-**FastAPI** ile <a href="https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API" class="external-link" target="_blank">WebSockets</a> kullanabilirsiniz.
-
-## `websockets` Kurulumu { #install-websockets }
-
-Bir [virtual environment](../virtual-environments.md){.internal-link target=_blank} oluşturduğunuzdan, onu aktive ettiğinizden ve `websockets`'i ("WebSocket" protokolünü kullanmayı kolaylaştıran bir Python kütüphanesi) kurduğunuzdan emin olun:
-
-<div class="termy">
-
-```console
-$ pip install websockets
-
----> 100%
-```
-
-</div>
-
-## WebSockets client { #websockets-client }
-
-### Production'da { #in-production }
-
-Production sisteminizde muhtemelen React, Vue.js veya Angular gibi modern bir framework ile oluşturulmuş bir frontend vardır.
-
-WebSockets kullanarak backend'inizle iletişim kurmak için de büyük ihtimalle frontend'inizin sağladığı yardımcı araçları kullanırsınız.
-
-Ya da native kod ile doğrudan WebSocket backend'inizle iletişim kuran native bir mobil uygulamanız olabilir.
-
-Veya WebSocket endpoint'i ile iletişim kurmak için başka herhangi bir yönteminizi de kullanıyor olabilirsiniz.
-
----
-
-Ancak bu örnek için, tamamı uzun bir string içinde olacak şekilde biraz JavaScript içeren çok basit bir HTML dokümanı kullanacağız.
-
-Elbette bu optimal değil ve production için kullanmazsınız.
-
-Production'da yukarıdaki seçeneklerden birini kullanırsınız.
-
-Ama WebSockets'in server tarafına odaklanmak ve çalışan bir örnek görmek için en basit yol bu:
-
-{* ../../docs_src/websockets/tutorial001_py39.py hl[2,6:38,41:43] *}
-
-## Bir `websocket` Oluşturun { #create-a-websocket }
-
-**FastAPI** uygulamanızda bir `websocket` oluşturun:
-
-{* ../../docs_src/websockets/tutorial001_py39.py hl[1,46:47] *}
-
-/// note | Teknik Detaylar
-
-`from starlette.websockets import WebSocket` da kullanabilirsiniz.
-
-**FastAPI**, geliştirici olarak işinizi kolaylaştırmak için aynı `WebSocket`'i doğrudan sağlar. Ancak aslında doğrudan Starlette'ten gelir.
-
-///
-
-## Mesajları `await` Edin ve Mesaj Gönderin { #await-for-messages-and-send-messages }
-
-WebSocket route'unuzda mesajları `await` edebilir ve mesaj gönderebilirsiniz.
-
-{* ../../docs_src/websockets/tutorial001_py39.py hl[48:52] *}
-
-Binary, text ve JSON verisi alıp gönderebilirsiniz.
-
-## Deneyin { #try-it }
-
-Dosyanızın adı `main.py` ise uygulamanızı şu şekilde çalıştırın:
-
-<div class="termy">
-
-```console
-$ fastapi dev main.py
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-Tarayıcınızda <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a> adresini açın.
-
-Şuna benzer basit bir sayfa göreceksiniz:
-
-<img src="/img/tutorial/websockets/image01.png">
-
-Input kutusuna mesaj yazıp gönderebilirsiniz:
-
-<img src="/img/tutorial/websockets/image02.png">
-
-Ve WebSockets kullanan **FastAPI** uygulamanız yanıt döndürecektir:
-
-<img src="/img/tutorial/websockets/image03.png">
-
-Birçok mesaj gönderebilir (ve alabilirsiniz):
-
-<img src="/img/tutorial/websockets/image04.png">
-
-Ve hepsinde aynı WebSocket bağlantısı kullanılacaktır.
-
-## `Depends` ve Diğerlerini Kullanma { #using-depends-and-others }
-
-WebSocket endpoint'lerinde `fastapi` içinden import edip şunları kullanabilirsiniz:
-
-* `Depends`
-* `Security`
-* `Cookie`
-* `Header`
-* `Path`
-* `Query`
-
-Diğer FastAPI endpoint'leri/*path operations* ile aynı şekilde çalışırlar:
-
-{* ../../docs_src/websockets/tutorial002_an_py310.py hl[68:69,82] *}
-
-/// info | Bilgi
-
-Bu bir WebSocket olduğu için `HTTPException` raise etmek pek anlamlı değildir; bunun yerine `WebSocketException` raise ederiz.
-
-<a href="https://tools.ietf.org/html/rfc6455#section-7.4.1" class="external-link" target="_blank">Spesifikasyonda tanımlanan geçerli kodlar</a> arasından bir kapatma kodu kullanabilirsiniz.
-
-///
-
-### Dependency'lerle WebSockets'i Deneyin { #try-the-websockets-with-dependencies }
-
-Dosyanızın adı `main.py` ise uygulamanızı şu şekilde çalıştırın:
-
-<div class="termy">
-
-```console
-$ fastapi dev main.py
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-Tarayıcınızda <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a> adresini açın.
-
-Burada şunları ayarlayabilirsiniz:
-
-* path'te kullanılan "Item ID".
-* query parametresi olarak kullanılan "Token".
-
-/// tip | İpucu
-
-query'deki `token` değerinin bir dependency tarafından ele alınacağına dikkat edin.
-
-///
-
-Bununla WebSocket'e bağlanabilir, ardından mesaj gönderip alabilirsiniz:
-
-<img src="/img/tutorial/websockets/image05.png">
-
-## Bağlantı Kopmalarını ve Birden Fazla Client'ı Yönetme { #handling-disconnections-and-multiple-clients }
-
-Bir WebSocket bağlantısı kapandığında, `await websocket.receive_text()` bir `WebSocketDisconnect` exception'ı raise eder; ardından bunu bu örnekteki gibi yakalayıp (catch) yönetebilirsiniz.
-
-{* ../../docs_src/websockets/tutorial003_py39.py hl[79:81] *}
-
-Denemek için:
-
-* Uygulamayı birden fazla tarayıcı sekmesiyle açın.
-* Bu sekmelerden mesaj yazın.
-* Sonra sekmelerden birini kapatın.
-
-Bu, `WebSocketDisconnect` exception'ını raise eder ve diğer tüm client'lar şuna benzer bir mesaj alır:
-
-```
-Client #1596980209979 left the chat
-```
-
-/// tip | İpucu
-
-Yukarıdaki uygulama, birden fazla WebSocket bağlantısına mesajları nasıl yönetip broadcast edeceğinizi göstermek için minimal ve basit bir örnektir.
-
-Ancak her şey memory'de, tek bir list içinde yönetildiği için yalnızca process çalıştığı sürece ve yalnızca tek bir process ile çalışacaktır.
-
-FastAPI ile kolay entegre olan ama Redis, PostgreSQL vb. tarafından desteklenen daha sağlam bir şeye ihtiyacınız varsa <a href="https://github.com/encode/broadcaster" class="external-link" target="_blank">encode/broadcaster</a>'a göz atın.
-
-///
-
-## Daha Fazla Bilgi { #more-info }
-
-Seçenekler hakkında daha fazlasını öğrenmek için Starlette dokümantasyonunda şunlara bakın:
-
-* <a href="https://www.starlette.dev/websockets/" class="external-link" target="_blank">`WebSocket` class'ı</a>.
-* <a href="https://www.starlette.dev/endpoints/#websocketendpoint" class="external-link" target="_blank">Class tabanlı WebSocket yönetimi</a>.

docs/tr/docs/advanced/wsgi.md

@@ -1,34 +1,18 @@
 # WSGI'yi Dahil Etme - Flask, Django ve Diğerleri { #including-wsgi-flask-django-others }
 
-WSGI uygulamalarını [Alt Uygulamalar - Mount Etme](sub-applications.md){.internal-link target=_blank}, [Bir Proxy Arkasında](behind-a-proxy.md){.internal-link target=_blank} bölümlerinde gördüğünüz gibi mount edebilirsiniz.
+WSGI uygulamalarını [Sub Applications - Mounts](sub-applications.md){.internal-link target=_blank}, [Behind a Proxy](behind-a-proxy.md){.internal-link target=_blank} bölümlerinde gördüğünüz gibi mount edebilirsiniz.
 
 Bunun için `WSGIMiddleware`'ı kullanabilir ve bunu WSGI uygulamanızı (örneğin Flask, Django vb.) sarmalamak için kullanabilirsiniz.
 
 ## `WSGIMiddleware` Kullanımı { #using-wsgimiddleware }
 
-/// info | Bilgi
-
-Bunun için `a2wsgi` kurulmalıdır; örneğin `pip install a2wsgi` ile.
-
-///
-
-`WSGIMiddleware`'ı `a2wsgi` paketinden import etmeniz gerekir.
+`WSGIMiddleware`'ı import etmeniz gerekir.
 
 Ardından WSGI (örn. Flask) uygulamasını middleware ile sarmalayın.
 
 Ve sonra bunu bir path'in altına mount edin.
 
-{* ../../docs_src/wsgi/tutorial001_py39.py hl[1,3,23] *}
-
-/// note | Not
-
-Önceden, `fastapi.middleware.wsgi` içindeki `WSGIMiddleware`'ın kullanılması öneriliyordu, ancak artık kullanımdan kaldırıldı.
-
-Bunun yerine `a2wsgi` paketini kullanmanız önerilir. Kullanım aynıdır.
-
-Sadece `a2wsgi` paketinin kurulu olduğundan emin olun ve `WSGIMiddleware`'ı `a2wsgi` içinden doğru şekilde import edin.
-
-///
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
 ## Kontrol Edelim { #check-it }
 

docs/tr/docs/deployment/concepts.md

@@ -1,321 +0,0 @@
-# Deployment Kavramları { #deployments-concepts }
-
-Bir **FastAPI** uygulamasını (hatta genel olarak herhangi bir web API'yi) deploy ederken, muhtemelen önemseyeceğiniz bazı kavramlar vardır. Bu kavramları kullanarak, **uygulamanızı deploy etmek** için **en uygun** yöntemi bulabilirsiniz.
-
-Önemli kavramlardan bazıları şunlardır:
-
-* Güvenlik - HTTPS
-* Startup'ta çalıştırma
-* Yeniden başlatmalar
-* Replikasyon (çalışan process sayısı)
-* Bellek
-* Başlatmadan önceki adımlar
-
-Bunların **deployment**'ları nasıl etkilediğine bakalım.
-
-Nihai hedef, **API client**'larınıza **güvenli** bir şekilde hizmet verebilmek, **kesintileri** önlemek ve **hesaplama kaynaklarını** (ör. uzak server'lar/sanal makineler) olabildiğince verimli kullanmaktır.
-
-Burada bu **kavramlar** hakkında biraz daha bilgi vereceğim. Böylece, çok farklı ortamlarda—hatta bugün var olmayan **gelecekteki** ortamlarda bile—API'nizi nasıl deploy edeceğinize karar verirken ihtiyaç duyacağınız **sezgiyi** kazanmış olursunuz.
-
-Bu kavramları dikkate alarak, **kendi API**'leriniz için en iyi deployment yaklaşımını **değerlendirebilir ve tasarlayabilirsiniz**.
-
-Sonraki bölümlerde, FastAPI uygulamalarını deploy etmek için daha **somut tarifler** (recipes) paylaşacağım.
-
-Ama şimdilik, bu önemli **kavramsal fikirleri** inceleyelim. Bu kavramlar diğer tüm web API türleri için de geçerlidir.
-
-## Güvenlik - HTTPS { #security-https }
-
-[HTTPS hakkındaki önceki bölümde](https.md){.internal-link target=_blank} HTTPS'in API'niz için nasıl şifreleme sağladığını öğrenmiştik.
-
-Ayrıca HTTPS'in genellikle uygulama server'ınızın **dışında** yer alan bir bileşen tarafından sağlandığını, yani bir **TLS Termination Proxy** ile yapıldığını da görmüştük.
-
-Ve **HTTPS sertifikalarını yenilemekten** sorumlu bir şey olmalıdır; bu aynı bileşen olabileceği gibi farklı bir bileşen de olabilir.
-
-### HTTPS için Örnek Araçlar { #example-tools-for-https }
-
-TLS Termination Proxy olarak kullanabileceğiniz bazı araçlar:
-
-* Traefik
-    * Sertifika yenilemelerini otomatik yönetir
-* Caddy
-    * Sertifika yenilemelerini otomatik yönetir
-* Nginx
-    * Sertifika yenilemeleri için Certbot gibi harici bir bileşenle
-* HAProxy
-    * Sertifika yenilemeleri için Certbot gibi harici bir bileşenle
-* Nginx gibi bir Ingress Controller ile Kubernetes
-    * Sertifika yenilemeleri için cert-manager gibi harici bir bileşenle
-* Bir cloud provider tarafından servislerinin parçası olarak içeride yönetilmesi (aşağıyı okuyun)
-
-Bir diğer seçenek de, HTTPS kurulumunu da dahil olmak üzere işin daha büyük kısmını yapan bir **cloud service** kullanmaktır. Bunun bazı kısıtları olabilir veya daha pahalı olabilir vb. Ancak bu durumda TLS Termination Proxy'yi kendiniz kurmak zorunda kalmazsınız.
-
-Sonraki bölümlerde bazı somut örnekler göstereceğim.
-
----
-
-Sonraki kavramlar, gerçek API'nizi çalıştıran programla (ör. Uvicorn) ilgilidir.
-
-## Program ve Process { #program-and-process }
-
-Çalışan "**process**" hakkında çok konuşacağız. Bu yüzden ne anlama geldiğini ve "**program**" kelimesinden farkının ne olduğunu netleştirmek faydalı.
-
-### Program Nedir { #what-is-a-program }
-
-**Program** kelimesi günlük kullanımda birçok şeyi anlatmak için kullanılır:
-
-* Yazdığınız **code**, yani **Python dosyaları**.
-* İşletim sistemi tarafından **çalıştırılabilen** **dosya**, örn: `python`, `python.exe` veya `uvicorn`.
-* İşletim sistemi üzerinde **çalışır durumdayken** CPU kullanan ve bellekte veri tutan belirli bir program. Buna **process** de denir.
-
-### Process Nedir { #what-is-a-process }
-
-**Process** kelimesi genellikle daha spesifik kullanılır; yalnızca işletim sistemi üzerinde çalışan şeye (yukarıdaki son madde gibi) işaret eder:
-
-* İşletim sistemi üzerinde **çalışır durumda** olan belirli bir program.
-    * Bu; dosyayı ya da code'u değil, işletim sistemi tarafından **çalıştırılan** ve yönetilen şeyi ifade eder.
-* Herhangi bir program, herhangi bir code, **yalnızca çalıştırılırken** bir şey yapabilir. Yani bir **process çalışıyorken**.
-* Process siz tarafından veya işletim sistemi tarafından **sonlandırılabilir** (ya da "killed" edilebilir). O anda çalışması/çalıştırılması durur ve artık **hiçbir şey yapamaz**.
-* Bilgisayarınızda çalışan her uygulamanın arkasında bir process vardır; çalışan her program, her pencere vb. Bilgisayar açıkken normalde **aynı anda** birçok process çalışır.
-* Aynı anda **aynı programın birden fazla process**'i çalışabilir.
-
-İşletim sisteminizdeki "task manager" veya "system monitor" (ya da benzeri araçlar) ile bu process'lerin birçoğunu çalışır halde görebilirsiniz.
-
-Örneğin muhtemelen aynı browser programını (Firefox, Chrome, Edge vb.) çalıştıran birden fazla process göreceksiniz. Genelde her tab için bir process, üstüne bazı ek process'ler çalıştırırlar.
-
-<img class="shadow" src="/img/deployment/concepts/image01.png">
-
----
-
-Artık **process** ve **program** arasındaki farkı bildiğimize göre, deployment konusuna devam edelim.
-
-## Startup'ta Çalıştırma { #running-on-startup }
-
-Çoğu durumda bir web API oluşturduğunuzda, client'larınızın her zaman erişebilmesi için API'nizin kesintisiz şekilde **sürekli çalışıyor** olmasını istersiniz. Elbette sadece belirli durumlarda çalışmasını istemenizin özel bir sebebi olabilir; ancak çoğunlukla onu sürekli açık ve **kullanılabilir** halde tutarsınız.
-
-### Uzak Bir Server'da { #in-a-remote-server }
-
-Uzak bir server (cloud server, sanal makine vb.) kurduğunuzda, yapabileceğiniz en basit şey; local geliştirme sırasında yaptığınız gibi, manuel olarak `fastapi run` (Uvicorn'u kullanır) veya benzeri bir komutla çalıştırmaktır.
-
-Bu yöntem çalışır ve **geliştirme sırasında** faydalıdır.
-
-Ancak server'a olan bağlantınız koparsa, **çalışan process** muhtemelen ölür.
-
-Ve server yeniden başlatılırsa (örneğin update'lerden sonra ya da cloud provider'ın migration'larından sonra) bunu muhtemelen **fark etmezsiniz**. Dolayısıyla process'i manuel yeniden başlatmanız gerektiğini de bilmezsiniz. Sonuçta API'niz ölü kalır.
-
-### Startup'ta Otomatik Çalıştırma { #run-automatically-on-startup }
-
-Genellikle server programının (ör. Uvicorn) server açılışında otomatik başlamasını ve herhangi bir **insan müdahalesi** gerektirmeden API'nizi çalıştıran bir process'in sürekli ayakta olmasını istersiniz (ör. FastAPI uygulamanızı çalıştıran Uvicorn).
-
-### Ayrı Bir Program { #separate-program }
-
-Bunu sağlamak için genellikle startup'ta uygulamanızın çalıştığından emin olacak **ayrı bir program** kullanırsınız. Pek çok durumda bu program, örneğin bir veritabanı gibi diğer bileşenlerin/uygulamaların da çalıştığından emin olur.
-
-### Startup'ta Çalıştırmak için Örnek Araçlar { #example-tools-to-run-at-startup }
-
-Bu işi yapabilen araçlara örnekler:
-
-* Docker
-* Kubernetes
-* Docker Compose
-* Docker in Swarm Mode
-* Systemd
-* Supervisor
-* Bir cloud provider tarafından servislerinin parçası olarak içeride yönetilmesi
-* Diğerleri...
-
-Sonraki bölümlerde daha somut örnekler vereceğim.
-
-## Yeniden Başlatmalar { #restarts }
-
-Uygulamanızın startup'ta çalıştığından emin olmaya benzer şekilde, hatalardan sonra **yeniden başlatıldığından** da emin olmak istersiniz.
-
-### Hata Yaparız { #we-make-mistakes }
-
-Biz insanlar sürekli **hata** yaparız. Yazılımın neredeyse *her zaman* farklı yerlerinde gizli **bug**'lar vardır.
-
-Ve biz geliştiriciler bu bug'ları buldukça ve yeni özellikler ekledikçe code'u iyileştiririz (muhtemelen yeni bug'lar da ekleyerek).
-
-### Küçük Hatalar Otomatik Yönetilir { #small-errors-automatically-handled }
-
-FastAPI ile web API geliştirirken, code'umuzda bir hata olursa FastAPI genellikle bunu hatayı tetikleyen tek request ile sınırlar.
-
-Client o request için **500 Internal Server Error** alır; ancak uygulama tamamen çöküp durmak yerine sonraki request'ler için çalışmaya devam eder.
-
-### Daha Büyük Hatalar - Çökmeler { #bigger-errors-crashes }
-
-Yine de bazı durumlarda, yazdığımız bir code **tüm uygulamayı çökertip** Uvicorn ve Python'ın crash olmasına neden olabilir.
-
-Böyle bir durumda, tek bir noktadaki hata yüzünden uygulamanın ölü kalmasını istemezsiniz; bozuk olmayan *path operations* en azından çalışmaya devam etsin istersiniz.
-
-### Crash Sonrası Yeniden Başlatma { #restart-after-crash }
-
-Ancak çalışan **process**'i çökerten gerçekten kötü hatalarda, process'i **yeniden başlatmaktan** sorumlu harici bir bileşen istersiniz; en azından birkaç kez...
-
-/// tip | İpucu
-
-...Yine de uygulama **hemen crash oluyorsa**, onu sonsuza kadar yeniden başlatmaya çalışmanın pek anlamı yoktur. Böyle durumları büyük ihtimalle geliştirme sırasında ya da en geç deploy'dan hemen sonra fark edersiniz.
-
-O yüzden ana senaryoya odaklanalım: Gelecekte bazı özel durumlarda tamamen çökebilir ve yine de yeniden başlatmak mantıklıdır.
-
-///
-
-Uygulamanızı yeniden başlatmakla görevli bileşenin **harici bir bileşen** olmasını istersiniz. Çünkü o noktada Uvicorn ve Python ile birlikte aynı uygulama zaten crash olmuştur; aynı app'in içindeki aynı code'un bunu düzeltmek için yapabileceği bir şey kalmaz.
-
-### Otomatik Yeniden Başlatma için Örnek Araçlar { #example-tools-to-restart-automatically }
-
-Çoğu durumda, **startup'ta programı çalıştırmak** için kullanılan aracın aynısı otomatik **restart**'ları yönetmek için de kullanılır.
-
-Örneğin bu şunlarla yönetilebilir:
-
-* Docker
-* Kubernetes
-* Docker Compose
-* Docker in Swarm Mode
-* Systemd
-* Supervisor
-* Bir cloud provider tarafından servislerinin parçası olarak içeride yönetilmesi
-* Diğerleri...
-
-## Replikasyon - Process'ler ve Bellek { #replication-processes-and-memory }
-
-FastAPI uygulamasında, Uvicorn'u çalıştıran `fastapi` komutu gibi bir server programı kullanırken, uygulamayı **tek bir process** içinde bir kez çalıştırmak bile aynı anda birden fazla client'a hizmet verebilir.
-
-Ancak birçok durumda, aynı anda birden fazla worker process çalıştırmak istersiniz.
-
-### Birden Fazla Process - Worker'lar { #multiple-processes-workers }
-
-Tek bir process'in karşılayabileceğinden daha fazla client'ınız varsa (örneğin sanal makine çok büyük değilse) ve server CPU'sunda **birden fazla core** varsa, aynı uygulamayla **birden fazla process** çalıştırıp tüm request'leri bunlara dağıtabilirsiniz.
-
-Aynı API programının **birden fazla process**'ini çalıştırdığınızda, bunlara genellikle **worker** denir.
-
-### Worker Process'ler ve Port'lar { #worker-processes-and-ports }
-
-[HTTPS hakkındaki dokümanda](https.md){.internal-link target=_blank} bir server'da aynı port ve IP adresi kombinasyonunu yalnızca tek bir process'in dinleyebileceğini hatırlıyor musunuz?
-
-Bu hâlâ geçerli.
-
-Dolayısıyla **aynı anda birden fazla process** çalıştırabilmek için, **port** üzerinde dinleyen **tek bir process** olmalı ve bu process iletişimi bir şekilde worker process'lere aktarmalıdır.
-
-### Process Başına Bellek { #memory-per-process }
-
-Program belleğe bir şeyler yüklediğinde—örneğin bir değişkende bir machine learning modelini veya büyük bir dosyanın içeriğini tutmak gibi—bunların hepsi server'ın **belleğini (RAM)** tüketir.
-
-Ve birden fazla process normalde **belleği paylaşmaz**. Yani her çalışan process'in kendi verileri, değişkenleri ve belleği vardır. Code'unuz çok bellek tüketiyorsa, **her process** buna denk bir miktar bellek tüketir.
-
-### Server Belleği { #server-memory }
-
-Örneğin code'unuz **1 GB** boyutunda bir Machine Learning modelini yüklüyorsa, API'niz tek process ile çalışırken en az 1 GB RAM tüketir. **4 process** (4 worker) başlatırsanız her biri 1 GB RAM tüketir. Yani toplamda API'niz **4 GB RAM** tüketir.
-
-Uzak server'ınız veya sanal makineniz yalnızca 3 GB RAM'e sahipse, 4 GB'tan fazla RAM yüklemeye çalışmak sorun çıkarır.
-
-### Birden Fazla Process - Bir Örnek { #multiple-processes-an-example }
-
-Bu örnekte, iki adet **Worker Process** başlatıp kontrol eden bir **Manager Process** vardır.
-
-Bu Manager Process büyük ihtimalle IP üzerindeki **port**'u dinleyen süreçtir ve tüm iletişimi worker process'lere aktarır.
-
-Worker process'ler uygulamanızı çalıştıran process'lerdir; bir **request** alıp bir **response** döndürmek için asıl hesaplamaları yaparlar ve sizin RAM'de değişkenlere koyduğunuz her şeyi yüklerler.
-
-<img src="/img/deployment/concepts/process-ram.drawio.svg">
-
-Elbette aynı makinede, uygulamanız dışında da muhtemelen **başka process**'ler çalışır.
-
-İlginç bir detay: Her process'in kullandığı **CPU** yüzdesi zaman içinde çok **değişken** olabilir; ancak **bellek (RAM)** genellikle az çok **stabil** kalır.
-
-Eğer API'niz her seferinde benzer miktarda hesaplama yapıyorsa ve çok sayıda client'ınız varsa, **CPU kullanımı** da muhtemelen *stabil olur* (hızlı hızlı sürekli yükselip alçalmak yerine).
-
-### Replikasyon Araçları ve Stratejileri Örnekleri { #examples-of-replication-tools-and-strategies }
-
-Bunu başarmak için farklı yaklaşımlar olabilir. Sonraki bölümlerde, örneğin Docker ve container'lar konuşurken, belirli stratejileri daha detaylı anlatacağım.
-
-Dikkate almanız gereken ana kısıt şudur: **public IP** üzerindeki **port**'u yöneten **tek** bir bileşen olmalı. Sonrasında bu bileşenin, replikasyonla çoğaltılmış **process/worker**'lara iletişimi **aktarmanın** bir yoluna sahip olması gerekir.
-
-Olası kombinasyonlar ve stratejiler:
-
-* `--workers` ile **Uvicorn**
-    * Bir Uvicorn **process manager** **IP** ve **port** üzerinde dinler ve **birden fazla Uvicorn worker process** başlatır.
-* **Kubernetes** ve diğer dağıtık **container sistemleri**
-    * **Kubernetes** katmanında bir şey **IP** ve **port** üzerinde dinler. Replikasyon, her birinde **tek bir Uvicorn process** çalışan **birden fazla container** ile yapılır.
-* Bunu sizin yerinize yapan **cloud service**'ler
-    * Cloud service muhtemelen **replikasyonu sizin yerinize yönetir**. Size çalıştırılacak **bir process** veya kullanılacak bir **container image** tanımlama imkânı verebilir; her durumda büyük ihtimalle **tek bir Uvicorn process** olur ve bunu çoğaltmaktan cloud service sorumlu olur.
-
-/// tip | İpucu
-
-**Container**, Docker veya Kubernetes ile ilgili bazı maddeler şimdilik çok anlamlı gelmiyorsa dert etmeyin.
-
-Container image'ları, Docker, Kubernetes vb. konuları ilerideki bir bölümde daha detaylı anlatacağım: [Container'larda FastAPI - Docker](docker.md){.internal-link target=_blank}.
-
-///
-
-## Başlatmadan Önceki Adımlar { #previous-steps-before-starting }
-
-Uygulamanızı **başlatmadan önce** bazı adımlar yapmak isteyeceğiniz birçok durum vardır.
-
-Örneğin **database migrations** çalıştırmak isteyebilirsiniz.
-
-Ancak çoğu durumda, bu adımları yalnızca **bir kez** çalıştırmak istersiniz.
-
-Bu yüzden, uygulamayı başlatmadan önce bu **ön adımları** çalıştıracak **tek bir process** olmasını istersiniz.
-
-Ve daha sonra uygulamanın kendisi için **birden fazla process** (birden fazla worker) başlatsanız bile, bu ön adımları çalıştıranın *yine* tek process olduğundan emin olmalısınız. Bu adımlar **birden fazla process** tarafından çalıştırılsaydı, işi **paralel** şekilde tekrarlarlardı. Adımlar database migration gibi hassas bir şeyse, birbirleriyle çakışıp çatışma çıkarabilirler.
-
-Elbette bazı durumlarda ön adımları birden fazla kez çalıştırmak sorun değildir; bu durumda yönetmesi çok daha kolay olur.
-
-/// tip | İpucu
-
-Ayrıca, kurulumunuza bağlı olarak bazı durumlarda uygulamanızı başlatmadan önce **hiç ön adıma ihtiyaç duymayabilirsiniz**.
-
-Bu durumda bunların hiçbirini düşünmeniz gerekmez.
-
-///
-
-### Ön Adımlar için Strateji Örnekleri { #examples-of-previous-steps-strategies }
-
-Bu konu, **sisteminizi nasıl deploy ettiğinize** çok bağlıdır ve muhtemelen programları nasıl başlattığınız, restart'ları nasıl yönettiğiniz vb. ile bağlantılıdır.
-
-Bazı olası fikirler:
-
-* Kubernetes'te, app container'ınızdan önce çalışan bir "Init Container"
-* Ön adımları çalıştırıp sonra uygulamanızı başlatan bir bash script
-    * Yine de o bash script'i başlatmak/restart etmek, hataları tespit etmek vb. için bir mekanizmaya ihtiyacınız olur.
-
-/// tip | İpucu
-
-Bunu container'larla nasıl yapabileceğinize dair daha somut örnekleri ilerideki bir bölümde anlatacağım: [Container'larda FastAPI - Docker](docker.md){.internal-link target=_blank}.
-
-///
-
-## Kaynak Kullanımı { #resource-utilization }
-
-Server(lar)ınız bir **kaynaktır**. Programlarınızla CPU'lardaki hesaplama zamanını ve mevcut RAM belleğini tüketebilir veya **kullanabilirsiniz**.
-
-Sistem kaynaklarının ne kadarını tüketmek/kullanmak istersiniz? "Az" demek kolaydır; ancak pratikte hedef genellikle **çökmeden mümkün olduğunca fazla** kullanmaktır.
-
-3 server için para ödüyor ama onların RAM ve CPU'sunun yalnızca küçük bir kısmını kullanıyorsanız, muhtemelen **para israf ediyorsunuz** ve muhtemelen **elektrik tüketimini** de gereksiz yere artırıyorsunuz vb.
-
-Bu durumda 2 server ile devam edip onların kaynaklarını (CPU, bellek, disk, ağ bant genişliği vb.) daha yüksek oranlarda kullanmak daha iyi olabilir.
-
-Öte yandan, 2 server'ınız var ve CPU ile RAM'in **%100**'ünü kullanıyorsanız, bir noktada bir process daha fazla bellek ister; server diski "bellek" gibi kullanmak zorunda kalır (binlerce kat daha yavaş olabilir) ya da hatta **crash** edebilir. Ya da bir process bir hesaplama yapmak ister ve CPU tekrar boşalana kadar beklemek zorunda kalır.
-
-Bu senaryoda **bir server daha** eklemek ve bazı process'leri orada çalıştırmak daha iyi olur; böylece hepsinin **yeterli RAM'i ve CPU zamanı** olur.
-
-Ayrıca, herhangi bir sebeple API'nizde bir kullanım **spike**'ı olma ihtimali de vardır. Belki viral olur, belki başka servisler veya bot'lar kullanmaya başlar. Bu durumlarda güvende olmak için ekstra kaynak isteyebilirsiniz.
-
-Hedef olarak **keyfi bir sayı** belirleyebilirsiniz; örneğin kaynak kullanımını **%50 ile %90 arasında** tutmak gibi. Önemli olan, bunların muhtemelen ölçmek isteyeceğiniz ve deployment'larınızı ayarlamak için kullanacağınız ana metrikler olmasıdır.
-
-Server'ınızda CPU ve RAM kullanımını veya her process'in ne kadar kullandığını görmek için `htop` gibi basit araçları kullanabilirsiniz. Ya da server'lar arasında dağıtık çalışan daha karmaşık monitoring araçları kullanabilirsiniz.
-
-## Özet { #recap }
-
-Uygulamanızı nasıl deploy edeceğinize karar verirken aklınızda tutmanız gereken ana kavramların bazılarını okudunuz:
-
-* Güvenlik - HTTPS
-* Startup'ta çalıştırma
-* Yeniden başlatmalar
-* Replikasyon (çalışan process sayısı)
-* Bellek
-* Başlatmadan önceki adımlar
-
-Bu fikirleri ve nasıl uygulayacağınızı anlamak, deployment'larınızı yapılandırırken ve ince ayar yaparken ihtiyaç duyacağınız sezgiyi kazanmanızı sağlamalıdır.
-
-Sonraki bölümlerde, izleyebileceğiniz stratejilere dair daha somut örnekler paylaşacağım.

docs/tr/docs/deployment/docker.md

@@ -1,620 +0,0 @@
-# Container'larda FastAPI - Docker { #fastapi-in-containers-docker }
-
-FastAPI uygulamalarını deploy ederken yaygın bir yaklaşım, bir **Linux container image** oluşturmaktır. Bu genellikle <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a> kullanılarak yapılır. Ardından bu container image'ı birkaç farklı yöntemden biriyle deploy edebilirsiniz.
-
-Linux container'ları kullanmanın **güvenlik**, **tekrarlanabilirlik**, **basitlik** gibi birçok avantajı vardır.
-
-/// tip | İpucu
-
-Aceleniz var ve bunları zaten biliyor musunuz? Aşağıdaki [`Dockerfile`'a atlayın 👇](#build-a-docker-image-for-fastapi).
-
-///
-
-<details>
-<summary>Dockerfile Önizleme 👀</summary>
-
-```Dockerfile
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-COPY ./app /code/app
-
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-
-# If running behind a proxy like Nginx or Traefik add --proxy-headers
-# CMD ["fastapi", "run", "app/main.py", "--port", "80", "--proxy-headers"]
-```
-
-</details>
-
-## Container Nedir { #what-is-a-container }
-
-Container'lar (özellikle Linux container'ları), bir uygulamayı tüm bağımlılıkları ve gerekli dosyalarıyla birlikte paketlemenin, aynı sistemdeki diğer container'lardan (diğer uygulama ya da bileşenlerden) izole tutarken yapılan, çok **hafif** bir yoludur.
-
-Linux container'ları, host'un (makine, sanal makine, cloud server vb.) aynı Linux kernel'ini kullanarak çalışır. Bu da, tüm bir işletim sistemini emüle eden tam sanal makinelere kıyasla çok daha hafif oldukları anlamına gelir.
-
-Bu sayede container'lar **az kaynak** tüketir; süreçleri doğrudan çalıştırmaya benzer bir seviyede (bir sanal makine çok daha fazla tüketirdi).
-
-Container'ların ayrıca kendi **izole** çalışan process'leri (çoğunlukla tek bir process), dosya sistemi ve ağı vardır. Bu da deployment, güvenlik, geliştirme vb. süreçleri kolaylaştırır.
-
-## Container Image Nedir { #what-is-a-container-image }
-
-Bir **container**, bir **container image**'dan çalıştırılır.
-
-Container image; bir container içinde bulunması gereken tüm dosyaların, environment variable'ların ve varsayılan komut/programın **statik** bir sürümüdür. Buradaki **statik**, container **image**'ının çalışmadığı, execute edilmediği; sadece paketlenmiş dosyalar ve metadata olduğu anlamına gelir.
-
-Depolanmış statik içerik olan "**container image**"ın aksine, "**container**" normalde çalışan instance'ı, yani **execute edilen** şeyi ifade eder.
-
-**Container** başlatılıp çalıştığında (bir **container image**'dan başlatılır), dosyalar oluşturabilir/değiştirebilir, environment variable'ları değiştirebilir vb. Bu değişiklikler sadece o container içinde kalır; alttaki container image'da kalıcı olmaz (diske kaydedilmez).
-
-Bir container image, **program** dosyası ve içeriklerine benzetilebilir; örn. `python` ve `main.py` gibi bir dosya.
-
-Ve **container**'ın kendisi (container image'a karşıt olarak) image'ın gerçek çalışan instance'ıdır; bir **process**'e benzer. Hatta bir container, yalnızca içinde **çalışan bir process** varken çalışır (ve genelde tek process olur). İçinde çalışan process kalmayınca container durur.
-
-## Container Image'lar { #container-images }
-
-Docker, **container image** ve **container** oluşturup yönetmek için kullanılan başlıca araçlardan biri olmuştur.
-
-Ayrıca birçok araç, ortam, veritabanı ve uygulama için önceden hazırlanmış **resmi container image**'ların bulunduğu herkese açık bir <a href="https://hub.docker.com/" class="external-link" target="_blank">Docker Hub</a> vardır.
-
-Örneğin, resmi bir <a href="https://hub.docker.com/_/python" class="external-link" target="_blank">Python Image</a> bulunur.
-
-Ve veritabanları gibi farklı şeyler için de birçok image vardır; örneğin:
-
-* <a href="https://hub.docker.com/_/postgres" class="external-link" target="_blank">PostgreSQL</a>
-* <a href="https://hub.docker.com/_/mysql" class="external-link" target="_blank">MySQL</a>
-* <a href="https://hub.docker.com/_/mongo" class="external-link" target="_blank">MongoDB</a>
-* <a href="https://hub.docker.com/_/redis" class="external-link" target="_blank">Redis</a>, vb.
-
-Hazır bir container image kullanarak farklı araçları **birleştirmek** ve birlikte kullanmak çok kolaydır. Örneğin yeni bir veritabanını denemek için. Çoğu durumda **resmi image**'ları kullanıp sadece environment variable'lar ile yapılandırmanız yeterlidir.
-
-Bu şekilde, çoğu zaman container'lar ve Docker hakkında öğrendiklerinizi farklı araç ve bileşenlerde tekrar kullanabilirsiniz.
-
-Dolayısıyla; veritabanı, Python uygulaması, React frontend uygulaması olan bir web server gibi farklı şeyler için **birden fazla container** çalıştırır ve bunları internal network üzerinden birbirine bağlarsınız.
-
-Docker veya Kubernetes gibi tüm container yönetim sistemlerinde bu ağ özellikleri entegre olarak bulunur.
-
-## Container'lar ve Process'ler { #containers-and-processes }
-
-Bir **container image** normalde metadata içinde, **container** başlatıldığında çalıştırılacak varsayılan program/komutu ve o programa geçirilecek parametreleri içerir. Bu, komut satırında yazacağınız şeye çok benzer.
-
-Bir **container** başlatıldığında bu komutu/programı çalıştırır (ancak isterseniz bunu override edip başka bir komut/program çalıştırabilirsiniz).
-
-Bir container, **ana process** (komut/program) çalıştığı sürece çalışır.
-
-Container'larda normalde **tek bir process** olur. Ancak ana process içinden subprocess'ler başlatmak da mümkündür; böylece aynı container içinde **birden fazla process** olur.
-
-Ama **en az bir çalışan process olmadan** çalışan bir container olamaz. Ana process durursa container da durur.
-
-## FastAPI için Docker Image Oluşturalım { #build-a-docker-image-for-fastapi }
-
-Tamam, şimdi bir şeyler inşa edelim! 🚀
-
-Resmi **Python** image'ını temel alarak, FastAPI için **sıfırdan** bir **Docker image** nasıl oluşturulur göstereceğim.
-
-Bu, örneğin şu durumlarda **çoğu zaman** yapmak isteyeceğiniz şeydir:
-
-* **Kubernetes** veya benzeri araçlar kullanırken
-* **Raspberry Pi** üzerinde çalıştırırken
-* Container image'ınızı sizin için çalıştıran bir cloud servisi kullanırken, vb.
-
-### Paket Gereksinimleri { #package-requirements }
-
-Uygulamanızın **paket gereksinimleri** genelde bir dosyada yer alır.
-
-Bu, gereksinimleri **yüklemek** için kullandığınız araca göre değişir.
-
-En yaygın yöntem, paket adları ve versiyonlarının satır satır yazıldığı bir `requirements.txt` dosyasına sahip olmaktır.
-
-Versiyon aralıklarını belirlemek için elbette [FastAPI sürümleri hakkında](versions.md){.internal-link target=_blank} bölümünde okuduğunuz fikirleri kullanırsınız.
-
-Örneğin `requirements.txt` şöyle görünebilir:
-
-```
-fastapi[standard]>=0.113.0,<0.114.0
-pydantic>=2.7.0,<3.0.0
-```
-
-Ve bu bağımlılıkları normalde `pip` ile yüklersiniz, örneğin:
-
-<div class="termy">
-
-```console
-$ pip install -r requirements.txt
----> 100%
-Successfully installed fastapi pydantic
-```
-
-</div>
-
-/// info | Bilgi
-
-Paket bağımlılıklarını tanımlamak ve yüklemek için başka formatlar ve araçlar da vardır.
-
-///
-
-### **FastAPI** Kodunu Oluşturun { #create-the-fastapi-code }
-
-* Bir `app` dizini oluşturun ve içine girin.
-* Boş bir `__init__.py` dosyası oluşturun.
-* Aşağıdakilerle bir `main.py` dosyası oluşturun:
-
-```Python
-from typing import Union
-
-from fastapi import FastAPI
-
-app = FastAPI()
-
-
-@app.get("/")
-def read_root():
-    return {"Hello": "World"}
-
-
-@app.get("/items/{item_id}")
-def read_item(item_id: int, q: Union[str, None] = None):
-    return {"item_id": item_id, "q": q}
-```
-
-### Dockerfile { #dockerfile }
-
-Şimdi aynı proje dizininde `Dockerfile` adlı bir dosya oluşturun ve içine şunları yazın:
-
-```{ .dockerfile .annotate }
-# (1)!
-FROM python:3.9
-
-# (2)!
-WORKDIR /code
-
-# (3)!
-COPY ./requirements.txt /code/requirements.txt
-
-# (4)!
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# (5)!
-COPY ./app /code/app
-
-# (6)!
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-```
-
-1. Resmi Python base image'ından başlayın.
-
-2. Geçerli çalışma dizinini `/code` olarak ayarlayın.
-
-    `requirements.txt` dosyasını ve `app` dizinini buraya koyacağız.
-
-3. Gereksinimleri içeren dosyayı `/code` dizinine kopyalayın.
-
-    Önce kodun tamamını değil, **sadece** gereksinim dosyasını kopyalayın.
-
-    Bu dosya **çok sık değişmediği** için Docker bunu tespit eder ve bu adımda **cache** kullanır; böylece bir sonraki adım için de cache devreye girer.
-
-4. Gereksinim dosyasındaki paket bağımlılıklarını yükleyin.
-
-    `--no-cache-dir` seçeneği, indirilen paketlerin yerel olarak kaydedilmemesini `pip`'e söyler. Bu kayıt, `pip` aynı paketleri tekrar yüklemek için yeniden çalıştırılacaksa işe yarar; ancak container'larla çalışırken genelde bu durum geçerli değildir.
-
-    /// note | Not
-
-    `--no-cache-dir` yalnızca `pip` ile ilgilidir; Docker veya container'larla ilgili değildir.
-
-    ///
-
-    `--upgrade` seçeneği, paketler zaten yüklüyse `pip`'e onları yükseltmesini söyler.
-
-    Bir önceki adım (dosyayı kopyalama) **Docker cache** tarafından tespit edilebildiği için, bu adım da uygun olduğunda **Docker cache'i kullanır**.
-
-    Bu adımda cache kullanmak, geliştirme sırasında image'ı tekrar tekrar build ederken size çok **zaman** kazandırır; her seferinde bağımlılıkları **indirip yüklemek** zorunda kalmazsınız.
-
-5. `./app` dizinini `/code` dizininin içine kopyalayın.
-
-    Burada en sık değişen şey olan kodun tamamı bulunduğundan, bu adım (ve genelde bundan sonraki adımlar) için Docker **cache**'i kolay kolay kullanılamaz.
-
-    Bu yüzden, container image build sürelerini optimize etmek için bunu `Dockerfile`'ın **sonlarına yakın** koymak önemlidir.
-
-6. Altta Uvicorn kullanan `fastapi run` komutunu **command** olarak ayarlayın.
-
-    `CMD` bir string listesi alır; bu string'lerin her biri komut satırında boşlukla ayrılmış şekilde yazacağınız parçaları temsil eder.
-
-    Bu komut, yukarıda `WORKDIR /code` ile ayarladığınız `/code` dizininden çalıştırılır.
-
-/// tip | İpucu
-
-Kod içindeki her numara balonuna tıklayarak her satırın ne yaptığını gözden geçirin. 👆
-
-///
-
-/// warning | Uyarı
-
-Aşağıda açıklandığı gibi `CMD` talimatının **her zaman** **exec form**'unu kullandığınızdan emin olun.
-
-///
-
-#### `CMD` Kullanımı - Exec Form { #use-cmd-exec-form }
-
-<a href="https://docs.docker.com/reference/dockerfile/#cmd" class="external-link" target="_blank">`CMD`</a> Docker talimatı iki formda yazılabilir:
-
-✅ **Exec** form:
-
-```Dockerfile
-# ✅ Do this
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-```
-
-⛔️ **Shell** form:
-
-```Dockerfile
-# ⛔️ Don't do this
-CMD fastapi run app/main.py --port 80
-```
-
-FastAPI'nin düzgün şekilde kapanabilmesi ve [lifespan event](../advanced/events.md){.internal-link target=_blank}'lerinin tetiklenmesi için her zaman **exec** formunu kullanın.
-
-Detaylar için <a href="https://docs.docker.com/reference/dockerfile/#shell-and-exec-form" class="external-link" target="_blank">shell ve exec form için Docker dokümanlarına</a> bakabilirsiniz.
-
-Bu durum `docker compose` kullanırken oldukça belirgin olabilir. Daha teknik detaylar için şu Docker Compose FAQ bölümüne bakın: <a href="https://docs.docker.com/compose/faq/#why-do-my-services-take-10-seconds-to-recreate-or-stop" class="external-link" target="_blank">Why do my services take 10 seconds to recreate or stop?</a>.
-
-#### Dizin Yapısı { #directory-structure }
-
-Artık dizin yapınız şöyle olmalı:
-
-```
-.
-├── app
-│   ├── __init__.py
-│   └── main.py
-├── Dockerfile
-└── requirements.txt
-```
-
-#### TLS Termination Proxy Arkasında { #behind-a-tls-termination-proxy }
-
-Container'ınızı Nginx veya Traefik gibi bir TLS Termination Proxy (load balancer) arkasında çalıştırıyorsanız `--proxy-headers` seçeneğini ekleyin. Bu, Uvicorn'a (FastAPI CLI üzerinden) uygulamanın HTTPS arkasında çalıştığını söyleyen proxy header'larına güvenmesini söyler.
-
-```Dockerfile
-CMD ["fastapi", "run", "app/main.py", "--proxy-headers", "--port", "80"]
-```
-
-#### Docker Cache { #docker-cache }
-
-Bu `Dockerfile` içinde önemli bir numara var: önce kodun geri kalanını değil, **sadece bağımlılık dosyasını** kopyalıyoruz. Nedenini anlatayım.
-
-```Dockerfile
-COPY ./requirements.txt /code/requirements.txt
-```
-
-Docker ve benzeri araçlar bu container image'larını **artımlı (incremental)** olarak **build** eder; `Dockerfile`'ın en üstünden başlayıp her talimatın oluşturduğu dosyaları ekleyerek **katman katman (layer)** ilerler.
-
-Docker ve benzeri araçlar image build ederken ayrıca bir **internal cache** kullanır. Son build'den beri bir dosya değişmediyse, dosyayı tekrar kopyalayıp sıfırdan yeni bir layer oluşturmak yerine, daha önce oluşturulan **aynı layer**'ı yeniden kullanır.
-
-Sadece dosya kopyalamayı azaltmak her zaman büyük fark yaratmaz. Ancak o adımda cache kullanıldığı için, **bir sonraki adımda da cache kullanılabilir**. Örneğin bağımlılıkları yükleyen şu talimat için:
-
-```Dockerfile
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-```
-
-Paket gereksinimleri dosyası **sık sık değişmez**. Bu yüzden sadece bu dosyayı kopyalayınca, Docker bu adımda **cache** kullanabilir.
-
-Sonra Docker, bağımlılıkları indirip yükleyen **bir sonraki adımda** da cache kullanabilir. Asıl **çok zaman kazandığımız** yer de burasıdır. ✨ ...ve beklerken sıkılmayı engeller. 😪😆
-
-Bağımlılıkları indirip yüklemek **dakikalar sürebilir**, fakat **cache** kullanmak en fazla **saniyeler** alır.
-
-Geliştirme sırasında kod değişikliklerinizin çalıştığını kontrol etmek için container image'ı tekrar tekrar build edeceğinizden, bu ciddi birikimli zaman kazancı sağlar.
-
-Sonra `Dockerfile`'ın sonlarına doğru tüm kodu kopyalarız. En sık değişen kısım bu olduğu için sona koyarız; çünkü neredeyse her zaman bu adımdan sonra gelen adımlar cache kullanamaz.
-
-```Dockerfile
-COPY ./app /code/app
-```
-
-### Docker Image'ını Build Edin { #build-the-docker-image }
-
-Tüm dosyalar hazır olduğuna göre container image'ı build edelim.
-
-* Proje dizinine gidin (`Dockerfile`'ınızın olduğu ve `app` dizininizi içeren dizin).
-* FastAPI image'ınızı build edin:
-
-<div class="termy">
-
-```console
-$ docker build -t myimage .
-
----> 100%
-```
-
-</div>
-
-/// tip | İpucu
-
-Sondaki `.` ifadesine dikkat edin; `./` ile aynı anlama gelir ve Docker'a container image build etmek için hangi dizini kullanacağını söyler.
-
-Bu örnekte, mevcut dizindir (`.`).
-
-///
-
-### Docker Container'ını Başlatın { #start-the-docker-container }
-
-* Image'ınızdan bir container çalıştırın:
-
-<div class="termy">
-
-```console
-$ docker run -d --name mycontainer -p 80:80 myimage
-```
-
-</div>
-
-## Kontrol Edin { #check-it }
-
-Docker container'ınızın URL'inden kontrol edebilmelisiniz. Örneğin: <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> veya <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> (ya da Docker host'unuzu kullanarak eşdeğeri).
-
-Şuna benzer bir şey görürsünüz:
-
-```JSON
-{"item_id": 5, "q": "somequery"}
-```
-
-## Etkileşimli API Dokümanları { #interactive-api-docs }
-
-Şimdi <a href="http://192.168.99.100/docs" class="external-link" target="_blank">http://192.168.99.100/docs</a> veya <a href="http://127.0.0.1/docs" class="external-link" target="_blank">http://127.0.0.1/docs</a> adresine gidebilirsiniz (ya da Docker host'unuzla eşdeğeri).
-
-Otomatik etkileşimli API dokümantasyonunu görürsünüz ( <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a> tarafından sağlanır):
-
-![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
-
-## Alternatif API Dokümanları { #alternative-api-docs }
-
-Ayrıca <a href="http://192.168.99.100/redoc" class="external-link" target="_blank">http://192.168.99.100/redoc</a> veya <a href="http://127.0.0.1/redoc" class="external-link" target="_blank">http://127.0.0.1/redoc</a> adresine de gidebilirsiniz (ya da Docker host'unuzla eşdeğeri).
-
-Alternatif otomatik dokümantasyonu görürsünüz (<a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a> tarafından sağlanır):
-
-![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
-
-## Tek Dosyalık FastAPI ile Docker Image Oluşturma { #build-a-docker-image-with-a-single-file-fastapi }
-
-FastAPI uygulamanız tek bir dosyaysa; örneğin `./app` dizini olmadan sadece `main.py` varsa, dosya yapınız şöyle olabilir:
-
-```
-.
-├── Dockerfile
-├── main.py
-└── requirements.txt
-```
-
-Bu durumda `Dockerfile` içinde dosyayı kopyaladığınız path'leri buna göre değiştirmeniz yeterlidir:
-
-```{ .dockerfile .annotate hl_lines="10  13" }
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-# (1)!
-COPY ./main.py /code/
-
-# (2)!
-CMD ["fastapi", "run", "main.py", "--port", "80"]
-```
-
-1. `main.py` dosyasını doğrudan `/code` dizinine kopyalayın (herhangi bir `./app` dizini olmadan).
-
-2. Tek dosya olan `main.py` içindeki uygulamanızı sunmak için `fastapi run` kullanın.
-
-Dosyayı `fastapi run`'a verdiğinizde, bunun bir package'ın parçası değil tek bir dosya olduğunu otomatik olarak algılar; nasıl import edip FastAPI uygulamanızı nasıl serve edeceğini bilir. 😎
-
-## Deployment Kavramları { #deployment-concepts }
-
-Aynı [Deployment Kavramları](concepts.md){.internal-link target=_blank}nı bu kez container'lar açısından tekrar konuşalım.
-
-Container'lar, bir uygulamayı **build etme ve deploy etme** sürecini basitleştiren bir araçtır. Ancak bu **deployment kavramları**nı ele almak için belirli bir yaklaşımı zorunlu kılmazlar; birkaç farklı strateji mümkündür.
-
-**İyi haber** şu: Hangi stratejiyi seçerseniz seçin, deployment kavramlarının tamamını kapsayacak bir yol vardır. 🎉
-
-Bu **deployment kavramları**nı container'lar açısından gözden geçirelim:
-
-* HTTPS
-* Startup'ta çalıştırma
-* Restart'lar
-* Replication (çalışan process sayısı)
-* Memory
-* Başlatmadan önceki adımlar
-
-## HTTPS { #https }
-
-Bir FastAPI uygulamasının sadece **container image**'ına (ve sonra çalışan **container**'a) odaklanırsak, HTTPS genellikle **haricen** başka bir araçla ele alınır.
-
-Örneğin <a href="https://traefik.io/" class="external-link" target="_blank">Traefik</a> kullanan başka bir container olabilir; **HTTPS** ve **sertifika**ların **otomatik** alınmasını o yönetebilir.
-
-/// tip | İpucu
-
-Traefik; Docker, Kubernetes ve diğerleriyle entegre çalışır. Bu sayede container'larınız için HTTPS'i kurup yapılandırmak oldukça kolaydır.
-
-///
-
-Alternatif olarak HTTPS, bir cloud provider'ın sunduğu servislerden biri tarafından da yönetilebilir (uygulama yine container içinde çalışırken).
-
-## Startup'ta Çalıştırma ve Restart'lar { #running-on-startup-and-restarts }
-
-Container'ınızı **başlatıp çalıştırmaktan** sorumlu genellikle başka bir araç olur.
-
-Bu; doğrudan **Docker**, **Docker Compose**, **Kubernetes**, bir **cloud service** vb. olabilir.
-
-Çoğu (veya tüm) durumda, container'ı startup'ta çalıştırmayı ve hata durumlarında restart'ları etkinleştirmeyi sağlayan basit bir seçenek vardır. Örneğin Docker'da bu, `--restart` komut satırı seçeneğidir.
-
-Container kullanmadan, uygulamaları startup'ta çalıştırmak ve restart mekanizması eklemek zahmetli ve zor olabilir. Ancak **container'larla çalışırken** çoğu zaman bu işlevler varsayılan olarak hazır gelir. ✨
-
-## Replication - Process Sayısı { #replication-number-of-processes }
-
-Kubernetes, Docker Swarm Mode, Nomad veya benzeri, birden fazla makinede dağıtık container'ları yöneten karmaşık bir sistemle kurulmuş bir <abbr title="A group of machines that are configured to be connected and work together in some way.">cluster</abbr>'ınız varsa, replication'ı her container içinde bir **process manager** (ör. worker'lı Uvicorn) kullanarak yönetmek yerine, muhtemelen **cluster seviyesinde** ele almak istersiniz.
-
-Kubernetes gibi dağıtık container yönetim sistemleri, gelen request'ler için **load balancing** desteği sunarken aynı zamanda **container replication**'ını yönetmek için entegre mekanizmalara sahiptir. Hepsi **cluster seviyesinde**.
-
-Bu tür durumlarda, yukarıda [anlatıldığı gibi](#dockerfile) bağımlılıkları yükleyip **sıfırdan bir Docker image** build etmek ve birden fazla Uvicorn worker kullanmak yerine **tek bir Uvicorn process** çalıştırmak istersiniz.
-
-### Load Balancer { #load-balancer }
-
-Container'lar kullanırken, genellikle ana port'ta dinleyen bir bileşen olur. Bu, **HTTPS**'i ele almak için bir **TLS Termination Proxy** olan başka bir container da olabilir ya da benzeri bir araç olabilir.
-
-Bu bileşen request'lerin **yükünü** alıp worker'lar arasında (umarım) **dengeli** şekilde dağıttığı için yaygın olarak **Load Balancer** diye de adlandırılır.
-
-/// tip | İpucu
-
-HTTPS için kullanılan aynı **TLS Termination Proxy** bileşeni muhtemelen bir **Load Balancer** olarak da çalışır.
-
-///
-
-Container'larla çalışırken, onları başlatıp yönettiğiniz sistem; bu **load balancer**'dan (aynı zamanda **TLS Termination Proxy** de olabilir) uygulamanızın bulunduğu container(lar)a **network communication**'ı (ör. HTTP request'leri) iletmek için zaten dahili araçlar sunar.
-
-### Tek Load Balancer - Çoklu Worker Container { #one-load-balancer-multiple-worker-containers }
-
-**Kubernetes** veya benzeri dağıtık container yönetim sistemleriyle çalışırken, dahili ağ mekanizmaları sayesinde ana **port**'u dinleyen tek bir **load balancer**, uygulamanızı çalıştıran muhtemelen **birden fazla container**'a request'leri iletebilir.
-
-Uygulamanızı çalıştıran bu container'ların her birinde normalde **tek bir process** olur (ör. FastAPI uygulamanızı çalıştıran bir Uvicorn process). Hepsi aynı şeyi çalıştıran **özdeş container**'lardır; ancak her birinin kendi process'i, memory'si vb. vardır. Böylece CPU'nun **farklı core**'larında, hatta **farklı makinelerde** paralelleştirmeden yararlanırsınız.
-
-Load balancer'lı dağıtık sistem, request'leri uygulamanızın bulunduğu container'ların her birine sırayla **dağıtır**. Böylece her request, uygulamanızın birden fazla **replicated container**'ından biri tarafından işlenebilir.
-
-Ve bu **load balancer** normalde cluster'ınızdaki *diğer* uygulamalara giden request'leri de (ör. farklı bir domain ya da farklı bir URL path prefix altında) yönetebilir ve iletişimi o *diğer* uygulamanın doğru container'larına iletir.
-
-### Container Başına Tek Process { #one-process-per-container }
-
-Bu senaryoda, replication'ı zaten cluster seviyesinde yaptığınız için, muhtemelen **container başına tek bir (Uvicorn) process** istersiniz.
-
-Dolayısıyla bu durumda container içinde `--workers` gibi bir komut satırı seçeneğiyle çoklu worker istemezsiniz. Container başına sadece **tek bir Uvicorn process** istersiniz (ama muhtemelen birden fazla container).
-
-Container içine ekstra bir process manager koymak (çoklu worker gibi) çoğu zaman zaten cluster sisteminizle çözdüğünüz şeye ek **gereksiz karmaşıklık** katar.
-
-### Birden Fazla Process'li Container'lar ve Özel Durumlar { #containers-with-multiple-processes-and-special-cases }
-
-Elbette bazı **özel durumlarda** bir container içinde birden fazla **Uvicorn worker process** çalıştırmak isteyebilirsiniz.
-
-Bu durumlarda çalıştırmak istediğiniz worker sayısını `--workers` komut satırı seçeneğiyle ayarlayabilirsiniz:
-
-```{ .dockerfile .annotate }
-FROM python:3.9
-
-WORKDIR /code
-
-COPY ./requirements.txt /code/requirements.txt
-
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-
-COPY ./app /code/app
-
-# (1)!
-CMD ["fastapi", "run", "app/main.py", "--port", "80", "--workers", "4"]
-```
-
-1. Burada worker sayısını 4 yapmak için `--workers` komut satırı seçeneğini kullanıyoruz.
-
-Bunun mantıklı olabileceği birkaç örnek:
-
-#### Basit Bir Uygulama { #a-simple-app }
-
-Uygulamanız tek bir server üzerinde (cluster değil) çalışacak kadar **basitse**, container içinde bir process manager isteyebilirsiniz.
-
-#### Docker Compose { #docker-compose }
-
-**Docker Compose** ile **tek bir server**'a (cluster değil) deploy ediyor olabilirsiniz. Bu durumda, paylaşılan ağı ve **load balancing**'i koruyarak container replication'ını (Docker Compose ile) yönetmenin kolay bir yolu olmayabilir.
-
-Bu durumda, tek bir container içinde **bir process manager** ile **birden fazla worker process** başlatmak isteyebilirsiniz.
-
----
-
-Ana fikir şu: Bunların **hiçbiri** körü körüne uymanız gereken **değişmez kurallar** değildir. Bu fikirleri, kendi kullanım senaryonuzu **değerlendirmek** ve sisteminiz için en iyi yaklaşımı seçmek için kullanabilirsiniz. Şu kavramları nasıl yöneteceğinize bakarak karar verin:
-
-* Güvenlik - HTTPS
-* Startup'ta çalıştırma
-* Restart'lar
-* Replication (çalışan process sayısı)
-* Memory
-* Başlatmadan önceki adımlar
-
-## Memory { #memory }
-
-**Container başına tek process** çalıştırırsanız, her container'ın tüketeceği memory miktarı aşağı yukarı tanımlı, stabil ve sınırlı olur (replication varsa birden fazla container için).
-
-Sonra aynı memory limit ve gereksinimlerini container yönetim sisteminizin (ör. **Kubernetes**) konfigürasyonlarında belirleyebilirsiniz. Böylece sistem; ihtiyaç duyulan memory miktarını ve cluster'daki makinelerde mevcut memory'yi dikkate alarak **uygun makinelerde container'ları replicate edebilir**.
-
-Uygulamanız **basitse**, muhtemelen bu **bir sorun olmaz** ve katı memory limitleri belirlemeniz gerekmeyebilir. Ancak **çok memory kullanıyorsanız** (ör. **machine learning** modelleriyle), ne kadar memory tükettiğinizi kontrol edip **her makinede** çalışacak **container sayısını** ayarlamalısınız (ve gerekirse cluster'a daha fazla makine eklemelisiniz).
-
-**Container başına birden fazla process** çalıştırırsanız, başlatılan process sayısının mevcut olandan **fazla memory tüketmediğinden** emin olmanız gerekir.
-
-## Başlatmadan Önceki Adımlar ve Container'lar { #previous-steps-before-starting-and-containers }
-
-Container kullanıyorsanız (örn. Docker, Kubernetes), temelde iki yaklaşım vardır.
-
-### Birden Fazla Container { #multiple-containers }
-
-**Birden fazla container**'ınız varsa ve muhtemelen her biri **tek process** çalıştırıyorsa (ör. bir **Kubernetes** cluster'ında), replication yapılan worker container'lar çalışmadan **önce**, **başlatmadan önceki adımlar**ın işini yapan **ayrı bir container** kullanmak isteyebilirsiniz (tek container, tek process).
-
-/// info | Bilgi
-
-Kubernetes kullanıyorsanız, bu muhtemelen bir <a href="https://kubernetes.io/docs/concepts/workloads/pods/init-containers/" class="external-link" target="_blank">Init Container</a> olur.
-
-///
-
-Kullanım senaryonuzda bu adımları **paralel olarak birden fazla kez** çalıştırmak sorun değilse (örneğin veritabanı migration çalıştırmıyor, sadece veritabanı hazır mı diye kontrol ediyorsanız), o zaman her container'da ana process başlamadan hemen önce de çalıştırabilirsiniz.
-
-### Tek Container { #single-container }
-
-Basit bir kurulumda; **tek bir container** olup onun içinde birden fazla **worker process** (ya da sadece bir process) başlatıyorsanız, bu adımları aynı container içinde, uygulama process'ini başlatmadan hemen önce çalıştırabilirsiniz.
-
-### Base Docker Image { #base-docker-image }
-
-Eskiden resmi bir FastAPI Docker image'ı vardı: <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Ancak artık kullanımdan kaldırıldı (deprecated). ⛔️
-
-Muhtemelen bu base Docker image'ını (veya benzeri başka bir image'ı) kullanmamalısınız.
-
-**Kubernetes** (veya diğerleri) kullanıyor ve cluster seviyesinde birden fazla **container** ile **replication** ayarlıyorsanız, bu durumda yukarıda anlatıldığı gibi **sıfırdan bir image build etmek** daha iyi olur: [FastAPI için Docker Image Oluşturalım](#build-a-docker-image-for-fastapi).
-
-Ve birden fazla worker gerekiyorsa, sadece `--workers` komut satırı seçeneğini kullanabilirsiniz.
-
-/// note | Teknik Detaylar
-
-Bu Docker image, Uvicorn dead worker'ları yönetmeyi ve yeniden başlatmayı desteklemediği dönemde oluşturulmuştu. Bu yüzden Uvicorn ile birlikte Gunicorn kullanmak gerekiyordu; sırf Gunicorn, Uvicorn worker process'lerini yönetip yeniden başlatsın diye oldukça fazla karmaşıklık ekleniyordu.
-
-Ancak artık Uvicorn (ve `fastapi` komutu) `--workers` kullanımını desteklediğine göre, kendi image'ınızı build etmek yerine bir base Docker image kullanmanın bir nedeni kalmadı (kod miktarı da hemen hemen aynı 😅).
-
-///
-
-## Container Image'ı Deploy Etme { #deploy-the-container-image }
-
-Bir Container (Docker) Image'ınız olduktan sonra bunu deploy etmenin birkaç yolu vardır.
-
-Örneğin:
-
-* Tek bir server'da **Docker Compose** ile
-* Bir **Kubernetes** cluster'ı ile
-* Docker Swarm Mode cluster'ı ile
-* Nomad gibi başka bir araçla
-* Container image'ınızı alıp deploy eden bir cloud servisiyle
-
-## `uv` ile Docker Image { #docker-image-with-uv }
-
-Projenizi yüklemek ve yönetmek için <a href="https://github.com/astral-sh/uv" class="external-link" target="_blank">uv</a> kullanıyorsanız, onların <a href="https://docs.astral.sh/uv/guides/integration/docker/" class="external-link" target="_blank">uv Docker rehberini</a> takip edebilirsiniz.
-
-## Özet { #recap }
-
-Container sistemleri (örn. **Docker** ve **Kubernetes** ile) kullanınca tüm **deployment kavramları**nı ele almak oldukça kolaylaşır:
-
-* HTTPS
-* Startup'ta çalıştırma
-* Restart'lar
-* Replication (çalışan process sayısı)
-* Memory
-* Başlatmadan önceki adımlar
-
-Çoğu durumda bir base image kullanmak istemezsiniz; bunun yerine resmi Python Docker image'ını temel alarak **sıfırdan bir container image** build edersiniz.
-
-`Dockerfile` içindeki talimatların **sırasına** ve **Docker cache**'ine dikkat ederek **build sürelerini minimize edebilir**, üretkenliğinizi artırabilirsiniz (ve beklerken sıkılmayı önlersiniz). 😎

docs/tr/docs/deployment/fastapicloud.md

@@ -1,65 +0,0 @@
-# FastAPI Cloud { #fastapi-cloud }
-
-FastAPI uygulamanızı <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>'a **tek bir komutla** deploy edebilirsiniz. Henüz yapmadıysanız gidip bekleme listesine katılın. 🚀
-
-## Giriş Yapma { #login }
-
-Önceden bir **FastAPI Cloud** hesabınız olduğundan emin olun (sizi bekleme listesinden davet ettik 😉).
-
-Ardından giriş yapın:
-
-<div class="termy">
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-</div>
-
-## Deploy { #deploy }
-
-Şimdi uygulamanızı **tek bir komutla** deploy edin:
-
-<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>
-
-Hepsi bu! Artık uygulamanıza o URL üzerinden erişebilirsiniz. ✨
-
-## FastAPI Cloud Hakkında { #about-fastapi-cloud }
-
-**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>**, **FastAPI**'nin arkasındaki aynı yazar ve ekip tarafından geliştirilmiştir.
-
-Bir API'yi minimum eforla **geliştirme**, **deploy etme** ve **erişilebilir kılma** sürecini sadeleştirir.
-
-FastAPI ile uygulama geliştirirken elde ettiğiniz aynı **developer experience**'ı, onları buluta **deploy etmeye** de taşır. 🎉
-
-Ayrıca bir uygulamayı deploy ederken ihtiyaç duyacağınız pek çok şeyi de sizin için halleder; örneğin:
-
-* HTTPS
-* Replication (çoğaltma), request'lere göre autoscaling ile
-* vb.
-
-FastAPI Cloud, *FastAPI and friends* açık kaynak projelerinin birincil sponsoru ve finansman sağlayıcısıdır. ✨
-
-## Diğer cloud sağlayıcılarına deploy etme { #deploy-to-other-cloud-providers }
-
-FastAPI açık kaynaklıdır ve standartlara dayanır. FastAPI uygulamalarını seçtiğiniz herhangi bir cloud sağlayıcısına deploy edebilirsiniz.
-
-FastAPI uygulamalarını deploy etmek için cloud sağlayıcınızın kendi kılavuzlarını takip edin. 🤓
-
-## Kendi server'ınıza deploy etme { #deploy-your-own-server }
-
-Bu **Deployment** kılavuzunun ilerleyen bölümlerinde tüm detayları da ele alacağız; böylece neler olduğunu, nelerin gerçekleşmesi gerektiğini ve FastAPI uygulamalarını kendi başınıza (kendi server'larınızla da) nasıl deploy edebileceğinizi anlayacaksınız. 🤓

docs/tr/docs/deployment/https.md

@@ -1,231 +0,0 @@
-# HTTPS Hakkında { #about-https }
-
-HTTPS’in sadece "açık" ya da "kapalı" olan bir şey olduğunu düşünmek kolaydır.
-
-Ancak bundan çok daha karmaşıktır.
-
-/// tip | İpucu
-
-Aceleniz varsa veya çok da önemsemiyorsanız, her şeyi farklı tekniklerle adım adım kurmak için sonraki bölümlere geçin.
-
-///
-
-Bir kullanıcı gözüyle **HTTPS’in temellerini öğrenmek** için <a href="https://howhttps.works/" class="external-link" target="_blank">https://howhttps.works/</a> adresine bakın.
-
-Şimdi de **geliştirici perspektifinden**, HTTPS hakkında düşünürken akılda tutulması gereken birkaç nokta:
-
-* HTTPS için **server**’ın, **üçüncü bir taraf** tarafından verilen **"sertifikalara"** sahip olması gerekir.
-    * Bu sertifikalar aslında üçüncü tarafça "üretilmez", üçüncü taraftan **temin edilir**.
-* Sertifikaların bir **geçerlilik süresi** vardır.
-    * Süresi **dolar**.
-    * Sonrasında **yenilenmeleri**, üçüncü taraftan **yeniden temin edilmeleri** gerekir.
-* Bağlantının şifrelenmesi **TCP seviyesinde** gerçekleşir.
-    * Bu, **HTTP’nin bir katman altıdır**.
-    * Dolayısıyla **sertifika ve şifreleme** işlemleri **HTTP’den önce** yapılır.
-* **TCP "domain"leri bilmez**. Yalnızca IP adreslerini bilir.
-    * İstenen **spesifik domain** bilgisi **HTTP verisinin** içindedir.
-* **HTTPS sertifikaları** belirli bir **domain**’i "sertifikalandırır"; ancak protokol ve şifreleme TCP seviyesinde, hangi domain ile çalışıldığı **henüz bilinmeden** gerçekleşir.
-* **Varsayılan olarak** bu, IP adresi başına yalnızca **bir HTTPS sertifikası** olabileceği anlamına gelir.
-    * Server’ınız ne kadar büyük olursa olsun ya da üzerindeki her uygulama ne kadar küçük olursa olsun.
-    * Ancak bunun bir **çözümü** vardır.
-* **TLS** protokolüne (TCP seviyesinde, HTTP’den önce şifrelemeyi yapan) eklenen **<a href="https://en.wikipedia.org/wiki/Server_Name_Indication" class="external-link" target="_blank"><abbr title="Server Name Indication - Sunucu Adı Belirtimi">SNI</abbr></a>** adlı bir **extension** vardır.
-    * Bu SNI extension’ı, tek bir server’ın (tek bir **IP adresiyle**) **birden fazla HTTPS sertifikası** kullanmasına ve **birden fazla HTTPS domain/uygulama** sunmasına izin verir.
-    * Bunun çalışması için server üzerinde, **public IP adresini** dinleyen tek bir bileşenin (programın) server’daki **tüm HTTPS sertifikalarına** sahip olması gerekir.
-* Güvenli bir bağlantı elde edildikten **sonra**, iletişim protokolü **hâlâ HTTP**’dir.
-    * İçerikler, **HTTP protokolü** ile gönderiliyor olsa bile **şifrelenmiştir**.
-
-Yaygın yaklaşım, server’da (makine, host vb.) çalışan **tek bir program/HTTP server** bulundurup **HTTPS ile ilgili tüm kısımları** yönetmektir: **şifreli HTTPS request**’leri almak, aynı server’da çalışan gerçek HTTP uygulamasına (bu örnekte **FastAPI** uygulaması) **şifresi çözülmüş HTTP request**’leri iletmek, uygulamadan gelen **HTTP response**’u almak, uygun **HTTPS sertifikası** ile **şifrelemek** ve **HTTPS** ile client’a geri göndermek. Bu server’a çoğu zaman **<a href="https://en.wikipedia.org/wiki/TLS_termination_proxy" class="external-link" target="_blank">TLS Termination Proxy</a>** denir.
-
-TLS Termination Proxy olarak kullanabileceğiniz seçeneklerden bazıları:
-
-* Traefik (sertifika yenilemelerini de yönetebilir)
-* Caddy (sertifika yenilemelerini de yönetebilir)
-* Nginx
-* HAProxy
-
-## Let's Encrypt { #lets-encrypt }
-
-Let's Encrypt’ten önce bu **HTTPS sertifikaları**, güvenilen üçüncü taraflar tarafından satılırdı.
-
-Bu sertifikalardan birini temin etme süreci zahmetliydi, epey evrak işi gerektirirdi ve sertifikalar oldukça pahalıydı.
-
-Sonra **<a href="https://letsencrypt.org/" class="external-link" target="_blank">Let's Encrypt</a>** ortaya çıktı.
-
-Linux Foundation’ın bir projesidir. **HTTPS sertifikalarını ücretsiz** ve otomatik bir şekilde sağlar. Bu sertifikalar tüm standart kriptografik güvenliği kullanır ve kısa ömürlüdür (yaklaşık 3 ay). Bu yüzden, ömürleri kısa olduğu için **güvenlik aslında daha iyidir**.
-
-Domain’ler güvenli şekilde doğrulanır ve sertifikalar otomatik üretilir. Bu sayede sertifikaların yenilenmesini otomatikleştirmek de mümkün olur.
-
-Amaç, bu sertifikaların temin edilmesi ve yenilenmesini otomatikleştirerek **ücretsiz, kalıcı olarak güvenli HTTPS** sağlamaktır.
-
-## Geliştiriciler İçin HTTPS { #https-for-developers }
-
-Burada, bir HTTPS API’nin adım adım nasıl görünebileceğine dair, özellikle geliştiriciler için önemli fikirlere odaklanan bir örnek var.
-
-### Domain Adı { #domain-name }
-
-Muhtemelen her şey, bir **domain adı** **temin etmenizle** başlar. Sonra bunu bir DNS server’ında (muhtemelen aynı cloud provider’ınızda) yapılandırırsınız.
-
-Muhtemelen bir cloud server (virtual machine) ya da benzeri bir şey alırsınız ve bunun <abbr title="That doesn't change - Bu değişmez">fixed</abbr> bir **public IP adresi** olur.
-
-DNS server(lar)ında, bir kaydı ("`A record`") **domain**’inizi server’ınızın **public IP adresine** yönlendirecek şekilde yapılandırırsınız.
-
-Bunu büyük olasılıkla ilk kurulumda, sadece bir kez yaparsınız.
-
-/// tip | İpucu
-
-Bu Domain Adı kısmı HTTPS’ten çok daha önce gelir. Ancak her şey domain ve IP adresine bağlı olduğu için burada bahsetmeye değer.
-
-///
-
-### DNS { #dns }
-
-Şimdi gerçek HTTPS parçalarına odaklanalım.
-
-Önce tarayıcı, bu örnekte `someapp.example.com` olan domain için **IP**’nin ne olduğunu **DNS server**’larına sorar.
-
-DNS server’ları tarayıcıya belirli bir **IP adresini** kullanmasını söyler. Bu, DNS server’larında yapılandırdığınız ve server’ınızın kullandığı public IP adresidir.
-
-<img src="/img/deployment/https/https01.drawio.svg">
-
-### TLS Handshake Başlangıcı { #tls-handshake-start }
-
-Tarayıcı daha sonra bu IP adresiyle **443 portu** (HTTPS portu) üzerinden iletişim kurar.
-
-İletişimin ilk kısmı, client ile server arasında bağlantıyı kurmak ve hangi kriptografik anahtarların kullanılacağına karar vermek vb. içindir.
-
-<img src="/img/deployment/https/https02.drawio.svg">
-
-Client ile server arasındaki, TLS bağlantısını kurmaya yönelik bu etkileşime **TLS handshake** denir.
-
-### SNI Extension’ı ile TLS { #tls-with-sni-extension }
-
-Server’da, belirli bir **IP adresindeki** belirli bir **portu** dinleyen **yalnızca bir process** olabilir. Aynı IP adresinde başka portları dinleyen başka process’ler olabilir, ancak IP+port kombinasyonu başına yalnızca bir tane olur.
-
-TLS (HTTPS) varsayılan olarak `443` portunu kullanır. Yani ihtiyaç duyacağımız port budur.
-
-Bu portu yalnızca bir process dinleyebileceği için, bunu yapacak process **TLS Termination Proxy** olur.
-
-TLS Termination Proxy, bir ya da daha fazla **TLS sertifikasına** (HTTPS sertifikası) erişebilir.
-
-Yukarıda bahsettiğimiz **SNI extension**’ını kullanarak TLS Termination Proxy, bu bağlantı için elindeki TLS (HTTPS) sertifikalarından hangisini kullanacağını kontrol eder; client’ın beklediği domain ile eşleşen sertifikayı seçer.
-
-Bu örnekte `someapp.example.com` sertifikasını kullanır.
-
-<img src="/img/deployment/https/https03.drawio.svg">
-
-Client, bu TLS sertifikasını üreten kuruluşa zaten **güvenir** (bu örnekte Let's Encrypt; birazdan ona da geleceğiz). Bu sayede sertifikanın geçerli olduğunu **doğrulayabilir**.
-
-Ardından client ve TLS Termination Proxy, sertifikayı kullanarak **TCP iletişiminin geri kalanını nasıl şifreleyeceklerine** karar verir. Böylece **TLS Handshake** kısmı tamamlanır.
-
-Bundan sonra client ve server arasında **şifreli bir TCP bağlantısı** vardır; TLS’in sağladığı şey budur. Sonra bu bağlantıyı kullanarak gerçek **HTTP iletişimini** başlatabilirler.
-
-Ve **HTTPS** de tam olarak budur: şifrelenmemiş bir TCP bağlantısı yerine, **güvenli bir TLS bağlantısının içinde** düz **HTTP**’dir.
-
-/// tip | İpucu
-
-Şifrelemenin HTTP seviyesinde değil, **TCP seviyesinde** gerçekleştiğine dikkat edin.
-
-///
-
-### HTTPS Request { #https-request }
-
-Artık client ile server (özellikle tarayıcı ile TLS Termination Proxy) arasında **şifreli bir TCP bağlantısı** olduğuna göre, **HTTP iletişimi** başlayabilir.
-
-Dolayısıyla client bir **HTTPS request** gönderir. Bu, şifreli bir TLS bağlantısı üzerinden giden bir HTTP request’tir.
-
-<img src="/img/deployment/https/https04.drawio.svg">
-
-### Request’in Şifresini Çözme { #decrypt-the-request }
-
-TLS Termination Proxy, üzerinde anlaşılan şifrelemeyi kullanarak **request’in şifresini çözer** ve **düz (şifresi çözülmüş) HTTP request**’i uygulamayı çalıştıran process’e iletir (ör. FastAPI uygulamasını çalıştıran Uvicorn process’i).
-
-<img src="/img/deployment/https/https05.drawio.svg">
-
-### HTTP Response { #http-response }
-
-Uygulama request’i işler ve TLS Termination Proxy’ye **düz (şifrelenmemiş) bir HTTP response** gönderir.
-
-<img src="/img/deployment/https/https06.drawio.svg">
-
-### HTTPS Response { #https-response }
-
-TLS Termination Proxy daha sonra response’u, daha önce üzerinde anlaşılan kriptografi ile (başlangıcı `someapp.example.com` sertifikasına dayanan) **şifreler** ve tarayıcıya geri gönderir.
-
-Sonrasında tarayıcı response’un geçerli olduğunu ve doğru kriptografik anahtarla şifrelendiğini doğrular vb. Ardından **response’un şifresini çözer** ve işler.
-
-<img src="/img/deployment/https/https07.drawio.svg">
-
-Client (tarayıcı), response’un doğru server’dan geldiğini bilir; çünkü daha önce **HTTPS sertifikası** ile üzerinde anlaştıkları kriptografiyi kullanmaktadır.
-
-### Birden Fazla Uygulama { #multiple-applications }
-
-Aynı server’da (veya server’larda) örneğin başka API programları ya da bir veritabanı gibi **birden fazla uygulama** olabilir.
-
-Belirli IP ve port kombinasyonunu yalnızca bir process yönetebilir (örneğimizde TLS Termination Proxy). Ancak diğer uygulamalar/process’ler, aynı **public IP + port kombinasyonunu** kullanmaya çalışmadıkları sürece server(lar)da çalışabilir.
-
-<img src="/img/deployment/https/https08.drawio.svg">
-
-Bu şekilde TLS Termination Proxy, birden fazla uygulama için **birden fazla domain**’in HTTPS ve sertifika işlerini yönetebilir ve her durumda request’leri doğru uygulamaya iletebilir.
-
-### Sertifika Yenileme { #certificate-renewal }
-
-Gelecekte bir noktada, her sertifikanın süresi **dolar** (temin edildikten yaklaşık 3 ay sonra).
-
-Ardından başka bir program (bazı durumlarda ayrı bir programdır, bazı durumlarda aynı TLS Termination Proxy olabilir) Let's Encrypt ile konuşup sertifika(ları) yeniler.
-
-<img src="/img/deployment/https/https.drawio.svg">
-
-**TLS sertifikaları** bir IP adresiyle değil, **domain adıyla ilişkilidir**.
-
-Bu yüzden sertifikaları yenilemek için, yenileme programı otoriteye (Let's Encrypt) gerçekten o domain’i **"sahiplendiğini" ve kontrol ettiğini** **kanıtlamalıdır**.
-
-Bunu yapmak ve farklı uygulama ihtiyaçlarını karşılamak için birden fazla yöntem vardır. Yaygın yöntemlerden bazıları:
-
-* Bazı **DNS kayıtlarını değiştirmek**.
-    * Bunun için yenileme programının DNS provider API’lerini desteklemesi gerekir. Dolayısıyla kullandığınız DNS provider’a bağlı olarak bu seçenek mümkün de olabilir, olmayabilir de.
-* Domain ile ilişkili public IP adresinde **server olarak çalışmak** (en azından sertifika temin sürecinde).
-    * Yukarıda söylediğimiz gibi, belirli bir IP ve portu yalnızca bir process dinleyebilir.
-    * Bu, aynı TLS Termination Proxy’nin sertifika yenileme sürecini de yönetmesinin neden çok faydalı olduğunun sebeplerinden biridir.
-    * Aksi halde TLS Termination Proxy’yi kısa süreliğine durdurmanız, sertifikaları temin etmek için yenileme programını başlatmanız, sonra bunları TLS Termination Proxy ile yapılandırmanız ve ardından TLS Termination Proxy’yi tekrar başlatmanız gerekebilir. Bu ideal değildir; çünkü TLS Termination Proxy kapalıyken uygulama(lar)ınıza erişilemez.
-
-Uygulamayı servis etmeye devam ederken tüm bu yenileme sürecini yönetebilmek, TLS sertifikalarını doğrudan uygulama server’ıyla (örn. Uvicorn) kullanmak yerine, TLS Termination Proxy ile HTTPS’i yönetecek **ayrı bir sistem** istemenizin başlıca nedenlerinden biridir.
-
-## Proxy Forwarded Headers { #proxy-forwarded-headers }
-
-HTTPS’i bir proxy ile yönetirken, **application server**’ınız (örneğin FastAPI CLI üzerinden Uvicorn) HTTPS süreci hakkında hiçbir şey bilmez; **TLS Termination Proxy** ile düz HTTP üzerinden iletişim kurar.
-
-Bu **proxy** normalde request’i **application server**’a iletmeden önce, request’in proxy tarafından **forward** edildiğini application server’a bildirmek için bazı HTTP header’larını anlık olarak ekler.
-
-/// note | Teknik Detaylar
-
-Proxy header’ları şunlardır:
-
-* <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>
-
-///
-
-Buna rağmen **application server**, güvenilen bir **proxy** arkasında olduğunu bilmediği için varsayılan olarak bu header’lara güvenmez.
-
-Ancak **application server**’ı, **proxy**’nin gönderdiği *forwarded* header’larına güvenecek şekilde yapılandırabilirsiniz. FastAPI CLI kullanıyorsanız, hangi IP’lerden gelen *forwarded* header’lara güvenmesi gerektiğini söylemek için *CLI Option* `--forwarded-allow-ips` seçeneğini kullanabilirsiniz.
-
-Örneğin **application server** yalnızca güvenilen **proxy**’den iletişim alıyorsa, yalnızca **proxy**’nin kullandığı IP’den request alacağı için `--forwarded-allow-ips="*"` ayarlayıp gelen tüm IP’lere güvenmesini sağlayabilirsiniz.
-
-Bu sayede uygulama kendi public URL’inin ne olduğunu, HTTPS kullanıp kullanmadığını, domain’i vb. bilebilir.
-
-Bu, örneğin redirect’leri doğru şekilde yönetmek için faydalıdır.
-
-/// tip | İpucu
-
-Bununla ilgili daha fazlasını [Behind a Proxy - Enable Proxy Forwarded Headers](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank} dokümantasyonunda öğrenebilirsiniz.
-
-///
-
-## Özet { #recap }
-
-**HTTPS** kullanmak çok önemlidir ve çoğu durumda oldukça **kritiktir**. Geliştirici olarak HTTPS etrafında harcadığınız çabanın büyük kısmı, aslında **bu kavramları** ve nasıl çalıştıklarını **anlamaktır**.
-
-Ancak **geliştiriciler için HTTPS**’in temel bilgilerini öğrendikten sonra, her şeyi basitçe yönetmek için farklı araçları kolayca birleştirip yapılandırabilirsiniz.
-
-Sonraki bölümlerin bazılarında, **FastAPI** uygulamaları için **HTTPS**’i nasıl kuracağınıza dair birkaç somut örnek göstereceğim. 🔒

docs/tr/docs/deployment/manually.md

@@ -1,157 +0,0 @@
-# Bir Sunucuyu Manuel Olarak Çalıştırın { #run-a-server-manually }
-
-## `fastapi run` Komutunu Kullanın { #use-the-fastapi-run-command }
-
-Kısacası, FastAPI uygulamanızı sunmak için `fastapi run` kullanın:
-
-<div class="termy">
-
-```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 production server 🚀
-
-             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>
-
-   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with
-             the following code:
-
-             <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>
-
-      <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>  Started server process <b>[</b><font color="#34E2E2"><b>2306215</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>  Application startup complete.
-     <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>
-```
-
-</div>
-
-Bu, çoğu durumda işinizi görür. 😎
-
-Örneğin bu komutu, **FastAPI** app'inizi bir container içinde, bir sunucuda vb. başlatmak için kullanabilirsiniz.
-
-## ASGI Sunucuları { #asgi-servers }
-
-Şimdi biraz daha detaya inelim.
-
-FastAPI, Python web framework'leri ve sunucularını inşa etmek için kullanılan <abbr title="Asynchronous Server Gateway Interface">ASGI</abbr> adlı bir standardı kullanır. FastAPI bir ASGI web framework'üdür.
-
-Uzak bir sunucu makinesinde **FastAPI** uygulamasını (veya herhangi bir ASGI uygulamasını) çalıştırmak için gereken ana şey, **Uvicorn** gibi bir ASGI server programıdır. `fastapi` komutuyla varsayılan olarak gelen de budur.
-
-Buna alternatif birkaç seçenek daha vardır, örneğin:
-
-* <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>: yüksek performanslı bir ASGI server.
-* <a href="https://hypercorn.readthedocs.io/" class="external-link" target="_blank">Hypercorn</a>: diğer özelliklerin yanında HTTP/2 ve Trio ile uyumlu bir ASGI server.
-* <a href="https://github.com/django/daphne" class="external-link" target="_blank">Daphne</a>: Django Channels için geliştirilmiş ASGI server.
-* <a href="https://github.com/emmett-framework/granian" class="external-link" target="_blank">Granian</a>: Python uygulamaları için bir Rust HTTP server.
-* <a href="https://unit.nginx.org/howto/fastapi/" class="external-link" target="_blank">NGINX Unit</a>: NGINX Unit, hafif ve çok yönlü bir web uygulaması runtime'ıdır.
-
-## Sunucu Makinesi ve Sunucu Programı { #server-machine-and-server-program }
-
-İsimlendirme konusunda akılda tutulması gereken küçük bir detay var. 💡
-
-"**server**" kelimesi yaygın olarak hem uzak/bulut bilgisayarı (fiziksel veya sanal makine) hem de o makinede çalışan programı (ör. Uvicorn) ifade etmek için kullanılır.
-
-Dolayısıyla genel olarak "server" dendiğinde, bu iki şeyden birini kast ediyor olabilir.
-
-Uzak makineden bahsederken genelde **server** denir; ayrıca **machine**, **VM** (virtual machine), **node** ifadeleri de kullanılır. Bunların hepsi, genellikle Linux çalıştıran ve üzerinde programlarınızı çalıştırdığınız bir tür uzak makineyi ifade eder.
-
-## Sunucu Programını Yükleyin { #install-the-server-program }
-
-FastAPI'yi kurduğunuzda, production sunucusu olarak Uvicorn da beraberinde gelir ve bunu `fastapi run` komutuyla başlatabilirsiniz.
-
-Ancak bir ASGI server'ı manuel olarak da kurabilirsiniz.
-
-Bir [virtual environment](../virtual-environments.md){.internal-link target=_blank} oluşturduğunuzdan, etkinleştirdiğinizden emin olun; ardından server uygulamasını kurabilirsiniz.
-
-Örneğin Uvicorn'u kurmak için:
-
-<div class="termy">
-
-```console
-$ pip install "uvicorn[standard]"
-
----> 100%
-```
-
-</div>
-
-Benzer bir süreç, diğer ASGI server programlarının tamamı için de geçerlidir.
-
-/// tip | İpucu
-
-`standard` eklediğinizde Uvicorn, önerilen bazı ek bağımlılıkları kurar ve kullanır.
-
-Bunlara, `asyncio` için yüksek performanslı bir drop-in replacement olan ve concurrency performansını ciddi şekilde artıran `uvloop` da dahildir.
-
-FastAPI'yi `pip install "fastapi[standard]"` gibi bir şekilde kurduğunuzda `uvicorn[standard]` da zaten kurulmuş olur.
-
-///
-
-## Sunucu Programını Çalıştırın { #run-the-server-program }
-
-Bir ASGI server'ı manuel olarak kurduysanız, FastAPI uygulamanızı import edebilmesi için genellikle özel bir formatta bir import string geçirmeniz gerekir:
-
-<div class="termy">
-
-```console
-$ uvicorn main:app --host 0.0.0.0 --port 80
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://0.0.0.0:80 (Press CTRL+C to quit)
-```
-
-</div>
-
-/// note | Not
-
-`uvicorn main:app` komutu şunları ifade eder:
-
-* `main`: `main.py` dosyası (Python "module").
-* `app`: `main.py` içinde `app = FastAPI()` satırıyla oluşturulan nesne.
-
-Şununla eşdeğerdir:
-
-```Python
-from main import app
-```
-
-///
-
-Her alternatif ASGI server programı için benzer bir komut bulunur; daha fazlası için ilgili dokümantasyonlarına bakabilirsiniz.
-
-/// warning | Uyarı
-
-Uvicorn ve diğer sunucular, geliştirme sırasında faydalı olan `--reload` seçeneğini destekler.
-
-`--reload` seçeneği çok daha fazla kaynak tüketir, daha kararsızdır vb.
-
-**Geliştirme** sırasında çok yardımcı olur, ancak **production** ortamında kullanmamalısınız.
-
-///
-
-## Deployment Kavramları { #deployment-concepts }
-
-Bu örnekler server programını (ör. Uvicorn) çalıştırır; **tek bir process** başlatır, tüm IP'lerde (`0.0.0.0`) ve önceden belirlenmiş bir port'ta (ör. `80`) dinler.
-
-Temel fikir budur. Ancak muhtemelen şunlar gibi bazı ek konularla da ilgilenmek isteyeceksiniz:
-
-* Güvenlik - HTTPS
-* Açılışta çalıştırma
-* Yeniden başlatmalar
-* Replikasyon (çalışan process sayısı)
-* Bellek
-* Başlatmadan önceki adımlar
-
-Sonraki bölümlerde bu kavramların her birini nasıl düşünmeniz gerektiğini ve bunlarla başa çıkmak için kullanabileceğiniz somut örnekleri/stratejileri anlatacağım. 🚀

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

@@ -1,139 +0,0 @@
-# Server Workers - Worker'larla Uvicorn { #server-workers-uvicorn-with-workers }
-
-Önceki bölümlerde bahsettiğimiz deployment kavramlarına tekrar bakalım:
-
-* Güvenlik - HTTPS
-* Başlangıçta çalıştırma
-* Yeniden başlatmalar
-* **Replikasyon (çalışan process sayısı)**
-* Bellek
-* Başlatmadan önceki adımlar
-
-Bu noktaya kadar, dokümantasyondaki tüm tutorial'larla muhtemelen bir **server programı** çalıştırıyordunuz; örneğin Uvicorn'u çalıştıran `fastapi` komutunu kullanarak ve **tek bir process** ile.
-
-Uygulamaları deploy ederken, **çok çekirdekten (multiple cores)** faydalanmak ve daha fazla request'i karşılayabilmek için büyük olasılıkla **process replikasyonu** (birden fazla process) isteyeceksiniz.
-
-[Daha önceki Deployment Concepts](concepts.md){.internal-link target=_blank} bölümünde gördüğünüz gibi, kullanabileceğiniz birden fazla strateji var.
-
-Burada, `fastapi` komutunu kullanarak ya da `uvicorn` komutunu doğrudan çalıştırarak **worker process**'lerle **Uvicorn**'u nasıl kullanacağınızı göstereceğim.
-
-/// info | Bilgi
-
-Container kullanıyorsanız (örneğin Docker veya Kubernetes ile), bununla ilgili daha fazlasını bir sonraki bölümde anlatacağım: [Container'larda FastAPI - Docker](docker.md){.internal-link target=_blank}.
-
-Özellikle **Kubernetes** üzerinde çalıştırırken, büyük olasılıkla worker kullanmak **istemeyeceksiniz**; bunun yerine **container başına tek bir Uvicorn process** çalıştırmak daha uygundur. Ancak bunu da o bölümde detaylandıracağım.
-
-///
-
-## Birden Fazla Worker { #multiple-workers }
-
-Komut satırında `--workers` seçeneğiyle birden fazla worker başlatabilirsiniz:
-
-//// tab | `fastapi`
-
-`fastapi` komutunu kullanıyorsanız:
-
-<div class="termy">
-
-```console
-$ <font color="#4E9A06">fastapi</font> run --workers 4 <u style="text-decoration-style:solid">main.py</u>
-
-  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting production server 🚀
-
-             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>
-
-   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
-             following code:
-
-             <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>
-
-      <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>
-
-////
-
-//// tab | `uvicorn`
-
-`uvicorn` komutunu doğrudan kullanmayı tercih ederseniz:
-
-<div class="termy">
-
-```console
-$ uvicorn main:app --host 0.0.0.0 --port 8080 --workers 4
-<font color="#A6E22E">INFO</font>:     Uvicorn running on <b>http://0.0.0.0:8080</b> (Press CTRL+C to quit)
-<font color="#A6E22E">INFO</font>:     Started parent process [<font color="#A1EFE4"><b>27365</b></font>]
-<font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27368</font>]
-<font color="#A6E22E">INFO</font>:     Waiting for application startup.
-<font color="#A6E22E">INFO</font>:     Application startup complete.
-<font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27369</font>]
-<font color="#A6E22E">INFO</font>:     Waiting for application startup.
-<font color="#A6E22E">INFO</font>:     Application startup complete.
-<font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27370</font>]
-<font color="#A6E22E">INFO</font>:     Waiting for application startup.
-<font color="#A6E22E">INFO</font>:     Application startup complete.
-<font color="#A6E22E">INFO</font>:     Started server process [<font color="#A1EFE4">27367</font>]
-<font color="#A6E22E">INFO</font>:     Waiting for application startup.
-<font color="#A6E22E">INFO</font>:     Application startup complete.
-```
-
-</div>
-
-////
-
-Buradaki tek yeni seçenek `--workers`; bu seçenek Uvicorn'a 4 adet worker process başlatmasını söyler.
-
-Ayrıca her process'in **PID**'inin gösterildiğini de görebilirsiniz: parent process için `27365` (bu **process manager**), her worker process için de bir PID: `27368`, `27369`, `27370` ve `27367`.
-
-## Deployment Kavramları { #deployment-concepts }
-
-Burada, uygulamanın çalışmasını **paralelleştirmek**, CPU'daki **çok çekirdekten** yararlanmak ve **daha fazla request** karşılayabilmek için birden fazla **worker**'ı nasıl kullanacağınızı gördünüz.
-
-Yukarıdaki deployment kavramları listesinden, worker kullanımı ağırlıklı olarak **replikasyon** kısmına yardımcı olur, ayrıca **yeniden başlatmalar** konusunda da az da olsa katkı sağlar. Ancak diğerlerini yine sizin yönetmeniz gerekir:
-
-* **Güvenlik - HTTPS**
-* **Başlangıçta çalıştırma**
-* ***Yeniden başlatmalar***
-* Replikasyon (çalışan process sayısı)
-* **Bellek**
-* **Başlatmadan önceki adımlar**
-
-## Container'lar ve Docker { #containers-and-docker }
-
-Bir sonraki bölümde, [Container'larda FastAPI - Docker](docker.md){.internal-link target=_blank} üzerinden diğer **deployment kavramlarını** ele almak için kullanabileceğiniz bazı stratejileri anlatacağım.
-
-Tek bir Uvicorn process çalıştıracak şekilde **sıfırdan kendi image'ınızı oluşturmayı** göstereceğim. Bu oldukça basit bir süreçtir ve **Kubernetes** gibi dağıtık bir container yönetim sistemi kullanırken büyük olasılıkla yapmak isteyeceğiniz şey de budur.
-
-## Özet { #recap }
-
-**Çok çekirdekli CPU**'lardan faydalanmak ve **birden fazla process'i paralel** çalıştırmak için `fastapi` veya `uvicorn` komutlarıyla `--workers` CLI seçeneğini kullanarak birden fazla worker process çalıştırabilirsiniz.
-
-Diğer deployment kavramlarını da kendiniz ele alarak **kendi deployment sisteminizi** kuruyorsanız, bu araçları ve fikirleri kullanabilirsiniz.
-
-Container'larla (örn. Docker ve Kubernetes) **FastAPI**'yi öğrenmek için bir sonraki bölüme göz atın. Bu araçların, diğer **deployment kavramlarını** çözmek için de basit yöntemleri olduğunu göreceksiniz. ✨

docs/tr/docs/deployment/versions.md

@@ -1,93 +0,0 @@
-# FastAPI Sürümleri Hakkında { #about-fastapi-versions }
-
-**FastAPI** hâlihazırda birçok uygulama ve sistemde production ortamında kullanılmaktadır. Ayrıca test kapsamı %100 seviyesinde tutulmaktadır. Ancak geliştirme süreci hâlâ hızlı şekilde ilerlemektedir.
-
-Yeni özellikler sık sık eklenir, bug'lar düzenli olarak düzeltilir ve kod sürekli iyileştirilmektedir.
-
-Bu yüzden mevcut sürümler hâlâ `0.x.x` şeklindedir; bu da her sürümde breaking change olma ihtimalini yansıtır. Bu yaklaşım <a href="https://semver.org/" class="external-link" target="_blank">Semantic Versioning</a> kurallarını takip eder.
-
-Şu anda **FastAPI** ile production uygulamaları geliştirebilirsiniz (muhtemelen bir süredir yapıyorsunuz da); sadece kodunuzun geri kalanıyla doğru çalışan bir sürüm kullandığınızdan emin olmanız gerekir.
-
-## `fastapi` sürümünü sabitleyin { #pin-your-fastapi-version }
-
-İlk yapmanız gereken, kullandığınız **FastAPI** sürümünü uygulamanızla doğru çalıştığını bildiğiniz belirli bir güncel sürüme "sabitlemek" (pinlemek) olmalı.
-
-Örneğin, uygulamanızda `0.112.0` sürümünü kullandığınızı varsayalım.
-
-`requirements.txt` dosyası kullanıyorsanız sürümü şöyle belirtebilirsiniz:
-
-```txt
-fastapi[standard]==0.112.0
-```
-
-Bu, tam olarak `0.112.0` sürümünü kullanacağınız anlamına gelir.
-
-Ya da şu şekilde de sabitleyebilirsiniz:
-
-```txt
-fastapi[standard]>=0.112.0,<0.113.0
-```
-
-Bu da `0.112.0` ve üzeri, ama `0.113.0` altındaki sürümleri kullanacağınız anlamına gelir; örneğin `0.112.2` gibi bir sürüm de kabul edilir.
-
-Kurulumları yönetmek için `uv`, Poetry, Pipenv gibi başka bir araç (veya benzerleri) kullanıyorsanız, bunların hepsinde paketler için belirli sürümler tanımlamanın bir yolu vardır.
-
-## Mevcut sürümler { #available-versions }
-
-Mevcut sürümleri (ör. en güncel son sürümün hangisi olduğunu kontrol etmek için) [Release Notes](../release-notes.md){.internal-link target=_blank} sayfasında görebilirsiniz.
-
-## Sürümler Hakkında { #about-versions }
-
-Semantic Versioning kurallarına göre, `1.0.0` altındaki herhangi bir sürüm breaking change içerebilir.
-
-FastAPI ayrıca "PATCH" sürüm değişikliklerinin bug fix'ler ve breaking olmayan değişiklikler için kullanılması kuralını da takip eder.
-
-/// tip | İpucu
-
-"PATCH" son sayıdır. Örneğin `0.2.3` içinde PATCH sürümü `3`'tür.
-
-///
-
-Dolayısıyla şu şekilde bir sürüme sabitleyebilmelisiniz:
-
-```txt
-fastapi>=0.45.0,<0.46.0
-```
-
-Breaking change'ler ve yeni özellikler "MINOR" sürümlerde eklenir.
-
-/// tip | İpucu
-
-"MINOR" ortadaki sayıdır. Örneğin `0.2.3` içinde MINOR sürümü `2`'dir.
-
-///
-
-## FastAPI Sürümlerini Yükseltme { #upgrading-the-fastapi-versions }
-
-Uygulamanız için test'ler eklemelisiniz.
-
-**FastAPI** ile bu çok kolaydır (Starlette sayesinde). Dokümantasyona bakın: [Testing](../tutorial/testing.md){.internal-link target=_blank}
-
-Test'leriniz olduktan sonra **FastAPI** sürümünü daha yeni bir sürüme yükseltebilir ve test'lerinizi çalıştırarak tüm kodunuzun doğru çalıştığından emin olabilirsiniz.
-
-Her şey çalışıyorsa (ya da gerekli değişiklikleri yaptıktan sonra) ve tüm test'leriniz geçiyorsa, `fastapi` sürümünü o yeni sürüme sabitleyebilirsiniz.
-
-## Starlette Hakkında { #about-starlette }
-
-`starlette` sürümünü sabitlememelisiniz.
-
-**FastAPI**'nin farklı sürümleri, Starlette'in belirli (daha yeni) bir sürümünü kullanır.
-
-Bu yüzden **FastAPI**'nin doğru Starlette sürümünü kullanmasına izin verebilirsiniz.
-
-## Pydantic Hakkında { #about-pydantic }
-
-Pydantic, **FastAPI** için olan test'leri kendi test'lerinin içine dahil eder; bu yüzden Pydantic'in yeni sürümleri (`1.0.0` üzeri) her zaman FastAPI ile uyumludur.
-
-Pydantic'i sizin için çalışan `1.0.0` üzerindeki herhangi bir sürüme sabitleyebilirsiniz.
-
-Örneğin:
-
-```txt
-pydantic>=2.7.0,<3.0.0
-```

docs/tr/docs/environment-variables.md

@@ -1,298 +0,0 @@
-# Ortam Değişkenleri { #environment-variables }
-
-/// tip | İpucu
-
-"Ortam değişkenleri"nin ne olduğunu ve nasıl kullanılacağını zaten biliyorsanız, bu bölümü atlayabilirsiniz.
-
-///
-
-Ortam değişkeni (genelde "**env var**" olarak da anılır), Python kodunun **dışında**, **işletim sistemi** seviyesinde bulunan ve Python kodunuz (veya diğer programlar) tarafından okunabilen bir değişkendir.
-
-Ortam değişkenleri; uygulama **ayarları**nı yönetmek, Python’un **kurulumu**nun bir parçası olarak konfigürasyon yapmak vb. durumlarda işe yarar.
-
-## Env Var Oluşturma ve Kullanma { #create-and-use-env-vars }
-
-Python’a ihtiyaç duymadan, **shell (terminal)** içinde ortam değişkenleri **oluşturabilir** ve kullanabilirsiniz:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// You could create an env var MY_NAME with
-$ export MY_NAME="Wade Wilson"
-
-// Then you could use it with other programs, like
-$ echo "Hello $MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Create an env var MY_NAME
-$ $Env:MY_NAME = "Wade Wilson"
-
-// Use it with other programs, like
-$ echo "Hello $Env:MY_NAME"
-
-Hello Wade Wilson
-```
-
-</div>
-
-////
-
-## Python’da env var Okuma { #read-env-vars-in-python }
-
-Ortam değişkenlerini Python’un **dışında** (terminalde veya başka bir yöntemle) oluşturup daha sonra **Python’da okuyabilirsiniz**.
-
-Örneğin `main.py` adında bir dosyanız şöyle olabilir:
-
-```Python hl_lines="3"
-import os
-
-name = os.getenv("MY_NAME", "World")
-print(f"Hello {name} from Python")
-```
-
-/// tip | İpucu
-
-<a href="https://docs.python.org/3.8/library/os.html#os.getenv" class="external-link" target="_blank">`os.getenv()`</a> fonksiyonunun ikinci argümanı, bulunamadığında döndürülecek varsayılan (default) değerdir.
-
-Verilmezse varsayılan olarak `None` olur; burada varsayılan değer olarak `"World"` verdik.
-
-///
-
-Sonrasında bu Python programını çalıştırabilirsiniz:
-
-//// tab | Linux, macOS, Windows Bash
-
-<div class="termy">
-
-```console
-// Here we don't set the env var yet
-$ python main.py
-
-// As we didn't set the env var, we get the default value
-
-Hello World from Python
-
-// But if we create an environment variable first
-$ export MY_NAME="Wade Wilson"
-
-// And then call the program again
-$ python main.py
-
-// Now it can read the environment variable
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-//// tab | Windows PowerShell
-
-<div class="termy">
-
-```console
-// Here we don't set the env var yet
-$ python main.py
-
-// As we didn't set the env var, we get the default value
-
-Hello World from Python
-
-// But if we create an environment variable first
-$ $Env:MY_NAME = "Wade Wilson"
-
-// And then call the program again
-$ python main.py
-
-// Now it can read the environment variable
-
-Hello Wade Wilson from Python
-```
-
-</div>
-
-////
-
-Ortam değişkenleri kodun dışında ayarlanabildiği, ama kod tarafından okunabildiği ve dosyalarla birlikte saklanmasının (ör. `git`’e commit edilmesinin) gerekmediği için, konfigürasyon veya **ayarlar** için sıkça kullanılır.
-
-Ayrıca, bir ortam değişkenini yalnızca **belirli bir program çalıştırımı** için oluşturabilirsiniz; bu değişken sadece o program tarafından, sadece o çalıştırma süresince kullanılabilir.
-
-Bunu yapmak için, program komutunun hemen öncesinde ve aynı satırda tanımlayın:
-
-<div class="termy">
-
-```console
-// Create an env var MY_NAME in line for this program call
-$ MY_NAME="Wade Wilson" python main.py
-
-// Now it can read the environment variable
-
-Hello Wade Wilson from Python
-
-// The env var no longer exists afterwards
-$ python main.py
-
-Hello World from Python
-```
-
-</div>
-
-/// tip | İpucu
-
-Bu konuyla ilgili daha fazlasını <a href="https://12factor.net/config" class="external-link" target="_blank">The Twelve-Factor App: Config</a> bölümünde okuyabilirsiniz.
-
-///
-
-## Tipler ve Doğrulama { #types-and-validation }
-
-Bu ortam değişkenleri yalnızca **metin string**’lerini taşıyabilir. Çünkü Python’un dışındadırlar ve diğer programlarla, sistemin geri kalanıyla (hatta Linux, Windows, macOS gibi farklı işletim sistemleriyle) uyumlu olmak zorundadırlar.
-
-Bu, Python’da bir ortam değişkeninden okunan **her değerin `str` olacağı** anlamına gelir. Farklı bir tipe dönüştürme veya doğrulama işlemleri kod içinde yapılmalıdır.
-
-Uygulama **ayarları**nı yönetmek için ortam değişkenlerini kullanmayı, [İleri Seviye Kullanıcı Rehberi - Ayarlar ve Ortam Değişkenleri](./advanced/settings.md){.internal-link target=_blank} bölümünde daha detaylı öğreneceksiniz.
-
-## `PATH` Ortam Değişkeni { #path-environment-variable }
-
-İşletim sistemlerinin (Linux, macOS, Windows) çalıştırılacak programları bulmak için kullandığı **özel** bir ortam değişkeni vardır: **`PATH`**.
-
-`PATH` değişkeninin değeri uzun bir string’dir; Linux ve macOS’te dizinler iki nokta üst üste `:` ile, Windows’ta ise noktalı virgül `;` ile ayrılır.
-
-Örneğin `PATH` ortam değişkeni şöyle görünebilir:
-
-//// tab | Linux, macOS
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
-```
-
-Bu, sistemin şu dizinlerde program araması gerektiği anlamına gelir:
-
-* `/usr/local/bin`
-* `/usr/bin`
-* `/bin`
-* `/usr/sbin`
-* `/sbin`
-
-////
-
-//// tab | Windows
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32
-```
-
-Bu, sistemin şu dizinlerde program araması gerektiği anlamına gelir:
-
-* `C:\Program Files\Python312\Scripts`
-* `C:\Program Files\Python312`
-* `C:\Windows\System32`
-
-////
-
-Terminalde bir **komut** yazdığınızda, işletim sistemi `PATH` ortam değişkeninde listelenen **bu dizinlerin her birinde** programı **arar**.
-
-Örneğin terminalde `python` yazdığınızda, işletim sistemi bu listedeki **ilk dizinde** `python` adlı bir program arar.
-
-Bulursa **onu kullanır**. Bulamazsa **diğer dizinlerde** aramaya devam eder.
-
-### Python Kurulumu ve `PATH`’in Güncellenmesi { #installing-python-and-updating-the-path }
-
-Python’u kurarken, `PATH` ortam değişkenini güncellemek isteyip istemediğiniz sorulabilir.
-
-//// tab | Linux, macOS
-
-Diyelim ki Python’u kurdunuz ve `/opt/custompython/bin` dizinine yüklendi.
-
-`PATH` ortam değişkenini güncellemeyi seçerseniz, kurulum aracı `/opt/custompython/bin` yolunu `PATH` ortam değişkenine ekler.
-
-Şöyle görünebilir:
-
-```plaintext
-/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/opt/custompython/bin
-```
-
-Böylece terminalde `python` yazdığınızda, sistem `/opt/custompython/bin` (son dizin) içindeki Python programını bulur ve onu kullanır.
-
-////
-
-//// tab | Windows
-
-Diyelim ki Python’u kurdunuz ve `C:\opt\custompython\bin` dizinine yüklendi.
-
-`PATH` ortam değişkenini güncellemeyi seçerseniz, kurulum aracı `C:\opt\custompython\bin` yolunu `PATH` ortam değişkenine ekler.
-
-```plaintext
-C:\Program Files\Python312\Scripts;C:\Program Files\Python312;C:\Windows\System32;C:\opt\custompython\bin
-```
-
-Böylece terminalde `python` yazdığınızda, sistem `C:\opt\custompython\bin` (son dizin) içindeki Python programını bulur ve onu kullanır.
-
-////
-
-Yani şunu yazarsanız:
-
-<div class="termy">
-
-```console
-$ python
-```
-
-</div>
-
-//// tab | Linux, macOS
-
-Sistem `python` programını `/opt/custompython/bin` içinde **bulur** ve çalıştırır.
-
-Bu, kabaca şunu yazmaya denktir:
-
-<div class="termy">
-
-```console
-$ /opt/custompython/bin/python
-```
-
-</div>
-
-////
-
-//// tab | Windows
-
-Sistem `python` programını `C:\opt\custompython\bin\python` içinde **bulur** ve çalıştırır.
-
-Bu, kabaca şunu yazmaya denktir:
-
-<div class="termy">
-
-```console
-$ C:\opt\custompython\bin\python
-```
-
-</div>
-
-////
-
-Bu bilgiler, [Virtual Environments](virtual-environments.md){.internal-link target=_blank} konusunu öğrenirken işinize yarayacak.
-
-## Sonuç { #conclusion }
-
-Buraya kadar **ortam değişkenleri**nin ne olduğuna ve Python’da nasıl kullanılacağına dair temel bir fikir edinmiş olmalısınız.
-
-Ayrıca <a href="https://en.wikipedia.org/wiki/Environment_variable" class="external-link" target="_blank">Wikipedia for Environment Variable</a> sayfasından daha fazlasını da okuyabilirsiniz.
-
-Çoğu zaman ortam değişkenlerinin hemen nasıl işe yarayacağı ilk bakışta çok net olmayabilir. Ancak geliştirme yaparken birçok farklı senaryoda tekrar tekrar karşınıza çıkarlar; bu yüzden bunları bilmek faydalıdır.
-
-Örneğin bir sonraki bölümde, [Virtual Environments](virtual-environments.md) konusunda bu bilgilere ihtiyaç duyacaksınız.

docs/tr/docs/fastapi-cli.md

@@ -1,75 +0,0 @@
-# FastAPI CLI { #fastapi-cli }
-
-**FastAPI CLI**, FastAPI uygulamanızı servis etmek, FastAPI projenizi yönetmek ve daha fazlası için kullanabileceğiniz bir komut satırı programıdır.
-
-FastAPI'yi kurduğunuzda (ör. `pip install "fastapi[standard]"`), beraberinde `fastapi-cli` adlı bir paket de gelir; bu paket terminalde `fastapi` komutunu sağlar.
-
-FastAPI uygulamanızı geliştirme için çalıştırmak üzere `fastapi dev` komutunu kullanabilirsiniz:
-
-<div class="termy">
-
-```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
-
-  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
-
-             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>
-
-   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
-             following code:
-
-             <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>
-
-      <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://127.0.0.1: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://127.0.0.1:8000/docs</u></font>
-
-      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
-             <b>fastapi run</b>
-
-             Logs:
-
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
-             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C to
-             quit<b>)</b>
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
-     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</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>  Application startup complete.
-```
-
-</div>
-
-`fastapi` adlı bu komut satırı programı, **FastAPI CLI**'dır.
-
-FastAPI CLI, Python programınızın path'ini (ör. `main.py`) alır; `FastAPI` instance'ını (genellikle `app` olarak adlandırılır) otomatik olarak tespit eder, doğru import sürecini belirler ve ardından uygulamayı servis eder.
-
-Production için bunun yerine `fastapi run` kullanırsınız. 🚀
-
-İçeride **FastAPI CLI**, yüksek performanslı, production'a hazır bir ASGI server olan <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>'u kullanır. 😎
-
-## `fastapi dev` { #fastapi-dev }
-
-`fastapi dev` çalıştırmak, geliştirme modunu başlatır.
-
-Varsayılan olarak **auto-reload** etkindir; kodunuzda değişiklik yaptığınızda server'ı otomatik olarak yeniden yükler. Bu, kaynak tüketimi yüksek bir özelliktir ve kapalı olduğuna kıyasla daha az stabil olabilir. Sadece geliştirme sırasında kullanmalısınız. Ayrıca yalnızca `127.0.0.1` IP adresini dinler; bu, makinenizin sadece kendisiyle iletişim kurması için kullanılan IP'dir (`localhost`).
-
-## `fastapi run` { #fastapi-run }
-
-`fastapi run` çalıştırmak, varsayılan olarak FastAPI'yi production modunda başlatır.
-
-Varsayılan olarak **auto-reload** kapalıdır. Ayrıca `0.0.0.0` IP adresini dinler; bu, kullanılabilir tüm IP adresleri anlamına gelir. Böylece makineyle iletişim kurabilen herkes tarafından genel erişime açık olur. Bu, normalde production'da çalıştırma şeklidir; örneğin bir container içinde.
-
-Çoğu durumda (ve genellikle yapmanız gereken şekilde) üst tarafta sizin yerinize HTTPS'i yöneten bir "termination proxy" bulunur. Bu, uygulamanızı nasıl deploy ettiğinize bağlıdır; sağlayıcınız bunu sizin için yapabilir ya da sizin ayrıca kurmanız gerekebilir.
-
-/// tip | İpucu
-
-Bununla ilgili daha fazla bilgiyi [deployment dokümantasyonunda](deployment/index.md){.internal-link target=_blank} bulabilirsiniz.
-
-///

docs/tr/docs/help-fastapi.md

@@ -1,256 +0,0 @@
-# FastAPI'ye Yardım Et - Yardım Al { #help-fastapi-get-help }
-
-**FastAPI**'yi seviyor musunuz?
-
-FastAPI'ye, diğer kullanıcılara ve yazara yardım etmek ister misiniz?
-
-Yoksa **FastAPI** ile ilgili yardım mı almak istiyorsunuz?
-
-Yardım etmenin çok basit yolları var (bazıları sadece bir-iki tıklama gerektirir).
-
-Yardım almanın da birkaç yolu var.
-
-## Bültene abone olun { #subscribe-to-the-newsletter }
-
-Şunlardan haberdar olmak için (seyrek yayımlanan) [**FastAPI and friends** bültenine](newsletter.md){.internal-link target=_blank} abone olabilirsiniz:
-
-* FastAPI ve friends ile ilgili haberler 🚀
-* Rehberler 📝
-* Özellikler ✨
-* Geriye dönük uyumsuz değişiklikler 🚨
-* İpuçları ve püf noktaları ✅
-
-## X (Twitter) üzerinden FastAPI'yi takip edin { #follow-fastapi-on-x-twitter }
-
-**FastAPI** ile ilgili en güncel haberleri almak için <a href="https://x.com/fastapi" class="external-link" target="_blank">@fastapi hesabını **X (Twitter)** üzerinde takip edin</a>. 🐦
-
-## GitHub'da **FastAPI**'ye yıldız verin { #star-fastapi-in-github }
-
-GitHub'da FastAPI'ye "star" verebilirsiniz (sağ üstteki yıldız butonuna tıklayarak): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. ⭐️
-
-Yıldız verince, diğer kullanıcılar projeyi daha kolay bulabilir ve başkaları için de faydalı olduğunu görebilir.
-
-## GitHub repository'sini release'ler için izleyin { #watch-the-github-repository-for-releases }
-
-GitHub'da FastAPI'yi "watch" edebilirsiniz (sağ üstteki "watch" butonuna tıklayarak): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
-
-Orada "Releases only" seçebilirsiniz.
-
-Böylece **FastAPI**'nin bug fix'ler ve yeni özelliklerle gelen her yeni release'inde (yeni versiyonunda) email ile bildirim alırsınız.
-
-## Yazarla bağlantı kurun { #connect-with-the-author }
-
-Yazar olan <a href="https://tiangolo.com" class="external-link" target="_blank">benimle (Sebastián Ramírez / `tiangolo`)</a> bağlantı kurabilirsiniz.
-
-Şunları yapabilirsiniz:
-
-* <a href="https://github.com/tiangolo" class="external-link" target="_blank">Beni **GitHub**'da takip edin</a>.
-    * Size yardımcı olabilecek oluşturduğum diğer Open Source projelere göz atın.
-    * Yeni bir Open Source proje oluşturduğumda haberdar olmak için beni takip edin.
-* <a href="https://x.com/tiangolo" class="external-link" target="_blank">Beni **X (Twitter)** üzerinde</a> veya <a href="https://fosstodon.org/@tiangolo" class="external-link" target="_blank">Mastodon</a>'da takip edin.
-    * FastAPI'yi nasıl kullandığınızı anlatın (bunu duymayı seviyorum).
-    * Duyuru yaptığımda veya yeni araçlar yayınladığımda haberdar olun.
-    * Ayrıca (ayrı bir hesap olan) <a href="https://x.com/fastapi" class="external-link" target="_blank">X (Twitter) üzerinde @fastapi hesabını da takip edebilirsiniz</a>.
-* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">Beni **LinkedIn**'de takip edin</a>.
-    * Duyuru yaptığımda veya yeni araçlar yayınladığımda haberdar olun (gerçi X (Twitter)'ı daha sık kullanıyorum 🤷‍♂).
-* <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> veya <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a> üzerinde yazdıklarımı okuyun (ya da beni takip edin).
-    * Diğer fikirleri, yazıları ve oluşturduğum araçlarla ilgili içerikleri okuyun.
-    * Yeni bir şey yayınladığımda görmek için beni takip edin.
-
-## **FastAPI** hakkında tweet atın { #tweet-about-fastapi }
-
-<a href="https://x.com/compose/tweet?text=I'm loving @fastapi because... https://github.com/fastapi/fastapi" class="external-link" target="_blank">**FastAPI** hakkında tweet atın</a> ve neden sevdiğinizi bana ve diğerlerine söyleyin. 🎉
-
-**FastAPI**'nin nasıl kullanıldığını, nelerini sevdiğinizi, hangi projede/şirkette kullandığınızı vb. duymayı seviyorum.
-
-## FastAPI için oy verin { #vote-for-fastapi }
-
-* <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Slant'ta **FastAPI** için oy verin</a>.
-* <a href="https://alternativeto.net/software/fastapi/about/" class="external-link" target="_blank">AlternativeTo'da **FastAPI** için oy verin</a>.
-* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">StackShare'de **FastAPI** kullandığınızı belirtin</a>.
-
-## GitHub'da sorularla başkalarına yardım edin { #help-others-with-questions-in-github }
-
-Şuralarda insanların sorularına yardımcı olmayı deneyebilirsiniz:
-
-* <a href="https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered" class="external-link" target="_blank">GitHub Discussions</a>
-* <a href="https://github.com/fastapi/fastapi/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-desc+label%3Aquestion+-label%3Aanswered+" class="external-link" target="_blank">GitHub Issues</a>
-
-Birçok durumda bu soruların cevabını zaten biliyor olabilirsiniz. 🤓
-
-Eğer insanların sorularına çok yardım ederseniz, resmi bir [FastAPI Expert](fastapi-people.md#fastapi-experts){.internal-link target=_blank} olabilirsiniz. 🎉
-
-Şunu unutmayın: en önemli nokta, nazik olmaya çalışmak. İnsanlar çoğu zaman biriken stresle geliyor ve birçok durumda soruyu en iyi şekilde sormuyor; yine de elinizden geldiğince nazik olmaya çalışın. 🤗
-
-Amaç, **FastAPI** topluluğunun nazik ve kapsayıcı olması. Aynı zamanda başkalarına zorbalık ya da saygısız davranışları da kabul etmeyin. Birbirimizi kollamalıyız.
-
----
-
-Sorularda (discussions veya issues içinde) başkalarına yardım etmek için şunları yapabilirsiniz:
-
-### Soruyu anlayın { #understand-the-question }
-
-* Soru soran kişinin **amacının** ve kullanım senaryosunun ne olduğunu anlayabiliyor musunuz, kontrol edin.
-
-* Sonra sorunun (büyük çoğunluğu soru olur) **net** olup olmadığına bakın.
-
-* Birçok durumda kullanıcı kafasında hayali bir çözüm kurup onu sorar; ancak **daha iyi** bir çözüm olabilir. Problemi ve kullanım senaryosunu daha iyi anladıysanız daha iyi bir **alternatif çözüm** önerebilirsiniz.
-
-* Soruyu anlayamıyorsanız daha fazla **detay** isteyin.
-
-### Problemi yeniden üretin { #reproduce-the-problem }
-
-Çoğu durumda ve çoğu soruda, kişinin **orijinal kodu** ile ilgili bir şey vardır.
-
-Birçok kişi sadece kodun bir parçasını kopyalar, ama bu **problemi yeniden üretmek** için yeterli olmaz.
-
-* Çalıştırıp aynı hatayı/davranışı görebileceğiniz veya kullanım senaryosunu daha iyi anlayabileceğiniz, yerelde **kopyala-yapıştır** yaparak çalıştırılabilen bir <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">minimal, reproducible, example</a> paylaşmalarını isteyebilirsiniz.
-
-* Çok cömert hissediyorsanız, problemi anlatan açıklamadan yola çıkarak kendiniz de böyle bir **örnek oluşturmayı** deneyebilirsiniz. Ancak bunun çok zaman alabileceğini unutmayın; çoğu zaman önce problemi netleştirmelerini istemek daha iyidir.
-
-### Çözüm önerin { #suggest-solutions }
-
-* Soruyu anlayabildikten sonra olası bir **cevap** verebilirsiniz.
-
-* Çoğu durumda, yapmak istediklerinden ziyade alttaki **asıl problemi veya kullanım senaryosunu** anlamak daha iyidir; çünkü denedikleri yöntemden daha iyi bir çözüm yolu olabilir.
-
-### Kapatılmasını isteyin { #ask-to-close }
-
-Eğer yanıt verirlerse, büyük ihtimalle problemi çözmüşsünüzdür, tebrikler, **kahramansınız**! 🦸
-
-* Eğer çözüm işe yaradıysa şunları yapmalarını isteyebilirsiniz:
-
-    * GitHub Discussions'ta: ilgili yorumu **answer** olarak işaretlemeleri.
-    * GitHub Issues'ta: issue'yu **close** etmeleri.
-
-## GitHub repository'sini izleyin { #watch-the-github-repository }
-
-GitHub'da FastAPI'yi "watch" edebilirsiniz (sağ üstteki "watch" butonuna tıklayarak): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
-
-"Releases only" yerine "Watching" seçerseniz biri yeni bir issue veya soru oluşturduğunda bildirim alırsınız. Ayrıca sadece yeni issue'lar, ya da discussions, ya da PR'lar vb. için bildirim almak istediğinizi belirtebilirsiniz.
-
-Sonra da bu soruları çözmelerine yardımcı olmayı deneyebilirsiniz.
-
-## Soru Sorun { #ask-questions }
-
-GitHub repository'sinde örneğin şunlar için <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">yeni bir soru oluşturabilirsiniz</a>:
-
-* Bir **soru** sorun veya bir **problem** hakkında danışın.
-* Yeni bir **feature** önerin.
-
-**Not**: Bunu yaparsanız, ben de sizden başkalarına yardım etmenizi isteyeceğim. 😉
-
-## Pull Request'leri İnceleyin { #review-pull-requests }
-
-Başkalarının gönderdiği pull request'leri incelememde bana yardımcı olabilirsiniz.
-
-Yine, lütfen elinizden geldiğince nazik olmaya çalışın. 🤗
-
----
-
-Bir pull request'i incelerken akılda tutmanız gerekenler:
-
-### Problemi anlayın { #understand-the-problem }
-
-* Önce, pull request'in çözmeye çalıştığı **problemi anladığınızdan** emin olun. GitHub Discussion veya issue içinde daha uzun bir tartışması olabilir.
-
-* Pull request'in aslında hiç gerekmiyor olma ihtimali de yüksektir; çünkü problem **farklı bir şekilde** çözülebilir. Bu durumda bunu önerebilir veya bununla ilgili soru sorabilirsiniz.
-
-### Style konusunda çok dert etmeyin { #dont-worry-about-style }
-
-* Commit message tarzı gibi şeyleri çok dert etmeyin; ben commit'leri manuel olarak düzenleyerek squash and merge yapacağım.
-
-* Style kuralları için de endişelenmeyin; bunları kontrol eden otomatik araçlar zaten var.
-
-Ek bir style veya tutarlılık ihtiyacı olursa, bunu doğrudan isterim ya da gerekli değişikliklerle üstüne commit eklerim.
-
-### Kodu kontrol edin { #check-the-code }
-
-* Kodu okuyup kontrol edin; mantıklı mı bakın, **yerelde çalıştırın** ve gerçekten problemi çözüyor mu görün.
-
-* Ardından bunu yaptığınızı belirten bir **yorum** yazın; böylece gerçekten kontrol ettiğinizi anlarım.
-
-/// info | Bilgi
-
-Ne yazık ki sadece birkaç onayı olan PR'lara körü körüne güvenemem.
-
-Defalarca, 3, 5 veya daha fazla onayı olan PR'lar oldu; muhtemelen açıklaması çekici olduğu için onay aldılar. Ama PR'lara baktığımda aslında bozuk olduklarını, bug içerdiğini veya iddia ettikleri problemi çözmediklerini gördüm. 😅
-
-Bu yüzden kodu gerçekten okuyup çalıştırmanız ve bunu yorumlarda bana bildirmeniz çok önemli. 🤓
-
-///
-
-* PR bir şekilde basitleştirilebiliyorsa bunu isteyebilirsiniz. Ancak çok didik didik etmeye gerek yok; konuya göre birçok öznel bakış açısı olabilir (benim de olacaktır 🙈). Bu yüzden temel noktalara odaklanmak daha iyi.
-
-### Testler { #tests }
-
-* PR'da **testler** olduğunu kontrol etmemde bana yardımcı olun.
-
-* PR'dan önce testlerin **fail** ettiğini kontrol edin. 🚨
-
-* PR'dan sonra testlerin **pass** ettiğini kontrol edin. ✅
-
-* Birçok PR test içermez; test eklemelerini **hatırlatabilirsiniz** veya hatta kendiniz bazı testler **önerebilirsiniz**. Bu, en çok zaman alan işlerden biridir ve burada çok yardımcı olabilirsiniz.
-
-* Ayrıca neleri denediğinizi yorumlara yazın; böylece kontrol ettiğinizi anlarım. 🤓
-
-## Pull Request Oluşturun { #create-a-pull-request }
-
-Örneğin şunlar için Pull Request'lerle kaynak koda [katkıda bulunabilirsiniz](contributing.md){.internal-link target=_blank}:
-
-* Dokümantasyonda bulduğunuz bir yazım hatasını düzeltmek.
-* FastAPI hakkında oluşturduğunuz veya bulduğunuz bir makaleyi, videoyu ya da podcast'i <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">bu dosyayı düzenleyerek</a> paylaşmak.
-    * Link'inizi ilgili bölümün başına eklediğinizden emin olun.
-* Dokümantasyonu kendi dilinize [çevirmeye yardımcı olmak](contributing.md#translations){.internal-link target=_blank}.
-    * Başkalarının yaptığı çevirileri gözden geçirmeye de yardımcı olabilirsiniz.
-* Yeni dokümantasyon bölümleri önermek.
-* Mevcut bir issue/bug'ı düzeltmek.
-    * Test eklediğinizden emin olun.
-* Yeni bir feature eklemek.
-    * Test eklediğinizden emin olun.
-    * İlgiliyse dokümantasyon da eklediğinizden emin olun.
-
-## FastAPI'nin Bakımına Yardım Edin { #help-maintain-fastapi }
-
-**FastAPI**'nin bakımını yapmama yardımcı olun! 🤓
-
-Yapılacak çok iş var ve bunların çoğunu **SİZ** yapabilirsiniz.
-
-Şu anda yapabileceğiniz ana işler:
-
-* [GitHub'da sorularla başkalarına yardım edin](#help-others-with-questions-in-github){.internal-link target=_blank} (yukarıdaki bölüme bakın).
-* [Pull Request'leri inceleyin](#review-pull-requests){.internal-link target=_blank} (yukarıdaki bölüme bakın).
-
-Bu iki iş, **en çok zamanı alan** işlerdir. FastAPI bakımının ana yükü buradadır.
-
-Burada yardımcı olursanız, **FastAPI'nin bakımını yapmama yardım etmiş** ve daha **hızlı ve daha iyi ilerlemesini** sağlamış olursunuz. 🚀
-
-## Sohbete katılın { #join-the-chat }
-
-FastAPI topluluğundan diğer kişilerle takılmak için 👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">Discord chat server</a> 👥 sohbetine katılın.
-
-/// tip | İpucu
-
-Sorular için <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussions</a>'a sorun; [FastAPI Experts](fastapi-people.md#fastapi-experts){.internal-link target=_blank} tarafından yardım alma ihtimaliniz çok daha yüksektir.
-
-Chat'i sadece genel sohbetler için kullanın.
-
-///
-
-### Sorular için chat'i kullanmayın { #dont-use-the-chat-for-questions }
-
-Chat sistemleri daha "serbest sohbet"e izin verdiği için, çok genel ve yanıtlaması daha zor sorular sormak kolaylaşır; bu nedenle cevap alamayabilirsiniz.
-
-GitHub'da ise şablon (template) doğru soruyu yazmanız için sizi yönlendirir; böylece daha kolay iyi bir cevap alabilir, hatta bazen sormadan önce problemi kendiniz çözebilirsiniz. Ayrıca GitHub'da (zaman alsa bile) her şeye mutlaka cevap verdiğimden emin olabilirim. Chat sistemlerinde bunu kişisel olarak yapamam. 😅
-
-Chat sistemlerindeki konuşmalar GitHub kadar kolay aranabilir değildir; bu yüzden soru ve cevaplar sohbet içinde kaybolabilir. Ayrıca [FastAPI Expert](fastapi-people.md#fastapi-experts){.internal-link target=_blank} olmak için sadece GitHub'daki katkılar sayılır; dolayısıyla büyük olasılıkla GitHub'da daha fazla ilgi görürsünüz.
-
-Öte yandan chat sistemlerinde binlerce kullanıcı vardır; bu yüzden neredeyse her zaman konuşacak birini bulma ihtimaliniz yüksektir. 😄
-
-## Yazara sponsor olun { #sponsor-the-author }
-
-Eğer **ürününüz/şirketiniz** **FastAPI**'ye bağlıysa veya onunla ilişkiliyse ve FastAPI kullanıcılarına ulaşmak istiyorsanız, <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub sponsors</a> üzerinden yazara (bana) sponsor olabilirsiniz. Tier'a göre dokümantasyonda bir rozet gibi ek faydalar elde edebilirsiniz. 🎁
-
----
-
-Teşekkürler! 🚀

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

@@ -1,17 +0,0 @@
-# Eski 403 Kimlik Doğrulama Hata Durum Kodlarını Kullanma { #use-old-403-authentication-error-status-codes }
-
-FastAPI `0.122.0` sürümünden önce, entegre security yardımcı araçları başarısız bir kimlik doğrulama (authentication) sonrasında client'a bir hata döndüğünde HTTP durum kodu olarak `403 Forbidden` kullanıyordu.
-
-FastAPI `0.122.0` sürümünden itibaren ise daha uygun olan HTTP durum kodu `401 Unauthorized` kullanılmakta ve HTTP spesifikasyonlarına uygun olarak response içinde anlamlı bir `WWW-Authenticate` header'ı döndürülmektedir: <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>.
-
-Ancak herhangi bir nedenle client'larınız eski davranışa bağlıysa, security class'larınızda `make_not_authenticated_error` metodunu override ederek eski davranışa geri dönebilirsiniz.
-
-Örneğin, varsayılan `401 Unauthorized` hatası yerine `403 Forbidden` hatası döndüren bir `HTTPBearer` alt sınıfı oluşturabilirsiniz:
-
-{* ../../docs_src/authentication_error_status_code/tutorial001_an_py39.py hl[9:13] *}
-
-/// tip | İpucu
-
-Fonksiyonun exception instance'ını döndürdüğüne dikkat edin; exception'ı raise etmiyor. Raise işlemi internal kodun geri kalan kısmında yapılıyor.
-
-///

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

@@ -1,56 +0,0 @@
-# Koşullu OpenAPI { #conditional-openapi }
-
-Gerekirse, ayarlar ve environment variable'ları kullanarak OpenAPI'yi ortama göre koşullu şekilde yapılandırabilir, hatta tamamen devre dışı bırakabilirsiniz.
-
-## Güvenlik, API'ler ve dokümantasyon hakkında { #about-security-apis-and-docs }
-
-Production ortamında dokümantasyon arayüzlerini gizlemek, API'nizi korumanın yolu *olmamalıdır*.
-
-Bu, API'nize ekstra bir güvenlik katmanı eklemez; *path operation*'lar bulundukları yerde yine erişilebilir olacaktır.
-
-Kodunuzda bir güvenlik açığı varsa, o açık yine var olmaya devam eder.
-
-Dokümantasyonu gizlemek, API'nizle nasıl etkileşime geçileceğini anlamayı zorlaştırır ve production'da debug etmeyi de daha zor hale getirebilir. Bu yaklaşım, basitçe <a href="https://en.wikipedia.org/wiki/Security_through_obscurity" class="external-link" target="_blank">Security through obscurity</a> olarak değerlendirilebilir.
-
-API'nizi güvence altına almak istiyorsanız, yapabileceğiniz daha iyi birçok şey var; örneğin:
-
-* request body'leriniz ve response'larınız için iyi tanımlanmış Pydantic model'larına sahip olduğunuzdan emin olun.
-* dependencies kullanarak gerekli izinleri ve rolleri yapılandırın.
-* Asla düz metin (plaintext) şifre saklamayın, yalnızca password hash'leri saklayın.
-* pwdlib ve JWT token'ları gibi, iyi bilinen kriptografik araçları uygulayın ve kullanın.
-* Gerektiğinde OAuth2 scope'ları ile daha ayrıntılı izin kontrolleri ekleyin.
-* ...vb.
-
-Yine de, bazı ortamlarda (örn. production) veya environment variable'lardan gelen konfigürasyonlara bağlı olarak API docs'u gerçekten devre dışı bırakmanız gereken çok spesifik bir use case'iniz olabilir.
-
-## Ayarlar ve env var'lar ile koşullu OpenAPI { #conditional-openapi-from-settings-and-env-vars }
-
-Üretilen OpenAPI'yi ve docs UI'larını yapılandırmak için aynı Pydantic settings'i kolayca kullanabilirsiniz.
-
-Örneğin:
-
-{* ../../docs_src/conditional_openapi/tutorial001_py39.py hl[6,11] *}
-
-Burada `openapi_url` ayarını, varsayılanı `"/openapi.json"` olacak şekilde tanımlıyoruz.
-
-Ardından `FastAPI` app'ini oluştururken bunu kullanıyoruz.
-
-Sonrasında, environment variable `OPENAPI_URL`'i boş string olarak ayarlayarak OpenAPI'yi (UI docs dahil) devre dışı bırakabilirsiniz; örneğin:
-
-<div class="termy">
-
-```console
-$ OPENAPI_URL= uvicorn main:app
-
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-Böylece `/openapi.json`, `/docs` veya `/redoc` URL'lerine giderseniz, aşağıdaki gibi bir `404 Not Found` hatası alırsınız:
-
-```JSON
-{
-    "detail": "Not Found"
-}
-```

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

@@ -1,70 +0,0 @@
-# Swagger UI'yi Yapılandırın { #configure-swagger-ui }
-
-Bazı ek <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">Swagger UI parametrelerini</a> yapılandırabilirsiniz.
-
-Bunları yapılandırmak için, `FastAPI()` uygulama nesnesini oluştururken ya da `get_swagger_ui_html()` fonksiyonuna `swagger_ui_parameters` argümanını verin.
-
-`swagger_ui_parameters`, Swagger UI'ye doğrudan iletilecek yapılandırmaları içeren bir `dict` alır.
-
-FastAPI, Swagger UI'nin ihtiyaç duyduğu şekilde JavaScript ile uyumlu olsun diye bu yapılandırmaları **JSON**'a dönüştürür.
-
-## Syntax Highlighting'i Devre Dışı Bırakın { #disable-syntax-highlighting }
-
-Örneğin, Swagger UI'de syntax highlighting'i devre dışı bırakabilirsiniz.
-
-Ayarları değiştirmeden bırakırsanız, syntax highlighting varsayılan olarak etkindir:
-
-<img src="/img/tutorial/extending-openapi/image02.png">
-
-Ancak `syntaxHighlight` değerini `False` yaparak devre dışı bırakabilirsiniz:
-
-{* ../../docs_src/configure_swagger_ui/tutorial001_py39.py hl[3] *}
-
-...ve ardından Swagger UI artık syntax highlighting'i göstermeyecektir:
-
-<img src="/img/tutorial/extending-openapi/image03.png">
-
-## Temayı Değiştirin { #change-the-theme }
-
-Aynı şekilde, `"syntaxHighlight.theme"` anahtarıyla (ortasında bir nokta olduğuna dikkat edin) syntax highlighting temasını ayarlayabilirsiniz:
-
-{* ../../docs_src/configure_swagger_ui/tutorial002_py39.py hl[3] *}
-
-Bu yapılandırma, syntax highlighting renk temasını değiştirir:
-
-<img src="/img/tutorial/extending-openapi/image04.png">
-
-## Varsayılan Swagger UI Parametrelerini Değiştirin { #change-default-swagger-ui-parameters }
-
-FastAPI, çoğu kullanım senaryosu için uygun bazı varsayılan yapılandırma parametreleriyle gelir.
-
-Şu varsayılan yapılandırmaları içerir:
-
-{* ../../fastapi/openapi/docs.py ln[9:24] hl[18:24] *}
-
-`swagger_ui_parameters` argümanında farklı bir değer vererek bunların herhangi birini ezebilirsiniz (override).
-
-Örneğin `deepLinking`'i devre dışı bırakmak için `swagger_ui_parameters`'a şu ayarları geçebilirsiniz:
-
-{* ../../docs_src/configure_swagger_ui/tutorial003_py39.py hl[3] *}
-
-## Diğer Swagger UI Parametreleri { #other-swagger-ui-parameters }
-
-Kullanabileceğiniz diğer tüm olası yapılandırmaları görmek için, resmi <a href="https://swagger.io/docs/open-source-tools/swagger-ui/usage/configuration/" class="external-link" target="_blank">Swagger UI parametreleri dokümantasyonunu</a> okuyun.
-
-## Yalnızca JavaScript ayarları { #javascript-only-settings }
-
-Swagger UI ayrıca bazı yapılandırmaların **yalnızca JavaScript** nesneleri olmasına izin verir (örneğin JavaScript fonksiyonları).
-
-FastAPI, bu yalnızca JavaScript olan `presets` ayarlarını da içerir:
-
-```JavaScript
-presets: [
-    SwaggerUIBundle.presets.apis,
-    SwaggerUIBundle.SwaggerUIStandalonePreset
-]
-```
-
-Bunlar string değil, **JavaScript** nesneleridir; dolayısıyla bunları Python kodundan doğrudan geçemezsiniz.
-
-Böyle yalnızca JavaScript yapılandırmalarına ihtiyacınız varsa, yukarıdaki yöntemlerden birini kullanabilirsiniz: Swagger UI'nin tüm *path operation*'larını override edin ve ihtiyaç duyduğunuz JavaScript'i elle yazın.