👥 Update FastAPI GitHub topic repositories

[skip ci]

.github/labeler.yml

@@ -31,6 +31,7 @@ internal:
         - .pre-commit-config.yaml
         - pdm_build.py
         - requirements*.txt
+        - uv.lock
         - docs/en/data/sponsors.yml
         - docs/en/overrides/main.html
       - all-globs-to-all-files:

docs/de/docs/_llm-test.md

@@ -189,7 +189,7 @@ Siehe Abschnitt `### Links` im allgemeinen Prompt in `scripts/translate.py`.
 
 ////
 
-## HTML „abbr“-Elemente { #html-abbr-elements }
+## HTML-„abbr“-Elemente { #html-abbr-elements }
 
 //// tab | Test
 

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

@@ -56,19 +56,19 @@ from app.routers import items
 
 Die gleiche Dateistruktur mit Kommentaren:
 
-```
+```bash
 .
-├── app                  # „app“ ist ein Python-Package
-│   ├── __init__.py      # diese Datei macht „app“ zu einem „Python-Package“
-│   ├── main.py          # „main“-Modul, z. B. import app.main
-│   ├── dependencies.py  # „dependencies“-Modul, z. B. import app.dependencies
-│   └── routers          # „routers“ ist ein „Python-Subpackage“
-│   │   ├── __init__.py  # macht „routers“ zu einem „Python-Subpackage“
-│   │   ├── items.py     # „items“-Submodul, z. B. import app.routers.items
-│   │   └── users.py     # „users“-Submodul, z. B. import app.routers.users
-│   └── internal         # „internal“ ist ein „Python-Subpackage“
-│       ├── __init__.py  # macht „internal“ zu einem „Python-Subpackage“
-│       └── admin.py     # „admin“-Submodul, z. B. import app.internal.admin
+├── app                  # "app" ist ein Python-Package
+│   ├── __init__.py      # diese Datei macht "app" zu einem "Python-Package"
+│   ├── main.py          # "main"-Modul, z. B. import app.main
+│   ├── dependencies.py  # "dependencies"-Modul, z. B. import app.dependencies
+│   └── routers          # "routers" ist ein "Python-Subpackage"
+│   │   ├── __init__.py  # macht "routers" zu einem "Python-Subpackage"
+│   │   ├── items.py     # "items"-Submodul, z. B. import app.routers.items
+│   │   └── users.py     # "users"-Submodul, z. B. import app.routers.users
+│   └── internal         # "internal" ist ein "Python-Subpackage"
+│       ├── __init__.py  # macht "internal" zu einem "Python-Subpackage"
+│       └── admin.py     # "admin"-Submodul, z. B. import app.internal.admin
 ```
 
 ## `APIRouter` { #apirouter }
@@ -479,7 +479,7 @@ $ fastapi dev app/main.py
 
 </div>
 
-und öffnen Sie die Dokumentation unter <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+Und öffnen Sie die Dokumentation unter <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
 Sie sehen die automatische API-Dokumentation, einschließlich der Pfade aller Submodule, mit den richtigen Pfaden (und Präfixen) und den richtigen Tags:
 

docs/en/data/sponsors.yml

@@ -65,9 +65,6 @@ bronze:
   # - url: https://testdriven.io/courses/tdd-fastapi/
   #   title: Learn to build high-quality web apps with best practices
   #   img: https://fastapi.tiangolo.com/img/sponsors/testdriven.svg
-  - url: https://lambdatest.com/?utm_source=fastapi&utm_medium=partner&utm_campaign=sponsor&utm_term=opensource&utm_content=webpage
-    title: LambdaTest, AI-Powered Cloud-based Test Orchestration Platform
-    img: https://fastapi.tiangolo.com/img/sponsors/lambdatest.png
-  - url: https://requestly.com/fastapi
-    title: All-in-one platform to Test, Mock and Intercept APIs. Built for speed, privacy and offline support.
-    img: https://fastapi.tiangolo.com/img/sponsors/requestly.png
+  - url: https://www.testmu.ai/?utm_source=fastapi&utm_medium=partner&utm_campaign=sponsor&utm_term=opensource&utm_content=webpage
+    title: TestMu AI. The Native AI-Agentic Cloud Platform to Supercharge Quality Engineering.
+    img: https://fastapi.tiangolo.com/img/sponsors/testmu.png

docs/en/data/topic_repos.yml

@@ -1,176 +1,181 @@
 - name: full-stack-fastapi-template
   html_url: https://github.com/fastapi/full-stack-fastapi-template
-  stars: 40334
+  stars: 41312
   owner_login: fastapi
   owner_html_url: https://github.com/fastapi
 - name: Hello-Python
   html_url: https://github.com/mouredev/Hello-Python
-  stars: 33628
+  stars: 34206
   owner_login: mouredev
   owner_html_url: https://github.com/mouredev
 - name: serve
   html_url: https://github.com/jina-ai/serve
-  stars: 21817
+  stars: 21832
   owner_login: jina-ai
   owner_html_url: https://github.com/jina-ai
 - name: HivisionIDPhotos
   html_url: https://github.com/Zeyi-Lin/HivisionIDPhotos
-  stars: 20409
+  stars: 20661
   owner_login: Zeyi-Lin
   owner_html_url: https://github.com/Zeyi-Lin
 - name: sqlmodel
   html_url: https://github.com/fastapi/sqlmodel
-  stars: 17415
+  stars: 17567
   owner_login: fastapi
   owner_html_url: https://github.com/fastapi
 - name: fastapi-best-practices
   html_url: https://github.com/zhanymkanov/fastapi-best-practices
-  stars: 15776
+  stars: 16291
   owner_login: zhanymkanov
   owner_html_url: https://github.com/zhanymkanov
 - name: Douyin_TikTok_Download_API
   html_url: https://github.com/Evil0ctal/Douyin_TikTok_Download_API
-  stars: 15588
+  stars: 16132
   owner_login: Evil0ctal
   owner_html_url: https://github.com/Evil0ctal
-- name: machine-learning-zoomcamp
-  html_url: https://github.com/DataTalksClub/machine-learning-zoomcamp
-  stars: 12447
-  owner_login: DataTalksClub
-  owner_html_url: https://github.com/DataTalksClub
 - name: SurfSense
   html_url: https://github.com/MODSetter/SurfSense
-  stars: 12128
+  stars: 12723
   owner_login: MODSetter
   owner_html_url: https://github.com/MODSetter
+- name: machine-learning-zoomcamp
+  html_url: https://github.com/DataTalksClub/machine-learning-zoomcamp
+  stars: 12575
+  owner_login: DataTalksClub
+  owner_html_url: https://github.com/DataTalksClub
 - name: fastapi_mcp
   html_url: https://github.com/tadata-org/fastapi_mcp
-  stars: 11326
+  stars: 11478
   owner_login: tadata-org
   owner_html_url: https://github.com/tadata-org
 - name: awesome-fastapi
   html_url: https://github.com/mjhea0/awesome-fastapi
-  stars: 10901
+  stars: 11018
   owner_login: mjhea0
   owner_html_url: https://github.com/mjhea0
 - name: XHS-Downloader
   html_url: https://github.com/JoeanAmier/XHS-Downloader
-  stars: 9584
+  stars: 9938
   owner_login: JoeanAmier
   owner_html_url: https://github.com/JoeanAmier
 - name: polar
   html_url: https://github.com/polarsource/polar
-  stars: 8951
+  stars: 9348
   owner_login: polarsource
   owner_html_url: https://github.com/polarsource
 - name: FastUI
   html_url: https://github.com/pydantic/FastUI
-  stars: 8934
+  stars: 8949
   owner_login: pydantic
   owner_html_url: https://github.com/pydantic
 - name: FileCodeBox
   html_url: https://github.com/vastsa/FileCodeBox
-  stars: 7934
+  stars: 8060
   owner_login: vastsa
   owner_html_url: https://github.com/vastsa
 - name: nonebot2
   html_url: https://github.com/nonebot/nonebot2
-  stars: 7248
+  stars: 7311
   owner_login: nonebot
   owner_html_url: https://github.com/nonebot
 - name: hatchet
   html_url: https://github.com/hatchet-dev/hatchet
-  stars: 6392
+  stars: 6479
   owner_login: hatchet-dev
   owner_html_url: https://github.com/hatchet-dev
 - name: fastapi-users
   html_url: https://github.com/fastapi-users/fastapi-users
-  stars: 5899
+  stars: 5970
   owner_login: fastapi-users
   owner_html_url: https://github.com/fastapi-users
 - name: serge
   html_url: https://github.com/serge-chat/serge
-  stars: 5754
+  stars: 5751
   owner_login: serge-chat
   owner_html_url: https://github.com/serge-chat
 - name: strawberry
   html_url: https://github.com/strawberry-graphql/strawberry
-  stars: 4577
+  stars: 4598
   owner_login: strawberry-graphql
   owner_html_url: https://github.com/strawberry-graphql
+- name: devpush
+  html_url: https://github.com/hunvreus/devpush
+  stars: 4407
+  owner_login: hunvreus
+  owner_html_url: https://github.com/hunvreus
+- name: Kokoro-FastAPI
+  html_url: https://github.com/remsky/Kokoro-FastAPI
+  stars: 4359
+  owner_login: remsky
+  owner_html_url: https://github.com/remsky
 - name: poem
   html_url: https://github.com/poem-web/poem
-  stars: 4303
+  stars: 4337
   owner_login: poem-web
   owner_html_url: https://github.com/poem-web
 - name: chatgpt-web-share
   html_url: https://github.com/chatpire/chatgpt-web-share
-  stars: 4287
+  stars: 4279
   owner_login: chatpire
   owner_html_url: https://github.com/chatpire
 - name: dynaconf
   html_url: https://github.com/dynaconf/dynaconf
-  stars: 4221
+  stars: 4244
   owner_login: dynaconf
   owner_html_url: https://github.com/dynaconf
-- name: Kokoro-FastAPI
-  html_url: https://github.com/remsky/Kokoro-FastAPI
-  stars: 4181
-  owner_login: remsky
-  owner_html_url: https://github.com/remsky
+- name: Yuxi-Know
+  html_url: https://github.com/xerrors/Yuxi-Know
+  stars: 4154
+  owner_login: xerrors
+  owner_html_url: https://github.com/xerrors
 - name: atrilabs-engine
   html_url: https://github.com/Atri-Labs/atrilabs-engine
-  stars: 4090
+  stars: 4086
   owner_login: Atri-Labs
   owner_html_url: https://github.com/Atri-Labs
-- name: devpush
-  html_url: https://github.com/hunvreus/devpush
-  stars: 4037
-  owner_login: hunvreus
-  owner_html_url: https://github.com/hunvreus
 - name: logfire
   html_url: https://github.com/pydantic/logfire
-  stars: 3896
+  stars: 3975
   owner_login: pydantic
   owner_html_url: https://github.com/pydantic
 - name: LitServe
   html_url: https://github.com/Lightning-AI/LitServe
-  stars: 3756
+  stars: 3797
   owner_login: Lightning-AI
   owner_html_url: https://github.com/Lightning-AI
 - name: huma
   html_url: https://github.com/danielgtaylor/huma
-  stars: 3702
+  stars: 3785
   owner_login: danielgtaylor
   owner_html_url: https://github.com/danielgtaylor
-- name: Yuxi-Know
-  html_url: https://github.com/xerrors/Yuxi-Know
-  stars: 3680
-  owner_login: xerrors
-  owner_html_url: https://github.com/xerrors
 - name: datamodel-code-generator
   html_url: https://github.com/koxudaxi/datamodel-code-generator
-  stars: 3675
+  stars: 3731
   owner_login: koxudaxi
   owner_html_url: https://github.com/koxudaxi
 - name: fastapi-admin
   html_url: https://github.com/fastapi-admin/fastapi-admin
-  stars: 3659
+  stars: 3697
   owner_login: fastapi-admin
   owner_html_url: https://github.com/fastapi-admin
 - name: farfalle
   html_url: https://github.com/rashadphz/farfalle
-  stars: 3497
+  stars: 3506
   owner_login: rashadphz
   owner_html_url: https://github.com/rashadphz
 - name: tracecat
   html_url: https://github.com/TracecatHQ/tracecat
-  stars: 3421
+  stars: 3458
   owner_login: TracecatHQ
   owner_html_url: https://github.com/TracecatHQ
+- name: mcp-context-forge
+  html_url: https://github.com/IBM/mcp-context-forge
+  stars: 3216
+  owner_login: IBM
+  owner_html_url: https://github.com/IBM
 - name: opyrator
   html_url: https://github.com/ml-tooling/opyrator
-  stars: 3136
+  stars: 3134
   owner_login: ml-tooling
   owner_html_url: https://github.com/ml-tooling
 - name: docarray
@@ -180,316 +185,311 @@
   owner_html_url: https://github.com/docarray
 - name: fastapi-realworld-example-app
   html_url: https://github.com/nsidnev/fastapi-realworld-example-app
-  stars: 3051
+  stars: 3072
   owner_login: nsidnev
   owner_html_url: https://github.com/nsidnev
-- name: mcp-context-forge
-  html_url: https://github.com/IBM/mcp-context-forge
-  stars: 3034
-  owner_login: IBM
-  owner_html_url: https://github.com/IBM
 - name: uvicorn-gunicorn-fastapi-docker
   html_url: https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker
-  stars: 2904
+  stars: 2908
   owner_login: tiangolo
   owner_html_url: https://github.com/tiangolo
 - name: FastAPI-template
   html_url: https://github.com/s3rius/FastAPI-template
-  stars: 2680
+  stars: 2728
   owner_login: s3rius
   owner_html_url: https://github.com/s3rius
 - name: best-of-web-python
   html_url: https://github.com/ml-tooling/best-of-web-python
-  stars: 2662
+  stars: 2686
   owner_login: ml-tooling
   owner_html_url: https://github.com/ml-tooling
 - name: YC-Killer
   html_url: https://github.com/sahibzada-allahyar/YC-Killer
-  stars: 2614
+  stars: 2648
   owner_login: sahibzada-allahyar
   owner_html_url: https://github.com/sahibzada-allahyar
 - name: sqladmin
   html_url: https://github.com/aminalaee/sqladmin
-  stars: 2587
+  stars: 2637
   owner_login: aminalaee
   owner_html_url: https://github.com/aminalaee
 - name: fastapi-react
   html_url: https://github.com/Buuntu/fastapi-react
-  stars: 2566
+  stars: 2573
   owner_login: Buuntu
   owner_html_url: https://github.com/Buuntu
 - name: RasaGPT
   html_url: https://github.com/paulpierre/RasaGPT
-  stars: 2456
+  stars: 2460
   owner_login: paulpierre
   owner_html_url: https://github.com/paulpierre
 - name: supabase-py
   html_url: https://github.com/supabase/supabase-py
-  stars: 2394
+  stars: 2428
   owner_login: supabase
   owner_html_url: https://github.com/supabase
+- name: 30-Days-of-Python
+  html_url: https://github.com/codingforentrepreneurs/30-Days-of-Python
+  stars: 2347
+  owner_login: codingforentrepreneurs
+  owner_html_url: https://github.com/codingforentrepreneurs
 - name: nextpy
   html_url: https://github.com/dot-agent/nextpy
-  stars: 2338
+  stars: 2337
   owner_login: dot-agent
   owner_html_url: https://github.com/dot-agent
 - name: fastapi-utils
   html_url: https://github.com/fastapiutils/fastapi-utils
-  stars: 2289
+  stars: 2299
   owner_login: fastapiutils
   owner_html_url: https://github.com/fastapiutils
 - name: langserve
   html_url: https://github.com/langchain-ai/langserve
-  stars: 2234
+  stars: 2255
   owner_login: langchain-ai
   owner_html_url: https://github.com/langchain-ai
-- name: 30-Days-of-Python
-  html_url: https://github.com/codingforentrepreneurs/30-Days-of-Python
-  stars: 2232
-  owner_login: codingforentrepreneurs
-  owner_html_url: https://github.com/codingforentrepreneurs
+- name: NoteDiscovery
+  html_url: https://github.com/gamosoft/NoteDiscovery
+  stars: 2182
+  owner_login: gamosoft
+  owner_html_url: https://github.com/gamosoft
 - name: solara
   html_url: https://github.com/widgetti/solara
-  stars: 2141
+  stars: 2154
   owner_login: widgetti
   owner_html_url: https://github.com/widgetti
 - name: mangum
   html_url: https://github.com/Kludex/mangum
-  stars: 2046
+  stars: 2071
   owner_login: Kludex
   owner_html_url: https://github.com/Kludex
 - name: fastapi_best_architecture
   html_url: https://github.com/fastapi-practices/fastapi_best_architecture
-  stars: 1963
+  stars: 2036
   owner_login: fastapi-practices
   owner_html_url: https://github.com/fastapi-practices
-- name: NoteDiscovery
-  html_url: https://github.com/gamosoft/NoteDiscovery
-  stars: 1943
-  owner_login: gamosoft
-  owner_html_url: https://github.com/gamosoft
-- name: agentkit
-  html_url: https://github.com/BCG-X-Official/agentkit
-  stars: 1936
-  owner_login: BCG-X-Official
-  owner_html_url: https://github.com/BCG-X-Official
 - name: vue-fastapi-admin
   html_url: https://github.com/mizhexiaoxiao/vue-fastapi-admin
-  stars: 1909
+  stars: 1983
   owner_login: mizhexiaoxiao
   owner_html_url: https://github.com/mizhexiaoxiao
-- name: manage-fastapi
-  html_url: https://github.com/ycd/manage-fastapi
-  stars: 1887
-  owner_login: ycd
-  owner_html_url: https://github.com/ycd
+- name: agentkit
+  html_url: https://github.com/BCG-X-Official/agentkit
+  stars: 1941
+  owner_login: BCG-X-Official
+  owner_html_url: https://github.com/BCG-X-Official
+- name: fastapi-langgraph-agent-production-ready-template
+  html_url: https://github.com/wassim249/fastapi-langgraph-agent-production-ready-template
+  stars: 1920
+  owner_login: wassim249
+  owner_html_url: https://github.com/wassim249
 - name: openapi-python-client
   html_url: https://github.com/openapi-generators/openapi-python-client
-  stars: 1879
+  stars: 1900
   owner_login: openapi-generators
   owner_html_url: https://github.com/openapi-generators
+- name: manage-fastapi
+  html_url: https://github.com/ycd/manage-fastapi
+  stars: 1894
+  owner_login: ycd
+  owner_html_url: https://github.com/ycd
 - name: slowapi
   html_url: https://github.com/laurentS/slowapi
-  stars: 1845
+  stars: 1891
   owner_login: laurentS
   owner_html_url: https://github.com/laurentS
 - name: piccolo
   html_url: https://github.com/piccolo-orm/piccolo
-  stars: 1843
+  stars: 1854
   owner_login: piccolo-orm
   owner_html_url: https://github.com/piccolo-orm
+- name: fastapi-cache
+  html_url: https://github.com/long2ice/fastapi-cache
+  stars: 1816
+  owner_login: long2ice
+  owner_html_url: https://github.com/long2ice
 - name: python-week-2022
   html_url: https://github.com/rochacbruno/python-week-2022
   stars: 1813
   owner_login: rochacbruno
   owner_html_url: https://github.com/rochacbruno
-- name: fastapi-cache
-  html_url: https://github.com/long2ice/fastapi-cache
-  stars: 1805
-  owner_login: long2ice
-  owner_html_url: https://github.com/long2ice
 - name: ormar
   html_url: https://github.com/collerek/ormar
-  stars: 1785
+  stars: 1797
   owner_login: collerek
   owner_html_url: https://github.com/collerek
-- name: fastapi-langgraph-agent-production-ready-template
-  html_url: https://github.com/wassim249/fastapi-langgraph-agent-production-ready-template
-  stars: 1780
-  owner_login: wassim249
-  owner_html_url: https://github.com/wassim249
 - name: FastAPI-boilerplate
   html_url: https://github.com/benavlabs/FastAPI-boilerplate
-  stars: 1734
+  stars: 1792
   owner_login: benavlabs
   owner_html_url: https://github.com/benavlabs
 - name: termpair
   html_url: https://github.com/cs01/termpair
-  stars: 1724
+  stars: 1727
   owner_login: cs01
   owner_html_url: https://github.com/cs01
 - name: fastapi-crudrouter
   html_url: https://github.com/awtkns/fastapi-crudrouter
-  stars: 1671
+  stars: 1677
   owner_login: awtkns
   owner_html_url: https://github.com/awtkns
 - name: langchain-serve
   html_url: https://github.com/jina-ai/langchain-serve
-  stars: 1633
+  stars: 1634
   owner_login: jina-ai
   owner_html_url: https://github.com/jina-ai
 - name: fastapi-pagination
   html_url: https://github.com/uriyyo/fastapi-pagination
-  stars: 1588
+  stars: 1607
   owner_login: uriyyo
   owner_html_url: https://github.com/uriyyo
 - name: awesome-fastapi-projects
   html_url: https://github.com/Kludex/awesome-fastapi-projects
-  stars: 1583
+  stars: 1592
   owner_login: Kludex
   owner_html_url: https://github.com/Kludex
-- name: coronavirus-tracker-api
-  html_url: https://github.com/ExpDev07/coronavirus-tracker-api
-  stars: 1571
-  owner_login: ExpDev07
-  owner_html_url: https://github.com/ExpDev07
 - name: bracket
   html_url: https://github.com/evroon/bracket
-  stars: 1549
+  stars: 1580
   owner_login: evroon
   owner_html_url: https://github.com/evroon
+- name: coronavirus-tracker-api
+  html_url: https://github.com/ExpDev07/coronavirus-tracker-api
+  stars: 1570
+  owner_login: ExpDev07
+  owner_html_url: https://github.com/ExpDev07
 - name: fastapi-amis-admin
   html_url: https://github.com/amisadmin/fastapi-amis-admin
-  stars: 1491
+  stars: 1512
   owner_login: amisadmin
   owner_html_url: https://github.com/amisadmin
-- name: fastapi-boilerplate
-  html_url: https://github.com/teamhide/fastapi-boilerplate
-  stars: 1452
-  owner_login: teamhide
-  owner_html_url: https://github.com/teamhide
 - name: fastcrud
   html_url: https://github.com/benavlabs/fastcrud
-  stars: 1452
+  stars: 1471
   owner_login: benavlabs
   owner_html_url: https://github.com/benavlabs
+- name: fastapi-boilerplate
+  html_url: https://github.com/teamhide/fastapi-boilerplate
+  stars: 1461
+  owner_login: teamhide
+  owner_html_url: https://github.com/teamhide
 - name: awesome-python-resources
   html_url: https://github.com/DjangoEx/awesome-python-resources
-  stars: 1430
+  stars: 1435
   owner_login: DjangoEx
   owner_html_url: https://github.com/DjangoEx
 - name: prometheus-fastapi-instrumentator
   html_url: https://github.com/trallnag/prometheus-fastapi-instrumentator
-  stars: 1399
+  stars: 1417
   owner_login: trallnag
   owner_html_url: https://github.com/trallnag
 - name: fastapi-code-generator
   html_url: https://github.com/koxudaxi/fastapi-code-generator
-  stars: 1371
+  stars: 1382
   owner_login: koxudaxi
   owner_html_url: https://github.com/koxudaxi
+- name: fastapi-scaff
+  html_url: https://github.com/atpuxiner/fastapi-scaff
+  stars: 1367
+  owner_login: atpuxiner
+  owner_html_url: https://github.com/atpuxiner
 - name: fastapi-tutorial
   html_url: https://github.com/liaogx/fastapi-tutorial
-  stars: 1346
+  stars: 1360
   owner_login: liaogx
   owner_html_url: https://github.com/liaogx
 - name: budgetml
   html_url: https://github.com/ebhy/budgetml
-  stars: 1345
+  stars: 1343
   owner_login: ebhy
   owner_html_url: https://github.com/ebhy
-- name: fastapi-scaff
-  html_url: https://github.com/atpuxiner/fastapi-scaff
-  stars: 1331
-  owner_login: atpuxiner
-  owner_html_url: https://github.com/atpuxiner
 - name: bolt-python
   html_url: https://github.com/slackapi/bolt-python
-  stars: 1266
+  stars: 1276
   owner_login: slackapi
   owner_html_url: https://github.com/slackapi
 - name: bedrock-chat
   html_url: https://github.com/aws-samples/bedrock-chat
-  stars: 1266
+  stars: 1268
   owner_login: aws-samples
   owner_html_url: https://github.com/aws-samples
 - name: fastapi-alembic-sqlmodel-async
-  html_url: https://github.com/jonra1993/fastapi-alembic-sqlmodel-async
-  stars: 1260
-  owner_login: jonra1993
-  owner_html_url: https://github.com/jonra1993
+  html_url: https://github.com/vargasjona/fastapi-alembic-sqlmodel-async
+  stars: 1265
+  owner_login: vargasjona
+  owner_html_url: https://github.com/vargasjona
 - name: fastapi_production_template
   html_url: https://github.com/zhanymkanov/fastapi_production_template
-  stars: 1222
+  stars: 1227
   owner_login: zhanymkanov
   owner_html_url: https://github.com/zhanymkanov
-- name: langchain-extract
-  html_url: https://github.com/langchain-ai/langchain-extract
-  stars: 1179
-  owner_login: langchain-ai
-  owner_html_url: https://github.com/langchain-ai
 - name: restish
   html_url: https://github.com/rest-sh/restish
-  stars: 1152
+  stars: 1200
   owner_login: rest-sh
   owner_html_url: https://github.com/rest-sh
+- name: langchain-extract
+  html_url: https://github.com/langchain-ai/langchain-extract
+  stars: 1183
+  owner_login: langchain-ai
+  owner_html_url: https://github.com/langchain-ai
 - name: odmantic
   html_url: https://github.com/art049/odmantic
-  stars: 1143
+  stars: 1162
   owner_login: art049
   owner_html_url: https://github.com/art049
-- name: authx
-  html_url: https://github.com/yezz123/authx
-  stars: 1128
-  owner_login: yezz123
-  owner_html_url: https://github.com/yezz123
-- name: SAG
-  html_url: https://github.com/Zleap-AI/SAG
-  stars: 1104
-  owner_login: Zleap-AI
-  owner_html_url: https://github.com/Zleap-AI
 - name: aktools
   html_url: https://github.com/akfamily/aktools
-  stars: 1072
+  stars: 1155
   owner_login: akfamily
   owner_html_url: https://github.com/akfamily
 - name: RuoYi-Vue3-FastAPI
   html_url: https://github.com/insistence/RuoYi-Vue3-FastAPI
-  stars: 1063
+  stars: 1155
   owner_login: insistence
   owner_html_url: https://github.com/insistence
+- name: authx
+  html_url: https://github.com/yezz123/authx
+  stars: 1142
+  owner_login: yezz123
+  owner_html_url: https://github.com/yezz123
+- name: SAG
+  html_url: https://github.com/Zleap-AI/SAG
+  stars: 1110
+  owner_login: Zleap-AI
+  owner_html_url: https://github.com/Zleap-AI
 - name: flock
   html_url: https://github.com/Onelevenvy/flock
-  stars: 1059
+  stars: 1069
   owner_login: Onelevenvy
   owner_html_url: https://github.com/Onelevenvy
 - name: fastapi-observability
   html_url: https://github.com/blueswen/fastapi-observability
-  stars: 1046
+  stars: 1063
   owner_login: blueswen
   owner_html_url: https://github.com/blueswen
 - name: enterprise-deep-research
   html_url: https://github.com/SalesforceAIResearch/enterprise-deep-research
-  stars: 1019
+  stars: 1061
   owner_login: SalesforceAIResearch
   owner_html_url: https://github.com/SalesforceAIResearch
 - name: titiler
   html_url: https://github.com/developmentseed/titiler
-  stars: 1016
+  stars: 1039
   owner_login: developmentseed
   owner_html_url: https://github.com/developmentseed
 - name: every-pdf
   html_url: https://github.com/DDULDDUCK/every-pdf
-  stars: 1004
+  stars: 1017
   owner_login: DDULDDUCK
   owner_html_url: https://github.com/DDULDDUCK
 - name: autollm
   html_url: https://github.com/viddexa/autollm
-  stars: 1003
+  stars: 1005
   owner_login: viddexa
   owner_html_url: https://github.com/viddexa
 - name: lanarky
   html_url: https://github.com/ajndkr/lanarky
-  stars: 996
+  stars: 995
   owner_login: ajndkr
   owner_html_url: https://github.com/ajndkr

docs/en/docs/release-notes.md

@@ -9,6 +9,7 @@ hide:
 
 ### Docs
 
+* 📝 Fix minor typos in release notes. PR [#14780](https://github.com/fastapi/fastapi/pull/14780) by [@whyvineet](https://github.com/whyvineet).
 * 🐛 Fix copy button in custom.js. PR [#14722](https://github.com/fastapi/fastapi/pull/14722) by [@fcharrier](https://github.com/fcharrier).
 * 📝 Add contribution instructions about LLM generated code and comments and automated tools for PRs. PR [#14706](https://github.com/fastapi/fastapi/pull/14706) by [@tiangolo](https://github.com/tiangolo).
 * 📝 Update docs for management tasks. PR [#14705](https://github.com/fastapi/fastapi/pull/14705) by [@tiangolo](https://github.com/tiangolo).
@@ -18,6 +19,17 @@ hide:
 
 ### Translations
 
+* 🌐 Update translations for uk (update outdated, found by fixer tool). PR [#14739](https://github.com/fastapi/fastapi/pull/14739) by [@YuriiMotov](https://github.com/YuriiMotov).
+* 🌐 Update translations for tr (update-outdated). PR [#14745](https://github.com/fastapi/fastapi/pull/14745) by [@tiangolo](https://github.com/tiangolo).
+* 🌐 Update `llm-prompt.md` for Korean language. PR [#14763](https://github.com/fastapi/fastapi/pull/14763) by [@seuthootDev](https://github.com/seuthootDev).
+* 🌐 Update translations for ko (update outdated, found by fixer tool). PR [#14738](https://github.com/fastapi/fastapi/pull/14738) by [@YuriiMotov](https://github.com/YuriiMotov).
+* 🌐 Update translations for de (update-outdated). PR [#14690](https://github.com/fastapi/fastapi/pull/14690) by [@tiangolo](https://github.com/tiangolo).
+* 🌐 Update LLM prompt for Russian translations. PR [#14733](https://github.com/fastapi/fastapi/pull/14733) by [@YuriiMotov](https://github.com/YuriiMotov).
+* 🌐 Update translations for ru (update-outdated). PR [#14693](https://github.com/fastapi/fastapi/pull/14693) by [@tiangolo](https://github.com/tiangolo).
+* 🌐 Update translations for pt (update-outdated). PR [#14724](https://github.com/fastapi/fastapi/pull/14724) by [@tiangolo](https://github.com/tiangolo).
+* 🌐 Update Korean LLM prompt. PR [#14740](https://github.com/fastapi/fastapi/pull/14740) by [@hard-coders](https://github.com/hard-coders).
+* 🌐 Improve LLM prompt for Turkish translations. PR [#14728](https://github.com/fastapi/fastapi/pull/14728) by [@Kadermiyanyedi](https://github.com/Kadermiyanyedi).
+* 🌐 Update portuguese llm-prompt.md. PR [#14702](https://github.com/fastapi/fastapi/pull/14702) by [@ceb10n](https://github.com/ceb10n).
 * 🌐 Update LLM prompt instructions file for French. PR [#14618](https://github.com/fastapi/fastapi/pull/14618) by [@tiangolo](https://github.com/tiangolo).
 * 🌐 Update translations for ko (add-missing). PR [#14699](https://github.com/fastapi/fastapi/pull/14699) by [@tiangolo](https://github.com/tiangolo).
 * 🌐 Update translations for ko (update-outdated). PR [#14589](https://github.com/fastapi/fastapi/pull/14589) by [@tiangolo](https://github.com/tiangolo).
@@ -29,6 +41,9 @@ hide:
 
 ### Internal
 
+* 🔧 Ensure that an edit to `uv.lock` gets the `internal` label. PR [#14759](https://github.com/fastapi/fastapi/pull/14759) by [@svlandeg](https://github.com/svlandeg).
+* 🔧 Update sponsors: remove Requestly. PR [#14735](https://github.com/fastapi/fastapi/pull/14735) by [@tiangolo](https://github.com/tiangolo).
+* 🔧 Update sponsors, LambdaTest changes to TestMu AI. PR [#14734](https://github.com/fastapi/fastapi/pull/14734) by [@tiangolo](https://github.com/tiangolo).
 * ⬆ Bump actions/cache from 4 to 5. PR [#14511](https://github.com/fastapi/fastapi/pull/14511) by [@dependabot[bot]](https://github.com/apps/dependabot).
 * ⬆ Bump actions/upload-artifact from 5 to 6. PR [#14525](https://github.com/fastapi/fastapi/pull/14525) by [@dependabot[bot]](https://github.com/apps/dependabot).
 * ⬆ Bump actions/download-artifact from 6 to 7. PR [#14526](https://github.com/fastapi/fastapi/pull/14526) by [@dependabot[bot]](https://github.com/apps/dependabot).
@@ -271,7 +286,7 @@ hide:
 
 ### Refactors
 
-* 🔥 Remove dangling extra condiitonal no longer needed. PR [#14435](https://github.com/fastapi/fastapi/pull/14435) by [@tiangolo](https://github.com/tiangolo).
+* 🔥 Remove dangling extra conditional no longer needed. PR [#14435](https://github.com/fastapi/fastapi/pull/14435) by [@tiangolo](https://github.com/tiangolo).
 * ♻️ Refactor internals, update `is_coroutine` check to reuse internal supported variants (unwrap, check class). PR [#14434](https://github.com/fastapi/fastapi/pull/14434) by [@tiangolo](https://github.com/tiangolo).
 
 ### Translations
@@ -406,7 +421,7 @@ hide:
 
 ### Docs
 
-* 📝 Upate docs for advanced dependencies with `yield`, noting the changes in 0.121.0, adding `scope`. PR [#14287](https://github.com/fastapi/fastapi/pull/14287) by [@tiangolo](https://github.com/tiangolo).
+* 📝 Update docs for advanced dependencies with `yield`, noting the changes in 0.121.0, adding `scope`. PR [#14287](https://github.com/fastapi/fastapi/pull/14287) by [@tiangolo](https://github.com/tiangolo).
 
 ### Internal
 
@@ -2634,7 +2649,7 @@ Read more in the [advisory: Content-Type Header ReDoS](https://github.com/tiango
 * 🌐 Add Japanese translation for `docs/ja/docs/tutorial/handling-errors.md`. PR [#1953](https://github.com/tiangolo/fastapi/pull/1953) by [@SwftAlpc](https://github.com/SwftAlpc).
 * 🌐 Add Japanese translation for `docs/ja/docs/tutorial/response-status-code.md`. PR [#1942](https://github.com/tiangolo/fastapi/pull/1942) by [@SwftAlpc](https://github.com/SwftAlpc).
 * 🌐 Add Japanese translation for `docs/ja/docs/tutorial/extra-models.md`. PR [#1941](https://github.com/tiangolo/fastapi/pull/1941) by [@SwftAlpc](https://github.com/SwftAlpc).
-* 🌐 Add Japanese tranlsation for `docs/ja/docs/tutorial/schema-extra-example.md`. PR [#1931](https://github.com/tiangolo/fastapi/pull/1931) by [@SwftAlpc](https://github.com/SwftAlpc).
+* 🌐 Add Japanese translation for `docs/ja/docs/tutorial/schema-extra-example.md`. PR [#1931](https://github.com/tiangolo/fastapi/pull/1931) by [@SwftAlpc](https://github.com/SwftAlpc).
 * 🌐 Add Japanese translation for `docs/ja/docs/tutorial/body-nested-models.md`. PR [#1930](https://github.com/tiangolo/fastapi/pull/1930) by [@SwftAlpc](https://github.com/SwftAlpc).
 * 🌐 Add Japanese translation for `docs/ja/docs/tutorial/body-fields.md`. PR [#1923](https://github.com/tiangolo/fastapi/pull/1923) by [@SwftAlpc](https://github.com/SwftAlpc).
 * 🌐 Add German translation for `docs/de/docs/tutorial/index.md`. PR [#9502](https://github.com/tiangolo/fastapi/pull/9502) by [@fhabers21](https://github.com/fhabers21).
@@ -4010,7 +4025,7 @@ You hopefully updated to a supported version of Python a while ago. If you haven
 ### Fixes
 
 * 🐛 Fix `RuntimeError` raised when `HTTPException` has a status code with no content. PR [#5365](https://github.com/tiangolo/fastapi/pull/5365) by [@iudeen](https://github.com/iudeen).
-* 🐛 Fix empty reponse body when default `status_code` is empty but the a `Response` parameter with `response.status_code` is set. PR [#5360](https://github.com/tiangolo/fastapi/pull/5360) by [@tmeckel](https://github.com/tmeckel).
+* 🐛 Fix empty response body when default `status_code` is empty but the a `Response` parameter with `response.status_code` is set. PR [#5360](https://github.com/tiangolo/fastapi/pull/5360) by [@tmeckel](https://github.com/tmeckel).
 
 ### Docs
 

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é.
 
@@ -8,29 +8,29 @@ Si vous débutez avec **FastAPI**, vous n'en aurez peut-être pas besoin.
 
 ///
 
-Vous pouvez déclarer des réponses supplémentaires, avec des codes de statut supplémentaires, des types de médias, des descriptions, etc.
+Vous pouvez déclarer des réponses supplémentaires, avec des codes HTTP, des types de médias, des descriptions, etc.
 
 Ces réponses supplémentaires seront incluses dans le schéma OpenAPI, elles apparaîtront donc également dans la documentation de l'API.
 
-Mais pour ces réponses supplémentaires, vous devez vous assurer de renvoyer directement une `Response` comme `JSONResponse`, avec votre code de statut et votre contenu.
+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 reçoit un `dict` : les clés sont des codes de statut pour chaque réponse (comme `200`), et les valeurs sont d'autres `dict` avec les informations pour chacune d'elles.
+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.
 
 Chacun de ces `dict` de réponse peut avoir une clé `model`, contenant un modèle Pydantic, tout comme `response_model`.
 
-**FastAPI** prendra ce modèle, générera son JSON Schema et l'inclura au bon endroit dans OpenAPI.
+**FastAPI** prendra ce modèle, générera son schéma JSON et l'inclura au bon endroit dans OpenAPI.
 
-Par exemple, pour déclarer une autre réponse avec un code de statut `404` et un modèle Pydantic `Message`, vous pouvez écrire :
+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
 
-Gardez à l'esprit que vous devez renvoyer directement le `JSONResponse`.
+Gardez à l'esprit que vous devez renvoyer directement `JSONResponse`.
 
 ///
 
@@ -38,18 +38,18 @@ Gardez à l'esprit que vous devez renvoyer directement le `JSONResponse`.
 
 La clé `model` ne fait pas partie d'OpenAPI.
 
-**FastAPI** prendra le modèle Pydantic à partir de là, générera le JSON Schema et le placera au bon endroit.
+**FastAPI** prendra le modèle Pydantic à partir de là, générera le `JSON Schema` et le placera au bon endroit.
 
 Le bon endroit est :
 
-* Dans la clé `content`, qui a pour valeur un autre objet JSON (`dict`) qui contient :
-    * Une clé avec le type de média, par ex. `application/json`, qui contient comme valeur un autre objet JSON, qui contient :
-        * Une clé `schema`, qui a pour valeur le JSON Schema du modèle, voici le bon endroit.
-            * **FastAPI** ajoute ici une référence aux JSON Schemas globaux à un autre endroit de votre OpenAPI au lieu de l'inclure directement. De cette façon, d'autres applications et clients peuvent utiliser ces JSON Schemas directement, fournir de meilleurs outils de génération de code, etc.
+* Dans la clé `content`, qui a pour valeur un autre objet JSON (`dict`) qui contient :
+    * Une clé avec le type de support, par ex. `application/json`, qui contient comme valeur un autre objet JSON, qui contient :
+        * Une clé `schema`, qui a pour valeur le schéma JSON du modèle, voici le bon endroit.
+            * **FastAPI** ajoute ici une référence aux schémas JSON globaux à un autre endroit de votre OpenAPI au lieu de l'inclure directement. De cette façon, d'autres applications et clients peuvent utiliser ces schémas JSON directement, fournir de meilleurs outils de génération de code, etc.
 
 ///
 
-Les réponses générées dans OpenAPI pour cette *opération de 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"
 {
@@ -88,7 +88,7 @@ Les réponses générées dans OpenAPI pour cette *opération de chemin d'accès
 }
 ```
 
-Les schémas sont référencés à un autre endroit dans le schéma OpenAPI :
+Les schémas sont référencés à un autre endroit du modèle OpenAPI :
 
 ```JSON hl_lines="4-16"
 {
@@ -169,13 +169,13 @@ Les schémas sont référencés à un autre endroit dans le schéma 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 *opération de 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,29 +191,29 @@ Mais si vous avez spécifié une classe de réponse personnalisée avec `None` c
 
 ///
 
-## Combinaison d'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`.
 
-Vous pouvez déclarer un `response_model`, en utilisant le code de statut par défaut `200` (ou un code personnalisé si vous en avez besoin), puis déclarer des informations supplémentaires pour cette même réponse dans `responses`, directement dans le schéma OpenAPI.
+Vous pouvez déclarer un `response_model`, en utilisant le code HTTP par défaut `200` (ou un code personnalisé si vous en avez besoin), puis déclarer des informations supplémentaires pour cette même réponse dans `responses`, directement dans le schéma OpenAPI.
 
-**FastAPI** conservera les informations supplémentaires des `responses` et les combinera avec le JSON Schema de votre modèle.
+**FastAPI** conservera les informations supplémentaires des `responses` et les combinera avec le schéma JSON de votre modèle.
 
-Par exemple, vous pouvez déclarer une réponse avec un code de statut `404` qui utilise un modèle Pydantic et a une `description` personnalisée.
+Par exemple, vous pouvez déclarer une réponse avec un code HTTP `404` qui utilise un modèle Pydantic et a une `description` personnalisée.
 
-Et une réponse avec un code de statut `200` qui utilise votre `response_model`, mais inclut un `example` personnalisé :
+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 :
+Tout sera combiné et inclus dans votre OpenAPI, et affiché dans la documentation de l'API :
 
 <img src="/img/tutorial/additional-responses/image01.png">
 
-## Combiner des réponses prédéfinies et des 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 nombreuses *opérations de chemin d'accès*, mais vous souhaitez les combiner avec des réponses personnalisées nécessaires à chaque *opération de 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 de « 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 = {
@@ -223,7 +223,7 @@ old_dict = {
 new_dict = {**old_dict, "new key": "new value"}
 ```
 
-Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la nouvelle paire clé-valeur :
+Ici, `new_dict` contiendra toutes les paires clé-valeur de `old_dict` plus la nouvelle paire clé-valeur :
 
 ```Python
 {
@@ -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 *opérations de chemin 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 :
+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 :
+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 d'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 d'OpenAPI</a>, vous pouvez inclure n'importe quoi à partir de celui-ci 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 JSON Schemas), 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 de statut supplémentaires { #additional-status-codes }
+# Codes HTTP supplémentaires
 
-Par défaut, **FastAPI** renverra les réponses en utilisant une `JSONResponse`, en plaçant le contenu que vous renvoyez depuis votre *chemin d'accès* à l'intérieur de cette `JSONResponse`.
+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 de statut par défaut ou celui que vous définissez dans votre *chemin d'accès*.
+Il utilisera le code HTTP par défaut ou celui que vous avez défini dans votre *chemin d'accès*.
 
-## Codes de statut supplémentaires { #additional-status-codes_1 }
+## Codes HTTP supplémentaires
 
-Si vous souhaitez renvoyer des codes de statut 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 de statut supplémentaire.
+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 des éléments et renvoie des codes de statut 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 de statut HTTP de 201 « Created ».
+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 voulez :
+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, etc.
+Elle ne sera pas sérialisée avec un modèle.
 
-Vous devez vous assurer qu'elle contient les données que vous voulez qu'elle contienne, et que les valeurs sont du JSON valide (si vous utilisez `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 @@ Vous devez vous assurer qu'elle contient les données que vous voulez qu'elle co
 
 Vous pouvez également utiliser `from starlette.responses import JSONResponse`.
 
-**FastAPI** fournit les mêmes `starlette.responses` que `fastapi.responses` uniquement par commodité pour vous, le développeur. Mais la plupart des réponses disponibles proviennent directement de Starlette. De même pour `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 de statut et des réponses supplémentaires, ils ne seront pas inclus dans le schéma OpenAPI (les documents de l'API), car FastAPI n'a aucun moyen de savoir à l'avance ce que vous allez renvoyer.
+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.
 
 ///
 
-## Lisez d'abord le didacticiel { #read-the-tutorial-first }
+## Lisez d'abord le didacticiel
 
-Vous pouvez toujours utiliser la plupart des fonctionnalités de **FastAPI** avec les connaissances du [Tutoriel - Guide de l'utilisateur](../tutorial/index.md){.internal-link target=_blank}.
+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 déjà lu, et supposent que vous connaissez ces idées principales.
+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,26 +1,26 @@
-# Configuration avancée des chemins d'accès { #path-operation-advanced-configuration }
+# Configuration avancée des paramètres de chemin
 
-## operationId OpenAPI { #openapi-operationid }
+## ID d'opération OpenAPI
 
-/// warning | Alertes
+/// warning | Attention
 
-Si vous n’êtes pas un « expert » en 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 chaque `operation_id` des *chemins 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
 
@@ -28,81 +28,79 @@ Si vous appelez manuellement `app.openapi()`, vous devez mettre à jour les `ope
 
 ///
 
-/// 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 sont 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 depuis 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.
 
-Ajouter un `\f` (un caractère « form feed » é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.
 
-Il n’apparaîtra pas dans la documentation, mais d’autres outils (tels que 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 concernant 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 Extra { #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 concernant 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">Operation Object</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 au *chemin d'accès* est normalement généré automatiquement par **FastAPI**, mais vous pouvez aussi 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
 
-C’est un point d’extension de bas niveau.
-
-Si vous avez uniquement besoin de déclarer des réponses supplémentaires, une manière plus pratique de le faire est avec [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 [OpenAPI Extensions](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 les documents automatiques de l’API, votre extension apparaîtra au 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 regardez l’OpenAPI résultant (dans `/openapi.json` de votre API), vous verrez aussi votre extension comme faisant 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 regardez l’OpenAPI résultant (dans `/openapi.json` de votre API),
 }
 ```
 
-### Schéma OpenAPI personnalisé pour 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 pourriez ajouter des données supplémentaires au schéma généré automatiquement.
+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 faire cela 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="converted from some plain format, like bytes, into Python objects - converti depuis un format simple, comme des octets, en objets Python">parsed</abbr> en tant que 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 faire cela 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 depuis les modèles Pydantic ni la validation automatique pour le JSON. En fait, nous déclarons le type de contenu de la requête comme étant du YAML, pas du 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 tout de même un modèle Pydantic pour générer manuellement le JSON Schema pour les données que nous voulons 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 la requête directement 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 comme du 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.
 
-Et ensuite, dans notre code, nous analysons directement ce contenu YAML, et 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 d’une autre façon.
+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 en 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 mettrait ces données compatibles JSON (par exemple un `dict`) à l'intérieur d'une `JSONResponse` qui serait utilisée pour envoyer la réponse au client.
+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`.
 
@@ -22,29 +22,29 @@ En fait, vous pouvez retourner n'importe quelle `Response` ou n'importe quelle s
 
 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, etc.
+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.
+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.
+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 objet `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,12 +54,12 @@ 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.
 
-Mais vous pouvez toujours les documenter comme décrit dans [Réponses supplémentaires dans OpenAPI](additional-responses.md){.internal-link target=_blank}.
+Mais vous pouvez toujours les documenter comme décrit dans [Additional Responses in OpenAPI](additional-responses.md){.internal-link target=_blank}.
 
 Vous pouvez voir dans les sections suivantes comment utiliser/déclarer ces `Response`s personnalisées tout en conservant la conversion automatique des données, la documentation, etc.

docs/fr/docs/benchmarks.md

@@ -1,34 +1,34 @@
-# Benchmarks { #benchmarks }
+# Test de performance
 
-Les benchmarks indépendants de TechEmpower montrent que les applications **FastAPI** exécutées 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">l’un des frameworks Python les plus rapides disponibles</a>, juste en dessous de Starlette et Uvicorn eux-mêmes (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 lorsque vous consultez des benchmarks et des comparaisons, vous devez garder ce qui suit à l’esprit.
+Mais en prêtant attention aux tests de performance et aux comparaisons, il faut tenir compte de ce qu'il suit.
 
-## Benchmarks et vitesse { #benchmarks-and-speed }
+## Tests de performance et rapidité
 
-Lorsque vous consultez les benchmarks, il est courant de voir plusieurs outils de types différents comparés comme s’ils étaient équivalents.
+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, de voir Uvicorn, Starlette et FastAPI comparés ensemble (parmi de nombreux autres outils).
+En particulier, on voit Uvicorn, Starlette et FastAPI comparés (parmi de nombreux autres outils).
 
-Plus le problème résolu par l’outil est simple, meilleures seront les performances qu’il obtiendra. Et la plupart des benchmarks ne testent pas les fonctionnalités supplémentaires fournies par l’outil.
+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 d’API avec plusieurs fonctionnalités supplémentaires pour construire des 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** :
-    * Aura les meilleures performances, car il n’a pas beaucoup de code supplémentaire en dehors du serveur lui-même.
-    * Vous n’écririez pas une application directement en Uvicorn. Cela signifierait que votre code devrait inclure plus ou moins, au minimum, tout le code fourni par Starlette (ou **FastAPI**). Et si vous faisiez cela, votre application finale aurait la même surcharge que si vous aviez utilisé un framework, tout en minimisant le code de votre application et les bugs.
-    * Si vous comparez Uvicorn, comparez-le à Daphne, Hypercorn, uWSGI, etc. Des serveurs d’applications.
+    * 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** :
-    * Aura les performances suivantes, après Uvicorn. En fait, Starlette utilise Uvicorn pour s’exécuter. Donc, il ne peut probablement que devenir « plus lent » qu’Uvicorn, en devant exécuter plus de code.
-    * Mais il vous fournit les outils pour construire des applications web simples, avec du routage basé sur des chemins, etc.
-    * Si vous comparez Starlette, comparez-le à Sanic, Flask, Django, etc. Des frameworks web (ou microframeworks).
+    * 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** :
-    * De la même manière que Starlette utilise Uvicorn et ne peut pas être plus rapide que lui, **FastAPI** utilise Starlette, donc il ne peut pas être plus rapide que lui.
-    * FastAPI fournit plus de fonctionnalités par-dessus Starlette. Des fonctionnalités dont vous avez presque toujours besoin lorsque vous construisez des API, comme la validation des données et la sérialisation. Et en l’utilisant, vous obtenez de la documentation automatique gratuitement (la documentation automatique n’ajoute même pas de surcharge à l’exécution des applications, elle est générée au démarrage).
-    * Si vous n’utilisiez pas FastAPI et utilisiez Starlette directement (ou un autre outil, comme Sanic, Flask, Responder, etc.), vous devriez implémenter vous-même toute la validation des données et la sérialisation. Ainsi, votre application finale aurait toujours la même surcharge que si elle avait été construite en utilisant 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.
-    * Ainsi, en utilisant FastAPI, vous économisez du temps de développement, des bugs, des lignes de code, et vous obtiendriez probablement les mêmes performances (ou de meilleures) que si vous ne l’utilisiez pas (puisque vous devriez tout implémenter dans votre code).
-    * Si vous comparez FastAPI, comparez-le à un framework d’application web (ou à un ensemble d’outils) qui fournit la validation des données, la sérialisation et la documentation, comme Flask-apispec, NestJS, Molten, etc. Des frameworks avec validation automatique intégrée des données, sérialisation et documentation.
+    * 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,151 +1,74 @@
-# 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**. Cela se fait généralement avec <a href="https://www.docker.com/" class="external-link" target="_blank">**Docker**</a>. Vous pouvez ensuite déployer cette image de conteneur de l’une de plusieurs manières 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é**, et d’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é(e) 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"]
-
-# If running behind a proxy like Nginx or Traefik add --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 une manière très **légère** d’empaqueter des applications, y compris toutes leurs dépendances et les fichiers nécessaires, tout en les gardant isolées des autres conteneurs (d’autres applications ou composants) sur le même système.
+```Dockerfile
+FROM tiangolo/uvicorn-gunicorn-fastapi:python3.7
 
-Les conteneurs Linux s’exécutent en utilisant le même kernel 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 (une machine virtuelle consommerait bien plus).
-
-Les conteneurs ont aussi leurs propres processus en cours 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/du programme par défaut qui doivent être présents dans un conteneur. **Statique** signifie ici que l’**image** de conteneur ne s’exécute pas, elle n’est pas lancée, ce sont uniquement les fichiers empaquetés et les métadonnées.
-
-Contrairement à une « image de conteneur » qui correspond au contenu statique stocké, un « conteneur » désigne généralement l’instance en cours d’exécution, la chose qui est **exécutée**.
-
-Quand le **conteneur** est démarré et s’exécute (démarré depuis 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, et ne persisteront pas dans l’image de conteneur sous-jacente (ils ne seront pas enregistrés sur disque).
-
-Une image de conteneur est comparable au fichier et au contenu d’un **programme**, par exemple `python` et un fichier `main.py`.
-
-Et le **conteneur** lui-même (par opposition à l’**image de conteneur**) est l’instance réellement exécutée de l’image, comparable à un **processus**. En fait, un conteneur ne s’exécute que lorsqu’il a un **processus en cours d’exécution** (et normalement c’est un seul processus). Le conteneur s’arrête lorsqu’il n’y a plus de processus en cours d’exécution à l’intérieur.
-
-## Images de conteneur { #container-images }
-
-Docker a été l’un des principaux outils pour créer et gérer les **images de conteneur** et les **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éfabriquées 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</a> officielle.
-
-Et il existe beaucoup d’autres images pour différentes choses comme des bases de données, par exemple pour :
-
-* <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éfabriquée, il est très facile de **combiner** et d’utiliser différents outils. Par exemple, pour tester une nouvelle base de données. Dans la plupart des cas, vous pouvez utiliser les **images officielles** et simplement les configurer via des variables d’environnement.
-
-De cette façon, dans de nombreux cas, vous pouvez apprendre les conteneurs et Docker et réutiliser ces connaissances avec beaucoup d’outils et de composants différents.
-
-Ainsi, vous exécuteriez **plusieurs conteneurs** avec différentes choses, comme une base de données, une application Python, un serveur web avec une application frontend React, et vous les connecteriez entre eux via leur réseau interne.
-
-Tous les systèmes de gestion de conteneurs (comme Docker ou Kubernetes) intègrent ces fonctionnalités réseau.
-
-## Conteneurs et processus { #containers-and-processes }
-
-Une **image de conteneur** inclut normalement dans ses métadonnées le programme ou la commande par défaut à exécuter lorsque le **conteneur** est démarré, ainsi que les paramètres à passer à ce programme. Très similaire à ce que ce serait en ligne de commande.
-
-Quand un **conteneur** est démarré, il exécutera cette commande/ce programme (bien que vous puissiez l’outrepasser et lui faire exécuter une commande/un programme différent).
-
-Un conteneur s’exécute tant que le **processus principal** (commande ou programme) s’exécute.
-
-Un conteneur a normalement un **seul processus**, mais il est aussi possible de démarrer des sous-processus depuis le 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 d’exécution**. Si le processus principal s’arrête, le conteneur s’arrête.
-
-## Construire une image Docker pour FastAPI { #build-a-docker-image-for-fastapi }
-
-Ok, construisons quelque chose maintenant ! 🚀
-
-Je vais vous montrer comment construire une **image Docker** pour FastAPI **à partir de zéro**, sur la base de l’**image Python officielle**.
-
-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écute une image de conteneur pour vous, etc.
-
-### Exigences de packages { #package-requirements }
-
-Vous aurez normalement les **exigences de packages** de votre application dans un fichier.
-
-Cela dépendra principalement de l’outil que vous utilisez pour **installer** ces exigences.
-
-La manière la plus courante de le faire est d’avoir un fichier `requirements.txt` avec les noms de packages et leurs versions, un par ligne.
-
-Vous utiliseriez bien sûr les mêmes idées que celles présentées 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 installeriez normalement ces dépendances de packages 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 packages.
-
-///
-
-### 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 Union
+from typing import Optional
 
 from fastapi import FastAPI
 
@@ -158,166 +81,20 @@ def read_root():
 
 
 @app.get("/items/{item_id}")
-def read_item(item_id: int, q: Union[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. Partir de l’image de base Python officielle.
-
-2. Définir le répertoire de travail courant sur `/code`.
-
-    C’est là que nous mettrons le fichier `requirements.txt` et le répertoire `app`.
-
-3. Copier le fichier contenant les exigences dans le répertoire `/code`.
-
-    Copier **uniquement** le fichier contenant les exigences d’abord, pas le reste du code.
-
-    Comme ce fichier **ne change pas souvent**, Docker le détectera et utilisera le **cache** pour cette étape, permettant d’utiliser le cache pour l’étape suivante aussi.
-
-4. Installer les dépendances de packages du fichier d’exigences.
-
-    L’option `--no-cache-dir` indique à `pip` de ne pas enregistrer localement les packages téléchargés, car cela ne sert que si `pip` devait être relancé pour installer les mêmes packages, mais ce n’est pas le cas lorsqu’on travaille avec des conteneurs.
-
-    /// note | Remarque
-
-    `--no-cache-dir` est uniquement lié à `pip`, il n’a rien à voir avec Docker ou les conteneurs.
-
-    ///
-
-    L’option `--upgrade` indique à `pip` de mettre à niveau les packages s’ils sont déjà installés.
-
-    Comme l’étape précédente de copie du fichier pourrait être détectée par le **cache Docker**, cette étape va aussi **utiliser le cache Docker** lorsqu’il est disponible.
-
-    Utiliser le cache à cette étape va vous **faire gagner** beaucoup de **temps** lorsque vous reconstruisez 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 **près de la fin** du `Dockerfile`, pour optimiser les temps de build de l’image de conteneur.
-
-6. Définir la **commande** pour utiliser `fastapi run`, qui utilise Uvicorn en dessous.
-
-    `CMD` prend une liste de chaînes de caractères, 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 depuis le **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 s’écrire sous deux formes :
-
-✅ Forme **exec** :
-
-```Dockerfile
-# ✅ Do this
-CMD ["fastapi", "run", "app/main.py", "--port", "80"]
-```
-
-⛔️ Forme **shell** :
-
-```Dockerfile
-# ⛔️ Don't do this
-CMD fastapi run app/main.py --port 80
-```
-
-Vous devez vous assurer de toujours utiliser la forme **exec** pour garantir que FastAPI puisse s’arrêter proprement et que les [événements de lifespan](../advanced/events.md){.internal-link target=_blank} soient déclenchés.
-
-Vous pouvez en lire plus à ce sujet 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 assez visible lors de l’utilisation de `docker compose`. Consultez 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">Why do my services take 10 seconds to recreate or stop?</a>.
-
-#### Structure de répertoires { #directory-structure }
-
-Vous devriez maintenant avoir une structure de répertoires 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 }
-
-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. Je vais 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 par-dessus 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 aussi 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 copier le fichier à nouveau et de créer une nouvelle couche à partir de zéro.
-
-Le simple fait d’éviter la copie de fichiers n’améliore pas forcément beaucoup les choses, mais comme le cache a été utilisé pour cette étape, il peut **être utilisé pour l’étape suivante**. Par exemple, il pourrait être utilisé pour l’instruction qui installe les dépendances avec :
-
-```Dockerfile
-RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
-```
-
-Le fichier des exigences de packages **ne changera pas fréquemment**. Donc, en ne copiant que 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 d’attendre. 😪😆
-
-Le téléchargement et l’installation des dépendances de packages **peuvent prendre des minutes**, mais utiliser le **cache** **prendrait au maximum quelques secondes**.
-
-Et comme vous reconstruiriez l’image de conteneur encore et encore pendant le développement pour vérifier que vos modifications de code fonctionnent, cela vous ferait gagner beaucoup de temps cumulé.
-
-Ensuite, près de la fin du `Dockerfile`, nous copions tout le code. Comme c’est ce qui **change le plus fréquemment**, nous le mettons près de la fin, car presque toujours, tout ce qui vient après 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.
+## Construire l'image Docker
 
 * Allez dans le répertoire du projet (dans lequel se trouve votre `Dockerfile`, contenant votre répertoire `app`).
 * Construisez votre image FastAPI :
@@ -332,17 +109,9 @@ $ docker build -t myimage .
 
 </div>
 
-/// tip | Astuce
+## Démarrer le conteneur Docker
 
-Remarquez le `.` à la fin, il est é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">
 
@@ -352,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 de l’API alternative { #alternative-api-docs }
+## Documentation de l'API alternative
 
 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 dans un seul 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.
 
-Ensuite, vous n’auriez qu’à modifier 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 aucun répertoire `./app`).
-
-2. Utiliser `fastapi run` pour servir votre application dans le fichier unique `main.py`.
-
-Quand vous passez le fichier à `fastapi run`, il détectera automatiquement qu’il s’agit d’un fichier unique et non d’une partie 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 avant de démarrer
-
-## HTTPS { #https }
-
-Si nous nous concentrons uniquement sur l’**image de conteneur** d’une application FastAPI (et plus tard sur le **conteneur** en cours d’exécution), HTTPS serait normalement géré **en externe** 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** de **certificats**.
-
-/// tip | Astuce
-
-Traefik dispose d’intégrations avec Docker, Kubernetes et d’autres, il est donc très simple à mettre en place et à configurer pour HTTPS avec vos conteneurs.
-
-///
-
-Alternativement, HTTPS pourrait être géré par un fournisseur cloud comme l’un de ses 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 tous) les cas, 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 en ligne de commande `--restart`.
-
-Sans utiliser de conteneurs, faire exécuter des applications au démarrage et avec redémarrages peut être contraignant 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 travailler ensemble d’une certaine façon.">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** au lieu d’utiliser un **gestionnaire de processus** (comme Uvicorn avec des workers) dans chaque conteneur.
-
-Un de ces systèmes de gestion de conteneurs distribués comme Kubernetes dispose normalement d’un moyen intégré de gérer la **réplication des conteneurs** tout en prenant en charge l’**équilibrage de charge** pour les 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), installer vos dépendances, et exécuter **un seul processus Uvicorn** au lieu d’utiliser plusieurs workers Uvicorn.
-
-### Load Balancer { #load-balancer }
-
-Lors de l’utilisation de conteneurs, vous aurez normalement un composant **à l’écoute sur le port principal**. Cela pourrait éventuellement être un autre conteneur qui est aussi un **proxy de terminaison TLS** pour gérer **HTTPS** ou un outil similaire.
-
-Comme ce composant prendrait la **charge** des requêtes et la distribuerait entre les workers d’une manière (espérons-le) **équilibrée**, on l’appelle aussi communément un **Load Balancer**.
-
-/// tip | Astuce
-
-Le même composant de **proxy de terminaison TLS** utilisé pour HTTPS serait probablement aussi un **Load Balancer**.
-
-///
-
-Et en travaillant avec des conteneurs, le même système que vous utilisez pour les démarrer et les gérer aura déjà des outils internes pour transmettre la **communication réseau** (par exemple les requêtes HTTP) depuis ce **load balancer** (qui pourrait aussi être un **proxy de terminaison TLS**) vers le(s) conteneur(s) avec votre application.
-
-### Un load balancer - Plusieurs conteneurs workers { #one-load-balancer-multiple-worker-containers }
-
-En travaillant avec **Kubernetes** ou des systèmes distribués de gestion de conteneurs similaires, utiliser leurs mécanismes réseau internes permettrait au **load balancer** unique qui écoute sur le **port** principal de transmettre la communication (les requêtes) à potentiellement **plusieurs conteneurs** exécutant votre application.
-
-Chacun de ces conteneurs exécutant votre application aurait normalement **un seul processus** (par exemple un processus Uvicorn exécutant votre application FastAPI). Ce seraient tous des **conteneurs identiques**, exécutant la même chose, mais chacun avec son propre processus, sa mémoire, etc. Ainsi, vous profiteriez de la **parallélisation** sur **différents cœurs** du CPU, ou même sur **différentes machines**.
-
-Et le système de conteneurs distribués avec le **load balancer** **distribuerait les requêtes** à chacun des conteneurs avec 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 ce **load balancer** serait capable de gérer des requêtes allant vers *d’autres* applications dans votre cluster (par exemple vers un domaine différent, ou sous un préfixe de chemin d’URL différent), et transmettrait 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 en 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) ne ferait qu’ajouter une **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 workers Uvicorn** à l’intérieur.
-
-Dans ces cas, vous pouvez utiliser l’option en 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 en 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 pouvoir 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**, et vous n’auriez donc 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** démarrant **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.
 
 ---
 
-Le point principal est que **rien** de tout cela n’est une **règle gravée dans le marbre** que vous devez suivre aveuglément. Vous pouvez utiliser ces idées pour **évaluer votre propre cas d’usage** et décider quelle est la meilleure approche pour votre système, en examinant comment gérer les concepts de :
+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 avant de démarrer
+## 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 plus ou moins bien définie, stable, et limitée consommée par chacun de ces conteneurs (plus d’un si vous les répliquez).
+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.
 
-Et ensuite, vous pouvez 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**). Ainsi, il pourra **répliquer les conteneurs** sur les **machines disponibles** en tenant compte de la quantité de mémoire nécessaire 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**, ce ne sera probablement **pas un problème**, et vous pourriez ne pas avoir besoin de spécifier des limites strictes de mémoire. Mais si vous **utilisez beaucoup de mémoire** (par exemple avec des modèles de **machine learning**), vous devriez vérifier la quantité de mémoire consommée 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 avant de démarrer 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 exemple 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**), vous voudrez probablement avoir un **conteneur séparé** pour effectuer le travail des **étapes préalables** dans un conteneur unique, exécutant un seul processus, **avant** d’exécuter les conteneurs workers répliqués.
-
-/// info
-
-Si vous utilisez Kubernetes, ce serait 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 des migrations de base de données, mais vérifiez simplement si la base de données est prête), alors vous pourriez aussi les placer dans chaque conteneur juste avant de démarrer le processus principal.
-
-### Conteneur unique { #single-container }
-
-Si vous avez une configuration simple, avec un **conteneur unique** qui démarre ensuite plusieurs **processus worker** (ou aussi juste un processus), alors vous pourriez 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 FastAPI officielle : <a href="https://github.com/tiangolo/uvicorn-gunicorn-fastapi-docker" class="external-link" target="_blank">tiangolo/uvicorn-gunicorn-fastapi</a>. Mais elle est maintenant dépréciée. ⛔️
-
-Vous ne devriez probablement **pas** utiliser cette image Docker de base (ni une autre similaire).
-
-Si vous utilisez **Kubernetes** (ou d’autres) et que vous définissez déjà la **réplication** au niveau du cluster, avec plusieurs **conteneurs**. Dans ces cas, il vaut mieux **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 en ligne de commande `--workers`.
-
-/// note | Détails techniques
-
-L’image Docker a été créée à une époque où Uvicorn ne prenait pas en charge la gestion et le redémarrage des workers morts, il était donc nécessaire d’utiliser Gunicorn avec Uvicorn, ce qui ajoutait pas mal de complexité, simplement pour que Gunicorn gère et redémarre les processus workers Uvicorn.
-
-Mais maintenant qu’Uvicorn (et la commande `fastapi`) prennent en charge l’utilisation de `--workers`, il n’y a aucune 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 en mode Docker Swarm
-* 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 uv</a>.
-
-## Récapitulatif { #recap }
-
-En utilisant des 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 avant de démarrer
-
-Dans la plupart des cas, vous ne voudrez probablement pas utiliser une image de base, et vous voudrez plutôt **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 build**, afin de maximiser votre productivité (et d’é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 bien plus complexe que cela.
+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 de 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 à garder à l'esprit en pensant à HTTPS :
+Maintenant, du point de vue d'un développeur, voici plusieurs choses à avoir en tête en pensant au HTTPS :
 
-* Pour HTTPS, **le serveur** doit **avoir des « 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**.
-    * Et ensuite ils doivent être **renouvelés**, **acquis à nouveau** auprès de la tierce partie.
-* Le chiffrement de la connexion se fait au **niveau TCP**.
-    * C'est une couche **en dessous de HTTP**.
-    * Donc, la gestion du **certificat et du chiffrement** est faite **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 chiffrement se font au niveau TCP, **avant de savoir** quel domaine est traité.
-* **Par défaut**, cela signifierait que vous ne pouvez avoir qu'**un seul certificat HTTPS par adresse IP**.
-    * Peu importe la taille de votre serveur ou à quel point chaque application que vous avez dessus peut être petite.
-    * Il existe cependant une **solution** à ce problème.
-* Il existe une **extension** du protocole **TLS** (celui qui gère le chiffrement 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** avoir obtenu une connexion sécurisée, le protocole de communication est **toujours HTTP**.
-    * Le contenu est **chiffré**, 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>.
 
-Certaines des options que vous pouvez utiliser comme Proxy de terminaison TLS sont :
+## Let's Encrypt
 
-* Traefik (qui peut aussi gérer les renouvellements de certificats)
-* Caddy (qui peut aussi gérer les renouvellements de certificats)
-* Nginx
-* HAProxy
-
-## Let's Encrypt { #lets-encrypt }
-
-Avant Let's Encrypt, ces **certificats HTTPS** étaient vendus par des tiers de confiance.
+Avant Let's Encrypt, ces certificats HTTPS étaient vendus par des tiers de confiance.
 
 Le processus d'acquisition d'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éé.
+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 Linux Foundation. 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, pour toujours**.
-
-## HTTPS pour les développeurs { #https-for-developers }
-
-Voici un exemple de ce à quoi une API HTTPS pourrait ressembler, étape par étape, en faisant attention principalement aux idées importantes pour les développeurs.
-
-### Nom de domaine { #domain-name }
-
-Cela commencerait probablement par le fait que vous **acquérez** un **nom de domaine**. Ensuite, vous le configureriez dans un serveur DNS (éventuellement votre même 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="That doesn't change - Qui ne change pas">fixed</abbr>.
-
-Dans le(s) serveur(s) 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, lorsque vous mettez tout en place.
-
-/// tip | Astuce
-
-Cette partie « nom de domaine » se situe bien avant HTTPS, mais comme tout dépend du domaine et de l'adresse IP, cela vaut la peine de le mentionner ici.
-
-///
-
-### DNS { #dns }
-
-Maintenant, concentrons-nous 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 diraient au navigateur d'utiliser une **adresse IP** spécifique. Ce serait l'adresse IP publique utilisée par votre serveur, que vous avez configurée dans les serveurs DNS.
-
-<img src="/img/deployment/https/https01.drawio.svg">
-
-### Début du handshake TLS { #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 le **handshake TLS**.
-
-### TLS avec l'extension SNI { #tls-with-sni-extension }
-
-**Un seul process** sur le serveur peut écouter sur un **port** spécifique sur une **adresse IP** spécifique. Il peut y avoir d'autres process écoutant sur d'autres ports sur 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`. Donc c'est ce port dont nous avons besoin.
-
-Comme un seul process peut écouter sur ce port, le process 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 ci-dessus, le Proxy de terminaison TLS vérifierait lequel des certificats TLS (HTTPS) disponibles il doit utiliser pour cette connexion, en utilisant 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 verrons cela 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 complète la partie **Handshake TLS**.
-
-Après cela, le client et le serveur ont une **connexion TCP chiffrée**, c'est ce que fournit TLS. Et ensuite ils peuvent utiliser cette connexion pour démarrer la véritable **communication HTTP**.
-
-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
-
-Notez que le chiffrement 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**. Il s'agit simplement d'une requête HTTP via 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 process exécutant l'application (par exemple un process 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 ensuite 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'il utilise la cryptographie qu'ils ont convenue en utilisant le **certificat HTTPS** auparavant.
-
-### 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 process peut gérer la combinaison spécifique d'IP et de port (le Proxy de terminaison TLS dans notre exemple) mais les autres applications/process peuvent également s'exécuter sur le(s) serveur(s), tant qu'ils n'essaient pas d'utiliser la même **combinaison d'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).
-
-Et ensuite, il y aurait un autre programme (dans certains cas c'est un autre programme, dans certains cas cela pourrait être le même Proxy de terminaison TLS) qui parlerait à Let's Encrypt, et renouvellerait le(s) certificat(s).
-
-<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 effectivement ce domaine**.
-
-Pour ce faire, et pour répondre à différents besoins applicatifs, il existe plusieurs façons de procéder. Voici quelques méthodes populaires :
-
-* **Modifier certains enregistrements DNS**.
-    * Pour cela, le programme de renouvellement doit prendre en charge les API du fournisseur DNS, donc, selon le fournisseur DNS que vous utilisez, cela peut ou non être 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 ci-dessus, un seul process peut écouter sur une 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 s'occupe aussi du processus de renouvellement des certificats.
-    * Sinon, vous devrez peut-être arrêter momentanément le Proxy de terminaison TLS, 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 app(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 de servir l'app, est l'une des principales raisons pour lesquelles vous voulez avoir un **système séparé pour gérer HTTPS** avec un Proxy de terminaison TLS au lieu de simplement utiliser les certificats TLS directement avec le serveur d'application (par ex. Uvicorn).
-
-## En-têtes de proxy transférés { #proxy-forwarded-headers }
-
-Lorsque vous utilisez un proxy pour gérer HTTPS, votre **serveur d'application** (par exemple Uvicorn via la FastAPI CLI) ne sait 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 indiquer au serveur d'application que la requête est **transférée** 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 est 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 faire confiance aux en-têtes *forwarded* envoyés par le **proxy**. Si vous utilisez la FastAPI CLI, vous pouvez utiliser l'*option CLI* `--forwarded-allow-ips` pour lui indiquer depuis quelles IP il doit faire confiance à ces en-têtes *forwarded*.
-
-Par exemple, si le **serveur d'application** ne reçoit la communication que du **proxy** de confiance, vous pouvez le définir sur `--forwarded-allow-ips="*"` pour lui faire confiance pour toutes les IP entrantes, car il ne recevra des requêtes que depuis l'adresse IP utilisée par le **proxy**.
-
-De cette façon, l'application serait capable de connaître sa propre URL publique, si elle utilise HTTPS, le domaine, etc.
-
-Ce serait utile par exemple pour gérer correctement les redirections.
-
-/// tip | Astuce
-
-Vous pouvez en apprendre davantage à ce sujet dans la documentation pour [Derrière un proxy - Activer les en-têtes Proxy Forwarded](../advanced/behind-a-proxy.md#enable-proxy-forwarded-headers){.internal-link target=_blank}
-
-///
-
-## Récapitulatif { #recap }
-
-Avoir **HTTPS** est très important, et assez **critique** dans la plupart des cas. La plupart des efforts que vous, en tant que développeur, devez fournir autour de HTTPS consistent simplement à **comprendre ces concepts** et comment ils fonctionnent.
-
-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 de manière simple.
-
-Dans certains des prochains chapitres, je vais vous montrer 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,23 +1,28 @@
-# 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**.
+**Déployer** une application signifie effectuer les étapes nécessaires pour la rendre **disponible pour les
+utilisateurs**.
 
-Pour une **API Web**, cela implique normalement de la placer sur une **machine distante**, avec un **programme serveur** qui offre de bonnes performances, une bonne stabilité, etc, afin que vos **utilisateurs** puissent **accéder** à l'application efficacement et sans interruption ni problème.
+Pour une **API Web**, cela implique normalement de la placer sur une **machine distante**, avec un **programme serveur**
+qui offre de bonnes performances, une bonne stabilité, _etc._, afin que vos **utilisateurs** puissent **accéder** à
+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.
+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.
+Il existe plusieurs façons de procéder, en fonction de votre cas d'utilisation spécifique et des outils que vous
+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.
+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>, afin de rendre le déploiement d'apps FastAPI sur le cloud aussi rationalisé que possible, avec la même expérience développeur que celle du travail 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).
+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).
 
 Vous verrez plus de détails à avoir en tête et certaines des techniques pour le faire dans les sections suivantes. ✨

docs/fr/docs/deployment/versions.md

@@ -1,78 +1,85 @@
-# À 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 systèmes. Et la couverture de test 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 continue de s’améliorer en continu.
+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 peut potentiellement introduire des changements incompatibles. Cela suit les conventions du <a href="https://semver.org/" class="external-link" target="_blank">Semantic Versioning</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 simplement vous assurer que vous utilisez une version qui fonctionne correctement avec le reste de votre code.
+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.
 
-## Épinglez votre version de `fastapi` { #pin-your-fastapi-version }
+## Épinglez votre version de `fastapi`
 
-La première chose que vous devez faire est d’« épingler » la version de **FastAPI** que vous utilisez à la version spécifique la plus récente 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 app.
+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
 ```
 
-cela 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 (p. ex. pour vérifier quelle est la dernière version actuelle) dans les [Notes de version](../release-notes.md){.internal-link target=_blank}.
-
-## À propos des versions { #about-versions }
-
-En suivant les conventions du Semantic Versioning, toute version inférieure à `1.0.0` peut potentiellement ajouter des changements incompatibles.
-
-FastAPI suit également la convention selon laquelle tout changement de version « PATCH » concerne des corrections de bogues et des changements compatibles.
-
-/// tip | Astuce
-
-Le « PATCH » est le dernier chiffre, par exemple, dans `0.2.3`, la version PATCH est `3`.
-
-///
-
-Ainsi, vous devriez pouvoir épingler une version comme suit :
+Ou vous pourriez aussi l'épingler avec :
 
 ```txt
 fastapi>=0.45.0,<0.46.0
 ```
 
-Les changements incompatibles 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 app.
+```txt
+fastapi>=0.45.0,<0.46.0
+```
 
-Avec **FastAPI**, c’est très facile (grâce à Starlette), consultez la documentation : [Testing](../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 alors 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 }
+///
+
+## 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`.
 
@@ -80,14 +87,15 @@ Différentes versions de **FastAPI** utiliseront une version spécifique plus r
 
 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</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>
 
@@ -41,124 +41,120 @@ Les principales fonctionnalités sont :
 * **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 les documents.
+* **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 Keystone { #keystone-sponsor }
-
-{% for sponsor in sponsors.keystone -%}
-<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
-{% endfor -%}
-
-### Sponsors Gold et Silver { #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
 
-"_[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products._"
+"_[...] 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>
 
 ---
 
-"_We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for 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, and 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** is pleased to announce the open-source release of our **crisis management** orchestration framework: **Dispatch**! [built with **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>
 
 ---
 
-"_I’m over the moon excited about **FastAPI**. It’s so fun!_"
+"_Je suis très enthousiaste à propos de **FastAPI**. C'est un bonheur !_"
 
-<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong><a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a> podcast host</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>
 
 ---
 
-"_Honestly, what you've built looks super solid and polished. In many ways, it's what I wanted **Hug** to be - it's really inspiring to see someone build that._"
+"_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><a href="https://github.com/hugapi/hug" target="_blank">Hug</a> creator</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>
 
 ---
 
-"_If you're looking to learn one **modern framework** for building REST APIs, check out **FastAPI** [...] It's fast, easy to use and easy to learn [...]_"
+"_Si vous cherchez à apprendre un **framework moderne** pour créer des APIs REST, regardez **FastAPI** [...] C'est rapide, facile à utiliser et à apprendre [...]_"
 
-"_We've switched over to **FastAPI** for our **APIs** [...] I think you'll like it [...]_"
+"_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><a href="https://explosion.ai" target="_blank">Explosion AI</a> founders - <a href="https://spacy.io" target="_blank">spaCy</a> creators</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>
+<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>
 
 ---
 
-"_If anyone is looking to build a production Python API, I would highly recommend **FastAPI**. It is **beautifully designed**, **simple to use** and **highly scalable**, it has become a **key component** in our API first development strategy and is driving many automations and services such as our Virtual TAC Engineer._"
+"_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 }
-
-Il existe un <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">mini-documentaire FastAPI</a> sorti à la fin de 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 <abbr title="Command Line Interface">CLI</abbr> { #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">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>.
+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 <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 mettre `"fastapi[standard]"` entre guillemets pour vous assurer 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éez-le { #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
@@ -179,7 +175,7 @@ def read_item(item_id: int, q: Union[str, None] = None):
 ```
 
 <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` :
 
@@ -201,37 +197,24 @@ 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 _« In a hurry? »_ à propos de <a href="https://fastapi.tiangolo.com/fr/async/#in-a-hurry" target="_blank">`async` et `await` dans les documents</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>
 
-### Lancez-le { #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.
 ```
@@ -239,21 +222,21 @@ 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'app **FastAPI** qu'il contient et démarre un serveur en utilisant <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 l'auto-reload activé pour le développement local.
-
-Vous pouvez en savoir plus dans <a href="https://fastapi.tiangolo.com/fr/fastapi-cli/" target="_blank">la documentation de FastAPI CLI</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érifiez-le { #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 comme suit :
+Vous obtenez alors cette réponse <abbr title="JavaScript Object Notation">JSON</abbr> :
 
 ```JSON
 {"item_id": 5, "q": "somequery"}
@@ -263,10 +246,10 @@ Vous venez de créer une API qui :
 
 * 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 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`.
+* 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>.
 
@@ -274,17 +257,17 @@ 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 automatique alternative (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é
 
-Maintenant, modifiez le fichier `main.py` pour recevoir un corps à partir d'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 ce corps en utilisant les types Python standards, grâce à Pydantic.
 
@@ -318,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 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.
 
@@ -368,48 +351,48 @@ item: Item
 
 ... et avec cette déclaration unique, vous obtenez :
 
-* Une assistance dans votre éditeur, notamment :
+* 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="also known as: serialization, parsing, marshalling">Conversion</abbr> des données d'entrée : venant du réseau et allant vers les données et types de Python. Lecture de :
-    * JSON.
-    * Les paramètres de chemin.
-    * Les paramètres de requête.
-    * Les cookies.
-    * Les en-têtes.
-    * Les formulaires.
-    * Les fichiers.
-* <abbr title="also known as: 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) :
-    * Convertir les types Python (`str`, `int`, `float`, `bool`, `list`, etc).
+    * 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, incluant 2 interfaces utilisateur alternatives :
+* 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 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 qu'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`.
-    * Puisque le paramètre `q` est déclaré avec `= None`, il est optionnel.
-    * Sans le `None`, il serait nécessaire (comme l'est le corps dans le cas du `PUT`).
-* Pour les requêtes `PUT` vers `/items/{item_id}`, lire le corps en JSON :
+    * 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 `price` qui doit être un `float`.
+    * 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 JSON profondément imbriqués.
-* Convertir automatiquement depuis et vers JSON.
+    * 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 interactive.
+    * 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.
 
@@ -437,129 +420,53 @@ Essayez de changer la ligne contenant :
 
 ... 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>.
 
 **Spoiler alert** : le tutoriel - guide utilisateur inclut :
 
-* Déclaration de **paramètres** provenant d'autres endroits différents 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="also known as components, resources, providers, services, injectables">Dependency Injection</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).
+* 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.
-* De nombreuses fonctionnalités supplémentaires (grâce à Starlette) comme :
+* D'obtenir de nombreuses fonctionnalités supplémentaires (grâce à  Starlette) comme :
     * **WebSockets**
-    * des tests extrêmement simples 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 app (optionnel) { #deploy-your-app-optional }
+## Performance
 
-Vous pouvez éventuellement déployer votre app 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 commande.
-
-Avant de déployer, assurez-vous que vous êtes connecté :
-
-<div class="termy">
-
-```console
-$ fastapi login
-
-You are logged in to FastAPI Cloud 🚀
-```
-
-</div>
-
-Puis déployez votre app :
-
-<div class="termy">
-
-```console
-$ fastapi deploy
-
-Deploying to FastAPI Cloud...
-
-✅ Deployment successful!
-
-🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
-```
-
-</div>
-
-C'est tout ! Vous pouvez maintenant accéder à votre app à 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 rationalise 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 construction d'apps avec FastAPI au **déploiement** dans le cloud. 🎉
-
-FastAPI Cloud est le sponsor principal et le fournisseur de financement 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 normes. Vous pouvez déployer des apps FastAPI sur n'importe quel fournisseur cloud de votre choix.
-
-Suivez les guides de votre fournisseur cloud pour y déployer des apps 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 disponibles 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 de Starlette.
-
-### Dépendances `standard` { #standard-dependencies }
-
-Quand vous installez FastAPI avec `pip install "fastapi[standard]"`, il est fourni avec le groupe `standard` de dépendances optionnelles :
-
-Utilisées par Pydantic :
+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 email.
 
 Utilisées par Starlette :
 
-* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Obligatoire si vous souhaitez utiliser `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 supporter le <abbr title="conversion de la chaîne qui provient d'une requête HTTP en données Python">« parsing »</abbr> de formulaire, 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 :
-
-* <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 inclut certaines dépendances (par exemple `uvloop`) nécessaires pour un service à 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 voulez 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 voulez 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 y a quelques dépendances supplémentaires que vous pourriez vouloir installer.
-
-Dépendances optionnelles Pydantic supplémentaires :
-
-* <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 les types supplémentaires à utiliser avec Pydantic.
-
-Dépendances optionnelles FastAPI supplémentaires :
+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.
 * <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 voulez utiliser `UJSONResponse`.
+* <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 fournis 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 commencer, car il inclut déjà une grande partie de la configuration initiale, de la sécurité, de la base de données et certains endpoints d’API déjà faits 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 - Stack 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’une stack frontend moderne.
-  - 🎨 [Tailwind CSS](https://tailwindcss.com) et [shadcn/ui](https://ui.shadcn.com) pour les composants du frontend.
-  - 🤖 Un client frontend généré automatiquement.
-  - 🧪 [Playwright](https://playwright.dev) pour les tests End-to-End.
-  - 🦇 Prise en charge du mode sombre.
-- 🐋 [Docker Compose](https://www.docker.com) pour le développement et la production.
-- 🔒 Hashage sécurisé des mots de passe par défaut.
-- 🔑 Authentification JWT (JSON Web Token).
-- 📫 Récupération du mot de passe par e-mail.
-- ✅ Tests avec [Pytest](https://pytest.org).
-- 📞 [Traefik](https://traefik.io) comme reverse proxy / load balancer.
-- 🚢 Instructions de déploiement utilisant Docker Compose, y compris comment configurer un proxy Traefik frontend pour gérer des certificats HTTPS automatiques.
-- 🏭 CI (intégration continue) et CD (déploiement continu) basées 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 supporte des « type hints » optionnels (aussi appelés « type annotations »).
+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 des types pour vos variables, les éditeurs et les 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 n'est qu'un **tutoriel rapide / rappel** sur les « type hints » de Python. Il couvre seulement 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 entièrement basé sur ces « type hints », ils 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 « type hints », 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*}
 
-L'exécution de 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()`.
-* Les <abbr title="Puts them together, as one. With the contents of one after the other.">concatène</abbr> 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] *}
 
-### Le modifier { #edit-it }
+### Limitations
 
 C'est un programme très simple.
 
-Mais imaginez maintenant que vous l'écriviez de zéro.
+Mais maintenant imaginez que vous l'écriviez de zéro.
 
-À un certain point, 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` ?
 
-Ensuite, vous essayez avec le vieil ami du programmeur, 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+Space` pour déclencher la complé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,11 +78,11 @@ Nous allons changer exactement ce fragment, les paramètres de la fonction, de :
 
 C'est tout.
 
-Ce sont les « type hints » :
+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, comme ce serait le cas avec :
+À ne pas confondre avec la déclaration de valeurs par défaut comme ici :
 
 ```Python
     first_name="john", last_name="doe"
@@ -88,377 +90,210 @@ Ce n'est pas la même chose que de déclarer des valeurs par défaut, comme ce s
 
 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 « type hints » ne change normalement pas ce qui se passe par rapport à ce qui se passerait sans eux.
+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 plein milieu de la création de cette fonction, mais avec des « type hints ».
+Maintenant, imaginez que vous êtes en train de créer cette fonction, mais avec des annotations de type cette fois.
 
-Au même endroit, vous essayez de déclencher l'autocomplétion avec `Ctrl+Space` 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 ça, vous pouvez faire défiler, voir 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 « type hints » :
+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] *}
 
-Parce que l'éditeur connaît les types des variables, vous n'avez pas seulement la complétion, vous avez 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">
 
-Maintenant vous savez que vous devez le corriger, convertir `age` en chaîne de caractères 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 « type hints ». En tant que paramètres de fonction.
+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 utiliseriez 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 des paramètres de type { #generic-types-with-type-parameters }
+### Types génériques avec des paramètres de types
 
-Il existe des 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 des types « génériques » (**generic**). 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 supporter ces « type hints ».
+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** offrent un support amélioré 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 déclarer les annotations de type.
+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 (quand 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 version la plus récente, ceux-ci 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 (`[`, `]`) :
 
-#### List { #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, avec la même syntaxe de 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, vous les mettez entre crochets :
-
-{* ../../docs_src/python_types/tutorial006_py39.py hl[1] *}
-
-/// info
-
-Ces types internes entre crochets sont appelés des « 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 fournir du support 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 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 du support pour ça.
+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 élément).
-    * Les valeurs de ce `dict` sont de type `float` (disons, le prix de chaque élément).
+#### `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] *}
 
-En 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`.
 
-En Python 3.10, il existe aussi une **nouvelle syntaxe** où vous pouvez mettre les types possibles séparés par une <abbr title='also called "bitwise or operator", but that meaning is not relevant here'>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` pourrait être un `int` ou un `str`.
-
-#### Possiblement `None` { #possibly-none }
-
-Vous pouvez déclarer qu'une valeur pourrait avoir un type, comme `str`, mais qu'elle pourrait aussi être `None`.
-
-En 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 seulement `str` permettra à l'éditeur de vous aider à détecter des erreurs où vous pourriez supposer qu'une valeur est toujours un `str`, alors qu'elle pourrait aussi être `None`.
-
-`Optional[Something]` est en fait un raccourci pour `Union[Something, None]`, ils sont équivalents.
-
-Cela signifie aussi qu'en 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 | Alternative Python 3.9+
-
-```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 une astuce de mon point de vue très **subjectif** :
-
-* 🚨 Évitez d'utiliser `Optional[SomeType]`
-* À la place ✨ **utilisez `Union[SomeType, None]`** ✨.
-
-Les deux sont équivalents et, en dessous, c'est la même chose, mais je recommande `Union` plutôt que `Optional` parce que le mot « optional » semblerait impliquer que la valeur est optionnelle, et cela signifie en réalité « elle peut être `None` », même si elle n'est pas optionnelle et est toujours requise.
-
-Je pense que `Union[SomeType, None]` est plus explicite sur ce que cela signifie.
-
-Ce n'est qu'une question de mots et de noms. Mais ces mots peuvent affecter la façon 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 optionnel**, vous ne pouvez pas appeler la fonction sans le paramètre :
-
-```Python
-say_hi()  # Oh, no, this throws an error! 😱
-```
-
-Le paramètre `name` est **toujours requis** (pas *optionnel*) parce qu'il n'a pas de valeur par défaut. Pourtant, `name` accepte `None` comme valeur :
-
-```Python
-say_hi(name=None)  # This works, None is valid 🎉
-```
-
-La bonne nouvelle est qu'une fois que vous serez sur Python 3.10, vous n'aurez 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 ensuite 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 **Generic types** ou **Generics**, par exemple :
-
-//// tab | Python 3.10+
-
-Vous pouvez utiliser les mêmes types intégrés comme generics (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.
 
-En Python 3.10, comme alternative à l'utilisation des generics `Union` et `Optional`, vous pouvez utiliser la <abbr title='also called "bitwise or operator", but that meaning is not relevant here'>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 generics (avec des crochets et des types à l'intérieur) :
-
-* `list`
-* `tuple`
-* `set`
-* `dict`
-
-Et des generics 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 alors, encore une fois, 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 que « `one_person` est une **instance** de la classe `Person` ».
-
-Cela ne signifie pas que « `one_person` est la **classe** appelée `Person` ».
-
-## Les 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 comme des 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é (si c'est le cas) 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 des documents officiels 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 sur <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 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 plus à ce sujet dans la documentation Pydantic sur les <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Required Optional fields</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 :
 
-## Type Hints avec des annotations de métadonnées { #type-hints-with-metadata-annotations }
+* **du support de l'éditeur**
+* **de la vérification de types**
 
-Python a aussi une fonctionnalité qui permet de mettre des **<abbr title="Data about the data, in this case, information about the type, e.g. a description.">métadonnées</abbr> supplémentaires** dans ces « type hints » 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 d'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 manière dont vous voulez que votre application se comporte.
-
-La chose importante à retenir est que **le premier *paramètre de type*** que vous passez à `Annotated` est le **vrai type**. Le reste n'est que des métadonnées pour d'autres outils.
-
-Pour le moment, vous devez juste 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 aurez toujours 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. 🚀
-
-///
-
-## Les annotations de type dans **FastAPI** { #type-hints-in-fastapi }
-
-**FastAPI** tire parti de ces « type hints » pour faire plusieurs choses.
-
-Avec **FastAPI** vous déclarez des paramètres avec des « type hints » et vous obtenez :
-
-* **Support de l'éditeur**.
-* **Vérifications de types**.
-
-... et **FastAPI** utilise les mêmes déclarations pour :
-
-* **Définir des exigences** : à 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 les données** : de la requête vers le type requis.
-* **Valider les données** : provenant de chaque requête :
-    * Générant des **erreurs automatiques** renvoyées au client lorsque les données sont invalides.
+* **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 automatiques de documentation interactive.
+    * 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, à 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 que vous ê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">la « cheat sheet » 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,86 +1,84 @@
-# 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 à exécuter *après* avoir renvoyé une réponse.
+Vous pouvez définir des tâches d'arrière-plan qui seront exécutées après avoir retourné une réponse.
 
-Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais pour lesquelles le client n'a pas réellement besoin d'attendre que l'opération se termine avant de recevoir la réponse.
+Ceci est utile pour les opérations qui doivent avoir lieu après une requête, mais où le client n'a pas réellement besoin d'attendre que l'opération soit terminée pour recevoir une réponse.
 
 Cela comprend, par exemple :
 
 * Les notifications par email envoyées après l'exécution d'une action :
-    * Comme se connecter à un serveur email et envoyer un email a tendance à être « lent » (plusieurs secondes), vous pouvez renvoyer la réponse immédiatement et envoyer la notification par email en arrière-plan.
-* Le traitement de données :
-    * Par exemple, disons que vous recevez un fichier qui doit passer par un traitement lent, vous pouvez renvoyer une réponse « Accepted » (HTTP 202) et traiter le fichier 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.
 
-## Utiliser `BackgroundTasks` { #using-backgroundtasks }
 
-Pour commencer, importez `BackgroundTasks` et définissez un paramètre dans votre *fonction de chemin d'accès* avec une déclaration de type `BackgroundTasks` :
+## 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
 
-Créez une fonction à exécuter comme tâche d'arrière-plan.
+Une fonction à exécuter comme tâche d'arrière-plan est juste une fonction standard qui peut recevoir des paramètres.
 
-C'est simplement une fonction standard qui peut recevoir des paramètres.
+Elle peut être une fonction asynchrone (`async def`) ou une fonction normale (`def`), **FastAPI** saura la gérer correctement.
 
-Elle peut être une fonction `async def` ou une fonction `def` normale, **FastAPI** saura la gérer correctement.
+Dans cet exemple, la fonction de tâche écrira dans un fichier (afin de simuler un envoi d'email).
 
-Dans ce cas, la fonction de tâche écrira dans un fichier (en simulant l'envoi d'un email).
+L'opération d'écriture n'utilisant ni `async` ni `await`, on définit la fonction avec un `def` normal.
 
-Et comme l'opération d'écriture n'utilise pas `async` et `await`, nous définissons la fonction avec un `def` normal :
+{* ../../docs_src/background_tasks/tutorial001.py hl[6:9] *}
 
-{* ../../docs_src/background_tasks/tutorial001_py39.py hl[6:9] *}
+## Ajouter une tâche d'arrière-plan
 
-## Ajouter la tâche d'arrière-plan { #add-the-background-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()` :
 
-À l'intérieur de votre *fonction de chemin d'accès*, passez votre fonction de tâche à l'objet de type *background tasks* avec 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 :
 
 * Une fonction de tâche à exécuter en arrière-plan (`write_notification`).
-* N'importe quelle séquence d'arguments qui doit être passée à la fonction de tâche dans l'ordre (`email`).
-* N'importe quels arguments nommés qui doivent être passés à la fonction de tâche (`message="some notification"`).
+* 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` à plusieurs 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, de sorte que toutes les tâches d'arrière-plan sont fusionnées et exécutées ensuite 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.py hl[13,15,22,25] *}
 
-{* ../../docs_src/background_tasks/tutorial002_an_py310.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 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.
 
-Dans cet exemple, les messages seront écrits dans le fichier `log.txt` *après* que la réponse est envoyée.
+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`.
 
-S'il y avait une query dans la requête, elle sera écrite dans le log via une tâche d'arrière-plan.
-
-Et ensuite une autre tâche d'arrière-plan générée au niveau de la *fonction de chemin d'accès* écrira un message en utilisant 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 afin que vous puissiez l'importer depuis `fastapi` et éviter d'importer accidentellement l'alternative `BackgroundTask` (sans le `s` à la fin) depuis `starlette.background`.
+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 uniquement `BackgroundTasks` (et non `BackgroundTask`), il est alors possible de l'utiliser comme paramètre de *fonction de chemin d'accès* et de laisser **FastAPI** gérer le reste pour vous, comme lorsque vous utilisez directement l'objet `Request`.
+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 toujours possible d'utiliser `BackgroundTask` seul dans FastAPI, mais vous devez créer l'objet dans votre code et renvoyer une `Response` Starlette l'incluant.
+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.
 
-Vous pouvez voir plus de détails dans <a href="https://www.starlette.dev/background/" class="external-link" target="_blank">la documentation officielle de Starlette sur les Background Tasks</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`).
 
-## Mise en garde { #caveat }
+## Avertissement
 
-Si vous devez effectuer des calculs lourds en arrière-plan et que vous n'avez pas nécessairement besoin qu'ils soient exécutés par le même process (par exemple, vous n'avez pas besoin de partager la mémoire, les variables, etc.), vous pouvez tirer bénéfice d'utiliser d'autres outils plus importants comme <a href="https://docs.celeryq.dev" class="external-link" target="_blank">Celery</a>.
+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>.
 
-Ils ont tendance à nécessiter des configurations plus complexes, un gestionnaire de file de messages/tâches, comme RabbitMQ ou Redis, mais ils vous permettent d'exécuter des tâches d'arrière-plan dans plusieurs 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 devez accéder à des variables et objets de la même app **FastAPI**, ou si vous devez effectuer de petites tâches d'arrière-plan (comme envoyer une notification par email), vous pouvez simplement utiliser `BackgroundTasks`.
+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` avec des paramètres dans les *fonctions 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 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, bien entendu, vous pouvez mélanger librement les déclarations de paramètres `Path`, `Query` et du corps de la requête, et **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 body comme étant optionnels, en définissant la 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, le `item` qui serait pris depuis le corps est optionnel, car il a une valeur par défaut à `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* s'attendraient à un corps JSON avec les attributs d'un `Item`, comme :
+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,14 +29,13 @@ Dans l'exemple précédent, les *chemins d'accès* s'attendraient à un corps JS
 }
 ```
 
-Mais vous pouvez aussi déclarer plusieurs paramètres body, par ex. `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 dans le body (chacun correspondant à un modèle Pydantic).
 
-Dans ce cas, **FastAPI** remarquera qu'il y a plus d'un paramètre body dans la fonction (il y a deux paramètres qui sont des modèles Pydantic).
-
-Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le corps, et s'attendra à un corps comme :
+Il utilisera alors les noms des paramètres comme clés, et s'attendra à recevoir quelque chose de semblable à :
 
 ```JSON
 {
@@ -53,30 +52,29 @@ Il utilisera alors les noms des paramètres comme clés (noms de champs) dans le
 }
 ```
 
-/// note | Remarque
+/// note
 
-Notez que, même si le `item` a été déclaré de la même manière qu'avant, il est maintenant attendu dans le corps avec une 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** fera la conversion automatique à partir de 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 les documents automatiques.
+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 scalaires dans le body { #singular-values-in-body }
+## Valeurs scalaires dans le body
 
-De la même manière 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 que vous voulez une autre clé `importance` dans le même corps, 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 scalaire, **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é dans le corps 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] *}
 
-
-Dans ce cas, **FastAPI** s'attendra à un corps comme :
+Dans ce cas, **FastAPI** s'attendra à un body semblable à :
 
 ```JSON
 {
@@ -94,19 +92,19 @@ Dans ce cas, **FastAPI** s'attendra à un corps comme :
 }
 ```
 
-Là encore, 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...
 
-## Plusieurs paramètres body et query { #multiple-body-params-and-query }
+## Paramètres multiples body et query
 
-Bien entendu, vous pouvez aussi déclarer des paramètres de requête supplémentaires dès que vous en avez besoin, en plus de n'importe quels paramètres 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 scalaires sont interprétées comme des paramètres de requête, vous n'avez pas besoin d'ajouter explicitement un `Query`, vous pouvez simplement faire :
+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 en Python 3.10 et supérieur :
+Ou bien, en Python 3.10 et supérieur :
 
 ```Python
 q: str | None = None
@@ -114,33 +112,31 @@ 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
 
-/// info | info
-
-`Body` possède aussi 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.
 
 ///
 
-## Inclure un seul paramètre body { #embed-a-single-body-parameter }
+## Inclure un paramètre imbriqué dans le body
 
-Disons que vous n'avez qu'un seul paramètre body `item` issu 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** s'attendra alors à son corps directement.
+Par défaut, **FastAPI** attendra sa déclaration directement dans le body.
 
-Mais si vous voulez qu'il s'attende à un JSON avec une clé `item` et, à l'intérieur, le contenu du modèle, comme il le fait lorsque vous déclarez des paramètres body supplémentaires, 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 corps comme :
+Dans ce cas **FastAPI** attendra un body semblable à :
 
 ```JSON hl_lines="2"
 {
@@ -164,12 +160,12 @@ au lieu de :
 }
 ```
 
-## Récapitulatif { #recap }
+## Pour résumer
 
-Vous pouvez ajouter plusieurs paramètres body à votre *fonction de chemin d'accès*, même si une requête ne peut avoir qu'un seul corps.
+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** le gérera, vous donnera les données correctes 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 aussi déclarer des valeurs scalaires à recevoir dans le corps.
+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'inclure le corps dans une clé même lorsqu'il n'y a qu'un seul paramètre 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,41 +1,40 @@
-# Corps de la requête { #request-body }
+# Corps de la requête
 
-Quand vous avez besoin d'envoyer des données depuis un client (disons, un navigateur) vers votre API, vous les envoyez en tant que **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 des données envoyées par le client à votre API. Le corps d'une **réponse** est la donnée envoyée par votre API au client.
+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 a presque toujours besoin d'envoyer un corps de **réponse**. Mais les clients n'ont pas nécessairement besoin d'envoyer des **corps de requête** en permanence, parfois ils demandent seulement un chemin, peut-être avec des paramètres de requête, mais n'envoient 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.
 
 /// info
 
-Pour envoyer des données, vous devriez utiliser l'une des méthodes suivantes : `POST` (la plus courante), `PUT`, `DELETE` ou `PATCH`.
+Pour envoyer de la donnée, vous devriez utiliser : `POST` (le plus populaire), `PUT`, `DELETE` ou `PATCH`.
 
-Envoyer un corps avec une requête `GET` a un comportement non défini dans les spécifications ; néanmoins, cela est supporté par FastAPI, uniquement pour des cas d'utilisation très complexes/extrêmes.
+Envoyer un corps dans une requête `GET` a un comportement non défini dans les spécifications, cela est néanmoins supporté par **FastAPI**, seulement pour des cas d'utilisation très complexes/extrêmes.
 
-Comme cela est déconseillé, la documentation interactive avec Swagger UI n'affichera pas la documentation du corps lors de l'utilisation de `GET`, et les proxys intermédiaires risquent de ne pas le supporter.
+Ceci étant découragé, la documentation interactive générée par Swagger UI ne montrera pas de documentation pour le corps d'une requête `GET`, et les proxys intermédiaires risquent de ne pas le supporter.
 
 ///
 
-## Importer le `BaseModel` de Pydantic { #import-pydantics-basemodel }
+## Importez le `BaseModel` de Pydantic
 
-Commencez par importer `BaseModel` depuis `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. Pour rendre ce champ optionnel simplement, utilisez `None` comme valeur par défaut.
 
-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 requis. Sinon, il est requis. Utilisez `None` pour le rendre simplement optionnel.
-
-Par exemple, le modèle ci-dessus déclare un « `object` » JSON (ou `dict` Python) tel que :
+Par exemple, le modèle ci-dessus déclare un "objet" JSON (ou `dict` Python) tel que :
 
 ```JSON
 {
@@ -46,7 +45,7 @@ Par exemple, le modèle ci-dessus déclare un « `object` » JSON (ou `dict` Pyt
 }
 ```
 
-... comme `description` et `tax` sont optionnels (avec une valeur par défaut de `None`), cet « `object` » JSON serait aussi valide :
+...`description` et `tax` étant des attributs optionnels (avec `None` comme valeur par défaut), cet "objet" JSON serait aussi valide :
 
 ```JSON
 {
@@ -55,112 +54,109 @@ Par exemple, le modèle ci-dessus déclare un « `object` » JSON (ou `dict` Pyt
 }
 ```
 
-## Le déclarer comme paramètre { #declare-it-as-a-parameter }
+## Déclarez-le comme paramètre
 
-Pour l'ajouter à votre *chemin d'accès*, déclarez-le de la même manière que vous avez déclaré les paramètres de chemin et de requête :
+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 son type comme étant 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
 
-Avec simplement cette déclaration de type Python, **FastAPI** va :
+En utilisant uniquement les déclarations de type Python, **FastAPI** réussit à :
 
-* Lire le corps de la requête en tant que JSON.
+* Lire le contenu de la requête en tant que JSON.
 * Convertir les types correspondants (si nécessaire).
-* Valider les données.
-    * Si les données sont invalides, il renverra une erreur propre et claire, indiquant exactement où et quelles étaient les données incorrectes.
-* Vous donner les données reçues dans le paramètre `item`.
-    * Comme vous l'avez 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 et leurs types.
-* 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 aussi les utiliser ailleurs si cela a du sens pour votre projet.
-* Ces schémas feront partie du schéma OpenAPI généré et seront utilisés par la documentation automatique <abbr title="User Interfaces - Interfaces utilisateur">UIs</abbr>.
+* Valider la donnée.
+    * 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 (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 JSON Schemas de vos modèles feront partie du schéma OpenAPI généré de votre application, et seront affichés dans la documentation interactive de l'API :
+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 :
 
 <img src="/img/tutorial/body/image01.png">
 
-Et seront aussi utilisés dans la documentation de l'API au sein de chaque *chemin d'accès* qui en a besoin :
+Et seront aussi utilisés dans chaque *opération de chemin* de la documentation utilisant ces modèles :
 
 <img src="/img/tutorial/body/image02.png">
 
-## Support de l'éditeur { #editor-support }
+## Support de l'éditeur
 
-Dans votre éditeur, à l'intérieur de votre fonction, vous obtiendrez des annotations de type et de la complétion partout (cela n'arriverait pas si vous receviez un `dict` au lieu d'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">
 
-Vous obtenez aussi des vérifications d'erreur pour les opérations incorrectes de types :
+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 autour de ce design.
+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 ont même été faits sur Pydantic lui-même pour supporter cela.
+Des changements sur Pydantic ont même été faits pour supporter cela.
 
-Les captures d'écrans précédentes ont été prises avec <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 plupart des autres éditeurs 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 <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>.
 
-Il améliore le support de l'éditeur pour les modèles Pydantic, avec :
+Ce qui améliore le support pour les modèles Pydantic avec :
 
-* autocomplétion
-* vérifications de type
-* refactoring
-* recherche
-* inspections
+* de l'auto-complétion
+* des vérifications de type
+* du "refactoring" (ou remaniement de code)
+* de la recherche
+* de l'inspection
 
 ///
 
-## Utiliser le modèle { #use-the-model }
+## Utilisez le modèle
 
-À l'intérieur de la fonction, vous pouvez accéder directement à tous les attributs de l'objet du 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 le corps de la requête en même temps.
+Vous pouvez déclarer des paramètres de chemin et un corps de requête pour la même *opération de chemin*.
 
-**FastAPI** reconnaîtra 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 fonction déclarés comme modèles Pydantic doivent être **récupérés depuis le corps de la requête**.
+**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
 
-## Corps de la requête + paramètres de chemin et de requête { #request-body-path-query-parameters }
+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*.
 
-Vous pouvez aussi déclarer des paramètres de **corps**, de **chemin** et de **requête**, tous en même temps.
+**FastAPI** saura reconnaître chacun d'entre eux et récupérer la bonne donnée au bon endroit.
 
-**FastAPI** reconnaîtra chacun d'entre eux et récupérera les données au bon endroit.
+{* ../../docs_src/body/tutorial004.py hl[18] *}
 
-{* ../../docs_src/body/tutorial004_py310.py hl[16] *}
-
-Les paramètres de la fonction seront reconnus comme suit :
+Les paramètres de la fonction seront reconnus comme tel :
 
 * Si le paramètre est aussi déclaré dans le **chemin**, il sera utilisé comme paramètre de chemin.
 * 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 étant du type d'un **modèle Pydantic**, il sera interprété comme faisant partie du **corps** de la 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`.
 
-Le `str | None` (Python 3.10+) ou `Union` dans `Union[str, None]` (Python 3.9+) n'est pas utilisé par FastAPI pour déterminer que la valeur n'est pas requise ; il saura qu'elle n'est pas requise parce qu'elle a une valeur par défaut `= None`.
-
-Mais ajouter les 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 de modèles Pydantic, vous pouvez aussi utiliser des paramètres **Body**. Consultez les documents pour [Body - Multiple Parameters: Singular values in body](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 @@
-# Débogage { #debugging }
+# <abbr title="En anglais: Debugging">Débogage</abbr>
 
-Vous pouvez connecter le débogueur dans votre éditeur, par exemple avec Visual Studio Code ou PyCharm.
+Vous pouvez connecter le <abbr title="En anglais: debugger">débogueur</abbr> dans votre éditeur, par exemple avec Visual Studio Code ou PyCharm.
 
-## Faites appel à `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`.
 
@@ -54,12 +54,12 @@ va s'exécuter.
 
 Cela ne se produira pas si vous importez ce module (fichier).
 
-Ainsi, si vous avez un autre fichier `importer.py` qui contient :
+Par exemple, si vous avez un autre fichier `importer.py` qui contient :
 
 ```Python
 from myapp import app
 
-# Some more code
+# Code supplémentaire
 ```
 
 dans ce cas, la variable automatique `__name__` à l'intérieur de `myapp.py` n'aura pas la valeur `"__main__"`.
@@ -78,18 +78,18 @@ Pour plus d'informations, consultez <a href="https://docs.python.org/3/library/_
 
 ///
 
-## Exécutez votre code avec votre débogueur { #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 débogueur.
+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>.
 
 ---
 
 Par exemple, dans Visual Studio Code, vous pouvez :
 
-* Aller dans le panneau « Debug ».
-* « Add configuration... ».
-* Sélectionner « Python »
-* Lancer le débogueur 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,10 +101,10 @@ Voici à quoi cela pourrait ressembler :
 
 Si vous utilisez Pycharm, vous pouvez :
 
-* Ouvrir le menu « Run ».
-* Sélectionner l'option « Debug... ».
-* Un menu contextuel s'affiche alors.
-* Sélectionner le fichier à déboguer (dans ce cas, `main.py`).
+- 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`).
 
 Il démarrera alors le serveur avec votre code **FastAPI**, s'arrêtera à vos points d'arrêt, etc.
 

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

@@ -1,122 +1,107 @@
-# Premiers pas { #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`.
 
-Lancez le serveur de développement :
+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 qui ressemble à :
+/// 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 affiche l’URL à laquelle votre app 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 :
+Vous obtiendrez cette réponse JSON :
 
 ```JSON
 {"message": "Hello World"}
 ```
 
-### Documentation interactive de l’API { #interactive-api-docs }
+### Documentation interactive de l'API
 
-Rendez-vous 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, 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>.
+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 alternative générée automatiquement (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 les 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 simplement 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
 
-Dans ce cas, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> est une spécification qui dicte comment définir un schéma de votre 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 acceptent, 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 aussi faire référence à la structure de certaines données, 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 signifierait les attributs JSON, et les types de données qu’ils ont, 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 des « schémas ») des données envoyées et reçues par votre API en utilisant **JSON Schema**, le standard des 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.
 
-#### Vérifiez 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 (schéma) JSON 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 aussi 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 app (optionnel) { #deploy-your-app-optional }
+## Récapitulatif, étape par étape
 
-Vous pouvez, de manière optionnelle, déployer votre app 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. 🚀
+### É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>
-
-Ensuite, déployez votre app :
-
-<div class="termy">
-
-```console
-$ fastapi deploy
-
-Deploying to FastAPI Cloud...
-
-✅ Deployment successful!
-
-🐔 Ready the chicken! Your app is ready at https://myapp.fastapicloud.dev
-```
-
-</div>
-
-C’est tout ! Vous pouvez maintenant accéder à votre app à 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 pour 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 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">
 
-« Path » fait référence ici à la dernière partie de l’URL à partir du premier `/`.
+```console
+$ uvicorn main:app --reload
 
-Donc, dans une URL comme :
+<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 « path » serait :
+...le "path" serait :
 
 ```
 /items/foo
@@ -223,67 +200,66 @@ https://example.com/items/foo
 
 /// info
 
-Un « path » est aussi communément appelé un « endpoint » ou une « route ».
+Un chemin, ou "path" est aussi souvent appelé route ou "endpoint".
 
 ///
 
-Lors de la construction d’une API, le « path » est la principale façon 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 référence ici à 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".
 
 ---
 
-Lors de la construction d’API, 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.
 
-Normalement 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 aussi les appeler des « **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="an HTTP GET method">opération <code>get</code></abbr>
+* en utilisant une <abbr title="une méthode GET HTTP">opération <code>get</code></abbr>
 
-/// info | `@decorator` Info
+/// 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 le mettez au-dessus d’une fonction. Comme un joli chapeau décoratif (j’imagine que c’est de là que le terme vient).
+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 elle.
+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()`
 
-Et les plus exotiques :
+Tout comme celles les plus exotiques :
 
 * `@app.options()`
 * `@app.head()`
@@ -302,79 +278,58 @@ Et 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 aucun sens spécifique.
+**FastAPI** n'impose pas de sens spécifique à chacune d'elle.
 
-Les informations présentées ici servent de guide, pas d’exigence.
+Les informations qui sont présentées ici forment une directive générale, pas des obligations.
 
-Par exemple, quand 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** : est `/`.
-* **opération** : est `get`.
-* **fonction** : est la fonction sous le « décorateur » (sous `@app.get("/")`).
+* **chemin** : `/`.
+* **opération** : `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 pourriez 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 | Remarque
+/// note
 
-Si vous ne connaissez pas la différence, consultez [Async : *« 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`, `list`, des valeurs seules 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 aussi 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 y a de nombreux autres objets et modèles qui seront automatiquement convertis en JSON (y compris les ORM, etc). Essayez d’utiliser vos favoris, il est très 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 app 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 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 **developer experience** de construction d’apps avec FastAPI au **déploiement** dans le cloud. 🎉
-
-FastAPI Cloud est le sponsor principal et le fournisseur de financement pour les 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 apps FastAPI sur n’importe quel fournisseur cloud de votre choix.
-
-Suivez les guides de votre fournisseur cloud pour y déployer des apps FastAPI. 🤓
-
-## Récapitulatif { #recap }
+## Récapitulatif
 
 * Importez `FastAPI`.
-* Créez une instance `app`.
-* Écrivez un **décorateur de chemin d'accès** en utilisant des décorateurs comme `@app.get("/")`.
-* Définissez une **fonction de chemin d'accès** ; par exemple, `def root(): ...`.
-* Lancez le serveur de développement avec la commande `fastapi dev`.
-* Déployez votre app de manière optionnelle 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,95 +1,83 @@
-# 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ésoudre vos besoins spécifiques en matière d'API.
 
-Il est également conçu pour fonctionner comme une référence future afin que vous puissiez revenir et 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>
 
-Il est **FORTEMENT encouragé** que vous écriviez ou copiiez le code, l'éditiez et l'exécutiez localement.
+Il est **FORTEMENT encouragé** que vous écriviez ou copiez le code, l'éditiez et l'exécutiez localement.
 
 L'utiliser dans votre éditeur est ce qui vous montre vraiment les avantages de FastAPI, en voyant le peu de code que vous avez à écrire, toutes les vérifications de type, l'autocomplétion, etc.
 
 ---
 
-## Installer FastAPI { #install-fastapi }
+## Installer FastAPI
 
 La première étape consiste à installer FastAPI.
 
-Vous devez vous assurer 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 certaines dépendances standard optionnelles par défaut, notamment `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 voulez pas avoir ces dépendances optionnelles, vous pouvez installer `pip install fastapi` à la place.
+Vous pouvez également l'installer pièce par pièce.
 
-Si vous voulez installer les dépendances standard mais sans le `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 utilisateur avancé { #advanced-user-guide }
+## Guide utilisateur avancé
 
-Il existe également un **Guide utilisateur avancé** que vous pouvez lire plus tard après ce **Tutoriel - Guide utilisateur**.
+Il existe également un **Guide d'utilisation avancé** que vous pouvez lire plus tard après ce **Tutoriel - Guide d'utilisation**.
 
-Le **Guide utilisateur avancé** s'appuie sur celui-ci, utilise les mêmes concepts et vous apprend quelques fonctionnalités supplémentaires.
+Le **Guide d'utilisation avancé**, qui s'appuie sur cette base, utilise les mêmes concepts et vous apprend quelques fonctionnalités supplémentaires.
 
-Mais vous devez d'abord lire le **Tutoriel - Guide utilisateur** (ce que vous êtes en train de lire en ce moment).
+Mais vous devez d'abord lire le **Tutoriel - Guide d'utilisation** (ce que vous êtes en train de lire en ce moment).
 
-Il est conçu pour que vous puissiez construire une application complète avec seulement le **Tutoriel - Guide utilisateur**, puis l'étendre de différentes manières, en fonction de vos besoins, en utilisant certaines des idées supplémentaires du **Guide utilisateur avancé**.
+Il est conçu pour que vous puissiez construire une application complète avec seulement le **Tutoriel - Guide d'utilisation**, puis l'étendre de différentes manières, en fonction de vos besoins, en utilisant certaines des idées supplémentaires du **Guide d'utilisation avancé**.

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` :
 
@@ -12,29 +12,29 @@ Tout d'abord, importez `Path` de `fastapi`, et importez `Annotated` :
 
 FastAPI a ajouté le support pour `Annotated` (et a commencé à le recommander) dans la version 0.95.0.
 
-Si vous avez une version plus ancienne, vous obtiendriez des erreurs en essayant d'utiliser `Annotated`.
+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 tous les mêmes paramètres que pour `Query`.
+Vous pouvez déclarer les mêmes paramètres que pour `Query`.
 
 Par exemple, pour déclarer une valeur de métadonnée `title` pour le paramètre de chemin `item_id`, vous pouvez écrire :
 
 {* ../../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 selon vos besoins { #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,23 +46,23 @@ 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 valeur par défaut (le paramètre de requête `q`) en premier.
+Mais vous pouvez les réorganiser, et avoir la valeur sans défaut (le paramètre de requête `q`) en premier.
 
 Cela n'a pas d'importance pour **FastAPI**. Il détectera les paramètres par leurs noms, types et déclarations par défaut (`Query`, `Path`, etc), il ne se soucie pas de l'ordre.
 
 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 selon vos besoins, 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 par mot-clé (paires clé-valeur), également connus sous le nom de <abbr title="From: K-ey W-ord Arg-uments"><code>kwargs</code></abbr>. Même s'ils n'ont pas de valeur par défaut.
+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,9 +129,9 @@ 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 n'avez pas encore vus) 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}.
+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}.
 
 Et vous pouvez également déclarer des validations numériques :
 
@@ -135,7 +144,7 @@ Et vous pouvez également déclarer des validations numériques :
 
 `Query`, `Path`, et d'autres classes que vous verrez plus tard sont des sous-classes d'une classe commune `Param`.
 
-Tous partagent les mêmes paramètres pour des validations supplémentaires et des métadonnées que vous avez vus.
+Tous partagent les mêmes paramètres pour des validations supplémentaires et des métadonnées que vous avez vu précédemment.
 
 ///
 

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 que celle 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 comme 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 standard de Python :
+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] *}
 
-Dans ce cas, `item_id` est déclaré comme `int`.
+{* ../../docs_src/path_params/tutorial002.py hl[7] *}
 
-/// check | Vérifications
+Ici, `item_id` est déclaré comme `int`.
 
-Cela vous donnera le support de l'éditeur dans votre fonction, avec des vérifications d'erreurs, l'autocomplétion, etc.
+/// check | vérifier
+
+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="aussi connu sous le nom de : serialization, 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`, comme un `int` Python, pas une chaîne « 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 le <abbr title="conversion de la chaîne provenant d'une requête HTTP en données Python">« parsing »</abbr> automatique 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` avait la 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 une validation de données.
+/// check | vérifier
 
-Remarquez que l'erreur indique aussi clairement le point exact où la validation n'est pas passée.
+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 de 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
 
-Encore une fois, uniquement avec cette même déclaration de type Python, **FastAPI** vous fournit une documentation automatique et interactive (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 un entier.
+On voit bien dans la documentation que `item_id` est déclaré comme entier.
 
 ///
 
-## Avantages basés sur les standards, 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é provient du standard <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** lui-même fournit une documentation d'API alternative (utilisant ReDoc), à laquelle vous pouvez accéder 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 en arrière-plan par <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, vous bénéficiez donc de tous ses avantages. Et vous savez 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 abordé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.
 
-Lors de la création de *chemins d'accès*, vous pouvez vous retrouver dans des situations où vous avez 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
 
-Comme `/users/me`, disons que c'est pour obtenir des données sur 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 obtenir des données sur un utilisateur spécifique via un identifiant 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 pour `/users/me` est déclaré avant celui pour `/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 pour `/users/{user_id}` correspondrait aussi à `/users/me`, en « 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 la même manière, 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 valides possibles du *paramètre de chemin* soient prédéfinies, vous pouvez utiliser un <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`, les documents de l'API pourront savoir que les valeurs doivent être de type `string` et pourront les 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 simplement des noms de <abbr title="Technically, Deep Learning model architectures">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 enum 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] *}
+///
 
-### Vérifier 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 bien les afficher :
+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 la comparer avec le *membre d'énumération* de votre enum créée `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 (un `str` dans ce cas) en utilisant `model_name.value`, ou de manière générale, `your_enum_member.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'enum* 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 en leurs valeurs correspondantes (des chaînes dans ce cas) avant de les renvoyer 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 obtiendrez une réponse JSON comme :
+Le client recevra une réponse JSON comme celle-ci :
 
 ```JSON
 {
@@ -199,53 +208,53 @@ Dans votre client, vous obtiendrez 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 le 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.
 
-Donc, l'URL pour ce fichier serait quelque chose comme : `/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 supporte pas une manière de déclarer qu'un *paramètre de chemin* contient un *chemin* à l'intérieur, car cela pourrait 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 quand même le faire dans **FastAPI**, en utilisant un des outils internes de Starlette.
+Néanmoins, cela reste faisable dans **FastAPI**, via les outils internes de Starlette.
 
-Et les documents fonctionneraient quand même, bien qu'ils n'ajoutent aucune documentation indiquant que le paramètre devrait 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*.
 
-Ainsi, vous pouvez l'utiliser avec :
+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.
-* « parsing » de données <abbr title="conversion de la chaîne provenant d'une requête HTTP en données Python">parsing</abbr>
-* Validation de données
-* Annotation de l'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 à les déclarer qu'une seule fois.
+Et vous n'avez besoin de le déclarer qu'une fois.
 
-C'est probablement le principal avantage visible de **FastAPI** comparé aux frameworks alternatifs (en dehors de la performance brute).
+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 supplémentaires et de la validation 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`, ce qui signifie qu’il est de type `str` mais pourrait 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 bien que `q` soit 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 y parvenir, 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é le support 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 obtiendriez 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.
 
-Vous devez vous assurer de [mettre à niveau la version de FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} au moins vers la 0.95.1 avant d’utiliser `Annotated`.
-
-///
-
-## Utiliser `Annotated` dans le type du paramètre `q` { #use-annotated-in-the-type-for-the-q-parameter }
-
-Vous vous souvenez que je vous ai dit précédemment 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 maintenant 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 est d’envelopper cela avec `Annotated`, pour 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**.
 
-Ces deux versions veulent dire la même chose, `q` est un paramètre qui peut être un `str` ou `None`, et par défaut, il vaut `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 ce `Annotated` où nous pouvons mettre plus d’informations (dans ce cas une validation additionnelle), 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 disons à FastAPI que nous voulons **de la validation additionnelle** pour cette valeur, nous voulons qu’elle ait au maximum 50 caractères. 😎
-
-/// tip | Astuce
-
-Ici, nous utilisons `Query()` parce que c’est un **paramètre de requête**. Plus tard, nous verrons d’autres éléments comme `Path()`, `Body()`, `Header()` et `Cookie()`, qui acceptent aussi les mêmes arguments que `Query()`.
+Le `Union[str, None]` est uniquement là pour permettre à votre éditeur un meilleur support.
 
 ///
 
-FastAPI va maintenant :
-
-* **Valider** les données en s’assurant que la longueur maximale est de 50 caractères
-* Afficher une **erreur claire** pour le client quand les données ne sont pas valides
-* **Documenter** le paramètre dans le schéma OpenAPI de la *path operation* (il apparaîtra donc dans l’**UI de documentation automatique**)
-
-## Alternative (ancienne) : `Query` comme valeur par défaut { #alternative-old-query-as-the-default-value }
-
-Les versions précédentes de FastAPI (avant <abbr title="before 2023-03 - avant 2023-03">0.95.0</abbr>) vous demandaient 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, donc je vais vous l’expliquer.
-
-/// tip | Astuce
-
-Pour du nouveau code et dès que possible, utilisez `Annotated` comme expliqué ci-dessus. Il y a plusieurs avantages (expliqués ci-dessous) et aucun inconvénient. 🍰
-
-///
-
-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 :
-
-{* ../../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)`, il sert le même objectif de définir cette valeur par défaut (au moins pour FastAPI).
-
-Donc :
+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 :
 
 ```Python
-q: str | None = Query(default=None)
+q: Union[str, None] = Query(default=None, max_length=50)
 ```
 
-... rend le paramètre optionnel, avec une valeur par défaut de `None`, identique à :
+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*.
 
-```Python
-q: str | None = None
-```
+## Rajouter plus de validation
 
-Mais la version avec `Query` le déclare explicitement comme étant un paramètre de requête.
+Vous pouvez aussi rajouter un second paramètre `min_length` :
 
-Ensuite, nous pouvons passer d’autres paramètres à `Query`. Dans ce cas, le paramètre `max_length` qui s’applique aux chaînes de caractères :
+{* ../../docs_src/query_params_str_validations/tutorial003.py hl[9] *}
 
-```Python
-q: str | None = Query(default=None, max_length=50)
-```
+## Ajouter des validations par expressions régulières
 
-Cela va valider les données, montrer une erreur claire quand les données ne sont pas valides, et documenter le paramètre dans le schéma OpenAPI de la *path operation*.
+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 :
 
-### `Query` comme valeur par défaut ou dans `Annotated` { #query-as-the-default-value-or-in-annotated }
+{* ../../docs_src/query_params_str_validations/tutorial004.py hl[10] *}
 
-Gardez à l’esprit que lorsque vous utilisez `Query` à l’intérieur de `Annotated`, vous ne pouvez pas utiliser le paramètre `default` pour `Query`.
+Cette expression régulière vérifie que la valeur passée comme paramètre :
 
-À la place, utilisez la valeur par défaut réelle du paramètre de la 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 devrait ê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 }
-
-**Utiliser `Annotated` est recommandé** 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 la fonction** est la **vraie valeur par défaut**, c’est plus intuitif avec Python en général. 😌
-
-Vous pourriez **appeler** cette même fonction à **d’autres endroits** sans FastAPI, et elle **fonctionnerait 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 que vous utilisez à la place le **style (ancien) avec valeur par défaut**, si vous appelez cette fonction sans FastAPI à **d’autres endroits**, vous devez **vous souvenir** de passer les arguments à la fonction pour qu’elle fonctionne correctement, sinon les valeurs seront différentes de ce que vous attendez (par exemple `QueryInfo` ou quelque chose de similaire au lieu de `str`). Et votre éditeur ne se plaindra pas, et Python ne se plaindra pas en exécutant cette fonction, seulement quand les opérations à l’intérieur échoueront.
-
-Parce que `Annotated` peut avoir plus d’une annotation de métadonnées, vous pourriez 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 validation { #add-more-validations }
-
-Vous pouvez aussi 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="A regular expression, regex or regexp is a sequence of characters that define a search pattern for strings. - 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 motif d’expression régulière spécifique vérifie que la valeur de paramètre reçue :
-
-* `^` : commence avec les caractères qui suivent, n’a pas de caractères avant.
+* `^` : commence avec les caractères qui suivent, avec aucun caractère avant ceux-là.
 * `fixedquery` : a pour valeur exacte `fixedquery`.
-* `$` : se termine là, n’a pas d’autres caractères après `fixedquery`.
+* `$` : se termine directement ensuite, n'a pas d'autres caractères après `fixedquery`.
 
-Si vous vous sentez perdu avec toutes ces idées d’**« regular expression »**, pas d’inquiétudes. C’est un sujet difficile pour beaucoup de gens. Vous pouvez encore faire beaucoup de choses sans avoir besoin d’expressions régulières.
+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.
 
-Maintenant, vous savez que chaque fois que vous en avez besoin, vous pouvez les utiliser dans **FastAPI**.
+Mais si vous décidez d'apprendre à les utiliser, sachez qu'ensuite vous pouvez les utiliser directement dans **FastAPI**.
 
-## Valeurs par défaut { #default-values }
+## Valeurs par défaut
 
-Vous pouvez, bien sûr, utiliser des valeurs par défaut autres que `None`.
+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 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"` :
+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_an_py39.py hl[9] *}
+{* ../../docs_src/query_params_str_validations/tutorial005.py hl[7] *}
 
-/// note | Remarque
+/// note | Rappel
 
-Avoir une valeur par défaut de n’importe quel type, y compris `None`, rend le paramètre optionnel (non requis).
+Avoir une valeur par défaut rend le paramètre optionnel.
 
 ///
 
-## Paramètres requis { #required-parameters }
+## Rendre ce paramètre requis
 
-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 simplement en ne déclarant 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 nous le déclarons maintenant avec `Query`, par exemple comme ceci :
+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 devez 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 être `None` { #required-can-be-none }
+/// info
 
-Vous pouvez déclarer qu’un paramètre peut accepter `None`, mais qu’il est quand même requis. Cela forcerait 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 faire cela, vous pouvez déclarer que `None` est un type valide mais simplement ne pas déclarer 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 le déclarer pour qu’il reçoive une liste de valeurs, ou dit autrement, pour qu’il reçoive plusieurs valeurs.
+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 *query parameters* `q` (`foo` et `bar`) dans une `list` Python au sein de votre *path operation function*, dans le *function parameter* `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 à cette URL serait :
+Donc la réponse de cette URL serait :
 
 ```JSON
 {
@@ -280,19 +173,19 @@ Donc la réponse à 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 cela serait interprété comme un 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.
 
 ///
 
-Les documents interactifs de l’API seront mis à 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 des valeurs par défaut { #query-parameter-list-multiple-values-with-defaults }
+### Combiner liste de paramètres et valeurs par défaut
 
-Vous pouvez aussi 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 seulement `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 `list` seul 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 utilisateur de la 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 support 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 montrer toutes les informations supplémentaires déclarées pour le moment, bien que dans la plupart des cas, la fonctionnalité manquante soit déjà prévue pour le 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] *}
 
-## Alias de paramètres { #alias-parameters }
+## Alias de paramètres
 
-Imaginez que vous voulez 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 en avez encore besoin pour qu’il soit exactement `item-query`...
+Mais vous avez vraiment envie que ce soit exactement `item-query`...
 
-Alors vous pouvez déclarer un `alias`, et cet alias sera ce qui 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 maintenant 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à pendant un moment parce qu’il y a des clients qui l’utilisent, mais vous voulez que les documents le montrent clairement comme <abbr title="obsolete, recommended not to use it - obsolète, recommandé de ne pas l’utiliser">deprecated</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>.
 
-Ensuite, passez 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 comme ceci :
+La documentation le présentera comme il suit :
 
 <img src="/img/tutorial/query-params-str-validations/image01.png">
 
-## Exclusion 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 automatique), 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] *}
-
-## Validation personnalisée { #custom-validation }
-
-Il peut y avoir des cas où vous devez faire de la **validation personnalisée** qui ne peut pas être faite avec les paramètres montrés ci-dessus.
-
-Dans ces cas, vous pouvez utiliser une **fonction de validateur personnalisée** qui est appliquée après la validation normale (par ex. après avoir validé que la valeur est un `str`).
-
-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`.
-
-/// 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 de l’item commence par `isbn-` pour un numéro de livre <abbr title="ISBN means International Standard Book Number - ISBN signifie International Standard Book Number">ISBN</abbr> ou par `imdb-` pour un ID d’URL de film <abbr title="IMDB (Internet Movie Database) is a website with information about movies - 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
-
-Ceci est disponible avec Pydantic version 2 ou supérieure. 😎
-
-///
-
-/// tip | Astuce
-
-Si vous devez faire tout type de validation qui nécessite de communiquer avec un **composant externe**, comme une base de données ou une autre API, vous devriez plutôt utiliser les **dépendances FastAPI**, vous en apprendrez plus à leur sujet plus tard.
-
-Ces validateurs personnalisés sont pour des choses qui peuvent être vérifiées avec **uniquement** 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 dans `Annotated`**. N’hésitez pas à sauter cette partie. 🤸
-
----
-
-Mais si vous êtes curieux à propos de cet exemple de code spécifique et que vous êtes encore diverti, 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 cela vérifiera chaque valeur dans le tuple :
-
-{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[16:19] hl[17] *}
-
-#### Un item aléatoire { #a-random-item }
-
-Avec `data.items()` nous obtenons un <abbr title="Something we can iterate on with a for loop, like a list, set, etc. - Quelque chose sur lequel on peut itérer avec une boucle for, comme une liste, un set, etc.">iterable object</abbr> avec des tuples contenant la clé et la valeur pour chaque élément du dictionnaire.
-
-Nous convertissons cet objet itérable en une vraie `list` avec `list(data.items())`.
-
-Ensuite, avec `random.choice()` nous pouvons obtenir une **valeur aléatoire** de la liste, donc, nous obtenons un tuple avec `(id, name)`. Ce sera quelque chose comme `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
-
-Ensuite, nous **assignons 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’aimez pas Python ? 🐍
-
-{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py ln[22:30] hl[29] *}
-
-## Pour résumer { #recap }
-
-Vous pouvez déclarer des validations additionnelles et des métadonnées pour vos paramètres.
-
-Validations et métadonnées génériques :
+Validateurs et métadonnées génériques:
 
 * `alias`
 * `title`
 * `description`
 * `deprecated`
 
-Validations spécifiques pour les chaînes de caractères :
+Validateurs spécifiques aux chaînes de caractères :
 
 * `min_length`
 * `max_length`
-* `pattern`
+* `regex`
 
-Validations personnalisées utilisant `AfterValidator`.
+Parmi ces exemples, vous avez pu voir comment déclarer des validateurs pour les chaînes de caractères.
 
-Dans ces exemples, vous avez vu comment déclarer des validations pour des valeurs `str`.
-
-Consultez les chapitres suivants 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 « requête ».
+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 requête est l'ensemble des paires clé-valeur qui suivent 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,72 +12,80 @@ 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 :
 
-* Support de l'éditeur (évidemment)
-* <abbr title="converting the string that comes from an HTTP request into Python data - conversion de la chaîne de caractères venant 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 constituent pas une partie fixe d'un chemin, ils peuvent être optionnels et peuvent 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`.
 
-Ainsi, aller à l'URL :
+Donc, accéder à l'URL :
 
 ```
 http://127.0.0.1:8000/items/
 ```
 
-serait équivalent à aller à :
+serait équivalent à accéder à l'URL :
 
 ```
 http://127.0.0.1:8000/items/?skip=0&limit=10
 ```
 
-Mais si vous allez à, 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` : parce que vous l'avez défini dans l'URL
-* `limit=10` : parce que 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 aura `None` comme valeur 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` n'en est pas un, donc c'est 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 du type des paramètres de requête { #query-parameter-type-conversion }
+/// note
 
-Vous pouvez aussi déclarer des types `bool`, et 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 à :
+///
+
+## 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,62 +115,60 @@ ou
 http://127.0.0.1:8000/items/foo?short=yes
 ```
 
-ou toute autre variation de casse (majuscules, première lettre en majuscule, etc.), votre fonction verra le paramètre `short` avec une valeur `bool` de `True`. Sinon, `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
 
-## Paramètres de chemin et de requête multiples { #multiple-path-and-query-parameters }
-
-Vous pouvez déclarer plusieurs paramètres de chemin et paramètres de requête en même temps, **FastAPI** sait lesquels sont lesquels.
+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
 
-Lorsque 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 des 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 ajouter une valeur spécifique mais juste le rendre optionnel, définissez la valeur par défaut sur `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 lorsque vous voulez rendre un paramètre de requête requis, vous pouvez simplement ne pas déclarer de 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
 {
@@ -171,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 pouvez 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/async.md

@@ -1,18 +1,18 @@
-# 동시성과 async / await
+# 동시성과 async / await { #concurrency-and-async-await }
 
-*경로 작동 함수*에서의 `async def` 문법에 대한 세부사항과 비동기 코드, 동시성 및 병렬성에 대한 배경
+*경로 처리 함수*에서의 `async def` 문법에 대한 세부사항과 비동기 코드, 동시성 및 병렬성에 대한 배경
 
-## 바쁘신 경우
+## 바쁘신가요? { #in-a-hurry }
 
-<strong>요약</strong>
+<abbr title="too long; didn't read - 너무 길어서 읽지 않음"><strong>TL;DR:</strong></abbr>
 
-다음과 같이 `await`를 사용해 호출하는 제3의 라이브러리를 사용하는 경우:
+다음과 같이 `await`를 사용해 호출하라고 안내하는 제3자 라이브러리를 사용하는 경우:
 
 ```Python
 results = await some_library()
 ```
 
-다음처럼 *경로 작동 함수*를 `async def`를 사용해 선언하십시오:
+다음처럼 *경로 처리 함수*를 `async def`를 사용해 선언하십시오:
 
 ```Python hl_lines="2"
 @app.get('/')
@@ -29,7 +29,7 @@ async def read_results():
 
 ---
 
-데이터베이스, API, 파일시스템 등과 의사소통하는 제3의 라이브러리를 사용하고, 그것이 `await`를 지원하지 않는 경우(현재 거의 모든 데이터베이스 라이브러리가 그러합니다), *경로 작동 함수*를 일반적인 `def`를 사용해 선언하십시오:
+데이터베이스, API, 파일시스템 등과 의사소통하는 제3자 라이브러리를 사용하고, 그것이 `await` 사용을 지원하지 않는 경우(현재 대부분의 데이터베이스 라이브러리가 그러합니다), *경로 처리 함수*를 일반적인 `def`를 사용해 선언하십시오:
 
 ```Python hl_lines="2"
 @app.get('/')
@@ -40,23 +40,23 @@ def results():
 
 ---
 
-만약 당신의 응용프로그램이 (어째서인지) 다른 무엇과 의사소통하고 그것이 응답하기를 기다릴 필요가 없다면 `async def`를 사용하십시오.
+만약 여러분의 애플리케이션이 (어째서인지) 다른 어떤 것과도 통신하고 그 응답을 기다릴 필요가 없다면, 내부에서 `await`를 사용할 필요가 없더라도 `async def`를 사용하세요.
 
 ---
 
-모르겠다면, 그냥 `def`를 사용하십시오.
+잘 모르겠다면, 일반적인 `def`를 사용하세요.
 
 ---
 
-**참고**: *경로 작동 함수*에서 필요한만큼 `def`와 `async def`를 혼용할 수 있고, 가장 알맞은 것을 선택해서 정의할 수 있습니다. FastAPI가 자체적으로 알맞은 작업을 수행할 것입니다.
+**참고**: *경로 처리 함수*에서 필요한 만큼 `def`와 `async def`를 혼용할 수 있으며, 각각에 대해 가장 알맞은 옵션을 선택해 정의하면 됩니다. FastAPI가 올바르게 처리합니다.
 
-어찌되었든, 상기 어떠한 경우라도, FastAPI는 여전히 비동기적으로 작동하고 매우 빠릅니다.
+어쨌든 위의 어떤 경우에서도 FastAPI는 여전히 비동기적으로 동작하며 매우 빠릅니다.
 
-그러나 상기 작업을 수행함으로써 어느 정도의 성능 최적화가 가능합니다.
+하지만 위의 단계를 따르면, 몇 가지 성능 최적화를 할 수 있습니다.
 
-## 기술적 세부사항
+## 기술적 세부사항 { #technical-details }
 
-최신 파이썬 버전은 `async`와 `await` 문법과 함께 **“코루틴”**이라고 하는 것을 사용하는 **“비동기 코드”**를 지원합니다.
+최신 파이썬 버전은 **“코루틴”**이라고 하는 것을 사용하는 **“비동기 코드”**를 **`async` 및 `await`** 문법과 함께 지원합니다.
 
 아래 섹션들에서 해당 문장을 부분별로 살펴보겠습니다:
 
@@ -64,251 +64,283 @@ def results():
 * **`async`와 `await`**
 * **코루틴**
 
-## 비동기 코드
+## 비동기 코드 { #asynchronous-code }
 
-비동기 코드란 언어 💬 가 코드의 어느 한 부분에서, 컴퓨터 / 프로그램🤖에게 *다른 무언가*가 어딘가에서 끝날 때까지 기다려야한다고 말하는 방식입니다. *다른 무언가*가 “느린-파일" 📝 이라고 불린다고 가정해봅시다.
+비동기 코드는 언어 💬 가 코드의 어느 한 부분에서 컴퓨터/프로그램 🤖 에게, 어느 시점에는 어딘가에서 *다른 무언가*가 끝날 때까지 기다려야 한다고 말할 수 있는 방법이 있다는 의미입니다. 그 *다른 무언가*를 "slow-file" 📝 이라고 해보겠습니다.
 
-따라서 “느린-파일” 📝이 끝날때까지 컴퓨터는 다른 작업을 수행할 수 있습니다.
+따라서 그 시간 동안 컴퓨터는 "slow-file" 📝 이 끝나는 동안 다른 작업을 하러 갈 수 있습니다.
 
-그 다음 컴퓨터 / 프로그램 🤖 은 다시 기다리고 있기 때문에 기회가 있을 때마다 다시 돌아오거나, 혹은 당시에 수행해야하는 작업들이 완료될 때마다 다시 돌아옵니다. 그리고 그것 🤖 은 기다리고 있던 작업 중 어느 것이 이미 완료되었는지, 그것 🤖 이 해야하는 모든 작업을 수행하면서 확인합니다.
+그 다음 컴퓨터/프로그램 🤖 은 다시 기다리는 중이기 때문에 기회가 있을 때마다 돌아오거나, 혹은 그 시점에 해야 할 작업을 모두 끝낼 때마다 돌아옵니다. 그리고 기다리던 작업 중 이미 끝난 것이 있는지 확인하면서, 해야 했던 작업을 수행합니다.
 
-다음으로, 그것 🤖 은 완료할 첫번째 작업에 착수하고(우리의 "느린-파일" 📝 이라고 가정합시다) 그에 대해 수행해야하는 작업을 계속합니다.
+다음으로, 완료된 첫 번째 작업(우리의 "slow-file" 📝 이라고 해보겠습니다)을 가져와서, 그에 대해 해야 했던 작업을 계속합니다.
 
-"다른 무언가를 기다리는 것"은 일반적으로 비교적 "느린" (프로세서와 RAM 메모리 속도에 비해) <abbr title="Input and Output">I/O</abbr> 작업을 의미합니다. 예를 들면 다음의 것들을 기다리는 것입니다:
+이 "다른 무언가를 기다리는 것"은 일반적으로 프로세서와 RAM 메모리 속도에 비해 상대적으로 "느린" <abbr title="Input and Output - 입력/출력">I/O</abbr> 작업을 의미합니다. 예를 들어 다음을 기다리는 것입니다:
 
-* 네트워크를 통해 클라이언트로부터 전송되는 데이터
-* 네트워크를 통해 클라이언트가 수신할, 당신의 프로그램으로부터 전송되는 데이터
-* 시스템이 읽고 프로그램에 전달할 디스크 내의 파일 내용
-* 당신의 프로그램이 시스템에 전달하는, 디스크에 작성될 내용
+* 네트워크를 통해 클라이언트가 데이터를 보내는 것
+* 네트워크를 통해 클라이언트가 여러분의 프로그램이 보낸 데이터를 받는 것
+* 시스템이 디스크의 파일 내용을 읽어서 프로그램에 전달하는 것
+* 프로그램이 시스템에 전달한 내용을 디스크에 쓰는 것
 * 원격 API 작업
-* 완료될 데이터베이스 작업
-* 결과를 반환하는 데이터베이스 쿼리
-* 기타
+* 데이터베이스 작업이 완료되는 것
+* 데이터베이스 쿼리가 결과를 반환하는 것
+* 기타 등등
 
-수행 시간의 대부분이 <abbr title="Input and Output">I/O</abbr> 작업을 기다리는데에 소요되기 때문에, "I/O에 묶인" 작업이라고 불립니다.
+실행 시간의 대부분이 <abbr title="Input and Output - 입력/출력">I/O</abbr> 작업을 기다리는 데 소비되기 때문에, 이를 "I/O bound" 작업이라고 부릅니다.
 
-이것은 "비동기"라고 불리는데 컴퓨터 / 프로그램이 작업 결과를 가지고 일을 수행할 수 있도록, 느린 작업에 "동기화"되어 아무것도 하지 않으면서 작업이 완료될 정확한 시점만을 기다릴 필요가 없기 때문입니다.
+이것은 컴퓨터/프로그램이 느린 작업과 "동기화"되어, 아무것도 하지 않은 채 그 작업이 끝나는 정확한 시점만 기다렸다가 결과를 가져와 일을 계속할 필요가 없기 때문에 "비동기"라고 불립니다.
 
-이 대신에, "비동기" 시스템에서는, 작업은 일단 완료되면, 컴퓨터 / 프로그램이 수행하고 있는 일을 완료하고 이후 다시 돌아와서 그것의 결과를 받아 이를 사용해 작업을 지속할 때까지 잠시 (몇 마이크로초) 대기할 수 있습니다.
+대신 "비동기" 시스템에서는, 작업이 끝나면 컴퓨터/프로그램이 하러 갔던 일을 마칠 때까지 잠시(몇 마이크로초) 줄에서 기다렸다가, 다시 돌아와 결과를 받아 이를 사용해 작업을 계속할 수 있습니다.
 
-"동기"("비동기"의 반대)는 컴퓨터 / 프로그램이 상이한 작업들간 전환을 하기 전에 그것이 대기를 동반하게 될지라도 모든 순서를 따르기 때문에 "순차"라는 용어로도 흔히 불립니다.
+"동기"(“비동기”의 반대)는 보통 "순차"라는 용어로도 불리는데, 컴퓨터/프로그램이 다른 작업으로 전환하기 전에 모든 단계를 순서대로 따르기 때문이며, 그 단계들에 기다림이 포함되어 있더라도 마찬가지입니다.
 
-### 동시성과 버거
+### 동시성과 햄버거 { #concurrency-and-burgers }
 
-위에서 설명한 **비동기** 코드에 대한 개념은 종종 **"동시성"**이라고도 불립니다. 이것은 **"병렬성"**과는 다릅니다.
+위에서 설명한 **비동기** 코드에 대한 개념은 때때로 **"동시성"**이라고도 불립니다. 이는 **"병렬성"**과는 다릅니다.
 
-**동시성**과 **병렬성**은 모두 "동시에 일어나는 서로 다른 일들"과 관련이 있습니다.
+**동시성**과 **병렬성**은 모두 "대략 같은 시간에 일어나는 서로 다른 일들"과 관련이 있습니다.
 
 하지만 *동시성*과 *병렬성*의 세부적인 개념에는 꽤 차이가 있습니다.
 
-차이를 확인하기 위해, 다음의 버거에 대한 이야기를 상상해보십시오:
+차이를 보기 위해, 다음의 햄버거 이야기를 상상해보세요:
 
-### 동시 버거
+### 동시 햄버거 { #concurrent-burgers }
 
-당신은 짝사랑 상대 😍 와 패스트푸드 🍔 를 먹으러 갔습니다. 당신은 점원 💁 이 당신 앞에 있는 사람들의 주문을 받을 동안 줄을 서서 기다리고 있습니다.
+여러분은 짝사랑 상대와 패스트푸드를 먹으러 갔고, 점원이 여러분 앞 사람들의 주문을 받는 동안 줄을 서서 기다립니다. 😍
 
-이제 당신의 순서가 되어서, 당신은 당신과 짝사랑 상대 😍 를 위한 두 개의 고급스러운 버거 🍔 를 주문합니다.
+<img src="/img/async/concurrent-burgers/concurrent-burgers-01.png" class="illustration">
 
-당신이 돈을 냅니다 💸.
+이제 여러분 차례가 되어, 여러분과 짝사랑 상대를 위해 매우 고급스러운 햄버거 2개를 주문합니다. 🍔🍔
 
-점원 💁 은 주방 👨‍🍳 에 요리를 하라고 전달하고, 따라서 그들은 당신의 버거 🍔 를 준비해야한다는 사실을 알게됩니다(그들이 지금은 당신 앞 고객들의 주문을 준비하고 있을지라도 말입니다).
+<img src="/img/async/concurrent-burgers/concurrent-burgers-02.png" class="illustration">
 
-점원 💁 은 당신의 순서가 적힌 번호표를 줍니다.
+점원은 주방의 요리사에게 무언가를 말해, (지금은 앞선 손님들의 주문을 준비하고 있더라도) 여러분의 햄버거를 준비해야 한다는 것을 알게 합니다.
 
-기다리는 동안, 당신은 짝사랑 상대 😍 와 함께 테이블을 고르고, 자리에 앉아 오랫동안 (당신이 주문한 버거는 꽤나 고급스럽기 때문에 준비하는데 시간이 조금 걸립니다 ✨🍔✨) 대화를 나눕니다.
+<img src="/img/async/concurrent-burgers/concurrent-burgers-03.png" class="illustration">
 
-짝사랑 상대 😍 와 테이블에 앉아서 버거 🍔 를 기다리는 동안, 그 사람 😍 이 얼마나 멋지고, 사랑스럽고, 똑똑한지 감탄하며 시간을 보냅니다 ✨😍✨.
+여러분이 돈을 냅니다. 💸
 
-짝사랑 상대 😍 와 기다리면서 얘기하는 동안, 때때로, 당신은 당신의 차례가 되었는지 보기 위해 카운터의 번호를 확인합니다.
+점원은 여러분 차례 번호를 줍니다.
 
-그러다 어느 순간, 당신의 차례가 됩니다. 카운터에 가서, 버거 🍔 를 받고, 테이블로 다시 돌아옵니다.
+<img src="/img/async/concurrent-burgers/concurrent-burgers-04.png" class="illustration">
 
-당신과 짝사랑 상대 😍 는 버거 🍔 를 먹으며 좋은 시간을 보냅니다 ✨.
+기다리는 동안, 여러분은 짝사랑 상대와 함께 자리를 고르고 앉아 오랫동안 대화를 나눕니다(여러분의 햄버거는 매우 고급스럽기 때문에 준비하는 데 시간이 좀 걸립니다).
+
+짝사랑 상대와 테이블에 앉아 햄버거를 기다리는 동안, 그 사람이 얼마나 멋지고 귀엽고 똑똑한지 감탄하며 시간을 보낼 수 있습니다 ✨😍✨.
+
+<img src="/img/async/concurrent-burgers/concurrent-burgers-05.png" class="illustration">
+
+기다리며 대화하는 동안, 때때로 여러분은 카운터에 표시되는 번호를 확인해 여러분 차례인지 봅니다.
+
+그러다 어느 순간 마침내 여러분 차례가 됩니다. 여러분은 카운터에 가서 햄버거를 받고, 테이블로 돌아옵니다.
+
+<img src="/img/async/concurrent-burgers/concurrent-burgers-06.png" class="illustration">
+
+여러분과 짝사랑 상대는 햄버거를 먹으며 좋은 시간을 보냅니다. ✨
+
+<img src="/img/async/concurrent-burgers/concurrent-burgers-07.png" class="illustration">
+
+/// info | 정보
+
+아름다운 일러스트: <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. 🎨
+
+///
 
 ---
 
-당신이 이 이야기에서 컴퓨터 / 프로그램 🤖 이라고 상상해보십시오.
+이 이야기에서 여러분이 컴퓨터/프로그램 🤖 이라고 상상해보세요.
 
-줄을 서서 기다리는 동안, 당신은 아무것도 하지 않고 😴 당신의 차례를 기다리며, 어떠한 "생산적인" 일도 하지 않습니다. 하지만 점원 💁 이 (음식을 준비하지는 않고) 주문을 받기만 하기 때문에 줄이 빨리 줄어들어서 괜찮습니다.
+줄을 서 있는 동안, 여러분은 그냥 쉬고 😴, 차례를 기다리며, 그다지 "생산적인" 일을 하지 않습니다. 하지만 점원은 주문만 받지(음식을 준비하진 않기) 때문에 줄이 빠르게 줄어들어 괜찮습니다.
 
-그다음, 당신이 차례가 오면, 당신은 실제로 "생산적인" 일 🤓 을 합니다. 당신은 메뉴를 보고, 무엇을 먹을지 결정하고, 짝사랑 상대 😍 의 선택을 묻고, 돈을 내고 💸 , 맞는 카드를 냈는지 확인하고, 비용이 제대로 지불되었는지 확인하고, 주문이 제대로 들어갔는지 확인을 하는 작업 등등을 수행합니다.
+그 다음 여러분 차례가 되면, 여러분은 실제로 "생산적인" 일을 합니다. 메뉴를 처리하고, 무엇을 먹을지 결정하고, 짝사랑 상대의 선택을 확인하고, 결제하고, 올바른 현금이나 카드를 냈는지 확인하고, 정확히 청구되었는지 확인하고, 주문에 올바른 항목들이 들어갔는지 확인하는 등등을 합니다.
 
-하지만 이후에는, 버거 🍔 를 아직 받지 못했음에도, 버거가 준비될 때까지 기다려야 🕙 하기 때문에 점원 💁 과의 작업은 "일시정지" ⏸  상태입니다.
+하지만 그 다음에는, 아직 햄버거를 받지 못했더라도, 햄버거가 준비될 때까지 기다려야 🕙 하므로 점원과의 작업은 "일시정지" ⏸ 상태입니다.
 
-하지만 번호표를 받고 카운터에서 나와 테이블에 앉으면, 당신은 짝사랑 상대 😍 와 그 "작업"  ⏯ 🤓 에 번갈아가며 🔀  집중합니다. 그러면 당신은 다시 짝사랑 상대 😍 에게 작업을 거는 매우 "생산적인" 일 🤓 을 합니다.
+하지만 번호를 들고 카운터에서 벗어나 테이블에 앉으면, 여러분은 짝사랑 상대에게 관심을 전환 🔀 하고, 그에 대한 "작업" ⏯ 🤓 을 할 수 있습니다. 그러면 여러분은 다시 짝사랑 상대에게 작업을 거는 매우 "생산적인" 일을 하게 됩니다 😍.
 
-점원 💁 이 카운터 화면에 당신의 번호를 표시함으로써 "버거 🍔 가 준비되었습니다"라고 해도, 당신은 즉시 뛰쳐나가지는 않을 것입니다. 당신은 당신의 번호를 갖고있고, 다른 사람들은 그들의 번호를 갖고있기 때문에, 아무도 당신의 버거 🍔 를 훔쳐가지 않는다는 사실을 알기 때문입니다.
+그 다음 점원 💁 이 카운터 화면에 여러분 번호를 띄워 "햄버거를 만들었어요"라고 말하지만, 표시된 번호가 여러분 차례로 바뀌었다고 해서 즉시 미친 듯이 뛰어가지는 않습니다. 여러분은 여러분 번호를 갖고 있고, 다른 사람들은 그들의 번호를 갖고 있으니, 아무도 여러분 햄버거를 훔쳐갈 수 없다는 것을 알기 때문입니다.
 
-그래서 당신은 짝사랑 상대 😍 가 이야기를 끝낼 때까지 기다린 후 (현재 작업 완료 ⏯ / 진행 중인 작업 처리 🤓 ), 정중하게 미소짓고 버거를 가지러 가겠다고 말합니다 ⏸.
+그래서 여러분은 짝사랑 상대가 이야기를 끝낼 때까지 기다린 다음(현재 작업 ⏯ / 처리 중인 작업 🤓 을 끝내고), 부드럽게 미소 지으며 햄버거를 가지러 가겠다고 말합니다 ⏸.
 
-그다음 당신은 카운터에 가서 🔀 , 초기 작업을 이제 완료하고 ⏯ , 버거 🍔 를 받고, 감사하다고 말하고 테이블로 가져옵니다. 이로써 카운터와의 상호작용 단계 / 작업이 종료됩니다 ⏹.
+그 다음 여러분은 카운터로 가서 🔀, 이제 끝난 초기 작업 ⏯ 으로 돌아와 햄버거를 받고, 감사 인사를 하고, 테이블로 가져옵니다. 이로써 카운터와 상호작용하는 그 단계/작업이 끝납니다 ⏹. 그리고 이는 새로운 작업인 "햄버거 먹기" 🔀 ⏯ 를 만들지만, 이전 작업인 "햄버거 받기"는 끝났습니다 ⏹.
 
-이전 작업인 "버거 받기"가 종료되면 ⏹ "버거 먹기"라는 새로운 작업이 생성됩니다 🔀 ⏯.
+### 병렬 햄버거 { #parallel-burgers }
 
-### 병렬 버거
+이제 이것이 "동시 햄버거"가 아니라 "병렬 햄버거"라고 상상해봅시다.
 
-이제 "동시 버거"가 아닌 "병렬 버거"를 상상해보십시오.
+여러분은 짝사랑 상대와 함께 병렬 패스트푸드를 먹으러 갑니다.
 
-당신은 짝사랑 상대 😍 와 함께 병렬 패스트푸드 🍔 를 먹으러 갔습니다.
+여러분은 여러 명(예: 8명)의 점원이 동시에 요리사이기도 하여 여러분 앞 사람들의 주문을 받는 동안 줄을 서 있습니다.
 
-당신은 여러명(8명이라고 가정합니다)의 점원이 당신 앞 사람들의 주문을 받으며 동시에 요리 👩‍🍳👨‍🍳👩‍🍳👨‍🍳👩‍🍳👨‍🍳👩‍🍳👨‍🍳 도 하는 동안 줄을 서서 기다립니다.
+여러분 앞의 모든 사람들은, 8명의 점원 각각이 다음 주문을 받기 전에 바로 햄버거를 준비하러 가기 때문에, 카운터를 떠나지 않고 햄버거가 준비될 때까지 기다립니다.
 
-당신 앞 모든 사람들이 버거가 준비될 때까지 카운터에서 떠나지 않고 기다립니다 🕙 . 왜냐하면 8명의 직원들이 다음 주문을 받기 전에 버거를 준비하러 가기 때문입니다.
+<img src="/img/async/parallel-burgers/parallel-burgers-01.png" class="illustration">
 
-마침내 당신의 차례가 왔고, 당신은 당신과 짝사랑 상대 😍 를 위한 두 개의 고급스러운 버거 🍔 를 주문합니다.
+마침내 여러분 차례가 되어, 여러분과 짝사랑 상대를 위해 매우 고급스러운 햄버거 2개를 주문합니다.
 
-당신이 비용을 지불합니다 💸 .
+여러분이 돈을 냅니다 💸.
 
-점원이 주방에 갑니다 👨‍🍳 .
+<img src="/img/async/parallel-burgers/parallel-burgers-02.png" class="illustration">
 
-당신은 번호표가 없기 때문에 누구도 당신의 버거 🍔 를 대신 가져갈 수 없도록 카운터에 서서 기다립니다 🕙 .
+점원은 주방으로 갑니다.
 
-당신과 짝사랑 상대 😍 는 다른 사람이 새치기해서 버거를 가져가지 못하게 하느라 바쁘기 때문에 🕙 , 짝사랑 상대에게 주의를 기울일 수 없습니다 😞 .
+여러분은 번호표가 없으므로, 다른 사람이 여러분보다 먼저 햄버거를 가져가지 못하도록 카운터 앞에 서서 기다립니다 🕙.
 
-이것은 "동기" 작업이고, 당신은 점원/요리사 👨‍🍳 와 "동기화" 되었습니다. 당신은 기다리고 🕙 , 점원/요리사 👨‍🍳 가 버거 🍔  준비를 완료한 후 당신에게 주거나, 누군가가 그것을 가져가는 그 순간에 그 곳에 있어야합니다.
+<img src="/img/async/parallel-burgers/parallel-burgers-03.png" class="illustration">
 
-카운터 앞에서 오랫동안 기다린 후에 🕙 , 점원/요리사 👨‍🍳 가 당신의 버거 🍔 를 가지고 돌아옵니다.
+여러분과 짝사랑 상대는 햄버거가 나오면 다른 사람이 끼어들어 가져가지 못하게 하느라 바쁘기 때문에, 짝사랑 상대에게 집중할 수 없습니다. 😞
 
-당신은 버거를 받고 짝사랑 상대와 함께 테이블로 돌아옵니다.
+이것은 "동기" 작업이며, 여러분은 점원/요리사 👨‍🍳 와 "동기화"되어 있습니다. 점원/요리사 👨‍🍳 가 햄버거를 완성해 여러분에게 주는 정확한 순간에 그 자리에 있어야 하므로, 여러분은 기다려야 🕙 하고, 그렇지 않으면 다른 사람이 가져갈 수도 있습니다.
 
-단지 먹기만 하다가, 다 먹었습니다 🍔 ⏹.
+<img src="/img/async/parallel-burgers/parallel-burgers-04.png" class="illustration">
 
-카운터 앞에서 기다리면서 🕙  너무 많은 시간을 허비했기 때문에 대화를 하거나 작업을 걸 시간이 거의 없었습니다 😞 .
+그러다 점원/요리사 👨‍🍳 가 카운터 앞에서 오랫동안 기다린 🕙 끝에 마침내 햄버거를 가지고 돌아옵니다.
+
+<img src="/img/async/parallel-burgers/parallel-burgers-05.png" class="illustration">
+
+여러분은 햄버거를 받아 짝사랑 상대와 테이블로 갑니다.
+
+그냥 먹고, 끝입니다. ⏹
+
+<img src="/img/async/parallel-burgers/parallel-burgers-06.png" class="illustration">
+
+대부분의 시간을 카운터 앞에서 기다리는 데 🕙 썼기 때문에, 대화하거나 작업을 걸 시간은 많지 않았습니다. 😞
+
+/// info | 정보
+
+아름다운 일러스트: <a href="https://www.instagram.com/ketrinadrawsalot" class="external-link" target="_blank">Ketrina Thompson</a>. 🎨
+
+///
 
 ---
 
-이 병렬 버거 시나리오에서, 당신은 기다리고 🕙 , 오랜 시간동안 "카운터에서 기다리는" 🕙 데에 주의를 기울이는 ⏯ 두 개의 프로세서(당신과 짝사랑 상대😍)를 가진 컴퓨터 / 프로그램 🤖 입니다.
+이 병렬 햄버거 시나리오에서, 여러분은 두 개의 프로세서(여러분과 짝사랑 상대)를 가진 컴퓨터/프로그램 🤖 이며, 둘 다 기다리고 🕙 오랫동안 "카운터에서 기다리기" 🕙 에 주의를 ⏯ 기울입니다.
 
-패스트푸드점에는 8개의 프로세서(점원/요리사) 👩‍🍳👨‍🍳👩‍🍳👨‍🍳👩‍🍳👨‍🍳👩‍🍳👨‍🍳 가 있습니다. 동시 버거는 단 두 개(한 명의 직원과 한 명의 요리사) 💁 👨‍🍳 만을 가지고 있었습니다.
+패스트푸드점에는 8개의 프로세서(점원/요리사)가 있습니다. 동시 햄버거 가게는 2개(점원 1명, 요리사 1명)만 있었을 것입니다.
 
-하지만 여전히, 병렬 버거 예시가 최선은 아닙니다 😞 .
+하지만 여전히 최종 경험은 그다지 좋지 않습니다. 😞
 
 ---
 
-이 예시는 버거🍔 이야기와 결이 같습니다.
+이것이 햄버거의 병렬 버전에 해당하는 이야기입니다. 🍔
 
-더 "현실적인" 예시로, 은행을 상상해보십시오.
+좀 더 "현실적인" 예시로, 은행을 상상해보세요.
 
-최근까지, 대다수의 은행에는 다수의 은행원들 👨‍💼👨‍💼👨‍💼👨‍💼 과 긴 줄 🕙🕙🕙🕙🕙🕙🕙🕙 이 있습니다.
+최근까지 대부분의 은행에는 여러 은행원 👨‍💼👨‍💼👨‍💼👨‍💼 과 긴 줄 🕙🕙🕙🕙🕙🕙🕙🕙 이 있었습니다.
 
-모든 은행원들은 한 명 한 명의 고객들을 차례로 상대합니다 👨‍💼⏯ .
+모든 은행원이 한 고객씩 순서대로 모든 일을 처리합니다 👨‍💼⏯.
 
-그리고 당신은 오랫동안 줄에서 기다려야하고 🕙 , 그렇지 않으면 당신의 차례를 잃게 됩니다.
+그리고 여러분은 오랫동안 줄에서 기다려야 🕙 하며, 그렇지 않으면 차례를 잃습니다.
 
-아마 당신은 은행 🏦 심부름에 짝사랑 상대 😍 를 데려가고 싶지는 않을 것입니다.
+아마 은행 🏦 업무를 보러 갈 때 짝사랑 상대 😍 를 데려가고 싶지는 않을 것입니다.
 
-### 버거 예시의 결론
+### 햄버거 예시의 결론 { #burger-conclusion }
 
-"짝사랑 상대와의 패스트푸드점 버거" 시나리오에서, 오랜 기다림 🕙 이 있기 때문에 동시 시스템 ⏸🔀⏯ 을 사용하는 것이 더 합리적입니다.
+"짝사랑 상대와의 패스트푸드점 햄버거" 시나리오에서는 기다림 🕙 이 많기 때문에, 동시 시스템 ⏸🔀⏯ 을 사용하는 것이 훨씬 더 합리적입니다.
 
-대다수의 웹 응용프로그램의 경우가 그러합니다.
+대부분의 웹 애플리케이션이 그렇습니다.
 
-매우 많은 수의 유저가 있지만, 서버는 그들의 요청을 전송하기 위해 그닥-좋지-않은 연결을 기다려야 합니다 🕙 .
+매우 많은 사용자들이 있고, 서버는 그들의 좋지 않은 연결을 통해 요청이 전송되기를 기다립니다 🕙.
 
-그리고 응답이 돌아올 때까지 다시 기다려야 합니다 🕙 .
+그리고 응답이 돌아오기를 다시 기다립니다 🕙.
 
-이 "기다림" 🕙 은 마이크로초 단위이지만, 모두 더해지면, 결국에는 매우 긴 대기시간이 됩니다.
+이 "기다림" 🕙 은 마이크로초 단위로 측정되지만, 모두 합치면 결국 꽤 많은 대기 시간이 됩니다.
 
-따라서 웹 API를 위해 비동기 ⏸🔀⏯ 코드를 사용하는 것이 합리적입니다.
+그래서 웹 API에는 비동기 ⏸🔀⏯ 코드를 사용하는 것이 매우 합리적입니다.
 
-대부분의 존재하는 유명한 파이썬 프레임워크 (Flask와 Django 등)은 새로운 비동기 기능들이 파이썬에 존재하기 전에 만들어졌습니다. 그래서, 그들의 배포 방식은 병렬 실행과 새로운 기능만큼 강력하지는 않은 예전 버전의 비동기 실행을 지원합니다.
+이러한 종류의 비동기성은 NodeJS가 인기 있는 이유(비록 NodeJS가 병렬은 아니지만)이자, 프로그래밍 언어로서 Go의 강점입니다.
 
-비동기 웹 파이썬(ASGI)에 대한 주요 명세가 웹소켓을 지원하기 위해 Django에서 개발 되었음에도 그렇습니다.
+그리고 이것이 **FastAPI**로 얻는 것과 같은 수준의 성능입니다.
 
-이러한 종류의 비동기성은 (NodeJS는 병렬적이지 않음에도) NodeJS가 사랑받는 이유이고, 프로그래밍 언어로서의 Go의 강점입니다.
+또한 병렬성과 비동기성을 동시에 사용할 수 있으므로, 대부분의 테스트된 NodeJS 프레임워크보다 더 높은 성능을 얻고, C에 더 가까운 컴파일 언어인 Go와 동등한 성능을 얻을 수 있습니다 <a href="https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1" class="external-link" target="_blank">(모두 Starlette 덕분입니다)</a>.
 
-그리고 **FastAPI**를 사용함으로써 동일한 성능을 낼 수 있습니다.
+### 동시성이 병렬성보다 더 나은가요? { #is-concurrency-better-than-parallelism }
 
-또한 병렬성과 비동기성을 동시에 사용할 수 있기 때문에, 대부분의 테스트가 완료된 NodeJS 프레임워크보다 더 높은 성능을 얻고 C에 더 가까운 컴파일 언어인 Go와 동등한 성능을 얻을 수 있습니다<a href="https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1" class="external-link" target="_blank">(모두 Starlette 덕분입니다)</a>.
+아니요! 그게 이 이야기의 교훈은 아닙니다.
 
-### 동시성이 병렬성보다 더 나은가?
+동시성은 병렬성과 다릅니다. 그리고 많은 기다림이 포함되는 **특정한** 시나리오에서는 더 낫습니다. 그 때문에 웹 애플리케이션 개발에서는 일반적으로 병렬성보다 훨씬 더 낫습니다. 하지만 모든 것에 해당하진 않습니다.
 
-그렇지 않습니다! 그것이 이야기의 교훈은 아닙니다.
+그래서 균형을 맞추기 위해, 다음의 짧은 이야기를 상상해보세요:
 
-동시성은 병렬성과 다릅니다. 그리고 그것은 많은 대기를 필요로하는 **특정한** 시나리오에서는 더 낫습니다. 이로 인해, 웹 응용프로그램 개발에서 동시성이 병렬성보다 일반적으로 훨씬 낫습니다. 하지만 모든 경우에 그런 것은 아닙니다.
-
-따라서, 균형을 맞추기 위해, 다음의 짧은 이야기를 상상해보십시오:
-
-> 당신은 크고, 더러운 집을 청소해야합니다.
+> 여러분은 크고 더러운 집을 청소해야 합니다.
 
 *네, 이게 전부입니다*.
 
 ---
 
-어디에도 대기 🕙 는 없고, 집안 곳곳에서 해야하는 많은 작업들만 있습니다.
+어디에도 기다림 🕙 은 없고, 집의 여러 장소에서 해야 할 일이 많을 뿐입니다.
 
-버거 예시처럼 처음에는 거실, 그 다음은 부엌과 같은 식으로 순서를 정할 수도 있으나, 무엇도 기다리지 🕙 않고 계속해서 청소 작업만 수행하기 때문에, 순서는 아무런 영향을 미치지 않습니다.
+햄버거 예시처럼 거실부터, 그 다음은 부엌처럼 순서를 정할 수도 있지만, 어떤 것도 기다리지 🕙 않고 계속 청소만 하기 때문에, 순서는 아무런 영향을 주지 않습니다.
 
-순서가 있든 없든 동일한 시간이 소요될 것이고(동시성) 동일한 양의 작업을 하게 될 것입니다.
+순서가 있든 없든(동시성) 끝내는 데 걸리는 시간은 같고, 같은 양의 일을 하게 됩니다.
 
-하지만 이 경우에서, 8명의 전(前)-점원/요리사이면서-현(現)-청소부 👩‍🍳👨‍🍳👩‍🍳👨‍🍳👩‍🍳👨‍🍳👩‍🍳👨‍🍳 를 고용할 수 있고, 그들 각자(그리고 당신)가 집의 한 부분씩 맡아 청소를 한다면, 당신은 **병렬적**으로 작업을 수행할 수 있고, 조금의 도움이 있다면, 훨씬 더 빨리 끝낼 수 있습니다.
+하지만 이 경우, 전(前) 점원/요리사이자 현(現) 청소부가 된 8명을 데려올 수 있고, 각자(그리고 여러분)가 집의 구역을 하나씩 맡아 청소한다면, 추가 도움과 함께 모든 일을 **병렬**로 수행하여 훨씬 더 빨리 끝낼 수 있습니다.
 
-이 시나리오에서, (당신을 포함한) 각각의 청소부들은 프로세서가 될 것이고, 각자의 역할을 수행합니다.
+이 시나리오에서 (여러분을 포함한) 각 청소부는 프로세서가 되어, 맡은 일을 수행합니다.
 
-실행 시간의 대부분이 대기가 아닌 실제 작업에 소요되고, 컴퓨터에서 작업은 <abbr title="Central Processing Unit">CPU</abbr>에서 이루어지므로, 이러한 문제를 "CPU에 묶였"다고 합니다.
+그리고 실행 시간의 대부분이 기다림이 아니라 실제 작업에 쓰이고, 컴퓨터에서 작업은 <abbr title="Central Processing Unit - 중앙 처리 장치">CPU</abbr>가 수행하므로, 이런 문제를 "CPU bound"라고 부릅니다.
 
 ---
 
-CPU에 묶인 연산에 관한 흔한 예시는 복잡한 수학 처리를 필요로 하는 경우입니다.
+CPU bound 작업의 흔한 예시는 복잡한 수학 처리가 필요한 것들입니다.
 
 예를 들어:
 
-* **오디오** 또는 **이미지** 처리.
-* **컴퓨터 비전**: 하나의 이미지는 수백개의 픽셀로 구성되어있고, 각 픽셀은 3개의 값 / 색을 갖고 있으며, 일반적으로 해당 픽셀들에 대해 동시에 무언가를 계산해야하는 처리.
-* **머신러닝**: 일반적으로 많은 "행렬"과 "벡터" 곱셈이 필요합니다. 거대한 스프레드 시트에 수들이 있고 그 수들을 동시에 곱해야 한다고 생각해보십시오.
-* **딥러닝**: 머신러닝의 하위영역으로, 동일한 예시가 적용됩니다. 단지 이 경우에는 하나의 스프레드 시트에 곱해야할 수들이 있는 것이 아니라, 거대한 세트의 스프레드 시트들이 있고, 많은 경우에, 이 모델들을 만들고 사용하기 위해 특수한 프로세서를 사용합니다.
+* **오디오** 또는 **이미지** 처리
+* **컴퓨터 비전**: 이미지는 수백만 개의 픽셀로 구성되며, 각 픽셀은 3개의 값/색을 갖습니다. 보통 그 픽셀들에 대해 동시에 무언가를 계산해야 합니다.
+* **머신러닝**: 보통 많은 "matrix"와 "vector" 곱셈이 필요합니다. 숫자가 있는 거대한 스프레드시트를 생각하고, 그 모든 수를 동시에 곱한다고 생각해보세요.
+* **딥러닝**: 머신러닝의 하위 분야이므로 동일하게 적용됩니다. 다만 곱해야 할 숫자가 있는 스프레드시트가 하나가 아니라, 아주 큰 집합이며, 많은 경우 그 모델을 만들고/또는 사용하기 위해 특별한 프로세서를 사용합니다.
 
-### 동시성 + 병렬성: 웹 + 머신러닝
+### 동시성 + 병렬성: 웹 + 머신러닝 { #concurrency-parallelism-web-machine-learning }
 
-**FastAPI**를 사용하면 웹 개발에서는 매우 흔한 동시성의 이점을 (NodeJS의 주된 매력만큼) 얻을 수 있습니다.
+**FastAPI**를 사용하면 웹 개발에서 매우 흔한 동시성의 이점을( NodeJS의 주요 매력과 같은) 얻을 수 있습니다.
 
-뿐만 아니라 머신러닝 시스템과 같이 **CPU에 묶인** 작업을 위해 병렬성과 멀티프로세싱(다수의 프로세스를 병렬적으로 동작시키는 것)을 이용하는 것도 가능합니다.
+또한 머신러닝 시스템처럼 **CPU bound** 워크로드에 대해 병렬성과 멀티프로세싱(여러 프로세스를 병렬로 실행)을 활용할 수도 있습니다.
 
-파이썬이 **데이터 사이언스**, 머신러닝과 특히 딥러닝에 의 주된 언어라는 간단한 사실에 더해서, 이것은 FastAPI를 데이터 사이언스 / 머신러닝 웹 API와 응용프로그램에 (다른 것들보다) 좋은 선택지가 되게 합니다.
+이것은 파이썬이 **데이터 사이언스**, 머신러닝, 특히 딥러닝의 주요 언어라는 단순한 사실과 더해져, FastAPI를 데이터 사이언스/머신러닝 웹 API 및 애플리케이션(그 외에도 많은 것들)에 매우 잘 맞는 선택으로 만들어 줍니다.
 
-배포시 병렬을 어떻게 가능하게 하는지 알고싶다면, [배포](deployment/index.md){.internal-link target=_blank}문서를 참고하십시오.
+프로덕션에서 이 병렬성을 어떻게 달성하는지 보려면 [배포](deployment/index.md){.internal-link target=_blank} 섹션을 참고하세요.
 
-## `async`와  `await`
+## `async`와 `await` { #async-and-await }
 
-최신 파이썬 버전에는 비동기 코드를 정의하는 매우 직관적인 방법이 있습니다. 이는 이것을 평범한 "순차적" 코드로 보이게 하고, 적절한 순간에 당신을 위해 "대기"합니다.
+최신 파이썬 버전에는 비동기 코드를 정의하는 매우 직관적인 방법이 있습니다. 이 방법은 이를 평범한 "순차" 코드처럼 보이게 하고, 적절한 순간에 여러분을 위해 "기다림"을 수행합니다.
 
-연산이 결과를 전달하기 전에 대기를 해야하고 새로운 파이썬 기능들을 지원한다면, 이렇게 코드를 작성할 수 있습니다:
+결과를 주기 전에 기다림이 필요한 작업이 있고, 이러한 새로운 파이썬 기능을 지원한다면, 다음과 같이 작성할 수 있습니다:
 
 ```Python
 burgers = await get_burgers(2)
 ```
 
-여기서 핵심은 `await`입니다. 이것은 파이썬에게 `burgers` 결과를 저장하기 이전에 `get_burgers(2)`의 작업이 완료되기를 🕙 기다리라고 ⏸ 말합니다. 이로 인해, 파이썬은 그동안 (다른 요청을 받는 것과 같은) 다른 작업을 수행해도 된다는 것을 🔀 ⏯ 알게될 것입니다.
+여기서 핵심은 `await`입니다. 이는 파이썬에게 `get_burgers(2)`가 그 일을 끝낼 때까지 🕙 기다리도록 ⏸ 말하고, 그 결과를 `burgers`에 저장하기 전에 완료되기를 기다리라고 합니다. 이를 통해 파이썬은 그동안(예: 다른 요청을 받는 것처럼) 다른 일을 하러 갈 수 있다는 것 🔀 ⏯ 을 알게 됩니다.
 
-`await`가 동작하기 위해, 이것은 비동기를 지원하는 함수 내부에 있어야 합니다. 이를 위해서 함수를 `async def`를 사용해 정의하기만 하면 됩니다:
+`await`가 동작하려면, 이 비동기성을 지원하는 함수 내부에 있어야 합니다. 그러려면 `async def`로 선언하기만 하면 됩니다:
 
 ```Python hl_lines="1"
 async def get_burgers(number: int):
-    # Do some asynchronous stuff to create the burgers
+    # 햄버거를 만들기 위한 비동기 처리를 수행
     return burgers
 ```
 
-...`def`를 사용하는 대신:
+...`def` 대신:
 
 ```Python hl_lines="2"
-# This is not asynchronous
+# 비동기가 아닙니다
 def get_sequential_burgers(number: int):
-    # Do some sequential stuff to create the burgers
+    # 햄버거를 만들기 위한 순차 처리를 수행
     return burgers
 ```
 
-`async def`를 사용하면, 파이썬은 해당 함수 내에서 `await` 표현에 주의해야한다는 사실과, 해당 함수의 실행을 "일시정지"⏸하고 다시 돌아오기 전까지 다른 작업을 수행🔀할 수 있다는 것을 알게됩니다.
+`async def`를 사용하면, 파이썬은 그 함수 내부에서 `await` 표현식에 주의해야 하며, 그 함수의 실행을 "일시정지" ⏸ 하고 다시 돌아오기 전에 다른 일을 하러 갈 수 있다는 것 🔀 을 알게 됩니다.
 
-`async def`f 함수를 호출하고자 할 때, "대기"해야합니다. 따라서, 아래는 동작하지 않습니다.
+`async def` 함수를 호출하고자 할 때는, 그 함수를 "await" 해야 합니다. 따라서 아래는 동작하지 않습니다:
 
 ```Python
-# This won't work, because get_burgers was defined with: async def
+# 동작하지 않습니다. get_burgers는 async def로 정의되었습니다
 burgers = get_burgers(2)
 ```
 
 ---
 
-따라서, `await`f를 사용해서 호출할 수 있는 라이브러리를 사용한다면, 다음과 같이 `async def`를 사용하는 *경로 작동 함수*를 생성해야 합니다:
+따라서, `await`로 호출할 수 있다고 말하는 라이브러리를 사용한다면, 다음과 같이 그것을 사용하는 *경로 처리 함수*를 `async def`로 만들어야 합니다:
 
 ```Python hl_lines="2-3"
 @app.get('/burgers')
@@ -317,94 +349,96 @@ async def read_burgers():
     return burgers
 ```
 
-### 더 세부적인 기술적 사항
+### 더 세부적인 기술적 사항 { #more-technical-details }
 
-`await`가 `async def`를 사용하는 함수 내부에서만 사용이 가능하다는 것을 눈치채셨을 것입니다.
+`await`는 `async def`로 정의된 함수 내부에서만 사용할 수 있다는 것을 눈치채셨을 것입니다.
 
-하지만 동시에, `async def`로 정의된 함수들은 "대기"되어야만 합니다. 따라서, `async def`를 사용한 함수들은 역시 `async def`를 사용한 함수 내부에서만 호출될 수 있습니다.
+하지만 동시에, `async def`로 정의된 함수는 "await" 되어야 합니다. 따라서 `async def`를 가진 함수는 `async def`로 정의된 함수 내부에서만 호출될 수 있습니다.
 
-그렇다면 닭이 먼저냐, 달걀이 먼저냐, 첫 `async` 함수를 어떻게 호출할 수 있겠습니까?
+그렇다면, 닭이 먼저냐 달걀이 먼저냐처럼, 첫 번째 `async` 함수는 어떻게 호출할 수 있을까요?
 
-**FastAPI**를 사용해 작업한다면 이것을 걱정하지 않아도 됩니다. 왜냐하면 그 "첫" 함수는 당신의 *경로 작동 함수*가 될 것이고, FastAPI는 어떻게 올바르게 처리할지 알고있기 때문입니다.
+**FastAPI**로 작업한다면 걱정할 필요가 없습니다. 그 "첫" 함수는 여러분의 *경로 처리 함수*가 될 것이고, FastAPI는 올바르게 처리하는 방법을 알고 있기 때문입니다.
 
-하지만 FastAPI를 사용하지 않고 `async` / `await`를 사용하고 싶다면, 이 역시 가능합니다.
+하지만 FastAPI 없이 `async` / `await`를 사용하고 싶다면, 그것도 가능합니다.
 
-### 당신만의 비동기 코드 작성하기
+### 여러분만의 async 코드 작성하기 { #write-your-own-async-code }
 
-Starlette(그리고 FastAPI)는 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>를 기반으로 하고있고, 따라서 파이썬 표준 라이브러리인 <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a> 및 <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>와 호환됩니다.
+Starlette(그리고 **FastAPI**)는 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>를 기반으로 하고 있으며, 파이썬 표준 라이브러리 <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a>와 <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a> 모두와 호환됩니다.
 
-특히, 코드에서 고급 패턴이 필요한 고급 동시성을 사용하는 경우 직접적으로 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>를 사용할 수 있습니다.
+특히, 코드에서 더 고급 패턴이 필요한 고급 동시성 사용 사례에서는 직접 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>를 사용할 수 있습니다.
 
-FastAPI를 사용하지 않더라도, 높은 호환성 및 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>의 이점(예: *구조화된 동시성*)을 취하기 위해 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>를 사용해 비동기 응용프로그램을 작성할 수 있습니다.
+그리고 FastAPI를 사용하지 않더라도, 높은 호환성을 확보하고 그 이점(예: *structured concurrency*)을 얻기 위해 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a>로 여러분만의 async 애플리케이션을 작성할 수도 있습니다.
 
-### 비동기 코드의 다른 형태
+저는 AnyIO 위에 얇은 레이어로 또 다른 라이브러리를 만들었는데, 타입 어노테이션을 조금 개선하고 더 나은 **자동완성**, **인라인 오류** 등을 얻기 위한 것입니다. 또한 **이해**하고 **여러분만의 async 코드**를 작성하도록 돕는 친절한 소개와 튜토리얼도 제공합니다: <a href="https://asyncer.tiangolo.com/" class="external-link" target="_blank">Asyncer</a>. 특히 **async 코드와 일반**(blocking/동기) 코드를 **결합**해야 한다면 아주 유용합니다.
 
-파이썬에서 `async`와 `await`를 사용하게 된 것은 비교적 최근의 일입니다.
+### 비동기 코드의 다른 형태 { #other-forms-of-asynchronous-code }
 
-하지만 이로 인해 비동기 코드 작업이 훨씬 간단해졌습니다.
+`async`와 `await`를 사용하는 이 스타일은 언어에서 비교적 최근에 추가되었습니다.
 
-같은 (또는 거의 유사한) 문법은 최신 버전의 자바스크립트(브라우저와 NodeJS)에도 추가되었습니다.
+하지만 비동기 코드를 다루는 일을 훨씬 더 쉽게 만들어 줍니다.
 
-하지만 그 이전에, 비동기 코드를 처리하는 것은 꽤 복잡하고 어려운 일이었습니다.
+거의 동일한 문법이 최근 브라우저와 NodeJS의 최신 JavaScript에도 포함되었습니다.
 
-파이썬의 예전 버전이라면, 스레드 또는 <a href="https://www.gevent.org/" class="external-link" target="_blank">Gevent</a>를 사용할 수 있을 것입니다. 하지만 코드를 이해하고, 디버깅하고, 이에 대해 생각하는게 훨씬 복잡합니다.
+하지만 그 이전에는 비동기 코드를 처리하는 것이 훨씬 더 복잡하고 어려웠습니다.
 
-예전 버전의 NodeJS / 브라우저 자바스크립트라면, "콜백 함수"를 사용했을 것입니다. 그리고 이로 인해 "콜백 지옥"에 빠지게 될 수 있습니다.
+이전 버전의 파이썬에서는 스레드 또는 <a href="https://www.gevent.org/" class="external-link" target="_blank">Gevent</a>를 사용할 수 있었을 것입니다. 하지만 코드를 이해하고, 디버깅하고, 이에 대해 생각하는 것이 훨씬 더 복잡합니다.
 
-## 코루틴
+이전 버전의 NodeJS/브라우저 JavaScript에서는 "callback"을 사용했을 것입니다. 이는 "callback hell"로 이어집니다.
 
-**코루틴**은 `async def` 함수가 반환하는 것을 칭하는 매우 고급스러운 용어일 뿐입니다. 파이썬은 그것이 시작되고 어느 시점에서 완료되지만 내부에 `await`가 있을 때마다 내부적으로 일시정지⏸될 수도 있는 함수와 유사한 것이라는 사실을 알고있습니다.
+## 코루틴 { #coroutines }
 
-그러나 `async` 및 `await`와 함께 비동기 코드를 사용하는 이 모든 기능들은 "코루틴"으로 간단히 요약됩니다. 이것은 Go의 주된 핵심 기능인 "고루틴"에 견줄 수 있습니다.
+**코루틴**은 `async def` 함수가 반환하는 것에 대한 매우 고급스러운 용어일 뿐입니다. 파이썬은 그것이 함수와 비슷한 무언가로서 시작할 수 있고, 어느 시점에 끝나지만, 내부에 `await`가 있을 때마다 내부적으로도 일시정지 ⏸ 될 수 있다는 것을 알고 있습니다.
 
-## 결론
+하지만 `async` 및 `await`와 함께 비동기 코드를 사용하는 이 모든 기능은 종종 "코루틴"을 사용한다고 요약됩니다. 이는 Go의 주요 핵심 기능인 "Goroutines"에 비견됩니다.
 
-상기 문장을 다시 한 번 봅시다:
+## 결론 { #conclusion }
 
-> 최신 파이썬 버전은 **`async` 및 `await`** 문법과 함께 **“코루틴”**이라고 하는 것을 사용하는 **“비동기 코드”**를 지원합니다.
+위의 같은 문장을 다시 봅시다:
 
-이제 이 말을 조금 더 이해할 수 있을 것입니다. ✨
+> 최신 파이썬 버전은 **“코루틴”**이라고 하는 것을 사용하는 **“비동기 코드”**를 **`async` 및 `await`** 문법과 함께 지원합니다.
 
-이것이 (Starlette을 통해) FastAPI를 강하게 하면서 그것이 인상적인 성능을 낼 수 있게 합니다.
+이제 더 이해가 될 것입니다. ✨
 
-## 매우 세부적인 기술적 사항
+이 모든 것이 FastAPI(Starlette을 통해)를 구동하고, 인상적인 성능을 내게 하는 원동력입니다.
+
+## 매우 세부적인 기술적 사항 { #very-technical-details }
 
 /// warning | 경고
 
-이 부분은 넘어가도 됩니다.
+이 부분은 아마 건너뛰어도 됩니다.
 
 이것들은 **FastAPI**가 내부적으로 어떻게 동작하는지에 대한 매우 세부적인 기술사항입니다.
 
-만약 기술적 지식(코루틴, 스레드, 블록킹 등)이 있고 FastAPI가 어떻게 `async def` vs `def`를 다루는지 궁금하다면, 계속하십시오.
+(코루틴, 스레드, 블로킹 등) 같은 기술 지식이 꽤 있고 FastAPI가 `async def`와 일반 `def`를 어떻게 처리하는지 궁금하다면, 계속 읽어보세요.
 
 ///
 
-### 경로 작동 함수
+### 경로 처리 함수 { #path-operation-functions }
 
-경로 작동 함수를 `async def` 대신 일반적인 `def`로 선언하는 경우, (서버를 차단하는 것처럼) 그것을 직접 호출하는 대신 대기중인 외부 스레드풀에서 실행됩니다.
+*경로 처리 함수*를 `async def` 대신 일반적인 `def`로 선언하면, (서버를 블로킹할 수 있으므로 직접 호출하는 대신) 외부 스레드풀에서 실행되고 그 결과를 await 합니다.
 
-만약 상기에 묘사된대로 동작하지 않는 비동기 프로그램을 사용해왔고 약간의 성능 향상 (약 100 나노초)을 위해 `def`를 사용해서 계산만을 위한 사소한 *경로 작동 함수*를 정의해왔다면, **FastAPI**는 이와는 반대라는 것에 주의하십시오. 이러한 경우에, *경로 작동 함수*가 블로킹 <abbr title="Input/Output: 디스크 읽기 또는 쓰기, 네트워크 통신.">I/O</abbr>를 수행하는 코드를 사용하지 않는 한 `async def`를 사용하는 편이 더 낫습니다.
+위에서 설명한 방식으로 동작하지 않는 다른 async 프레임워크를 사용해본 적이 있고, 아주 작은 성능 향상(약 100 나노초)을 위해 계산만 하는 사소한 *경로 처리 함수*를 일반 `def`로 정의하곤 했다면, **FastAPI**에서는 그 효과가 정반대가 될 수 있다는 점에 유의하세요. 이런 경우에는 *경로 처리 함수*에서 블로킹 <abbr title="Input/Output - 입력/출력: 디스크 읽기 또는 쓰기, 네트워크 통신.">I/O</abbr> 를 수행하는 코드를 사용하지 않는 한 `async def`를 사용하는 편이 더 낫습니다.
 
-하지만 두 경우 모두, FastAPI가 당신이 전에 사용하던 프레임워크보다 [더 빠를](index.md#_11){.internal-link target=_blank} (최소한 비견될) 확률이 높습니다.
+그럼에도 두 경우 모두, **FastAPI**는 이전에 사용하던 프레임워크보다 [여전히 더 빠를](index.md#performance){.internal-link target=_blank} 가능성이 높습니다(또는 최소한 비슷합니다).
 
-### 의존성
+### 의존성 { #dependencies }
 
-의존성에도 동일하게 적용됩니다. 의존성이 `async def`가 아닌 표준 `def` 함수라면, 외부 스레드풀에서 실행됩니다.
+[의존성](tutorial/dependencies/index.md){.internal-link target=_blank}에도 동일하게 적용됩니다. 의존성이 `async def` 대신 표준 `def` 함수라면, 외부 스레드풀에서 실행됩니다.
 
-### 하위-의존성
+### 하위 의존성 { #sub-dependencies }
 
-함수 정의시 매개변수로 서로를 필요로하는 다수의 의존성과 하위-의존성을 가질 수 있고, 그 중 일부는 `async def`로, 다른 일부는 일반적인 `def`로 생성되었을 수 있습니다. 이것은 여전히 잘 동작하고, 일반적인 `def`로 생성된 것들은 "대기"되는 대신에 (스레드풀로부터) 외부 스레드에서 호출됩니다.
+서로를 필요로 하는 여러 의존성과 [하위 의존성](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank}을 함수 정의의 매개변수로 가질 수 있으며, 그중 일부는 `async def`로, 다른 일부는 일반 `def`로 생성되었을 수 있습니다. 그래도 정상 동작하며, 일반 `def`로 생성된 것들은 "await"되는 대신 (스레드풀에서) 외부 스레드에서 호출됩니다.
 
-### 다른 유틸리티 함수
+### 다른 유틸리티 함수 { #other-utility-functions }
 
-직접 호출되는 다른 모든 유틸리티 함수는 일반적인 `def`나 `async def`로 생성될 수 있고 FastAPI는 이를 호출하는 방식에 영향을 미치지 않습니다.
+직접 호출하는 다른 모든 유틸리티 함수는 일반 `def`나 `async def`로 생성될 수 있으며, FastAPI는 호출 방식에 영향을 주지 않습니다.
 
-이것은 FastAPI가 당신을 위해 호출하는 함수와는 반대입니다: *경로 작동 함수*와 의존성
+이는 FastAPI가 여러분을 위해 호출하는 함수(즉, *경로 처리 함수*와 의존성)와 대비됩니다.
 
-만약 당신의 유틸리티 함수가 `def`를 사용한 일반적인 함수라면, 스레드풀에서가 아니라 직접 호출(당신이 코드에 작성한 대로)될 것이고, `async def`로 생성된 함수라면 코드에서 호출할 때 그 함수를 `await` 해야 합니다.
+유틸리티 함수가 `def`로 만든 일반 함수라면, 스레드풀이 아니라 직접(코드에 작성한 대로) 호출됩니다. 그리고 `async def`로 생성된 함수라면, 코드에서 호출할 때 그 함수를 `await` 해야 합니다.
 
 ---
 
-다시 말하지만, 이것은 당신이 이것에 대해 찾고있던 경우에 한해 유용할 매우 세부적인 기술사항입니다.
+다시 말하지만, 이것들은 아마도 이를 찾고 있었던 경우에 유용한 매우 세부적인 기술사항입니다.
 
-그렇지 않은 경우, 상기의 가이드라인만으로도 충분할 것입니다: [바쁘신 경우](#_1).
+그렇지 않다면, 위 섹션의 가이드라인이면 충분합니다: <a href="#in-a-hurry">바쁘신가요?</a>.

docs/ko/docs/fastapi-cli.md

@@ -1,83 +1,75 @@
-# FastAPI CLI
+# FastAPI CLI { #fastapi-cli }
 
-**FastAPI CLI**는 FastAPI 애플리케이션을 실행하고, 프로젝트를 관리하는 등 다양한 작업을 수행할 수 있는 커맨드 라인 프로그램입니다.
+**FastAPI CLI**는 FastAPI 애플리케이션을 서빙하고, FastAPI 프로젝트를 관리하는 등 다양한 작업에 사용할 수 있는 커맨드 라인 프로그램입니다.
 
-FastAPI를 설치할 때 (예: `pip install "fastapi[standard]"` 명령어를 사용할 경우), `fastapi-cli`라는 패키지가 포함됩니다. 이 패키지는 터미널에서 사용할 수 있는 `fastapi` 명령어를 제공합니다.
+FastAPI를 설치할 때(예: `pip install "fastapi[standard]"`), `fastapi-cli`라는 패키지가 포함되며, 이 패키지는 터미널에서 `fastapi` 명령어를 제공합니다.
 
-개발용으로 FastAPI 애플리케이션을 실행하려면 다음과 같이 `fastapi dev` 명령어를 사용할 수 있습니다:
+개발용으로 FastAPI 애플리케이션을 실행하려면 `fastapi dev` 명령어를 사용할 수 있습니다:
 
 <div class="termy">
 
 ```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:single">main.py</u>
-<font color="#3465A4">INFO    </font> Using path <font color="#3465A4">main.py</font>
-<font color="#3465A4">INFO    </font> Resolved absolute path <font color="#75507B">/home/user/code/awesomeapp/</font><font color="#AD7FA8">main.py</font>
-<font color="#3465A4">INFO    </font> Searching for package file structure from directories with <font color="#3465A4">__init__.py</font> files
-<font color="#3465A4">INFO    </font> Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
 
- ╭─ <font color="#8AE234"><b>Python module file</b></font> ─╮
- │                      │
- │  🐍 main.py          │
- │                      │
- ╰──────────────────────╯
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
 
-<font color="#3465A4">INFO    </font> Importing module <font color="#4E9A06">main</font>
-<font color="#3465A4">INFO    </font> Found importable FastAPI app
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
- ╭─ <font color="#8AE234"><b>Importable FastAPI app</b></font> ─╮
- │                          │
- │  <span style="background-color:#272822"><font color="#FF4689">from</font></span><span style="background-color:#272822"><font color="#F8F8F2"> main </font></span><span style="background-color:#272822"><font color="#FF4689">import</font></span><span style="background-color:#272822"><font color="#F8F8F2"> app</font></span><span style="background-color:#272822">  </span>  │
- │                          │
- ╰──────────────────────────╯
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-<font color="#3465A4">INFO    </font> Using import string <font color="#8AE234"><b>main:app</b></font>
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
 
- <span style="background-color:#C4A000"><font color="#2E3436">╭────────── FastAPI CLI - Development mode ───────────╮</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Serving at: http://127.0.0.1:8000                  │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  API docs: http://127.0.0.1:8000/docs               │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Running in development mode, for production use:   │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  </font></span><span style="background-color:#C4A000"><font color="#555753"><b>fastapi run</b></font></span><span style="background-color:#C4A000"><font color="#2E3436">                                        │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">╰─────────────────────────────────────────────────────╯</font></span>
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-<font color="#4E9A06">INFO</font>:     Will watch for changes in these directories: [&apos;/home/user/code/awesomeapp&apos;]
-<font color="#4E9A06">INFO</font>:     Uvicorn running on <b>http://127.0.0.1:8000</b> (Press CTRL+C to quit)
-<font color="#4E9A06">INFO</font>:     Started reloader process [<font color="#34E2E2"><b>2265862</b></font>] using <font color="#34E2E2"><b>WatchFiles</b></font>
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">2265873</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
+      <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`라고 불리는 명령어 프로그램은 **FastAPI CLI**입니다.
+`fastapi`라고 불리는 커맨드 라인 프로그램은 **FastAPI CLI**입니다.
 
-FastAPI CLI는 Python 프로그램의 경로(예: `main.py`)를 인수로 받아, `FastAPI` 인스턴스(일반적으로 `app`으로 명명)를 자동으로 감지하고 올바른 임포트 과정을 결정한 후 이를 실행합니다.
+FastAPI CLI는 Python 프로그램의 경로(예: `main.py`)를 받아 `FastAPI` 인스턴스(일반적으로 `app`으로 이름을 붙임)를 자동으로 감지하고, 올바른 임포트 과정을 결정한 다음 서빙합니다.
 
-프로덕션 환경에서는 `fastapi run` 명령어를 사용합니다. 🚀
+프로덕션에서는 대신 `fastapi run`을 사용합니다. 🚀
 
-내부적으로, **FastAPI CLI**는 고성능의, 프로덕션에 적합한, ASGI 서버인 <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>을 사용합니다. 😎
+내부적으로 **FastAPI CLI**는 고성능의, 프로덕션에 적합한 ASGI 서버인 <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>을 사용합니다. 😎
 
-## `fastapi dev`
+## `fastapi dev` { #fastapi-dev }
 
-`fastapi dev` 명령을 실행하면 개발 모드가 시작됩니다.
+`fastapi dev`를 실행하면 개발 모드가 시작됩니다.
 
-기본적으로 **자동 재시작(auto-reload)** 기능이 활성화되어, 코드에 변경이 생기면 서버를 자동으로 다시 시작합니다. 하지만 이 기능은 리소스를 많이 사용하며, 비활성화했을 때보다 안정성이 떨어질 수 있습니다. 따라서 개발 환경에서만 사용하는 것이 좋습니다. 또한, 서버는 컴퓨터가 자체적으로 통신할 수 있는 IP 주소(`localhost`)인 `127.0.0.1`에서 연결을 대기합니다.
+기본적으로 **auto-reload**가 활성화되어 코드에 변경이 생기면 서버를 자동으로 다시 로드합니다. 이는 리소스를 많이 사용하며, 비활성화했을 때보다 안정성이 떨어질 수 있습니다. 개발 환경에서만 사용해야 합니다. 또한 컴퓨터가 자신과만 통신하기 위한(`localhost`) IP인 `127.0.0.1`에서 연결을 대기합니다.
 
-## `fastapi run`
+## `fastapi run` { #fastapi-run }
 
-`fastapi run` 명령을 실행하면 기본적으로 프로덕션 모드로 FastAPI가 시작됩니다.
+`fastapi run`을 실행하면 기본적으로 프로덕션 모드로 FastAPI가 시작됩니다.
 
-기본적으로 **자동 재시작(auto-reload)** 기능이 비활성화되어 있습니다. 또한, 사용 가능한 모든 IP 주소인 `0.0.0.0`에서 연결을 대기하므로 해당 컴퓨터와 통신할 수 있는 모든 사람이 공개적으로 액세스할 수 있습니다. 이는 일반적으로 컨테이너와 같은 프로덕션 환경에서 실행하는 방법입니다.
+기본적으로 **auto-reload**는 비활성화되어 있습니다. 또한 사용 가능한 모든 IP 주소를 의미하는 `0.0.0.0`에서 연결을 대기하므로, 해당 컴퓨터와 통신할 수 있는 누구에게나 공개적으로 접근 가능해집니다. 보통 프로덕션에서는 이렇게 실행하며, 예를 들어 컨테이너에서 이런 방식으로 실행합니다.
 
-애플리케이션을 배포하는 방식에 따라 다르지만, 대부분 "종료 프록시(termination proxy)"를 활용해 HTTPS를 처리하는 것이 좋습니다. 배포 서비스 제공자가 이 작업을 대신 처리해줄 수도 있고, 직접 설정해야 할 수도 있습니다.
+대부분의 경우 위에 "termination proxy"를 두고 HTTPS를 처리하게(그리고 처리해야) 됩니다. 이는 애플리케이션을 배포하는 방식에 따라 달라지며, 제공자가 이 작업을 대신 처리해줄 수도 있고 직접 설정해야 할 수도 있습니다.
 
-/// tip
+/// tip | 팁
 
-자세한 내용은 [deployment documentation](deployment/index.md){.internal-link target=\_blank}에서 확인할 수 있습니다.
+자세한 내용은 [배포 문서](deployment/index.md){.internal-link target=_blank}에서 확인할 수 있습니다.
 
 ///

docs/ko/docs/features.md

@@ -1,43 +1,43 @@
-# 기능
+# 기능 { #features }
 
-## FastAPI의 기능
+## FastAPI의 기능 { #fastapi-features }
 
 **FastAPI**는 다음과 같은 기능을 제공합니다:
 
-### 개방형 표준을 기반으로
+### 개방형 표준을 기반으로 { #based-on-open-standards }
 
-* <abbr title="엔드포인트, 라우트로도 알려져 있습니다">경로</abbr><abbr title="POST, GET, PUT, DELETE와 같은 HTTP 메소드로 알려져 있습니다">작동</abbr>, 매개변수, 본문 요청, 보안 그 외의 선언을 포함한 API 생성을 위한 <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a>
-* <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a> (OpenAPI 자체가 JSON Schema를 기반으로 하고 있습니다)를 사용한 자동 데이터 모델 문서화.
-* 단순히 떠올려서 덧붙인 기능이 아닙니다. 세심한 검토를 거친 후, 이러한 표준을 기반으로 설계되었습니다.
-* 이는 또한 다양한 언어로 자동적인 **클라이언트 코드 생성**을 사용할 수 있게 지원합니다.
+* <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a>: <abbr title="또한 다음으로도 불립니다: 엔드포인트, 라우트">path</abbr> <abbr title="HTTP 메소드(POST, GET, PUT, DELETE 등)로도 알려져 있습니다">operations</abbr>, 매개변수, 요청 본문, 보안 등의 선언을 포함하여 API를 생성합니다.
+* <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a>를 사용한 자동 데이터 모델 문서화(OpenAPI 자체가 JSON Schema를 기반으로 하기 때문입니다).
+* 단순히 떠올려서 덧붙인 레이어가 아니라, 세심한 검토를 거친 뒤 이러한 표준을 중심으로 설계되었습니다.
+* 이는 또한 다양한 언어로 자동 **클라이언트 코드 생성**을 사용할 수 있게 해줍니다.
 
-### 문서 자동화
+### 문서 자동화 { #automatic-docs }
 
-대화형 API 문서와 웹 탐색 유저 인터페이스를 제공합니다. 프레임워크가 OpenAPI를 기반으로 하기에, 2가지 옵션이 기본적으로 들어간 여러 옵션이 존재합니다.
+대화형 API 문서와 탐색용 웹 사용자 인터페이스를 제공합니다. 프레임워크가 OpenAPI를 기반으로 하기에 여러 옵션이 있으며, 기본으로 2가지가 포함됩니다.
 
-* 대화형 탐색 <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a>를 이용해, 브라우저에서 바로 여러분의 API를 호출하거나 테스트할 수 있습니다.
+* 대화형 탐색이 가능한 <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a>로 브라우저에서 직접 API를 호출하고 테스트할 수 있습니다.
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
-* <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank"><strong>ReDoc</strong></a>을 이용해 API 문서화를 대체할 수 있습니다.
+* <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank"><strong>ReDoc</strong></a>을 이용한 대체 API 문서화.
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### 그저 현대 파이썬
+### 그저 현대 파이썬 { #just-modern-python }
 
-(Pydantic 덕분에) FastAPI는 표준 **파이썬 3.6 타입** 선언에 기반하고 있습니다. 새로 배울 문법이 없습니다. 그저 표준적인 현대 파이썬입니다.
+( Pydantic 덕분에) 모든 것이 표준 **Python 타입** 선언을 기반으로 합니다. 새로 배울 문법이 없습니다. 그저 표준적인 현대 파이썬입니다.
 
-만약 여러분이 파이썬 타입을 어떻게 사용하는지에 대한 2분 정도의 복습이 필요하다면 (비록 여러분이 FastAPI를 사용하지 않는다 하더라도), 다음의 짧은 자습서를 확인하세요: [파이썬 타입](python-types.md){.internal-link target=\_blank}.
+Python 타입을 어떻게 사용하는지 2분 정도 복습이 필요하다면(FastAPI를 사용하지 않더라도), 다음의 짧은 자습서를 확인하세요: [Python 타입](python-types.md){.internal-link target=_blank}.
 
-여러분은 타입을 이용한 표준 파이썬을 다음과 같이 적을 수 있습니다:
+여러분은 타입이 있는 표준 Python을 다음과 같이 작성합니다:
 
 ```Python
 from datetime import date
 
 from pydantic import BaseModel
 
-# 변수를 str로 선언
-# 그 후 함수 안에서 편집기 지원을 받으세요
+# 변수를 str로 선언합니다
+# 그리고 함수 내부에서 편집기 지원을 받습니다
 def main(user_id: str):
     return user_id
 
@@ -49,7 +49,7 @@ class User(BaseModel):
     joined: date
 ```
 
-위의 코드는 다음과 같이 사용될 수 있습니다:
+그 다음 다음과 같이 사용할 수 있습니다:
 
 ```Python
 my_user: User = User(id=3, name="John Doe", joined="2018-07-19")
@@ -65,23 +65,23 @@ my_second_user: User = User(**second_user_data)
 
 /// info | 정보
 
-`**second_user_data`가 뜻하는 것:
+`**second_user_data`는 다음을 의미합니다:
 
-`second_user_data` 딕셔너리의 키와 값을 키-값 인자로서 바로 넘겨줍니다. 다음과 동일합니다: `User(id=4, name="Mary", joined="2018-11-30")`
+`second_user_data` `dict`의 키와 값을 키-값 인자로서 바로 넘겨주는 것으로, 다음과 동일합니다: `User(id=4, name="Mary", joined="2018-11-30")`
 
 ///
 
-### 편집기 지원
+### 편집기 지원 { #editor-support }
 
-모든 프레임워크는 사용하기 쉽고 직관적으로 설계되었으며, 좋은 개발 경험을 보장하기 위해 개발을 시작하기도 전에 모든 결정들은 여러 편집기에서 테스트됩니다.
+프레임워크 전체는 사용하기 쉽고 직관적으로 설계되었으며, 최고의 개발 경험을 보장하기 위해 개발을 시작하기도 전에 모든 결정은 여러 편집기에서 테스트되었습니다.
 
-최근 파이썬 개발자 설문조사에서 <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">"자동 완성"이 가장 많이 사용되는 기능</a>이라는 것이 밝혀졌습니다.
+Python 개발자 설문조사에서 <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">가장 많이 사용되는 기능 중 하나가 "자동 완성"이라는 점</a>이 분명합니다.
 
-**FastAPI** 프레임워크의 모든 부분은 이를 충족하기 위해 설계되었습니다. 자동완성은 어느 곳에서나 작동합니다.
+**FastAPI** 프레임워크 전체는 이를 만족하기 위해 만들어졌습니다. 자동 완성은 어디서나 작동합니다.
 
-여러분은 문서로 다시 돌아올 일이 거의 없을 겁니다.
+문서로 다시 돌아올 일은 거의 없을 것입니다.
 
-다음은 편집기가 어떻게 여러분을 도와주는지 보여줍니다:
+편집기가 여러분을 어떻게 도와줄 수 있는지 살펴보세요:
 
 * <a href="https://code.visualstudio.com/" class="external-link" target="_blank">Visual Studio Code</a>에서:
 
@@ -91,111 +91,111 @@ my_second_user: User = User(**second_user_data)
 
 ![editor support](https://fastapi.tiangolo.com/img/pycharm-completion.png)
 
-여러분이 이전에 불가능하다고 고려했던 코드도 완성할 수 있을 겁니다. 예를 들어, 요청에서 전달되는 (중첩될 수도 있는)JSON 본문 내부에 있는 `price` 키입니다.
+이전에 불가능하다고 생각했을 코드에서도 자동 완성을 받을 수 있습니다. 예를 들어, 요청에서 전달되는(중첩될 수도 있는) JSON 본문 내부의 `price` 키 같은 경우입니다.
 
-잘못된 키 이름을 적을 일도, 문서를 왔다 갔다할 일도 없으며, 혹은 마지막으로 `username` 또는 `user_name`을 사용했는지 찾기 위해 위 아래로 스크롤할 일도 없습니다.
+더 이상 잘못된 키 이름을 입력하거나, 문서 사이를 왔다 갔다 하거나, `username`을 썼는지 `user_name`을 썼는지 찾으려고 위아래로 스크롤할 필요가 없습니다.
 
-### 토막 정보
+### 간결함 { #short }
 
-어느 곳에서나 선택적 구성이 가능한 모든 것에 합리적인 기본값이 설정되어 있습니다. 모든 매개변수는 여러분이 필요하거나, 원하는 API를 정의하기 위해 미세하게 조정할 수 있습니다.
+선택적 구성을 어디서나 할 수 있도록 하면서도, 모든 것에 합리적인 **기본값**이 설정되어 있습니다. 모든 매개변수는 필요한 작업을 하거나 필요한 API를 정의하기 위해 미세하게 조정할 수 있습니다.
 
-하지만 기본적으로 모든 것이 "그냥 작동합니다".
+하지만 기본적으로 모든 것이 **"그냥 작동합니다"**.
 
-### 검증
+### 검증 { #validation }
 
-* 다음을 포함한, 대부분의 (혹은 모든?) 파이썬 **데이터 타입** 검증할 수 있습니다:
+* 다음을 포함해 대부분(혹은 전부?)의 Python **데이터 타입**에 대한 검증:
     * JSON 객체 (`dict`).
     * 아이템 타입을 정의하는 JSON 배열 (`list`).
-    * 최소 길이와 최대 길이를 정의하는 문자열 (`str`) 필드.
-    * 최솟값과 최댓값을 가지는 숫자 (`int`, `float`), 그 외.
+    * 최소/최대 길이를 정의하는 문자열(`str`) 필드.
+    * 최소/최대 값을 가지는 숫자(`int`, `float`) 등.
 
-* 다음과 같이 더욱 이색적인 타입에 대해 검증할 수 있습니다:
+* 다음과 같은 좀 더 이색적인 타입에 대한 검증:
     * URL.
-    * 이메일.
+    * Email.
     * UUID.
-    * ...다른 것들.
+    * ...그 외.
 
-모든 검증은 견고하면서 잘 확립된 **Pydantic**에 의해 처리됩니다.
+모든 검증은 잘 확립되어 있고 견고한 **Pydantic**이 처리합니다.
 
-### 보안과 인증
+### 보안과 인증 { #security-and-authentication }
 
-보안과 인증이 통합되어 있습니다. 데이터베이스나 데이터 모델과의 타협없이 사용할 수 있습니다.
+보안과 인증이 통합되어 있습니다. 데이터베이스나 데이터 모델과 타협하지 않습니다.
 
-다음을 포함하는, 모든 보안 스키마가 OpenAPI에 정의되어 있습니다.
+다음을 포함해 OpenAPI에 정의된 모든 보안 스키마:
 
 * HTTP Basic.
-* **OAuth2** (**JWT tokens** 또한 포함). [OAuth2 with JWT](tutorial/security/oauth2-jwt.md){.internal-link target=\_blank}에 있는 자습서를 확인해 보세요.
+* **OAuth2**(**JWT tokens** 또한 포함). [JWT를 사용한 OAuth2](tutorial/security/oauth2-jwt.md){.internal-link target=_blank} 자습서를 확인해 보세요.
 * 다음에 들어 있는 API 키:
     * 헤더.
-    * 매개변수.
-    * 쿠키 및 그 외.
+    * 쿼리 매개변수.
+    * 쿠키 등.
 
-추가적으로 (**세션 쿠키**를 포함한) 모든 보안 기능은 Starlette에 있습니다.
+추가로 Starlette의 모든 보안 기능(**세션 쿠키** 포함)도 제공합니다.
 
-모두 재사용할 수 있는 도구와 컴포넌트로 만들어져 있어 여러분의 시스템, 데이터 저장소, 관계형 및 NoSQL 데이터베이스 등과 쉽게 통합할 수 있습니다.
+모두 재사용 가능한 도구와 컴포넌트로 만들어져 있어, 여러분의 시스템, 데이터 저장소, 관계형 및 NoSQL 데이터베이스 등과 쉽게 통합할 수 있습니다.
 
-### 의존성 주입
+### 의존성 주입 { #dependency-injection }
 
-FastAPI는 사용하기 매우 간편하지만, 엄청난 <abbr title='"컴포넌트", "자원", "서비스", "제공자"로도 알려진'><strong>의존성 주입</strong></abbr>시스템을 포함하고 있습니다.
+FastAPI는 사용하기 매우 쉽지만, 매우 강력한 <abbr title='또한 다음으로도 불립니다: "컴포넌트", "자원", "서비스", "제공자"'><strong>Dependency Injection</strong></abbr> 시스템을 포함하고 있습니다.
 
-* 의존성은 의존성을 가질수도 있어, 이를 통해 의존성의 계층이나 **의존성의 "그래프"**를 형성합니다.
-* 모든 것이 프레임워크에 의해 **자동적으로 처리됩니다**.
-* 모든 의존성은 요청에서 데이터를 요구하여 자동 문서화와 **경로 작동 제약을 강화할 수 있습니다**.
-* 의존성에서 정의된 _경로 작동_ 매개변수에 대해서도 **자동 검증**이 이루어 집니다.
-* 복잡한 사용자의 인증 시스템, **데이터베이스 연결**, 등등을 지원합니다.
-* 데이터베이스, 프론트엔드 등과 관련되어 **타협하지 않아도 됩니다**. 하지만 그 모든 것과 쉽게 통합이 가능합니다.
+* 의존성도 의존성을 가질 수 있어, 의존성의 계층 또는 **의존성의 "그래프"**를 생성합니다.
+* 모든 것이 프레임워크에 의해 **자동으로 처리됩니다**.
+* 모든 의존성은 요청에서 데이터를 요구할 수 있으며, **경로 처리** 제약과 자동 문서화를 강화할 수 있습니다.
+* 의존성에 정의된 *경로 처리* 매개변수에 대해서도 **자동 검증**을 합니다.
+* 복잡한 사용자 인증 시스템, **데이터베이스 연결** 등을 지원합니다.
+* 데이터베이스, 프론트엔드 등과 **타협하지 않습니다**. 하지만 모두와 쉽게 통합할 수 있습니다.
 
-### 제한 없는 "플러그인"
+### 제한 없는 "플러그인" { #unlimited-plug-ins }
 
-또는 다른 방법으로, 그것들을 사용할 필요 없이 필요한 코드만 임포트할 수 있습니다.
+또 다른 방식으로는, 그것들이 필요 없습니다. 필요한 코드를 임포트해서 사용하면 됩니다.
 
-어느 통합도 (의존성과 함께) 사용하기 쉽게 설계되어 있어, *경로 작동*에 사용된 것과 동일한 구조와 문법을 사용하여 2줄의 코드로 여러분의 어플리케이션에 사용할 "플러그인"을 만들 수 있습니다.
+어떤 통합이든(의존성과 함께) 사용하기 매우 간단하도록 설계되어 있어, *경로 처리*에 사용된 것과 동일한 구조와 문법을 사용해 2줄의 코드로 애플리케이션용 "플러그인"을 만들 수 있습니다.
 
-### 테스트 결과
+### 테스트됨 { #tested }
 
-* 100% <abbr title="자동적으로 테스트된 코드의 양">테스트 범위</abbr>.
-* 100% <abbr title="파이썬의 타입 어노테이션, 이를 통해 여러분의 편집기와 외부 도구는 여러분에게 더 나은 지원을 할 수 있습니다">타입이 명시된</abbr> 코드 베이스.
-* 상용 어플리케이션에서의 사용.
+* 100% <abbr title="자동으로 테스트되는 코드의 양">test coverage</abbr>.
+* 100% <abbr title="Python 타입 어노테이션으로, 이를 통해 편집기와 외부 도구가 더 나은 지원을 제공할 수 있습니다">type annotated</abbr> 코드 베이스.
+* 프로덕션 애플리케이션에서 사용됩니다.
 
-## Starlette 기능
+## Starlette 기능 { #starlette-features }
 
-**FastAPI**는 <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>를 기반으로 구축되었으며, 이와 완전히 호환됩니다. 따라서, 여러분이 보유하고 있는 어떤 추가적인 Starlette 코드도 작동할 것입니다.
+**FastAPI**는 <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>와 완전히 호환되며(또한 이를 기반으로 합니다). 따라서 추가로 가지고 있는 Starlette 코드도 모두 동작합니다.
 
-`FastAPI`는 실제로 `Starlette`의 하위 클래스입니다. 그래서, 여러분이 이미 Starlette을 알고 있거나 사용하고 있으면, 대부분의 기능이 같은 방식으로 작동할 것입니다.
+`FastAPI`는 실제로 `Starlette`의 하위 클래스입니다. 그래서 Starlette을 이미 알고 있거나 사용하고 있다면, 대부분의 기능이 같은 방식으로 동작할 것입니다.
 
-**FastAPI**를 사용하면 여러분은 **Starlette**의 기능 대부분을 얻게 될 것입니다(FastAPI가 단순히 Starlette를 강화했기 때문입니다):
+**FastAPI**를 사용하면 **Starlette**의 모든 기능을 얻게 됩니다(FastAPI는 Starlette에 강력한 기능을 더한 것입니다):
 
-* 아주 인상적인 성능. 이는 <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">**NodeJS**와 **Go**와 동등하게 사용 가능한 가장 빠른 파이썬 프레임워크 중 하나입니다</a>.
+* 정말 인상적인 성능. <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">**NodeJS**와 **Go**에 버금가는, 사용 가능한 가장 빠른 Python 프레임워크 중 하나입니다</a>.
 * **WebSocket** 지원.
-* 프로세스 내의 백그라운드 작업.
-* 시작과 종료 이벤트.
+* 프로세스 내 백그라운드 작업.
+* 시작 및 종료 이벤트.
 * HTTPX 기반 테스트 클라이언트.
 * **CORS**, GZip, 정적 파일, 스트리밍 응답.
 * **세션과 쿠키** 지원.
-* 100% 테스트 범위.
-* 100% 타입이 명시된 코드 베이스.
+* 100% test coverage.
+* 100% type annotated codebase.
 
-## Pydantic 기능
+## Pydantic 기능 { #pydantic-features }
 
-**FastAPI**는 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>을 기반으로 하며 Pydantic과 완벽하게 호환됩니다. 그래서 어느 추가적인 Pydantic 코드를 여러분이 가지고 있든 작동할 것입니다.
+**FastAPI**는 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>과 완벽하게 호환되며(또한 이를 기반으로 합니다). 따라서 추가로 가지고 있는 Pydantic 코드도 모두 동작합니다.
 
-Pydantic을 기반으로 하는, 데이터베이스를 위한 <abbr title="Object-Relational Mapper">ORM</abbr>, <abbr title="Object-Document Mapper">ODM</abbr>을 포함한 외부 라이브러리를 포함합니다.
+데이터베이스를 위한 <abbr title="Object-Relational Mapper - 객체-관계 매퍼">ORM</abbr>, <abbr title="Object-Document Mapper - 객체-문서 매퍼">ODM</abbr>과 같은, Pydantic을 기반으로 하는 외부 라이브러리도 포함합니다.
 
-이는 모든 것이 자동으로 검증되기 때문에, 많은 경우에서 요청을 통해 얻은 동일한 객체를, **직접 데이터베이스로** 넘겨줄 수 있습니다.
+이는 모든 것이 자동으로 검증되기 때문에, 많은 경우 요청에서 얻은 동일한 객체를 **직접 데이터베이스로** 넘겨줄 수 있다는 의미이기도 합니다.
 
-반대로도 마찬가지이며, 많은 경우에서 여러분은 **직접 클라이언트로** 그저 객체를 넘겨줄 수 있습니다.
+반대로도 마찬가지이며, 많은 경우 데이터베이스에서 얻은 객체를 **직접 클라이언트로** 그대로 넘겨줄 수 있습니다.
 
-**FastAPI**를 사용하면 (모든 데이터 처리를 위해 FastAPI가 Pydantic을 기반으로 하기 있기에) **Pydantic**의 모든 기능을 얻게 됩니다:
+**FastAPI**를 사용하면(모든 데이터 처리를 위해 FastAPI가 Pydantic을 기반으로 하기에) **Pydantic**의 모든 기능을 얻게 됩니다:
 
-* **어렵지 않은 언어**:
-    * 새로운 스키마 정의 마이크로 언어를 배우지 않아도 됩니다.
-    * 여러분이 파이썬 타입을 안다면, 여러분은 Pydantic을 어떻게 사용하는지 아는 겁니다.
-* 여러분의 **<abbr title="통합 개발 환경, 코드 편집기와 비슷합니다">IDE</abbr>/<abbr title="코드 에러를 확인하는 프로그램">린터</abbr>/뇌**와 잘 어울립니다:
-    * Pydantic 데이터 구조는 단순 여러분이 정의한 클래스의 인스턴스이기 때문에, 자동 완성, 린팅, mypy 그리고 여러분의 직관까지 여러분의 검증된 데이터와 올바르게 작동합니다.
+* **No brainfuck**:
+    * 새로운 스키마 정의 마이크로 언어를 배울 필요가 없습니다.
+    * Python 타입을 알고 있다면 Pydantic 사용법도 알고 있는 것입니다.
+* 여러분의 **<abbr title="Integrated Development Environment - 통합 개발 환경: 코드 편집기와 비슷합니다">IDE</abbr>/<abbr title="코드 오류를 확인하는 프로그램">linter</abbr>/뇌**와 잘 어울립니다:
+    * pydantic 데이터 구조는 여러분이 정의한 클래스 인스턴스일 뿐이므로, 자동 완성, 린팅, mypy, 그리고 직관까지도 검증된 데이터와 함께 제대로 작동합니다.
 * **복잡한 구조**를 검증합니다:
-    * 계층적인 Pydantic 모델, 파이썬 `typing`의 `List`와 `Dict`, 그 외를 사용합니다.
-    * 그리고 검증자는 복잡한 데이터 스키마를 명확하고 쉽게 정의 및 확인하며 JSON 스키마로 문서화합니다.
-    * 여러분은 깊게 **중첩된 JSON** 객체를 가질 수 있으며, 이 객체 모두 검증하고 설명을 붙일 수 있습니다.
-* **확장 가능성**:
-    * Pydantic은 사용자 정의 데이터 타입을 정의할 수 있게 하거나, 검증자 데코레이터가 붙은 모델의 메소드를 사용하여 검증을 확장할 수 있습니다.
-* 100% 테스트 범위.
+    * 계층적인 Pydantic 모델, Python `typing`의 `List`와 `Dict` 등을 사용합니다.
+    * 그리고 validator는 복잡한 데이터 스키마를 명확하고 쉽게 정의하고, 검사하고, JSON Schema로 문서화할 수 있게 해줍니다.
+    * 깊게 **중첩된 JSON** 객체를 가질 수 있으며, 이를 모두 검증하고 주석을 달 수 있습니다.
+* **확장 가능**:
+    * Pydantic은 사용자 정의 데이터 타입을 정의할 수 있게 하거나, validator decorator가 붙은 모델 메서드로 검증을 확장할 수 있습니다.
+* 100% test coverage.

docs/ko/docs/help-fastapi.md

@@ -1,4 +1,4 @@
-# FastAPI 지원 - 도움 받기
+# FastAPI 지원 - 도움 받기 { #help-fastapi-get-help }
 
 **FastAPI** 가 마음에 드시나요?
 
@@ -10,9 +10,9 @@ FastAPI, 다른 사용자, 개발자를 응원하고 싶으신가요?
 
 또한 도움을 받을 수 있는 방법도 몇 가지 있습니다.
 
-## 뉴스레터 구독
+## 뉴스레터 구독 { #subscribe-to-the-newsletter }
 
-[**FastAPI and friends** 뉴스레터](newsletter.md){.internal-link target=\_blank}를 구독하여 최신 정보를 유지할 수 있습니다:
+(자주 발송되지 않는) [**FastAPI and friends** 뉴스레터](newsletter.md){.internal-link target=_blank}를 구독하여 최신 정보를 유지할 수 있습니다:
 
 * FastAPI and friends에 대한 뉴스 🚀
 * 가이드 📝
@@ -20,65 +20,65 @@ FastAPI, 다른 사용자, 개발자를 응원하고 싶으신가요?
 * 획기적인 변화 🚨
 * 팁과 요령 ✅
 
-## 트위터에서 FastAPI 팔로우하기
+## X(Twitter)에서 FastAPI 팔로우하기 { #follow-fastapi-on-x-twitter }
 
 <a href="https://x.com/fastapi" class="external-link" target="_blank">**X (Twitter)**의 @fastapi를 팔로우</a>하여 **FastAPI** 에 대한 최신 뉴스를 얻을 수 있습니다. 🐦
 
-## Star **FastAPI** in GitHub
+## GitHub에서 **FastAPI**에 Star 주기 { #star-fastapi-in-github }
 
 GitHub에서 FastAPI에 "star"를 붙일 수 있습니다 (오른쪽 상단의 star 버튼을 클릭): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. ⭐️
 
 스타를 늘림으로써, 다른 사용자들이 좀 더 쉽게 찾을 수 있고, 많은 사람들에게 유용한 것임을 나타낼 수 있습니다.
 
-## GitHub 저장소에서 릴리즈 확인
+## 릴리즈 확인을 위해 GitHub 저장소 보기 { #watch-the-github-repository-for-releases }
 
-GitHub에서 FastAPI를 "watch"할 수 있습니다 (오른쪽 상단 watch 버튼을 클릭): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
+GitHub에서 FastAPI를 "watch"할 수 있습니다 (오른쪽 상단 "watch" 버튼을 클릭): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
 
-여기서 "Releases only"을 선택할 수 있습니다.
+여기서 "Releases only"를 선택할 수 있습니다.
 
-이렇게하면, **FastAPI** 의 버그 수정 및 새로운 기능의 구현 등의 새로운 자료 (최신 버전)이 있을 때마다 (이메일) 통지를 받을 수 있습니다.
+이렇게하면, **FastAPI** 의 버그 수정 및 새로운 기능의 구현 등의 새로운 릴리즈(새 버전)가 있을 때마다 (이메일) 통지를 받을 수 있습니다.
 
-## 개발자와의 연결
+## 개발자와의 연결 { #connect-with-the-author }
 
-<a href="https://tiangolo.com" class="external-link" target="_blank">개발자(Sebastián Ramírez / `tiangolo`)</a>와 연락을 취할 수 있습니다.
+개발자(작성자)인 <a href="https://tiangolo.com" class="external-link" target="_blank">저(Sebastián Ramírez / `tiangolo`)</a>와 연락을 취할 수 있습니다.
 
 여러분은 할 수 있습니다:
 
-* <a href="https://github.com/tiangolo" class="external-link" target="_blank">**GitHub**에서 팔로우하기.</a>.
-    * 당신에게 도움이 될 저의 다른 오픈소스 프로젝트를 확인하십시오.
+* <a href="https://github.com/tiangolo" class="external-link" target="_blank">**GitHub**에서 팔로우하기</a>.
+    * 여러분에게 도움이 될 저의 다른 오픈소스 프로젝트를 확인하십시오.
     * 새로운 오픈소스 프로젝트를 만들었을 때 확인하려면 팔로우 하십시오.
 * <a href="https://x.com/tiangolo" class="external-link" target="_blank">**X (Twitter)**</a> 또는 <a href="https://fosstodon.org/@tiangolo" class="external-link" target="_blank">Mastodon</a>에서 팔로우하기.
     * FastAPI의 사용 용도를 알려주세요 (그것을 듣는 것을 좋아합니다).
     * 발표나 새로운 툴 출시 소식을 받아보십시오.
-    * <a href="https://x.com/fastapi" class="external-link" target="_blank">**X (Twitter)**의 @fastapi를 팔로우</a> (별도 계정에서) 할 수 있습니다.
-* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">**LinkedIn**에서 팔로우하기.</a>.
-    * 새로운 툴의 발표나 출시 소식을 받아보십시오. (단, X (Twitter)를 더 자주 사용합니다 🤷‍♂).
+    * <a href="https://x.com/fastapi" class="external-link" target="_blank">X(Twitter)에서 @fastapi를 팔로우</a> (별도 계정에서) 할 수 있습니다.
+* <a href="https://www.linkedin.com/in/tiangolo/" class="external-link" target="_blank">**LinkedIn**에서 팔로우하기</a>.
+    * 새로운 툴의 발표나 출시 소식을 받아보십시오 (단, X (Twitter)를 더 자주 사용합니다 🤷‍♂).
 * <a href="https://dev.to/tiangolo" class="external-link" target="_blank">**Dev.to**</a> 또는 <a href="https://medium.com/@tiangolo" class="external-link" target="_blank">**Medium**</a>에서 제가 작성한 내용을 읽어 보십시오 (또는 팔로우).
-    * 다른 기사나 아이디어들을 읽고, 제가 만들어왔던 툴에 대해서도 읽으십시오.
-    * 새로운 기사를 읽기 위해 팔로우 하십시오.
+    * 다른 아이디어와 기사들을 읽고, 제가 만들어왔던 툴에 대해서도 읽으십시오.
+    * 새로운 내용을 게시할 때 읽기 위해 팔로우 하십시오.
 
-## **FastAPI**에 대한 트윗
+## **FastAPI**에 대해 트윗하기 { #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**에 대해 트윗</a> 하고 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**에 대해 트윗</a> 하고 저와 다른 사람들에게 FastAPI가 마음에 드는 이유를 알려주세요. 🎉
 
 **FastAPI**가 어떻게 사용되고 있는지, 어떤 점이 마음에 들었는지, 어떤 프로젝트/회사에서 사용하고 있는지 등에 대해 듣고 싶습니다.
 
-## FastAPI에 투표하기
+## FastAPI에 투표하기 { #vote-for-fastapi }
 
 * <a href="https://www.slant.co/options/34241/~fastapi-review" class="external-link" target="_blank">Slant에서 **FastAPI** 에 대해 투표하십시오</a>.
 * <a href="https://alternativeto.net/software/fastapi/about/" class="external-link" target="_blank">AlternativeTo에서 **FastAPI** 에 대해 투표하십시오</a>.
-* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">StackShare에서 **FastAPI** 에 대해 투표하십시오</a>.
+* <a href="https://stackshare.io/pypi-fastapi" class="external-link" target="_blank">StackShare에서 **FastAPI**를 사용한다고 표시하세요</a>.
 
-## GitHub의 이슈로 다른사람 돕기
+## GitHub에서 질문으로 다른 사람 돕기 { #help-others-with-questions-in-github }
 
 다른 사람들의 질문에 도움을 줄 수 있습니다:
 
-* <a href="https://github.com/fastapi/fastapi/discussions/categories/questions?discussions_q=category%3AQuestions+is%3Aunanswered" class="external-link" target="_blank">GitHub 디스커션</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 이슈</a>
+* <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>
 
 많은 경우, 여러분은 이미 그 질문에 대한 답을 알고 있을 수도 있습니다. 🤓
 
-만약 많은 사람들의 문제를 도와준다면, 공식적인 [FastAPI 전문가](fastapi-people.md#fastapi-experts){.internal-link target=\_blank} 가 될 것입니다. 🎉
+만약 많은 사람들의 질문을 도와준다면, 공식적인 [FastAPI 전문가](fastapi-people.md#fastapi-experts){.internal-link target=_blank}가 될 것입니다. 🎉
 
 가장 중요한 점은: 친절하려고 노력하는 것입니다. 사람들은 좌절감을 안고 오며, 많은 경우 최선의 방식으로 질문하지 않을 수도 있습니다. 하지만 최대한 친절하게 대하려고 노력하세요. 🤗
 
@@ -86,183 +86,170 @@ GitHub에서 FastAPI를 "watch"할 수 있습니다 (오른쪽 상단 watch 버
 
 ---
 
-다른 사람들의 질문 (디스커션 또는 이슈에서) 해결을 도울 수 있는 방법은 다음과 같습니다.
+다른 사람들의 질문(디스커션 또는 이슈에서) 해결을 도울 수 있는 방법은 다음과 같습니다.
 
-### 질문 이해하기
+### 질문 이해하기 { #understand-the-question }
 
 * 질문하는 사람이 가진 **목적**과 사용 사례를 이해할 수 있는지 확인하세요.
 
-* 질문 (대부분은 질문입니다)이 **명확**한지 확인하세요.
+* 그런 다음 질문(대부분은 질문입니다)이 **명확**한지 확인하세요.
 
-* 많은 경우, 사용자가 가정한 해결책에 대한 질문을 하지만, 더 **좋은** 해결책이 있을 수 있습니다. 문제와 사용 사례를 더 잘 이해하면 더 나은 **대안적인 해결책**을 제안할 수 있습니다.
+* 많은 경우 사용자가 상상한 해결책에 대한 질문을 하지만, 더 **좋은** 해결책이 있을 수 있습니다. 문제와 사용 사례를 더 잘 이해하면 더 나은 **대안적인 해결책**을 제안할 수 있습니다.
 
 * 질문을 이해할 수 없다면, 더 **자세한 정보**를 요청하세요.
 
-### 문제 재현하기
+### 문제 재현하기 { #reproduce-the-problem }
 
-대부분의 경우, 질문은 질문자의 **원본 코드**와 관련이 있습니다.
+대부분의 경우 그리고 대부분의 질문에서는 질문자의 **원본 코드**와 관련된 내용이 있습니다.
 
 많은 경우, 코드의 일부만 복사해서 올리지만, 그것만으로는 **문제를 재현**하기에 충분하지 않습니다.
 
-* 질문자에게 <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">최소한의 재현 가능한 예제</a>를 제공해달라고 요청하세요. 이렇게 하면 코드를 **복사-붙여넣기**하여 직접 실행하고, 동일한 오류나 동작을 확인하거나 사용 사례를 더 잘 이해할 수 있습니다.
+* 질문자에게 <a href="https://stackoverflow.com/help/minimal-reproducible-example" class="external-link" target="_blank">최소한의 재현 가능한 예제</a>를 제공해달라고 요청할 수 있습니다. 이렇게 하면 코드를 **복사-붙여넣기**하여 로컬에서 실행하고, 질문자가 보고 있는 것과 동일한 오류나 동작을 확인하거나 사용 사례를 더 잘 이해할 수 있습니다.
 
-* 너그러운 마음이 든다면, 문제 설명만을 기반으로 직접 **예제를 만들어**볼 수도 있습니다. 하지만, 이는 시간이 많이 걸릴 수 있으므로, 먼저 질문을 명확히 해달라고 요청하는 것이 좋습니다.
+* 너그러운 마음이 든다면, 문제 설명만을 기반으로 직접 **예제를 만들어**볼 수도 있습니다. 다만 이는 시간이 많이 걸릴 수 있으므로, 먼저 문제를 명확히 해달라고 요청하는 것이 더 나을 수 있다는 점을 기억하세요.
 
-### 해결책 제안하기
+### 해결책 제안하기 { #suggest-solutions }
 
 * 질문을 충분히 이해한 후에는 가능한 **답변**을 제공할 수 있습니다.
 
-* 많은 경우, 질문자의 **근본적인 문제나 사용 사례**를 이해하는 것이 중요합니다. 그들이 시도하는 방법보다 더 나은 해결책이 있을 수 있기 때문입니다.
+* 많은 경우, 질문자의 **근본적인 문제나 사용 사례**를 이해하는 것이 더 좋습니다. 그들이 시도하는 방법보다 더 나은 해결책이 있을 수 있기 때문입니다.
 
-### 해결 요청하기
+### 종료 요청하기 { #ask-to-close }
 
-질문자가 답변을 확인하고 나면, 당신이 문제를 해결했을 가능성이 높습니다. 축하합니다, **당신은 영웅입니다**! 🦸
+질문자가 답변을 하면, 여러분이 문제를 해결했을 가능성이 높습니다. 축하합니다, **여러분은 영웅입니다**! 🦸
 
 * 이제 문제를 해결했다면, 질문자에게 다음을 요청할 수 있습니다.
 
-    * GitHub 디스커션에서: 댓글을 **답변**으로 표시하도록 요청하세요.
-    * GitHub 이슈에서: 이슈를 **닫아달라고** 요청하세요.
+    * GitHub Discussions에서: 댓글을 **답변**으로 표시하도록 요청하세요.
+    * GitHub Issues에서: 이슈를 **닫아달라고** 요청하세요.
 
-## GitHub 저장소 보기
+## GitHub 저장소 보기 { #watch-the-github-repository }
 
-GitHub에서 FastAPI를 "watch"할 수 있습니다 (오른쪽 상단 watch 버튼을 클릭): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
+GitHub에서 FastAPI를 "watch"할 수 있습니다 (오른쪽 상단 "watch" 버튼을 클릭): <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">https://github.com/fastapi/fastapi</a>. 👀
 
-"Releases only" 대신 "Watching"을 선택하면, 새로운 이슈나 질문이 생성될 때 알림을 받을 수 있습니다. 또한, 특정하게 새로운 이슈, 디스커션, PR 등만 알림 받도록 설정할 수도 있습니다.
+"Releases only" 대신 "Watching"을 선택하면 누군가가 새 이슈나 질문을 만들 때 알림을 받게 됩니다. 또한 새 이슈, 디스커션, PR 등만 알림을 받도록 지정할 수도 있습니다.
 
-그런 다음 이런 이슈들을 해결 할 수 있도록 도움을 줄 수 있습니다.
+그런 다음 이런 질문들을 해결하도록 도와줄 수 있습니다.
 
-## 이슈 생성하기
+## 질문하기 { #ask-questions }
 
-GitHub 저장소에 <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">새로운 이슈 생성</a>을 할 수 있습니다, 예를들면 다음과 같습니다:
+GitHub 저장소에서 <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">새 질문을 생성</a>할 수 있습니다. 예를 들면 다음과 같습니다:
 
 * **질문**을 하거나 **문제**에 대해 질문합니다.
 * 새로운 **기능**을 제안 합니다.
 
-**참고**: 만약 이슈를 생성한다면, 저는 여러분에게 다른 사람들을 도와달라고 부탁할 것입니다. 😉
+**참고**: 만약 이렇게 한다면, 저는 여러분에게 다른 사람들도 도와달라고 요청할 것입니다. 😉
 
-## Pull Requests 리뷰하기
+## Pull Request 리뷰하기 { #review-pull-requests }
 
-다른 사람들의 pull request를 리뷰하는 데 도움을 줄 수 있습니다.
+다른 사람들이 만든 pull request를 리뷰하는 데 저를 도와줄 수 있습니다.
 
 다시 한번 말하지만, 최대한 친절하게 리뷰해 주세요. 🤗
 
 ---
 
-Pull Rrquest를 리뷰할 때 고려해야 할 사항과 방법은 다음과 같습니다:
+Pull request를 리뷰할 때 고려해야 할 사항과 방법은 다음과 같습니다:
 
-### 문제 이해하기
+### 문제 이해하기 { #understand-the-problem }
 
-* 먼저, 해당 pull request가 해결하려는 **문제를 이해하는지** 확인하세요. GitHub 디스커션 또는 이슈에서 더 긴 논의가 있었을 수도 있습니다.
+* 먼저, 해당 pull request가 해결하려는 **문제를 이해하는지** 확인하세요. GitHub Discussion 또는 이슈에서 더 긴 논의가 있었을 수도 있습니다.
 
-* Pull request가 필요하지 않을 가능성도 있습니다. **다른 방식**으로 문제를 해결할 수 있다면, 그 방법을 제안하거나 질문할 수 있습니다.
+* Pull request가 실제로 필요하지 않을 가능성도 큽니다. 문제가 **다른 방식**으로 해결될 수 있기 때문입니다. 그런 경우 그 방법을 제안하거나 질문할 수 있습니다.
 
-### 스타일에 너무 신경 쓰지 않기
+### 스타일에 너무 신경 쓰지 않기 { #dont-worry-about-style }
 
-* 커밋 메시지 스타일 같은 것에 너무 신경 쓰지 않아도 됩니다. 저는 직접 커밋을 수정하여 squash and merge를 수행할 것입니다.
+* 커밋 메시지 스타일 같은 것에 너무 신경 쓰지 마세요. 저는 커밋을 수동으로 조정해서 squash and merge를 할 것입니다.
 
 * 코드 스타일 규칙도 걱정할 필요 없습니다. 이미 자동화된 도구들이 이를 검사하고 있습니다.
 
-스타일이나 일관성 관련 요청이 필요한 경우, 제가 직접 요청하거나 필요한 변경 사항을 추가 커밋으로 수정할 것입니다.
+그리고 다른 스타일이나 일관성 관련 필요 사항이 있다면, 제가 직접 요청하거나 필요한 변경 사항을 위에 커밋으로 추가할 것입니다.
 
-### 코드 확인하기
+### 코드 확인하기 { #check-the-code }
 
-* 코드를 읽고, **논리적으로 타당**한지 확인한 후 로컬에서 실행하여 문제가 해결되는지 확인하세요.
+* 코드를 확인하고 읽어서 말이 되는지 보고, **로컬에서 실행**해 실제로 문제가 해결되는지 확인하세요.
 
-* 그런 다음, 확인했다고 **댓글**을 남겨 주세요. 그래야 제가 검토했음을 알 수 있습니다.
+* 그런 다음 그렇게 했다고 **댓글**로 남겨 주세요. 그래야 제가 정말로 확인했음을 알 수 있습니다.
 
-/// info
+/// info | 정보
 
 불행히도, 제가 단순히 여러 개의 승인만으로 PR을 신뢰할 수는 없습니다.
 
-3개, 5개 이상의 승인이 달린 PR이 실제로는 깨져 있거나, 버그가 있거나, 주장하는 문제를 해결하지 못하는 경우가 여러 번 있었습니다. 😅
+여러 번, 설명이 그럴듯해서인지 3개, 5개 이상의 승인이 달린 PR이 있었지만, 제가 확인해보면 실제로는 깨져 있거나, 버그가 있거나, 주장하는 문제를 해결하지 못하는 경우가 있었습니다. 😅
 
 따라서, 정말로 코드를 읽고 실행한 뒤, 댓글로 확인 내용을 남겨 주는 것이 매우 중요합니다. 🤓
 
 ///
 
-* PR을 더 단순하게 만들 수 있다면 그렇게 요청할 수 있지만, 너무 까다로울 필요는 없습니다. 주관적인 견해가 많이 있을 수 있기 때문입니다 (그리고 저도 제 견해가 있을 거예요 🙈). 따라서 핵심적인 부분에 집중하는 것이 좋습니다.
+* PR을 더 단순하게 만들 수 있다면 그렇게 요청할 수 있지만, 너무 까다로울 필요는 없습니다. 주관적인 견해가 많이 있을 수 있기 때문입니다(그리고 저도 제 견해가 있을 거예요 🙈). 따라서 핵심적인 부분에 집중하는 것이 좋습니다.
 
-### 테스트
+### 테스트 { #tests }
 
 * PR에 **테스트**가 포함되어 있는지 확인하는 데 도움을 주세요.
 
-* PR을 적용하기 전에 테스트가 **실패**하는지 확인하세요. 🚨
+* PR 전에는 테스트가 **실패**하는지 확인하세요. 🚨
 
-* PR을 적용한 후 테스트가 **통과**하는지 확인하세요. ✅
+* 그런 다음 PR 후에는 테스트가 **통과**하는지 확인하세요. ✅
 
-* 많은 PR에는 테스트가 없습니다. 테스트를 추가하도록 **상기**시켜줄 수도 있고, 직접 테스트를 **제안**할 수도 있습니다. 이는 시간이 많이 소요되는 부분 중 하나이며, 그 부분을 많이 도와줄 수 있습니다.
+* 많은 PR에는 테스트가 없습니다. 테스트를 추가하도록 **상기**시켜줄 수도 있고, 직접 테스트를 **제안**할 수도 있습니다. 이는 시간이 가장 많이 드는 것들 중 하나이며, 그 부분을 많이 도와줄 수 있습니다.
 
 * 그리고 시도한 내용을 댓글로 남겨주세요. 그러면 제가 확인했다는 걸 알 수 있습니다. 🤓
 
-## Pull Request를 만드십시오
+## Pull Request 만들기 { #create-a-pull-request }
 
-Pull Requests를 이용하여 소스코드에 [컨트리뷰트](contributing.md){.internal-link target=\_blank} 할 수 있습니다. 예를 들면 다음과 같습니다:
+Pull Requests를 이용하여 소스 코드에 [기여](contributing.md){.internal-link target=_blank}할 수 있습니다. 예를 들면 다음과 같습니다:
 
 * 문서에서 발견한 오타를 수정할 때.
-* FastAPI 관련 문서, 비디오 또는 팟캐스트를 작성했거나 발견하여 <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">이 파일을 편집하여</a> 공유할 때.
+* FastAPI에 대한 글, 비디오, 팟캐스트를 작성했거나 발견했다면 <a href="https://github.com/fastapi/fastapi/edit/master/docs/en/data/external_links.yml" class="external-link" target="_blank">이 파일을 편집</a>하여 공유할 때.
     * 해당 섹션의 시작 부분에 링크를 추가해야 합니다.
-* 당신의 언어로 [문서 번역하는데](contributing.md#translations){.internal-link target=\_blank} 기여할 때.
+* 여러분의 언어로 [문서 번역에](contributing.md#translations){.internal-link target=_blank} 도움을 줄 때.
     * 다른 사람이 작성한 번역을 검토하는 것도 도울 수 있습니다.
-* 새로운 문서의 섹션을 제안할 때.
-* 기존 문제/버그를 수정할 때.
+* 새로운 문서 섹션을 제안할 때.
+* 기존 이슈/버그를 수정할 때.
     * 테스트를 반드시 추가해야 합니다.
-* 새로운 feature를 추가할 때.
+* 새로운 기능을 추가할 때.
     * 테스트를 반드시 추가해야 합니다.
-    * 관련 문서가 필요하다면 반드시 추가해야 합니다.
+    * 관련 문서가 있다면 반드시 추가해야 합니다.
 
-## FastAPI 유지 관리에 도움 주기
+## FastAPI 유지 관리 돕기 { #help-maintain-fastapi }
 
-**FastAPI**의 유지 관리를 도와주세요! 🤓
+**FastAPI** 유지를 도와주세요! 🤓
 
-할 일이 많고, 그 중 대부분은 **여러분**이 할 수 있습니다.
+할 일이 많고, 그중 대부분은 **여러분**이 할 수 있습니다.
 
 지금 할 수 있는 주요 작업은:
 
-* [GitHub에서 다른 사람들의 질문에 도움 주기](#github_1){.internal-link target=_blank} (위의 섹션을 참조하세요).
-* [Pull Request 리뷰하기](#pull-requests){.internal-link target=_blank} (위의 섹션을 참조하세요).
+* [GitHub에서 질문으로 다른 사람 돕기](#help-others-with-questions-in-github){.internal-link target=_blank} (위의 섹션을 참조하세요).
+* [Pull Request 리뷰하기](#review-pull-requests){.internal-link target=_blank} (위의 섹션을 참조하세요).
 
-이 두 작업이 **가장 많은 시간을 소모**하는 일입니다. 그것이 FastAPI 유지 관리의 주요 작업입니다.
+이 두 작업이 **가장 많은 시간을 소모**합니다. 이것이 FastAPI를 유지 관리하는 주요 작업입니다.
 
-이 작업을 도와주신다면, **FastAPI 유지 관리에 도움을 주는 것**이며 그것이 **더 빠르고 더 잘 발전하는 것**을 보장하는 것입니다. 🚀
+이 작업을 도와주신다면, **FastAPI 유지를 돕는 것**이며 FastAPI가 **더 빠르고 더 잘 발전하는 것**을 보장하는 것입니다. 🚀
 
-## 채팅에 참여하십시오
+## 채팅에 참여하기 { #join-the-chat }
 
-👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">디스코드 채팅 서버</a> 👥 에 가입하고 FastAPI 커뮤니티에서 다른 사람들과 어울리세요.
+👥 <a href="https://discord.gg/VQjSZaeJmf" class="external-link" target="_blank">Discord 채팅 서버</a> 👥 에 참여해서 FastAPI 커뮤니티의 다른 사람들과 어울리세요.
 
-/// tip
+/// tip | 팁
 
-질문이 있는 경우, <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub 디스커션</a> 에서 질문하십시오, [FastAPI Experts](fastapi-people.md#fastapi-experts){.internal-link target=_blank} 의 도움을 받을 가능성이 높습니다.
+질문은 <a href="https://github.com/fastapi/fastapi/discussions/new?category=questions" class="external-link" target="_blank">GitHub Discussions</a>에서 하세요. [FastAPI Experts](fastapi-people.md#fastapi-experts){.internal-link target=_blank}로부터 도움을 받을 가능성이 훨씬 높습니다.
 
-다른 일반적인 대화에서만 채팅을 사용하십시오.
+채팅은 다른 일반적인 대화를 위해서만 사용하세요.
 
 ///
 
-### 질문을 위해 채팅을 사용하지 마십시오
+### 질문을 위해 채팅을 사용하지 마세요 { #dont-use-the-chat-for-questions }
 
-채팅은 더 많은 "자유로운 대화"를 허용하기 때문에, 너무 일반적인 질문이나 대답하기 어려운 질문을 쉽게 질문을 할 수 있으므로, 답변을 받지 못할 수 있습니다.
+채팅은 더 많은 "자유로운 대화"를 허용하기 때문에, 너무 일반적인 질문이나 답하기 어려운 질문을 쉽게 할 수 있어 답변을 받지 못할 수도 있다는 점을 기억하세요.
 
-GitHub 이슈에서의 템플릿은 올바른 질문을 작성하도록 안내하여 더 쉽게 좋은 답변을 얻거나 질문하기 전에 스스로 문제를 해결할 수도 있습니다. 그리고 GitHub에서는 시간이 조금 걸리더라도 항상 모든 것에 답할 수 있습니다. 채팅 시스템에서는 개인적으로 그렇게 할 수 없습니다. 😅
+GitHub에서는 템플릿이 올바른 질문을 작성하도록 안내하여 더 쉽게 좋은 답변을 얻거나, 질문하기 전에 스스로 문제를 해결할 수도 있습니다. 그리고 GitHub에서는 시간이 조금 걸리더라도 제가 항상 모든 것에 답하도록 보장할 수 있습니다. 채팅 시스템에서는 제가 개인적으로 그렇게 할 수 없습니다. 😅
 
-채팅 시스템에서의 대화 또한 GitHub에서 처럼 쉽게 검색할 수 없기 때문에 대화 중에 질문과 답변이 손실될 수 있습니다. 그리고 GitHub 이슈에 있는 것만 [FastAPI Expert](fastapi-people.md#fastapi-experts){.internal-link target=_blank}가 되는 것으로 간주되므로, GitHub 이슈에서 더 많은 관심을 받을 것입니다.
+채팅 시스템에서의 대화 또한 GitHub만큼 쉽게 검색할 수 없기 때문에, 질문과 답변이 대화 속에서 사라질 수 있습니다. 그리고 GitHub에 있는 것만 [FastAPI Expert](fastapi-people.md#fastapi-experts){.internal-link target=_blank}가 되는 것으로 인정되므로, GitHub에서 더 많은 관심을 받게 될 가능성이 큽니다.
 
-반면, 채팅 시스템에는 수천 명의 사용자가 있기 때문에, 거의 항상 대화 상대를 찾을 가능성이 높습니다. 😄
+반면, 채팅 시스템에는 수천 명의 사용자가 있으므로, 거의 항상 대화 상대를 찾을 가능성이 높습니다. 😄
 
-## 개발자 스폰서가 되십시오
+## 개발자 스폰서 되기 { #sponsor-the-author }
 
-<a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub 스폰서</a> 를 통해 개발자를 경제적으로 지원할 수 있습니다.
-
-감사하다는 말로 커피를 ☕️ 한잔 사줄 수 있습니다. 😄
-
-또한 FastAPI의 실버 또는 골드 스폰서가 될 수 있습니다. 🏅🎉
-
-## FastAPI를 강화하는 도구의 스폰서가 되십시오
-
-문서에서 보았듯이, FastAPI는 Starlette과 Pydantic 라는 거인의 어깨에 타고 있습니다.
-
-다음의 스폰서가 될 수 있습니다
-
-* <a href="https://github.com/sponsors/samuelcolvin" class="external-link" target="_blank">Samuel Colvin (Pydantic)</a>
-* <a href="https://github.com/sponsors/encode" class="external-link" target="_blank">Encode (Starlette, Uvicorn)</a>
+여러분의 **제품/회사**가 **FastAPI**에 의존하거나 관련되어 있고, FastAPI 사용자를 대상으로 알리고 싶다면 <a href="https://github.com/sponsors/tiangolo" class="external-link" target="_blank">GitHub sponsors</a>를 통해 개발자(저)를 스폰서할 수 있습니다. 티어에 따라 문서에 배지 같은 추가 혜택을 받을 수도 있습니다. 🎁
 
 ---
 

docs/ko/docs/history-design-future.md

@@ -1,81 +1,79 @@
-# 역사, 디자인 그리고 미래
+# 역사, 디자인 그리고 미래 { #history-design-and-future }
 
-어느 날, [한 FastAPI 사용자](https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920)가 이렇게 물었습니다:
+얼마 전, <a href="https://github.com/fastapi/fastapi/issues/3#issuecomment-454956920" class="external-link" target="_blank">한 **FastAPI** 사용자가 이렇게 물었습니다</a>:
 
-> 이 프로젝트의 역사를 알려 주실 수 있나요? 몇 주 만에 멋진 결과를 낸 것 같아요. [...]
+> 이 프로젝트의 역사는 무엇인가요? 몇 주 만에 아무 데서도 갑자기 나타나 엄청나게 좋아진 것처럼 보이네요 [...]
 
 여기서 그 역사에 대해 간단히 설명하겠습니다.
 
----
+## 대안 { #alternatives }
 
-## 대안
+저는 여러 해 동안 복잡한 요구사항(머신러닝, 분산 시스템, 비동기 작업, NoSQL 데이터베이스 등)을 가진 API를 만들면서 여러 개발 팀을 이끌어 왔습니다.
 
-저는 여러 해 동안 머신러닝, 분산 시스템, 비동기 작업, NoSQL 데이터베이스 같은 복잡한 요구사항을 가진 API를 개발하며 여러 팀을 이끌어 왔습니다.
+그 과정에서 많은 대안을 조사하고, 테스트하고, 사용해야 했습니다.
 
-이 과정에서 많은 대안을 조사하고, 테스트하며, 사용해야 했습니다. **FastAPI**의 역사는 그 이전에 나왔던 여러 도구의 역사와 밀접하게 연관되어 있습니다.
+**FastAPI**의 역사는 상당 부분 그 이전에 있던 도구들의 역사입니다.
 
 [대안](alternatives.md){.internal-link target=_blank} 섹션에서 언급된 것처럼:
 
-> **FastAPI**는 이전에 나왔던 많은 도구들의 노력 없이는 존재하지 않았을 것입니다.
->
-> 이전에 개발된 여러 도구들이 이 프로젝트에 영감을 주었습니다.
->
-> 저는 오랫동안 새로운 프레임워크를 만드는 것을 피하고자 했습니다. 처음에는 **FastAPI**가 제공하는 기능들을 다양한 프레임워크와 플러그인, 도구들을 조합해 해결하려 했습니다.
->
-> 하지만 결국에는 이 모든 기능을 통합하는 도구가 필요해졌습니다. 이전 도구들로부터 최고의 아이디어들을 모으고, 이를 최적의 방식으로 조합해야만 했습니다. 이는 :term:Python 3.6+ 타입 힌트 <type hints>와 같은, 이전에는 사용할 수 없었던 언어 기능이 가능했기 때문입니다.
+<blockquote markdown="1">
 
----
+**FastAPI**는 다른 사람들이 이전에 해온 작업이 없었다면 존재하지 않았을 것입니다.
 
-## 조사
+그 전에 만들어진 많은 도구들이 이것의 탄생에 영감을 주었습니다.
 
-여러 대안을 사용해 보며 다양한 도구에서 배운 점들을 모아 저와 개발팀에게 가장 적합한 방식을 찾았습니다.
+저는 여러 해 동안 새로운 프레임워크를 만드는 것을 피하고 있었습니다. 처음에는 **FastAPI**가 다루는 모든 기능을 여러 다른 프레임워크, 플러그인, 도구들을 사용해 해결하려고 했습니다.
 
-예를 들어, 표준 :term:Python 타입 힌트 <type hints>에 기반하는 것이 이상적이라는 점이 명확했습니다.
+하지만 어느 시점에는, 이전 도구들의 최고의 아이디어를 가져와 가능한 한 최선의 방식으로 조합하고, 이전에는 존재하지 않았던 언어 기능(Python 3.6+ type hints)을 사용해 이 모든 기능을 제공하는 무언가를 만드는 것 외에는 다른 선택지가 없었습니다.
 
-또한, 이미 존재하는 표준을 활용하는 것이 가장 좋은 접근법이라 판단했습니다.
+</blockquote>
 
-그래서 **FastAPI**의 코드를 작성하기 전에 몇 달 동안 OpenAPI, JSON Schema, OAuth2 명세를 연구하며 이들의 관계와 겹치는 부분, 차이점을 이해했습니다.
+## 조사 { #investigation }
 
----
+이전의 모든 대안을 사용해 보면서, 각 도구로부터 배울 기회를 얻었고, 아이디어를 가져와 제가 일해온 개발 팀들과 저 자신에게 가장 적합하다고 찾은 방식으로 조합할 수 있었습니다.
 
-## 디자인
+예를 들어, 이상적으로는 표준 Python 타입 힌트에 기반해야 한다는 점이 분명했습니다.
 
-그 후, **FastAPI** 사용자가 될 개발자로서 사용하고 싶은 개발자 "API"를 디자인했습니다.
+또한, 가장 좋은 접근법은 이미 존재하는 표준을 사용하는 것이었습니다.
 
-[Python Developer Survey](https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools)에 따르면 약 80%의 Python 개발자가 PyCharm, VS Code, Jedi 기반 편집기 등에서 개발합니다. 이 과정에서 여러 아이디어를 테스트했습니다.
+그래서 **FastAPI**의 코딩을 시작하기도 전에, OpenAPI, JSON Schema, OAuth2 등과 같은 명세를 몇 달 동안 공부했습니다. 이들의 관계, 겹치는 부분, 차이점을 이해하기 위해서였습니다.
 
-대부분의 다른 편집기도 유사하게 동작하기 때문에, **FastAPI**의 이점은 거의 모든 편집기에서 누릴 수 있습니다.
+## 디자인 { #design }
 
-이 과정을 통해 코드 중복을 최소화하고, 모든 곳에서 자동 완성, 타입 검사, 에러 확인 기능이 제공되는 최적의 방식을 찾아냈습니다.
+그 다음에는 (FastAPI를 사용하는 개발자로서) 사용자로서 갖고 싶었던 개발자 "API"를 디자인하는 데 시간을 썼습니다.
 
-이 모든 것은 개발자들에게 최고의 개발 경험을 제공하기 위해 설계되었습니다.
+가장 인기 있는 Python 편집기들: PyCharm, VS Code, Jedi 기반 편집기에서 여러 아이디어를 테스트했습니다.
 
----
+약 80%의 사용자를 포함하는 최근 <a href="https://www.jetbrains.com/research/python-developers-survey-2018/#development-tools" class="external-link" target="_blank">Python Developer Survey</a>에 따르면 그렇습니다.
 
-## 필요조건
+즉, **FastAPI**는 Python 개발자의 80%가 사용하는 편집기들로 특별히 테스트되었습니다. 그리고 대부분의 다른 편집기도 유사하게 동작하는 경향이 있으므로, 그 모든 이점은 사실상 모든 편집기에서 동작해야 합니다.
 
-여러 대안을 테스트한 후, [Pydantic](https://docs.pydantic.dev/)을 사용하기로 결정했습니다.
+그렇게 해서 코드 중복을 가능한 한 많이 줄이고, 어디서나 자동 완성, 타입 및 에러 검사 등을 제공하는 최선의 방법을 찾을 수 있었습니다.
 
-이후 저는 **Pydantic**이 JSON Schema와 완벽히 호환되도록 개선하고, 다양한 제약 조건 선언을 지원하며, 여러 편집기에서의 자동 완성과 타입 검사 기능을 향상하기 위해 기여했습니다.
+모든 개발자에게 최고의 개발 경험을 제공하는 방식으로 말입니다.
 
-또한, 또 다른 주요 필요조건이었던 [Starlette](https://www.starlette.dev/)에도 기여했습니다.
+## 필요조건 { #requirements }
 
----
+여러 대안을 테스트한 후, 장점 때문에 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">**Pydantic**</a>을 사용하기로 결정했습니다.
 
-## 개발
+그 후, JSON Schema를 완전히 준수하도록 하고, 제약 조건 선언을 정의하는 다양한 방식을 지원하며, 여러 편집기에서의 테스트를 바탕으로 편집기 지원(타입 검사, 자동 완성)을 개선하기 위해 기여했습니다.
 
-**FastAPI**를 개발하기 시작할 즈음에는 대부분의 준비가 이미 완료된 상태였습니다. 설계가 정의되었고, 필요조건과 도구가 준비되었으며, 표준과 명세에 대한 지식도 충분했습니다.
+개발 과정에서, 또 다른 핵심 필요조건인 <a href="https://www.starlette.dev/" class="external-link" target="_blank">**Starlette**</a>에도 기여했습니다.
 
----
+## 개발 { #development }
 
-## 미래
+**FastAPI** 자체를 만들기 시작했을 때쯤에는, 대부분의 조각들이 이미 갖춰져 있었고, 디자인은 정의되어 있었으며, 필요조건과 도구는 준비되어 있었고, 표준과 명세에 대한 지식도 명확하고 최신 상태였습니다.
 
-현시점에서 **FastAPI**가 많은 사람들에게 유용하다는 것이 명백해졌습니다.
+## 미래 { #future }
 
-여러 용도에 더 적합한 도구로서 기존 대안보다 선호되고 있습니다.
-이미 많은 개발자와 팀들이 **FastAPI**에 의존해 프로젝트를 진행 중입니다 (저와 제 팀도 마찬가지입니다).
+이 시점에는, **FastAPI**가 그 아이디어와 함께 많은 사람들에게 유용하다는 것이 이미 분명합니다.
 
-하지만 여전히 개선해야 할 점과 추가할 기능들이 많이 남아 있습니다.
+많은 사용 사례에 더 잘 맞기 때문에 이전 대안들보다 선택되고 있습니다.
+
+많은 개발자와 팀이 이미 자신의 프로젝트를 위해 **FastAPI**에 의존하고 있습니다(저와 제 팀도 포함해서요).
+
+하지만 여전히, 앞으로 나올 개선 사항과 기능들이 많이 있습니다.
+
+**FastAPI**의 미래는 밝습니다.
 
-**FastAPI**는 밝은 미래로 나아가고 있습니다.
 그리고 [여러분의 도움](help-fastapi.md){.internal-link target=_blank}은 큰 힘이 됩니다.

docs/ko/llm-prompt.md

@@ -8,6 +8,7 @@ Language code: ko.
 
 - Use polite, instructional Korean (e.g. 합니다/하세요 style).
 - Keep the tone consistent with the existing Korean FastAPI docs.
+- Do not translate “You” literally as “당신”. Use “여러분” where appropriate, or omit the subject if it sounds more natural in Korean.
 
 ### Headings
 
@@ -32,6 +33,9 @@ Use the following preferred translations when they apply in documentation prose:
 - response (HTTP): 응답
 - path operation: 경로 처리
 - path operation function: 경로 처리 함수
+- app: 애플리케이션
+- command: 명령어
+- burger: 햄버거 (NOT 버거)
 
 ### `///` admonitions
 

docs/pt/docs/_llm-test.md

@@ -1,8 +1,8 @@
 # Arquivo de teste de LLM { #llm-test-file }
 
-Este documento testa se o <abbr title="Large Language Model – Modelo de Linguagem de Grande Porte">LLM</abbr>, que traduz a documentação, entende o `general_prompt` em `scripts/translate.py` e o prompt específico do idioma em `docs/{language code}/llm-prompt.md`. O prompt específico do idioma é anexado ao `general_prompt`.
+Este documento testa se o <abbr title="Large Language Model - Modelo de Linguagem de Grande Porte">LLM</abbr>, que traduz a documentação, entende o `general_prompt` em `scripts/translate.py` e o prompt específico do idioma em `docs/{language code}/llm-prompt.md`. O prompt específico do idioma é anexado ao `general_prompt`.
 
-Os testes adicionados aqui serão vistos por todos os autores dos prompts específicos de idioma.
+Os testes adicionados aqui serão vistos por todos os designers dos prompts específicos de idioma.
 
 Use da seguinte forma:
 
@@ -23,7 +23,7 @@ Este é um trecho de código: `foo`. E este é outro trecho de código: `bar`. E
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 O conteúdo dos trechos de código deve ser deixado como está.
 
@@ -45,9 +45,9 @@ O LLM provavelmente vai traduzir isso errado. O interessante é apenas se ele ma
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
-O autor do prompt pode escolher se deseja converter aspas neutras em aspas tipográficas. Também é aceitável deixá-las como estão.
+O designer do prompt pode escolher se quer converter aspas neutras em aspas tipográficas. Também é aceitável deixá-las como estão.
 
 Veja, por exemplo, a seção `### Quotes` em `docs/de/llm-prompt.md`.
 
@@ -67,7 +67,7 @@ Pesado: `Yesterday, my friend wrote: "If you spell incorrectly correctly, you ha
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 ... No entanto, as aspas dentro de trechos de código devem permanecer como estão.
 
@@ -95,24 +95,24 @@ $ <font color="#4E9A06">fastapi</font> run <u style="text-decoration-style:solid
 ...e outro exemplo de código de console...
 
 ```console
-// Crie um diretório "Code"
+// Criar um diretório "Code"
 $ mkdir code
-// Entre nesse diretório
+// Mudar para esse diretório
 $ cd code
 ```
 
 ...e um exemplo de código Python...
 
 ```Python
-wont_work()  # Isto não vai funcionar 😱
-works(foo="bar")  # Isto funciona 🎉
+wont_work()  # This won't work 😱
+works(foo="bar")  # This works 🎉
 ```
 
 ...e é isso.
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 O código em blocos de código não deve ser modificado, com exceção dos comentários.
 
@@ -154,7 +154,7 @@ Algum texto
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 Abas e blocos `Info`/`Note`/`Warning`/etc. devem ter a tradução do seu título adicionada após uma barra vertical (`|`).
 
@@ -181,7 +181,7 @@ O texto do link deve ser traduzido, o endereço do link deve apontar para a trad
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 Os links devem ser traduzidos, mas seus endereços devem permanecer inalterados. Uma exceção são links absolutos para páginas da documentação do FastAPI. Nesse caso, devem apontar para a tradução.
 
@@ -197,10 +197,10 @@ Aqui estão algumas coisas envolvidas em elementos HTML "abbr" (algumas são inv
 
 ### O abbr fornece uma frase completa { #the-abbr-gives-a-full-phrase }
 
-* <abbr title="Getting Things Done – Fazer as Coisas">GTD</abbr>
-* <abbr title="menos que"><code>lt</code></abbr>
-* <abbr title="XML Web Token – Token Web XML">XWT</abbr>
-* <abbr title="Parallel Server Gateway Interface – Interface de Gateway de Servidor Paralelo">PSGI</abbr>
+* <abbr title="Getting Things Done">GTD</abbr>
+* <abbr title="less than - menos que"><code>lt</code></abbr>
+* <abbr title="XML Web Token">XWT</abbr>
+* <abbr title="Parallel Server Gateway Interface - Interface de Gateway de Servidor Paralelo">PSGI</abbr>
 
 ### O abbr fornece uma explicação { #the-abbr-gives-an-explanation }
 
@@ -209,12 +209,12 @@ Aqui estão algumas coisas envolvidas em elementos HTML "abbr" (algumas são inv
 
 ### O abbr fornece uma frase completa e uma explicação { #the-abbr-gives-a-full-phrase-and-an-explanation }
 
-* <abbr title="Mozilla Developer Network – Rede de Desenvolvedores da Mozilla: documentação para desenvolvedores, escrita pelo pessoal do Firefox">MDN</abbr>
-* <abbr title="Input/Output – Entrada/Saída: leitura ou escrita em disco, comunicações de rede.">I/O</abbr>.
+* <abbr title="Mozilla Developer Network: documentação para desenvolvedores, escrita pelo pessoal do Firefox">MDN</abbr>
+* <abbr title="Input/Output: leitura ou escrita em disco, comunicações de rede.">I/O</abbr>.
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 Os atributos "title" dos elementos "abbr" são traduzidos seguindo algumas instruções específicas.
 
@@ -228,7 +228,7 @@ Veja a seção `### HTML abbr elements` no prompt geral em `scripts/translate.py
 
 //// tab | Teste
 
-### Desenvolver uma aplicação web - um tutorial { #develop-a-webapp-a-tutorial }
+### Desenvolver uma webapp - um tutorial { #develop-a-webapp-a-tutorial }
 
 Olá.
 
@@ -242,7 +242,7 @@ Olá novamente.
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
 A única regra rígida para títulos é que o LLM deixe a parte do hash dentro de chaves inalterada, o que garante que os links não quebrem.
 
@@ -494,9 +494,9 @@ Para algumas instruções específicas do idioma, veja, por exemplo, a seção `
 
 ////
 
-//// tab | Informações
+//// tab | Informação
 
-Esta é uma lista não completa e não normativa de termos (principalmente) técnicos vistos na documentação. Pode ser útil para o autor do prompt descobrir para quais termos o LLM precisa de uma ajudinha. Por exemplo, quando ele continua revertendo uma boa tradução para uma tradução subótima. Ou quando tem problemas para conjugar/declinar um termo no seu idioma.
+Esta é uma lista não completa e não normativa de termos (principalmente) técnicos vistos na documentação. Pode ser útil para o designer do prompt descobrir para quais termos o LLM precisa de uma ajudinha. Por exemplo, quando ele continua revertendo uma boa tradução para uma tradução subótima. Ou quando tem problemas para conjugar/declinar um termo no seu idioma.
 
 Veja, por exemplo, a seção `### List of English terms and their preferred German translations` em `docs/de/llm-prompt.md`.
 

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

@@ -10,7 +10,7 @@ Se você não é um "especialista" no OpenAPI, você provavelmente não precisa
 
 Você pode definir o `operationId` do OpenAPI que será utilizado na sua *operação de rota* com o parâmetro `operation_id`.
 
-Você precisa ter certeza que ele é único para cada operação.
+Você deveria ter certeza que ele é único para cada operação.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial001_py39.py hl[6] *}
 
@@ -18,13 +18,13 @@ Você precisa ter certeza que ele é único para cada operação.
 
 Se você quiser utilizar o nome das funções da sua API como `operationId`s, você pode iterar sobre todos esses nomes e sobrescrever o `operation_id` em  cada *operação de rota* utilizando o `APIRoute.name` dela.
 
-Você deve fazer isso depois de adicionar todas as suas *operações de rota*.
+Você deveria fazer isso depois de adicionar todas as suas *operações de rota*.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial002_py39.py hl[2, 12:21, 24] *}
 
 /// tip | Dica
 
-Se você chamar `app.openapi()` manualmente, os `operationId`s devem ser atualizados antes dessa chamada.
+Se você chamar `app.openapi()` manualmente, você deveria atualizar os `operationId`s antes dessa chamada.
 
 ///
 
@@ -44,11 +44,11 @@ Para excluir uma *operação de rota* do esquema OpenAPI gerado (e por consequê
 
 ## Descrição avançada a partir de docstring { #advanced-description-from-docstring }
 
-Você pode limitar as linhas utilizadas a partir de uma docstring de uma *função de operação de rota* para o OpenAPI.
+Você pode limitar as linhas utilizadas a partir da docstring de uma *função de operação de rota* para o OpenAPI.
 
-Adicionar um `\f` (um caractere de escape para alimentação de formulário) faz com que o **FastAPI** restrinja a saída utilizada pelo OpenAPI até esse ponto.
+Adicionar um `\f` (um caractere de escape para "form feed") faz com que o **FastAPI** trunque a saída usada para o OpenAPI até esse ponto.
 
-Ele não será mostrado na documentação, mas outras ferramentas (como o Sphinx) serão capazes de utilizar o resto do texto.
+Ele não será mostrado na documentação, mas outras ferramentas (como o Sphinx) serão capazes de utilizar o resto.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
 
@@ -131,70 +131,38 @@ E se você olhar o esquema OpenAPI resultante (na rota `/openapi.json` da sua AP
 
 ### Esquema de *operação de rota* do OpenAPI personalizado { #custom-openapi-path-operation-schema }
 
-O dicionário em `openapi_extra` vai ter todos os seus níveis mesclados dentro do esquema OpenAPI gerado automaticamente para a *operação de rota*.
+O dicionário em `openapi_extra` vai ser mesclado profundamente com o esquema OpenAPI gerado automaticamente para a *operação de rota*.
 
-Então, você pode adicionar dados extras para o esquema gerado automaticamente.
+Então, você pode adicionar dados extras ao esquema gerado automaticamente.
 
-Por exemplo, você poderia optar por ler e validar a requisição com seu próprio código, sem utilizar funcionalidades automatizadas do FastAPI com o Pydantic, mas você ainda pode quere definir a requisição no esquema OpenAPI.
+Por exemplo, você poderia decidir ler e validar a requisição com seu próprio código, sem usar as funcionalidades automáticas do FastAPI com o Pydantic, mas ainda assim querer definir a requisição no esquema OpenAPI.
 
 Você pode fazer isso com `openapi_extra`:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial006_py39.py hl[19:36, 39:40] *}
 
-Nesse exemplo, nós não declaramos nenhum modelo do Pydantic. Na verdade, o corpo da requisição não está nem mesmo <abbr title="convertido de um formato plano, como bytes, para objetos Python">analisado</abbr> como JSON, ele é lido diretamente como `bytes` e a função `magic_data_reader()` seria a responsável por analisar ele de alguma forma.
+Nesse exemplo, nós não declaramos nenhum modelo do Pydantic. Na verdade, o corpo da requisição não está nem mesmo <abbr title="converted from some plain format, like bytes, into Python objects - convertido de algum formato simples, como bytes, em objetos Python">analisado</abbr> como JSON, ele é lido diretamente como `bytes`, e a função `magic_data_reader()` seria a responsável por analisar ele de alguma forma.
 
 De toda forma, nós podemos declarar o esquema esperado para o corpo da requisição.
 
 ### Tipo de conteúdo do OpenAPI personalizado { #custom-openapi-content-type }
 
-Utilizando esse mesmo truque, você pode utilizar um modelo Pydantic para definir o JSON Schema que é então incluído na seção do esquema personalizado do OpenAPI na *operação de rota*.
+Utilizando esse mesmo truque, você pode usar um modelo Pydantic para definir o JSON Schema que é então incluído na seção do esquema personalizado do OpenAPI na *operação de rota*.
 
-E você pode fazer isso até mesmo quando os dados da requisição não seguem o formato JSON.
+E você pode fazer isso até mesmo quando o tipo de dados na requisição não é JSON.
 
-Por exemplo, nesta aplicação nós não usamos a funcionalidade integrada ao FastAPI de extrair o JSON Schema dos modelos Pydantic nem a validação automática do JSON. Na verdade, estamos declarando o tipo do conteúdo da requisição como YAML, em vez de JSON:
-
-//// tab | Pydantic v2
+Por exemplo, nesta aplicação nós não usamos a funcionalidade integrada ao FastAPI de extrair o JSON Schema dos modelos Pydantic nem a validação automática para JSON. Na verdade, estamos declarando o tipo de conteúdo da requisição como YAML, em vez de JSON:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
 
-////
+Entretanto, mesmo que não utilizemos a funcionalidade integrada por padrão, ainda estamos usando um modelo Pydantic para gerar um JSON Schema manualmente para os dados que queremos receber em YAML.
 
-//// tab | Pydantic v1
+Então utilizamos a requisição diretamente e extraímos o corpo como `bytes`. Isso significa que o FastAPI não vai sequer tentar analisar o payload da requisição como JSON.
 
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
-
-////
-
-/// info | Informação
-
-Na versão 1 do Pydantic, o método para obter o JSON Schema de um modelo é `Item.schema()`, na versão 2 do Pydantic, o método é `Item.model_json_schema()`.
-
-///
-
-Entretanto, mesmo que não utilizemos a funcionalidade integrada por padrão, ainda estamos usando um modelo Pydantic para gerar um JSON Schema manualmente para os dados que queremos receber no formato YAML.
-
-Então utilizamos a requisição diretamente, e extraímos o corpo como `bytes`. Isso significa que o FastAPI não vai sequer tentar analisar o corpo da requisição como JSON.
-
-E então no nosso código, nós analisamos o conteúdo YAML diretamente, e estamos utilizando o mesmo modelo Pydantic para validar o conteúdo YAML:
-
-//// tab | Pydantic v2
+E então no nosso código, nós analisamos o conteúdo YAML diretamente e, em seguida, estamos usando novamente o mesmo modelo Pydantic para validar o conteúdo YAML:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
-
-////
-
-/// info | Informação
-
-Na versão 1 do Pydantic, o método para analisar e validar um objeto era `Item.parse_obj()`, na versão 2 do Pydantic, o método é chamado de `Item.model_validate()`.
-
-///
-
 /// tip | Dica
 
 Aqui reutilizamos o mesmo modelo do Pydantic.

docs/pt/docs/advanced/settings.md

@@ -46,12 +46,6 @@ $ pip install "fastapi[all]"
 
 </div>
 
-/// info | Informação
-
-No Pydantic v1 ele vinha incluído no pacote principal. Agora é distribuído como um pacote independente para que você possa optar por instalá-lo ou não, caso não precise dessa funcionalidade.
-
-///
-
 ### Criar o objeto `Settings` { #create-the-settings-object }
 
 Importe `BaseSettings` do Pydantic e crie uma subclasse, muito parecido com um modelo do Pydantic.
@@ -60,24 +54,8 @@ Da mesma forma que com modelos do Pydantic, você declara atributos de classe co
 
 Você pode usar as mesmas funcionalidades e ferramentas de validação que usa em modelos do Pydantic, como diferentes tipos de dados e validações adicionais com `Field()`.
 
-//// tab | Pydantic v2
-
 {* ../../docs_src/settings/tutorial001_py39.py hl[2,5:8,11] *}
 
-////
-
-//// tab | Pydantic v1
-
-/// info | Informação
-
-No Pydantic v1 você importaria `BaseSettings` diretamente de `pydantic` em vez de `pydantic_settings`.
-
-///
-
-{* ../../docs_src/settings/tutorial001_pv1_py39.py hl[2,5:8,11] *}
-
-////
-
 /// tip | Dica
 
 Se você quer algo rápido para copiar e colar, não use este exemplo, use o último abaixo.
@@ -215,8 +193,6 @@ APP_NAME="ChimichangApp"
 
 E então atualizar seu `config.py` com:
 
-//// tab | Pydantic v2
-
 {* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
 
 /// tip | Dica
@@ -225,26 +201,6 @@ O atributo `model_config` é usado apenas para configuração do Pydantic. Você
 
 ///
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
-
-/// tip | Dica
-
-A classe `Config` é usada apenas para configuração do Pydantic. Você pode ler mais em <a href="https://docs.pydantic.dev/1.10/usage/model_config/" class="external-link" target="_blank">Pydantic Model Config</a>.
-
-///
-
-////
-
-/// info | Informação
-
-Na versão 1 do Pydantic a configuração era feita em uma classe interna `Config`, na versão 2 do Pydantic é feita em um atributo `model_config`. Esse atributo recebe um `dict`, e para ter autocompletar e erros inline você pode importar e usar `SettingsConfigDict` para definir esse `dict`.
-
-///
-
 Aqui definimos a configuração `env_file` dentro da sua classe `Settings` do Pydantic e definimos o valor como o nome do arquivo dotenv que queremos usar.
 
 ### Criando o `Settings` apenas uma vez com `lru_cache` { #creating-the-settings-only-once-with-lru-cache }

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

@@ -2,21 +2,23 @@
 
 Se você tem uma aplicação FastAPI antiga, pode estar usando o Pydantic versão 1.
 
-O FastAPI tem suporte ao Pydantic v1 ou v2 desde a versão 0.100.0.
+O FastAPI versão 0.100.0 tinha suporte ao Pydantic v1 ou v2. Ele usaria aquele que você tivesse instalado.
 
-Se você tiver o Pydantic v2 instalado, ele será utilizado. Se, em vez disso, tiver o Pydantic v1, será ele que será utilizado.
+O FastAPI versão 0.119.0 introduziu suporte parcial ao Pydantic v1 a partir de dentro do Pydantic v2 (como `pydantic.v1`), para facilitar a migração para o v2.
 
-O Pydantic v1 está agora descontinuado e o suporte a ele será removido nas próximas versões do FastAPI, você deveria migrar para o Pydantic v2. Assim, você terá as funcionalidades, melhorias e correções mais recentes.
+O FastAPI 0.126.0 removeu o suporte ao Pydantic v1, enquanto ainda oferece suporte a `pydantic.v1` por mais algum tempo.
 
 /// warning | Atenção
 
-Além disso, a equipe do Pydantic interrompeu o suporte ao Pydantic v1 para as versões mais recentes do Python, a partir do **Python 3.14**.
+A equipe do Pydantic interrompeu o suporte ao Pydantic v1 para as versões mais recentes do Python, a partir do **Python 3.14**.
+
+Isso inclui `pydantic.v1`, que não é mais suportado no Python 3.14 e superiores.
 
 Se quiser usar as funcionalidades mais recentes do Python, você precisará garantir que usa o Pydantic v2.
 
 ///
 
-Se você tem uma aplicação FastAPI antiga com Pydantic v1, aqui vou mostrar como migrá-la para o Pydantic v2 e as **novas funcionalidades no FastAPI 0.119.0** para ajudar em uma migração gradual.
+Se você tem uma aplicação FastAPI antiga com Pydantic v1, aqui vou mostrar como migrá-la para o Pydantic v2, e as **funcionalidades no FastAPI 0.119.0** para ajudar em uma migração gradual.
 
 ## Guia oficial { #official-guide }
 
@@ -44,7 +46,7 @@ Depois disso, você pode rodar os testes e verificar se tudo funciona. Se funcio
 
 ## Pydantic v1 no v2 { #pydantic-v1-in-v2 }
 
-O Pydantic v2 inclui tudo do Pydantic v1 como um submódulo `pydantic.v1`.
+O Pydantic v2 inclui tudo do Pydantic v1 como um submódulo `pydantic.v1`. Mas isso não é mais suportado em versões acima do Python 3.13.
 
 Isso significa que você pode instalar a versão mais recente do Pydantic v2 e importar e usar os componentes antigos do Pydantic v1 a partir desse submódulo, como se tivesse o Pydantic v1 antigo instalado.
 
@@ -66,7 +68,7 @@ Tenha em mente que, como a equipe do Pydantic não oferece mais suporte ao Pydan
 
 ### Pydantic v1 e v2 na mesma aplicação { #pydantic-v1-and-v2-on-the-same-app }
 
-Não é suportado pelo Pydantic ter um modelo do Pydantic v2 com campos próprios definidos como modelos do Pydantic v1, ou vice-versa.
+Não é **suportado** pelo Pydantic ter um modelo do Pydantic v2 com campos próprios definidos como modelos do Pydantic v1, ou vice-versa.
 
 ```mermaid
 graph TB
@@ -86,7 +88,7 @@ graph TB
     style V2Field fill:#f9fff3
 ```
 
-...but, you can have separated models using Pydantic v1 and v2 in the same app.
+...mas, você pode ter modelos separados usando Pydantic v1 e v2 na mesma aplicação.
 
 ```mermaid
 graph TB
@@ -106,7 +108,7 @@ graph TB
     style V2Field fill:#f9fff3
 ```
 
-Em alguns casos, é até possível ter modelos Pydantic v1 e v2 na mesma operação de rota na sua aplicação FastAPI:
+Em alguns casos, é até possível ter modelos Pydantic v1 e v2 na mesma **operação de rota** na sua aplicação FastAPI:
 
 {* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
 
@@ -122,7 +124,7 @@ Se você precisar usar algumas das ferramentas específicas do FastAPI para par
 
 /// tip | Dica
 
-Primeiro tente com o `bump-pydantic`; se seus testes passarem e isso funcionar, então você concluiu tudo com um único comando. ✨
+Primeiro tente com o `bump-pydantic`, se seus testes passarem e isso funcionar, então você concluiu tudo com um único comando. ✨
 
 ///
 

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

@@ -1,8 +1,8 @@
 # Esquemas OpenAPI Separados para Entrada e Saída ou Não { #separate-openapi-schemas-for-input-and-output-or-not }
 
-Ao usar **Pydantic v2**, o OpenAPI gerado é um pouco mais exato e **correto** do que antes. 😎
+Desde que o **Pydantic v2** foi lançado, o OpenAPI gerado é um pouco mais exato e **correto** do que antes. 😎
 
-Inclusive, em alguns casos, ele terá até **dois JSON Schemas** no OpenAPI para o mesmo modelo Pydantic, para entrada e saída, dependendo se eles possuem **valores padrão**.
+De fato, em alguns casos, ele terá até **dois JSON Schemas** no OpenAPI para o mesmo modelo Pydantic, para entrada e saída, dependendo se eles possuem **valores padrão**.
 
 Vamos ver como isso funciona e como alterar se for necessário.
 
@@ -95,10 +95,8 @@ O suporte para `separate_input_output_schemas` foi adicionado no FastAPI `0.102.
 
 ### Mesmo Esquema para Modelos de Entrada e Saída na Documentação { #same-schema-for-input-and-output-models-in-docs }
 
-E agora haverá um único esquema para entrada e saída para o modelo, apenas `Item`, e `description` **não será obrigatório**:
+E agora haverá um único esquema para entrada e saída para o modelo, apenas `Item`, e ele terá `description` como **não obrigatório**:
 
 <div class="screenshot">
 <img src="/img/tutorial/separate-openapi-schemas/image05.png">
 </div>
-
-Esse é o mesmo comportamento do Pydantic v1. 🤓

docs/pt/docs/index.md

@@ -40,8 +40,8 @@ Os recursos chave são:
 * **Rápido**: alta performance, equivalente a **NodeJS** e **Go** (graças ao Starlette e Pydantic). [Um dos frameworks mais rápidos disponíveis](#performance).
 * **Rápido para codar**: Aumenta a velocidade para desenvolver recursos entre 200% a 300%. *
 * **Poucos bugs**: Reduz cerca de 40% de erros induzidos por humanos (desenvolvedores). *
-* **Intuitivo**: Grande suporte a _IDEs_. <abbr title="também conhecido como autocompletar, preenchimento automático, IntelliSense">Preenchimento automático</abbr> em todos os lugares. Menos tempo debugando.
-* **Fácil**: Projetado para ser fácil de aprender e usar. Menos tempo lendo documentação.
+* **Intuitivo**: Grande suporte a editores. <abbr title="também conhecido como auto-complete, autocompletion, IntelliSense">Completação</abbr> em todos os lugares. Menos tempo debugando.
+* **Fácil**: Projetado para ser fácil de aprender e usar. Menos tempo lendo docs.
 * **Enxuto**: Minimize duplicação de código. Múltiplas funcionalidades para cada declaração de parâmetro. Menos bugs.
 * **Robusto**: Tenha código pronto para produção. E com documentação interativa automática.
 * **Baseado em padrões**: Baseado em (e totalmente compatível com) os padrões abertos para APIs: <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (anteriormente conhecido como Swagger) e <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
@@ -73,7 +73,7 @@ Os recursos chave são:
 
 ## Opiniões { #opinions }
 
-"*[...] Estou usando **FastAPI** muito esses dias. [...] Estou na verdade planejando utilizar ele em todos os times de **serviços _Machine Learning_ na Microsoft**. Alguns deles estão sendo integrados no _core_ do produto **Windows** e alguns produtos **Office**.*"
+"_[...] Estou usando **FastAPI** muito esses dias. [...] Estou na verdade planejando utilizar ele em todos os times de **serviços ML na Microsoft**. Alguns deles estão sendo integrados no _core_ do produto **Windows** e alguns produtos **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>
 
@@ -91,39 +91,45 @@ Os recursos chave são:
 
 ---
 
-"*Estou extremamente entusiasmado com o **FastAPI**. É tão divertido!*"
+"_Estou muito entusiasmado com o **FastAPI**. É tão divertido!_"
 
-<div style="text-align: right; margin-right: 10%;">Brian Okken - <strong><a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a> podcaster</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><a href="https://pythonbytes.fm/episodes/show/123/time-to-right-the-py-wrongs?time_in_sec=855" target="_blank">Python Bytes</a> apresentador do podcast</strong> <a href="https://x.com/brianokken/status/1112220079972728832" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-"*Honestamente, o que você construiu parece super sólido e rebuscado. De muitas formas, eu queria que o **Hug** fosse assim - é realmente inspirador ver alguém que construiu ele.*"
+"_Honestamente, o que você construiu parece super sólido e refinado. De muitas formas, é o que eu queria que o **Hug** fosse - é realmente inspirador ver alguém construir isso._"
 
 <div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong>criador do<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>
 
 ---
 
-"*Se você está procurando aprender um **_framework_ moderno** para construir aplicações _REST_, dê uma olhada no **FastAPI** [...] É rápido, fácil de usar e fácil de aprender [...]*"
+"_Se você está procurando aprender um **framework moderno** para construir APIs REST, dê uma olhada no **FastAPI** [...] É rápido, fácil de usar e fácil de aprender [...]_"
 
-"*Nós trocamos nossas **APIs** por **FastAPI** [...] Acredito que vocês gostarão dele [...]*"
+"_Nós trocamos nossas **APIs** por **FastAPI** [...] Acredito que você gostará dele [...]_"
 
 <div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong>fundadores da <a href="https://explosion.ai" target="_blank">Explosion AI</a> - criadores da <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>
 
 ---
 
-"_Se alguém estiver procurando construir uma API Python para produção, eu recomendaria fortemente o **FastAPI**. Ele é **lindamente projetado**, **simples de usar** e **altamente escalável**. Ele se tornou um **componente chave** para a nossa estratégia API first de desenvolvimento e está impulsionando diversas automações e serviços, como o nosso Virtual TAC Engineer._"
+"_Se alguém estiver procurando construir uma API Python para produção, eu recomendaria fortemente o **FastAPI**. Ele é **lindamente projetado**, **simples de usar** e **altamente escalável**, e se tornou um **componente chave** para a nossa estratégia de desenvolvimento API first, impulsionando diversas automações e serviços, como o nosso Virtual TAC Engineer._"
 
 <div style="text-align: right; margin-right: 10%;">Deon Pillsbury - <strong>Cisco</strong> <a href="https://www.linkedin.com/posts/deonpillsbury_cisco-cx-python-activity-6963242628536487936-trAp/" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
+## Mini documentário do FastAPI { #fastapi-mini-documentary }
+
+Há um <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">mini documentário do FastAPI</a> lançado no fim de 2025, você pode assisti-lo online:
+
+<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**, o FastAPI das interfaces de linhas de comando { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
 
-Se você estiver construindo uma aplicação <abbr title="Command Line Interface – Interface de Linha de Comando">CLI</abbr> para ser utilizada em um terminal ao invés de uma aplicação web, dê uma olhada no <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
+Se você estiver construindo uma aplicação <abbr title="Command Line Interface - Interface de Linha de Comando">CLI</abbr> para ser utilizada no terminal ao invés de uma API web, dê uma olhada no <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>.
 
-**Typer** é o irmão menor do FastAPI. E seu propósito é ser o **FastAPI das _CLIs_**. ⌨️ 🚀
+**Typer** é o irmão menor do FastAPI. E seu propósito é ser o **FastAPI das CLIs**. ⌨️ 🚀
 
 ## Requisitos { #requirements }
 
@@ -255,10 +261,10 @@ Você verá a resposta JSON como:
 
 Você acabou de criar uma API que:
 
-* Recebe requisições HTTP nas _rotas_ `/` e `/items/{item_id}`.
-* Ambas _rotas_ fazem <em>operações</em> `GET` (também conhecido como _métodos_ HTTP).
-* A _rota_ `/items/{item_id}` tem um _parâmetro de rota_ `item_id` que deve ser um `int`.
-* A _rota_ `/items/{item_id}` tem um _parâmetro query_ `q` `str` opcional.
+* Recebe requisições HTTP nos _paths_ `/` e `/items/{item_id}`.
+* Ambos _paths_ fazem <em>operações</em> `GET` (também conhecido como _métodos_ HTTP).
+* O _path_ `/items/{item_id}` tem um _parâmetro de path_ `item_id` que deve ser um `int`.
+* O _path_ `/items/{item_id}` tem um _parâmetro query_ `q` `str` opcional.
 
 ### Documentação Interativa da API { #interactive-api-docs }
 
@@ -278,7 +284,7 @@ Você verá a documentação automática alternativa (fornecida por <a href="htt
 
 ## Evoluindo o Exemplo { #example-upgrade }
 
-Agora modifique o arquivo `main.py` para receber um corpo para uma requisição `PUT`.
+Agora modifique o arquivo `main.py` para receber um corpo de uma requisição `PUT`.
 
 Declare o corpo utilizando tipos padrão Python, graças ao Pydantic.
 
@@ -334,7 +340,7 @@ Agora vá para <a href="http://127.0.0.1:8000/docs" class="external-link" target
 
 E agora, vá para <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-* A documentação alternativa também irá refletir o novo parâmetro da _query_ e o corpo:
+* A documentação alternativa também irá refletir o novo parâmetro query e o corpo:
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
@@ -368,15 +374,15 @@ item: Item
 * Validação de dados:
     * Erros automáticos e claros quando o dado é inválido.
     * Validação até para objetos JSON profundamente aninhados.
-* <abbr title="também conhecido como: serialização, parsing, marshalling">Conversão</abbr> de dados de entrada: vindo da rede para dados e tipos Python. Consegue ler:
+* <abbr title="também conhecido como: serialization, parsing, marshalling">Conversão</abbr> de dados de entrada: vindo da rede para dados e tipos Python. Consegue ler:
     * JSON.
-    * Parâmetros de rota.
-    * Parâmetros de _query_ .
-    * _Cookies_.
+    * Parâmetros de path.
+    * Parâmetros query.
+    * Cookies.
     * Cabeçalhos.
     * Formulários.
     * Arquivos.
-* <abbr title="também conhecido como: serialização, parsing, marshalling">Conversão</abbr> de dados de saída de tipos e dados Python para dados de rede (como JSON):
+* <abbr title="também conhecido como: serialization, parsing, marshalling">Conversão</abbr> de dados de saída: convertendo de tipos e dados Python para dados de rede (como JSON):
     * Converte tipos Python (`str`, `int`, `float`, `bool`, `list` etc).
     * Objetos `datetime`.
     * Objetos `UUID`.
@@ -390,17 +396,17 @@ item: Item
 
 Voltando ao código do exemplo anterior, **FastAPI** irá:
 
-* Validar que existe um `item_id` na rota para requisições `GET` e `PUT`.
+* Validar que existe um `item_id` no path para requisições `GET` e `PUT`.
 * Validar que `item_id` é do tipo `int` para requisições `GET` e `PUT`.
-    * Se não é validado, o cliente verá um útil, claro erro.
-* Verificar se existe um parâmetro de _query_ opcional nomeado como `q` (como em `http://127.0.0.1:8000/items/foo?q=somequery`) para requisições `GET`.
+    * Se não for, o cliente verá um erro útil e claro.
+* Verificar se existe um parâmetro query opcional nomeado como `q` (como em `http://127.0.0.1:8000/items/foo?q=somequery`) para requisições `GET`.
     * Como o parâmetro `q` é declarado com `= None`, ele é opcional.
-    * Sem o `None` ele poderia ser obrigatório (como o corpo no caso de `PUT`).
+    * Sem o `None` ele seria obrigatório (como o corpo no caso de `PUT`).
 * Para requisições `PUT` para `/items/{item_id}`, lerá o corpo como JSON:
     * Verifica que tem um atributo obrigatório `name` que deve ser `str`.
-    * Verifica que tem um atributo obrigatório `price` que deve ser `float`.
-    * Verifica que tem an atributo opcional `is_offer`, que deve ser `bool`, se presente.
-    * Tudo isso também funciona para objetos JSON profundamente aninhados.
+    * Verifica que tem um atributo obrigatório `price` que tem que ser um `float`.
+    * Verifica que tem um atributo opcional `is_offer`, que deve ser um `bool`, se presente.
+    * Tudo isso também funcionaria para objetos JSON profundamente aninhados.
 * Converter de e para JSON automaticamente.
 * Documentar tudo com OpenAPI, que poderá ser usado por:
     * Sistemas de documentação interativos.
@@ -409,7 +415,7 @@ Voltando ao código do exemplo anterior, **FastAPI** irá:
 
 ---
 
-Nós apenas arranhamos a superfície, mas você já tem idéia de como tudo funciona.
+Nós apenas arranhamos a superfície, mas você já tem ideia de como tudo funciona.
 
 Experimente mudar a seguinte linha:
 
@@ -437,22 +443,22 @@ Para um exemplo mais completo incluindo mais recursos, veja <a href="https://fas
 
 **Alerta de Spoiler**: o tutorial - guia do usuário inclui:
 
-* Declaração de **parâmetetros** de diferentes lugares como: **cabeçalhos**, **cookies**, **campos de formulários** e **arquivos**.
-* Como configurar **Limitações de Validação** como `maximum_length` ou `regex`.
-* Um poderoso e fácil de usar sistema de **<abbr title="também conhecido como componentes, recursos, fornecedores, serviços, injetáveis">Injeção de Dependência</abbr>**.
-* Segurança e autenticação, incluindo suporte para **OAuth2** com autenticação **JWT tokens** e **HTTP Basic**.
+* Declaração de **parâmetros** de diferentes lugares como: **cabeçalhos**, **cookies**, **campos de formulários** e **arquivos**.
+* Como configurar **limitações de validação** como `maximum_length` ou `regex`.
+* Um poderoso e fácil de usar sistema de **<abbr title="também conhecido como components, resources, providers, services, injectables">Injeção de Dependência</abbr>**.
+* Segurança e autenticação, incluindo suporte para **OAuth2** com autenticação com **JWT tokens** e **HTTP Basic**.
 * Técnicas mais avançadas (mas igualmente fáceis) para declaração de **modelos JSON profundamente aninhados** (graças ao Pydantic).
 * Integrações **GraphQL** com o <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> e outras bibliotecas.
 * Muitos recursos extras (graças ao Starlette) como:
     * **WebSockets**
-    * testes extrememamente fáceis baseados em HTTPX e `pytest`
+    * testes extremamente fáceis baseados em HTTPX e `pytest`
     * **CORS**
     * **Cookie Sessions**
     * ...e mais.
 
 ### Implemente sua aplicação (opcional) { #deploy-your-app-optional }
 
-Você pode opcionalmente implantar sua aplicação FastAPI na <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, inscreva-se na lista de espera se ainda não o fez. 🚀
+Você pode opcionalmente implantar sua aplicação FastAPI na <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>, vá e entre na lista de espera se ainda não o fez. 🚀
 
 Se você já tem uma conta na **FastAPI Cloud** (nós convidamos você da lista de espera 😉), pode implantar sua aplicação com um único comando.
 
@@ -506,7 +512,7 @@ Siga os tutoriais do seu provedor de nuvem para implantar aplicações FastAPI c
 
 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 performance, veja a seção <a href="https://fastapi.tiangolo.com/pt/benchmarks/" class="internal-link" target="_blank">Comparações</a>.
+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>.
 
 ## Dependências { #dependencies }
 
@@ -514,7 +520,7 @@ O FastAPI depende do Pydantic e do Starlette.
 
 ### Dependências `standard` { #standard-dependencies }
 
-Quando você instala o FastAPI com `pip install "fastapi[standard]"`, ele vêm com o grupo `standard` (padrão) de dependências opcionais:
+Quando você instala o FastAPI com `pip install "fastapi[standard]"`, ele vem com o grupo `standard` de dependências opcionais:
 
 Utilizado pelo Pydantic:
 
@@ -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:
 
@@ -547,7 +553,7 @@ Existem algumas dependências adicionais que você pode querer instalar.
 Dependências opcionais adicionais do Pydantic:
 
 * <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - para gerenciamento de configurações.
-* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - tipos extras para serem utilizados com o Pydantic.
+* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - para tipos extras a serem utilizados com o Pydantic.
 
 Dependências opcionais adicionais do FastAPI:
 

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

@@ -31,7 +31,7 @@ Digamos que você tenha uma estrutura de arquivos como esta:
 
 /// tip | Dica
 
-Existem vários arquivos `__init__.py` presentes em cada diretório ou subdiretório.
+Existem vários arquivos `__init__.py`: um em cada diretório ou subdiretório.
 
 Isso permite a importação de código de um arquivo para outro.
 
@@ -43,32 +43,32 @@ from app.routers import items
 
 ///
 
-* O diretório `app` contém todo o código da aplicação. Ele possui um arquivo `app/__init__.py` vazio, o que o torna um "pacote Python" (uma coleção de "módulos Python"): `app`.
-* Dentro dele, o arquivo `app/main.py` está localizado em um pacote Python (diretório com  `__init__.py`). Portanto, ele é um "módulo" desse pacote: `app.main`.
-* Existem também um arquivo `app/dependencies.py`, assim como o `app/main.py`, ele é um "módulo": `app.dependencies`.
+* O diretório `app` contém tudo. E possui um arquivo vazio `app/__init__.py`, então ele é um "pacote Python" (uma coleção de "módulos Python"): `app`.
+* Ele contém um arquivo `app/main.py`. Como está dentro de um pacote Python (um diretório com um arquivo `__init__.py`), ele é um "módulo" desse pacote: `app.main`.
+* Existe também um arquivo `app/dependencies.py`, assim como `app/main.py`, ele é um "módulo": `app.dependencies`.
 * Há um subdiretório `app/routers/` com outro arquivo `__init__.py`, então ele é um "subpacote Python": `app.routers`.
-* O arquivo `app/routers/items.py` está dentro de um pacote, `app/routers/`, portanto, é um "submódulo": `app.routers.items`.
-* O mesmo com `app/routers/users.py`,  ele é outro submódulo: `app.routers.users`.
-* Há também um subdiretório `app/internal/` com outro arquivo `__init__.py`, então ele é outro "subpacote Python":`app.internal`.
+* O arquivo `app/routers/items.py` está dentro de um pacote, `app/routers/`, portanto é um submódulo: `app.routers.items`.
+* O mesmo com `app/routers/users.py`, ele é outro submódulo: `app.routers.users`.
+* Há também um subdiretório `app/internal/` com outro arquivo `__init__.py`, então ele é outro "subpacote Python": `app.internal`.
 * E o arquivo `app/internal/admin.py` é outro submódulo: `app.internal.admin`.
 
 <img src="/img/tutorial/bigger-applications/package.drawio.svg">
 
 A mesma estrutura de arquivos com comentários:
 
-```
+```bash
 .
-├── app                  # "app" é um pacote Python
-│   ├── __init__.py      # este arquivo torna "app" um "pacote Python"
-│   ├── main.py          # "main" módulo, e.g. import app.main
-│   ├── dependencies.py  # "dependencies" módulo, e.g. import app.dependencies
-│   └── routers          # "routers" é um  "subpacote Python"
-│   │   ├── __init__.py  # torna "routers" um "subpacote Python"
-│   │   ├── items.py     # "items" submódulo, e.g. import app.routers.items
-│   │   └── users.py     # "users" submódulo, e.g. import app.routers.users
-│   └── internal         # "internal" é um  "subpacote Python"
-│       ├── __init__.py  # torna "internal" um  "subpacote Python"
-│       └── admin.py     # "admin" submódulo, e.g. import app.internal.admin
+├── app                  # "app" is a Python package
+│   ├── __init__.py      # this file makes "app" a "Python package"
+│   ├── main.py          # "main" module, e.g. import app.main
+│   ├── dependencies.py  # "dependencies" module, e.g. import app.dependencies
+│   └── routers          # "routers" is a "Python subpackage"
+│   │   ├── __init__.py  # makes "routers" a "Python subpackage"
+│   │   ├── items.py     # "items" submodule, e.g. import app.routers.items
+│   │   └── users.py     # "users" submodule, e.g. import app.routers.users
+│   └── internal         # "internal" is a "Python subpackage"
+│       ├── __init__.py  # makes "internal" a "Python subpackage"
+│       └── admin.py     # "admin" submodule, e.g. import app.internal.admin
 ```
 
 ## `APIRouter` { #apirouter }
@@ -79,11 +79,11 @@ Você quer manter as *operações de rota* relacionadas aos seus usuários separ
 
 Mas ele ainda faz parte da mesma aplicação/web API **FastAPI** (faz parte do mesmo "pacote Python").
 
-Você pode criar as *operações de rotas* para esse módulo usando o `APIRouter`.
+Você pode criar as *operações de rota* para esse módulo usando o `APIRouter`.
 
 ### Importe `APIRouter` { #import-apirouter }
 
-você o importa e cria uma "instância" da mesma maneira que faria com a classe `FastAPI`:
+Você o importa e cria uma "instância" da mesma maneira que faria com a classe `FastAPI`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
 
@@ -91,7 +91,7 @@ você o importa e cria uma "instância" da mesma maneira que faria com a classe
 
 E então você o utiliza para declarar suas *operações de rota*.
 
-Utilize-o da mesma maneira que utilizaria a classe  `FastAPI`:
+Utilize-o da mesma maneira que utilizaria a classe `FastAPI`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
 
@@ -151,7 +151,7 @@ Então, em vez de adicionar tudo isso a cada *operação de rota*, podemos adici
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
 
-Como o caminho de cada *operação de rota* deve começar com `/`, como em:
+Como o path de cada *operação de rota* tem que começar com `/`, como em:
 
 ```Python hl_lines="1"
 @router.get("/{item_id}")
@@ -163,9 +163,9 @@ async def read_item(item_id: str):
 
 Então, o prefixo neste caso é `/items`.
 
-Também podemos adicionar uma lista de `tags` e `responses` extras que serão aplicadas a todas as *operações de rota* incluídas neste roteador.
+Também podemos adicionar uma list de `tags` e `responses` extras que serão aplicadas a todas as *operações de rota* incluídas neste router.
 
-E podemos adicionar uma lista de `dependencies` que serão adicionadas a todas as *operações de rota* no roteador e serão executadas/resolvidas para cada request feita a elas.
+E podemos adicionar uma list de `dependencies` que serão adicionadas a todas as *operações de rota* no router e serão executadas/resolvidas para cada request feita a elas.
 
 /// tip | Dica
 
@@ -173,7 +173,7 @@ Observe que, assim como [dependências em *decoradores de operação de rota*](d
 
 ///
 
-O resultado final é que os caminhos dos itens agora são:
+O resultado final é que os paths dos itens agora são:
 
 * `/items/`
 * `/items/{item_id}`
@@ -183,9 +183,9 @@ O resultado final é que os caminhos dos itens agora são:
 * Elas serão marcadas com uma lista de tags que contêm uma única string `"items"`.
     * Essas "tags" são especialmente úteis para os sistemas de documentação interativa automática (usando OpenAPI).
 * Todas elas incluirão as `responses` predefinidas.
-* Todas essas *operações de rota* terão a lista de `dependencies` avaliada/executada antes delas.
+* Todas essas *operações de rota* terão a list de `dependencies` avaliada/executada antes delas.
     * Se você também declarar dependências em uma *operação de rota* específica, **elas também serão executadas**.
-    * As dependências do roteador são executadas primeiro, depois as [`dependencies` no decorador](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} e, em seguida, as dependências de parâmetros normais.
+    * As dependências do router são executadas primeiro, depois as [`dependencies` no decorador](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} e, em seguida, as dependências de parâmetros normais.
     * Você também pode adicionar [dependências de `Segurança` com `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
 
 /// tip | Dica
@@ -246,7 +246,7 @@ from ..dependencies import get_token_header
 
 significa:
 
-* Começando no mesmo pacote em que este módulo (o arquivo `app/routers/items.py`) reside (o diretório `app/routers/`)...
+* Começando no mesmo pacote em que este módulo (o arquivo `app/routers/items.py`) vive (o diretório `app/routers/`)...
 * vá para o pacote pai (o diretório `app/`)...
 * e lá, encontre o módulo `dependencies` (o arquivo em `app/dependencies.py`)...
 * e dele, importe a função `get_token_header`.
@@ -283,9 +283,9 @@ Mas ainda podemos adicionar _mais_ `tags` que serão aplicadas a uma *operação
 
 /// tip | Dica
 
-Esta última operação de caminho terá a combinação de tags: `["items", "custom"]`.
+Esta última operação de rota terá a combinação de tags: `["items", "custom"]`.
 
-E também terá ambas as respostas na documentação, uma para `404` e uma para `403`.
+E também terá ambas as responses na documentação, uma para `404` e uma para `403`.
 
 ///
 
@@ -325,7 +325,7 @@ from .routers import items, users
 
 significa:
 
-* Começando no mesmo pacote em que este módulo (o arquivo `app/main.py`) reside (o diretório `app/`)...
+* Começando no mesmo pacote em que este módulo (o arquivo `app/main.py`) vive (o diretório `app/`)...
 * procure o subpacote `routers` (o diretório em `app/routers/`)...
 * e dele, importe o submódulo `items` (o arquivo em `app/routers/items.py`) e `users` (o arquivo em `app/routers/users.py`)...
 
@@ -376,7 +376,7 @@ Então, para poder usar ambos no mesmo arquivo, importamos os submódulos direta
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
 
-### Inclua os `APIRouter`s para `usuários` e `itens` { #include-the-apirouters-for-users-and-items }
+### Inclua os `APIRouter`s para `users` e `items` { #include-the-apirouters-for-users-and-items }
 
 Agora, vamos incluir os `router`s dos submódulos `users` e `items`:
 
@@ -392,7 +392,7 @@ E `items.router` contém o `APIRouter` dentro do arquivo `app/routers/items.py`.
 
 Com `app.include_router()` podemos adicionar cada `APIRouter` ao aplicativo principal `FastAPI`.
 
-Ele incluirá todas as rotas daquele roteador como parte dele.
+Ele incluirá todas as rotas daquele router como parte dele.
 
 /// note | Detalhes Técnicos
 
@@ -404,7 +404,7 @@ Então, nos bastidores, ele realmente funcionará como se tudo fosse o mesmo apl
 
 /// check | Verifique
 
-Você não precisa se preocupar com desempenho ao incluir roteadores.
+Você não precisa se preocupar com desempenho ao incluir routers.
 
 Isso levará microssegundos e só acontecerá na inicialização.
 
@@ -453,7 +453,7 @@ e funcionará corretamente, junto com todas as outras *operações de rota* adic
 
 /// note | Detalhes Técnicos Avançados
 
-**Observação**: este é um detalhe muito técnico que você provavelmente pode **simplesmente pular**.
+**Nota**: este é um detalhe muito técnico que você provavelmente pode **simplesmente pular**.
 
 ---
 
@@ -479,15 +479,15 @@ $ fastapi dev app/main.py
 
 </div>
 
-E abra os documentos em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
+E abra a documentação em <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
-Você verá a documentação automática da API, incluindo os caminhos de todos os submódulos, usando os caminhos (e prefixos) corretos e as tags corretas:
+Você verá a documentação automática da API, incluindo os paths de todos os submódulos, usando os paths (e prefixos) corretos e as tags corretas:
 
 <img src="/img/tutorial/bigger-applications/image01.png">
 
-## Inclua o mesmo roteador várias vezes com `prefix` diferentes { #include-the-same-router-multiple-times-with-different-prefix }
+## Inclua o mesmo router várias vezes com `prefix` diferentes { #include-the-same-router-multiple-times-with-different-prefix }
 
-Você também pode usar `.include_router()` várias vezes com o *mesmo* roteador usando prefixos diferentes.
+Você também pode usar `.include_router()` várias vezes com o *mesmo* router usando prefixos diferentes.
 
 Isso pode ser útil, por exemplo, para expor a mesma API sob prefixos diferentes, por exemplo, `/api/v1` e `/api/latest`.
 
@@ -495,10 +495,10 @@ Esse é um uso avançado que você pode não precisar, mas está lá caso precis
 
 ## Inclua um `APIRouter` em outro { #include-an-apirouter-in-another }
 
-Da mesma forma que você pode incluir um `APIRouter` em um aplicativo `FastAPI`, você pode incluir um `APIRouter` em outro `APIRouter` usando:
+Da mesma forma que você pode incluir um `APIRouter` em uma aplicação `FastAPI`, você pode incluir um `APIRouter` em outro `APIRouter` usando:
 
 ```Python
 router.include_router(other_router)
 ```
 
-Certifique-se de fazer isso antes de incluir `router` no aplicativo `FastAPI`, para que as *operações de rota* de `other_router` também sejam incluídas.
+Certifique-se de fazer isso antes de incluir `router` na aplicação `FastAPI`, para que as *operações de rota* de `other_router` também sejam incluídas.

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

@@ -1,6 +1,6 @@
 # Corpo - Atualizações { #body-updates }
 
-## Atualização de dados existentes com `PUT` { #update-replacing-with-put }
+## Atualização substituindo com `PUT` { #update-replacing-with-put }
 
 Para atualizar um item, você pode usar a operação <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
 
@@ -22,13 +22,13 @@ Isso significa que, se você quiser atualizar o item `bar` usando `PUT` com um c
 }
 ```
 
-Como ele não inclui o atributo já armazenado `"tax": 20.2`, o modelo de entrada assumiria o valor padrão de `"tax": 10.5`.
+como ele não inclui o atributo já armazenado `"tax": 20.2`, o modelo de entrada assumiria o valor padrão de `"tax": 10.5`.
 
 E os dados seriam salvos com esse "novo" `tax` de `10.5`.
 
 ## Atualizações parciais com `PATCH` { #partial-updates-with-patch }
 
-Você também pode usar a operação <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> para atualizar parcialmente os dados.
+Você também pode usar a operação <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> para atualizar dados *parcialmente*.
 
 Isso significa que você pode enviar apenas os dados que deseja atualizar, deixando o restante intacto.
 
@@ -40,25 +40,17 @@ E muitas equipes usam apenas `PUT`, mesmo para atualizações parciais.
 
 Você é **livre** para usá-los como preferir, **FastAPI** não impõe restrições.
 
-Mas este guia te dá uma ideia de como eles são destinados a serem usados.
+Mas este guia mostra, mais ou menos, como eles são destinados a serem usados.
 
 ///
 
 ### Usando o parâmetro `exclude_unset` do Pydantic { #using-pydantics-exclude-unset-parameter }
 
-Se você quiser receber atualizações parciais, é muito útil usar o parâmetro `exclude_unset` no método `.model_dump()` do modelo do Pydantic.
+Se você quiser receber atualizações parciais, é muito útil usar o parâmetro `exclude_unset` no `.model_dump()` do modelo do Pydantic.
 
 Como `item.model_dump(exclude_unset=True)`.
 
-/// info | Informação
-
-No Pydantic v1, o método que era chamado `.dict()` e foi descontinuado (mas ainda suportado) no Pydantic v2. Agora, deve-se usar o método `.model_dump()`.
-
-Os exemplos aqui usam `.dict()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` a partir do Pydantic v2.
-
-///
-
-Isso gera um `dict` com apenas os dados definidos ao criar o modelo `item`, excluindo os valores padrão.
+Isso geraria um `dict` com apenas os dados que foram definidos ao criar o modelo `item`, excluindo os valores padrão.
 
 Então, você pode usar isso para gerar um `dict` com apenas os dados definidos (enviados na solicitação), omitindo valores padrão:
 
@@ -68,31 +60,23 @@ Então, você pode usar isso para gerar um `dict` com apenas os dados definidos
 
 Agora, você pode criar uma cópia do modelo existente usando `.model_copy()`, e passar o parâmetro `update` com um `dict` contendo os dados para atualizar.
 
-/// info | Informação
-
-No Pydantic v1, o método era chamado `.copy()`, ele foi descontinuado (mas ainda suportado) no Pydantic v2, e renomeado para `.model_copy()`.
-
-Os exemplos aqui usam `.copy()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_copy()` com o Pydantic v2.
-
-///
-
 Como `stored_item_model.model_copy(update=update_data)`:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
 
 ### Recapitulando as atualizações parciais { #partial-updates-recap }
 
-Resumindo, para aplicar atualizações parciais você pode:
+Resumindo, para aplicar atualizações parciais você deveria:
 
 * (Opcionalmente) usar `PATCH` em vez de `PUT`.
 * Recuperar os dados armazenados.
 * Colocar esses dados em um modelo do Pydantic.
 * Gerar um `dict` sem valores padrão a partir do modelo de entrada (usando `exclude_unset`).
-    * Dessa forma, você pode atualizar apenas os valores definidos pelo usuário, em vez de substituir os valores já armazenados com valores padrão em seu modelo.
+    * Dessa forma, você pode atualizar apenas os valores realmente definidos pelo usuário, em vez de substituir valores já armazenados por valores padrão do modelo.
 * Criar uma cópia do modelo armazenado, atualizando seus atributos com as atualizações parciais recebidas (usando o parâmetro `update`).
-* Converter o modelo copiado em algo que possa ser armazenado no seu banco de dados (por exemplo, usando o `jsonable_encoder`).
-    * Isso é comparável ao uso do método `.model_dump()`, mas garante (e converte) os valores para tipos de dados que possam ser convertidos em JSON, por exemplo, `datetime` para `str`.
-* Salvar os dados no seu banco de dados.
+* Converter o modelo copiado em algo que possa ser armazenado no seu BD (por exemplo, usando o `jsonable_encoder`).
+    * Isso é comparável a usar o método `.model_dump()` do modelo novamente, mas garante (e converte) os valores para tipos de dados que possam ser convertidos em JSON, por exemplo, `datetime` para `str`.
+* Salvar os dados no seu BD.
 * Retornar o modelo atualizado.
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}
@@ -109,8 +93,8 @@ Mas o exemplo aqui usa `PATCH` porque foi criado para esses casos de uso.
 
 Observe que o modelo de entrada ainda é validado.
 
-Portanto, se você quiser receber atualizações parciais que possam omitir todos os atributos, precisará ter um modelo com todos os atributos marcados como opcionais (com valores padrão ou `None`).
+Portanto, se você quiser receber atualizações parciais que possam omitir todos os atributos, você precisa ter um modelo com todos os atributos marcados como opcionais (com valores padrão ou `None`).
 
-Para distinguir os modelos com todos os valores opcionais para **atualizações** e modelos com valores obrigatórios para **criação**, você pode usar as ideias descritas em [Modelos Adicionais](extra-models.md){.internal-link target=_blank}.
+Para distinguir entre os modelos com todos os valores opcionais para **atualizações** e modelos com valores obrigatórios para **criação**, você pode usar as ideias descritas em [Modelos Adicionais](extra-models.md){.internal-link target=_blank}.
 
 ///

docs/pt/docs/tutorial/body.md

@@ -10,11 +10,11 @@ Para declarar um corpo da **requisição**, você utiliza os modelos do <a href=
 
 /// info | Informação
 
-Para enviar dados, você deve usar um dos: `POST` (o mais comum), `PUT`, `DELETE` ou `PATCH`.
+Para enviar dados, você deveria usar um dos: `POST` (o mais comum), `PUT`, `DELETE` ou `PATCH`.
 
 Enviar um corpo em uma requisição `GET` não tem um comportamento definido nas especificações, porém é suportado pelo FastAPI, apenas para casos de uso bem complexos/extremos.
 
-Como é desencorajado, a documentação interativa com Swagger UI não irá mostrar a documentação para o corpo da requisição para um `GET`, e proxies que intermediarem podem não suportar o corpo da requisição.
+Como é desencorajado, a documentação interativa com Swagger UI não irá mostrar a documentação para o corpo da requisição ao usar `GET`, e proxies intermediários podem não suportá-lo.
 
 ///
 
@@ -32,7 +32,8 @@ Utilize os tipos Python padrão para todos os atributos:
 
 {* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
 
-Assim como quando declaramos parâmetros de consulta, quando um atributo do modelo possui um valor padrão, ele se torna opcional. Caso contrário, se torna obrigatório. Use `None` para torná-lo opcional.
+
+Assim como quando declaramos parâmetros de consulta, quando um atributo do modelo possui um valor padrão, ele não é obrigatório. Caso contrário, é obrigatório. Use `None` para torná-lo apenas opcional.
 
 Por exemplo, o modelo acima declara um JSON "`object`" (ou `dict` no Python) como esse:
 
@@ -66,7 +67,7 @@ Para adicioná-lo à sua *operação de rota*, declare-o da mesma maneira que vo
 
 Apenas com essa declaração de tipos do Python, o **FastAPI** irá:
 
-* Ler o corpo da requisição como um JSON.
+* Ler o corpo da requisição como JSON.
 * Converter os tipos correspondentes (se necessário).
 * Validar os dados.
     * Se algum dado for inválido, irá retornar um erro bem claro, indicando exatamente onde e o que estava incorreto.
@@ -127,14 +128,6 @@ Dentro da função, você pode acessar todos os atributos do objeto do modelo di
 
 {* ../../docs_src/body/tutorial002_py310.py *}
 
-/// info | Informação
-
-No Pydantic v1 o método se chamava `.dict()`, ele foi descontinuado (mas ainda é suportado) no Pydantic v2, e renomeado para `.model_dump()`.
-
-Os exemplos aqui usam `.dict()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` se puder usar o Pydantic v2.
-
-///
-
 ## Corpo da requisição + parâmetros de rota { #request-body-path-parameters }
 
 Você pode declarar parâmetros de rota e corpo da requisição ao mesmo tempo.
@@ -143,6 +136,7 @@ O **FastAPI** irá reconhecer que os parâmetros da função que combinam com pa
 
 {* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
 
+
 ## Corpo da requisição + parâmetros de rota + parâmetros de consulta { #request-body-path-query-parameters }
 
 Você também pode declarar parâmetros de **corpo**, **rota** e **consulta**, ao mesmo tempo.

docs/pt/docs/tutorial/extra-models.md

@@ -22,21 +22,13 @@ Aqui está uma ideia geral de como os modelos poderiam parecer com seus campos d
 
 {* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
 
-/// info | Informação
+### Sobre `**user_in.model_dump()` { #about-user-in-model-dump }
 
-No Pydantic v1 o método se chamava `.dict()`, ele foi descontinuado (mas ainda é suportado) no Pydantic v2 e renomeado para `.model_dump()`.
-
-Os exemplos aqui usam `.dict()` por compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` se puder usar o Pydantic v2.
-
-///
-
-### Sobre `**user_in.dict()` { #about-user-in-dict }
-
-#### O `.dict()` do Pydantic { #pydantics-dict }
+#### O `.model_dump()` do Pydantic { #pydantics-model-dump }
 
 `user_in` é um modelo Pydantic da classe `UserIn`.
 
-Os modelos Pydantic possuem um método `.dict()` que retorna um `dict` com os dados do modelo.
+Os modelos Pydantic possuem um método `.model_dump()` que retorna um `dict` com os dados do modelo.
 
 Então, se criarmos um objeto Pydantic `user_in` como:
 
@@ -47,7 +39,7 @@ user_in = UserIn(username="john", password="secret", email="john.doe@example.com
 e depois chamarmos:
 
 ```Python
-user_dict = user_in.dict()
+user_dict = user_in.model_dump()
 ```
 
 agora temos um `dict` com os dados na variável `user_dict` (é um `dict` em vez de um objeto de modelo Pydantic).
@@ -103,20 +95,20 @@ UserInDB(
 
 #### Um modelo Pydantic a partir do conteúdo de outro { #a-pydantic-model-from-the-contents-of-another }
 
-Como no exemplo acima, obtivemos o `user_dict` a partir do `user_in.dict()`, este código:
+Como no exemplo acima, obtivemos o `user_dict` a partir do `user_in.model_dump()`, este código:
 
 ```Python
-user_dict = user_in.dict()
+user_dict = user_in.model_dump()
 UserInDB(**user_dict)
 ```
 
 seria equivalente a:
 
 ```Python
-UserInDB(**user_in.dict())
+UserInDB(**user_in.model_dump())
 ```
 
-...porque `user_in.dict()` é um `dict`, e depois fazemos o Python "desembrulhá-lo" passando-o para `UserInDB` precedido por `**`.
+...porque `user_in.model_dump()` é um `dict`, e depois fazemos o Python "desembrulhá-lo" passando-o para `UserInDB` precedido por `**`.
 
 Então, obtemos um modelo Pydantic a partir dos dados em outro modelo Pydantic.
 
@@ -125,7 +117,7 @@ Então, obtemos um modelo Pydantic a partir dos dados em outro modelo Pydantic.
 E, então, adicionando o argumento de palavra-chave extra `hashed_password=hashed_password`, como em:
 
 ```Python
-UserInDB(**user_in.dict(), hashed_password=hashed_password)
+UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
 ```
 
 ...acaba sendo como:

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

@@ -33,7 +33,7 @@ Para isso, primeiro importe:
 
 O FastAPI adicionou suporte a `Annotated` (e passou a recomendá-lo) na versão 0.95.0.
 
-Se você tiver uma versão mais antiga, terá erros ao tentar usar `Annotated`.
+Se você tiver uma versão mais antiga, teria erros ao tentar usar `Annotated`.
 
 Certifique-se de [Atualizar a versão do FastAPI](../deployment/versions.md#upgrading-the-fastapi-versions){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
 
@@ -109,7 +109,7 @@ Agora o FastAPI vai:
 
 ## Alternativa (antiga): `Query` como valor padrão { #alternative-old-query-as-the-default-value }
 
-Versões anteriores do FastAPI (antes de <abbr title="antes de 2023-03">0.95.0</abbr>) exigiam que você usasse `Query` como valor padrão do seu parâmetro, em vez de colocá-lo em `Annotated`. É muito provável que você veja código assim por aí, então vou te explicar.
+Versões anteriores do FastAPI (antes de <abbr title="before 2023-03 - antes de 2023-03">0.95.0</abbr>) exigiam que você usasse `Query` como valor padrão do seu parâmetro, em vez de colocá-lo em `Annotated`, há uma grande chance de você ver código usando isso por aí, então vou explicar.
 
 /// tip | Dica
 
@@ -192,7 +192,7 @@ Você também pode adicionar um parâmetro `min_length`:
 
 ## Adicione expressões regulares { #add-regular-expressions }
 
-Você pode definir um `pattern` de <abbr title="Uma expressão regular, regex ou regexp é uma sequência de caracteres que define um padrão de busca para strings.">expressão regular</abbr> que o parâmetro deve corresponder:
+Você pode definir um `pattern` de <abbr title="A regular expression, regex or regexp is a sequence of characters that define a search pattern for strings. - Uma expressão regular, regex ou regexp é uma sequência de caracteres que define um padrão de busca para strings.">expressão regular</abbr> que o parâmetro deve corresponder:
 
 {* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
 
@@ -206,20 +206,6 @@ Se você se sentir perdido com essas ideias de **"expressão regular"**, não se
 
 Agora você sabe que, sempre que precisar delas, pode usá-las no **FastAPI**.
 
-### Pydantic v1 `regex` em vez de `pattern` { #pydantic-v1-regex-instead-of-pattern }
-
-Antes da versão 2 do Pydantic e antes do FastAPI 0.100.0, o parâmetro se chamava `regex` em vez de `pattern`, mas agora está descontinuado.
-
-Você ainda pode ver algum código usando isso:
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/query_params_str_validations/tutorial004_regex_an_py310.py hl[11] *}
-
-////
-
-Mas saiba que isso está descontinuado e deve ser atualizado para usar o novo parâmetro `pattern`. 🤓
-
 ## Valores padrão { #default-values }
 
 Você pode, claro, usar valores padrão diferentes de `None`.
@@ -280,7 +266,7 @@ Então, com uma URL como:
 http://localhost:8000/items/?q=foo&q=bar
 ```
 
-você receberá os múltiplos valores do *parâmetro de consulta* `q` (`foo` e `bar`) em uma `list` Python dentro da sua *função de operação de rota*, no *parâmetro da função* `q`.
+você receberia os múltiplos valores dos *parâmetros de consulta* `q` (`foo` e `bar`) em uma `list` Python dentro da sua *função de operação de rota*, no *parâmetro da função* `q`.
 
 Assim, a resposta para essa URL seria:
 
@@ -350,7 +336,7 @@ Essas informações serão incluídas no OpenAPI gerado e usadas pelas interface
 
 Tenha em mente que ferramentas diferentes podem ter níveis diferentes de suporte ao OpenAPI.
 
-Algumas delas podem ainda não mostrar todas as informações extras declaradas, embora na maioria dos casos o recurso ausente já esteja planejado para desenvolvimento.
+Algumas delas podem ainda não mostrar todas as informações extras declaradas, embora na maioria dos casos a funcionalidade ausente já esteja planejada para desenvolvimento.
 
 ///
 
@@ -386,7 +372,7 @@ Então você pode declarar um `alias`, e esse alias será usado para encontrar o
 
 Agora digamos que você não gosta mais desse parâmetro.
 
-Você tem que deixá-lo por um tempo, pois há clientes usando-o, mas quer que a documentação mostre claramente que ele está <abbr title="obsoleto, recomenda-se não usá-lo">descontinuado</abbr>.
+Você tem que deixá-lo por um tempo, pois há clientes usando-o, mas quer que a documentação mostre claramente que ele está <abbr title="obsolete, recommended not to use it - obsoleto, recomenda-se não usá-lo">deprecated</abbr>.
 
 Então passe o parâmetro `deprecated=True` para `Query`:
 
@@ -416,7 +402,7 @@ O Pydantic também tem <a href="https://docs.pydantic.dev/latest/concepts/valida
 
 ///
 
-Por exemplo, este validador personalizado verifica se o ID do item começa com `isbn-` para um número de livro <abbr title="ISBN significa Número Padrão Internacional de Livro">ISBN</abbr> ou com `imdb-` para um ID de URL de filme <abbr title="IMDB (Internet Movie Database) é um site com informações sobre filmes">IMDB</abbr>:
+Por exemplo, este validador personalizado verifica se o ID do item começa com `isbn-` para um número de livro <abbr title="ISBN means International Standard Book Number - ISBN significa Número Padrão Internacional de Livro">ISBN</abbr> ou com `imdb-` para um ID de URL de filme <abbr title="IMDB (Internet Movie Database) is a website with information about movies - IMDB (Internet Movie Database) é um site com informações sobre filmes">IMDB</abbr>:
 
 {* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
 
@@ -428,7 +414,7 @@ Isso está disponível com a versão 2 do Pydantic ou superior. 😎
 
 /// tip | Dica
 
-Se você precisar fazer qualquer tipo de validação que exija comunicação com algum **componente externo**, como um banco de dados ou outra API, você deve usar **Dependências do FastAPI** em vez disso; você aprenderá sobre elas mais adiante.
+Se você precisar fazer qualquer tipo de validação que exija comunicação com algum **componente externo**, como um banco de dados ou outra API, você deveria usar **Dependências do FastAPI** em vez disso; você aprenderá sobre elas mais adiante.
 
 Esses validadores personalizados são para coisas que podem ser verificadas **apenas** com os **mesmos dados** fornecidos na requisição.
 
@@ -440,7 +426,7 @@ O ponto importante é apenas usar **`AfterValidator` com uma função dentro de
 
 ---
 
-Mas se você está curioso sobre este exemplo específico e ainda entretido, aqui vão alguns detalhes extras.
+Mas se você estiver curioso sobre este exemplo de código específico e ainda entretido, aqui vão alguns detalhes extras.
 
 #### String com `value.startswith()` { #string-with-value-startswith }
 
@@ -450,7 +436,7 @@ Percebeu? Uma string usando `value.startswith()` pode receber uma tupla, e verif
 
 #### Um item aleatório { #a-random-item }
 
-Com `data.items()` obtemos um <abbr title="Algo que podemos iterar com um laço for, como uma list, set, etc.">objeto iterável</abbr> com tuplas contendo a chave e o valor de cada item do dicionário.
+Com `data.items()` obtemos um <abbr title="Something we can iterate on with a for loop, like a list, set, etc. - Algo que podemos iterar com um laço for, como uma list, set, etc.">objeto iterável</abbr> com tuplas contendo a chave e o valor de cada item do dicionário.
 
 Convertimos esse objeto iterável em uma `list` adequada com `list(data.items())`.
 

docs/pt/docs/tutorial/response-model.md

@@ -252,20 +252,6 @@ Então, se você enviar uma solicitação para essa *operação de rota* para o
 
 /// info | Informação
 
-No Pydantic v1, o método era chamado `.dict()`, ele foi descontinuado (mas ainda suportado) no Pydantic v2 e renomeado para `.model_dump()`.
-
-Os exemplos aqui usam `.dict()` para compatibilidade com Pydantic v1, mas você deve usar `.model_dump()` em vez disso se puder usar Pydantic v2.
-
-///
-
-/// info | Informação
-
-O FastAPI usa `.dict()` do modelo Pydantic com <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">seu parâmetro `exclude_unset`</a> para chegar a isso.
-
-///
-
-/// info | Informação
-
 Você também pode usar:
 
 * `response_model_exclude_defaults=True`

docs/pt/docs/tutorial/schema-extra-example.md

@@ -8,39 +8,17 @@ Aqui estão várias maneiras de fazer isso.
 
 Você pode declarar `examples` para um modelo Pydantic que serão adicionados ao JSON Schema gerado.
 
-//// tab | Pydantic v2
-
 {* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/schema_extra_example/tutorial001_pv1_py310.py hl[13:23] *}
-
-////
-
 Essas informações extras serão adicionadas como estão ao **JSON Schema** de saída para esse modelo e serão usadas na documentação da API.
 
-//// tab | Pydantic v2
-
-Na versão 2 do Pydantic, você usaria o atributo `model_config`, que recebe um `dict`, conforme descrito na <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">documentação do Pydantic: Configuration</a>.
+Você pode usar o atributo `model_config`, que recebe um `dict`, conforme descrito na <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">documentação do Pydantic: Configuration</a>.
 
 Você pode definir `"json_schema_extra"` com um `dict` contendo quaisquer dados adicionais que você queira que apareçam no JSON Schema gerado, incluindo `examples`.
 
-////
-
-//// tab | Pydantic v1
-
-Na versão 1 do Pydantic, você usaria uma classe interna `Config` e `schema_extra`, conforme descrito na <a href="https://docs.pydantic.dev/1.10/usage/schema/#schema-customization" class="external-link" target="_blank">documentação do Pydantic: Schema customization</a>.
-
-Você pode definir `schema_extra` com um `dict` contendo quaisquer dados adicionais que você queira que apareçam no JSON Schema gerado, incluindo `examples`.
-
-////
-
 /// tip | Dica
 
-Você pode usar a mesma técnica para estender o JSON Schema e adicionar suas próprias informações extras personalizadas.
+Você poderia usar a mesma técnica para estender o JSON Schema e adicionar suas próprias informações extras personalizadas.
 
 Por exemplo, você poderia usá-la para adicionar metadados para uma interface de usuário de front-end, etc.
 
@@ -50,7 +28,7 @@ Por exemplo, você poderia usá-la para adicionar metadados para uma interface d
 
 O OpenAPI 3.1.0 (usado desde o FastAPI 0.99.0) adicionou suporte a `examples`, que faz parte do padrão **JSON Schema**.
 
-Antes disso, ele suportava apenas a palavra‑chave `example` com um único exemplo. Isso ainda é suportado pelo OpenAPI 3.1.0, mas é descontinuado e não faz parte do padrão JSON Schema. Portanto, é recomendado migrar de `example` para `examples`. 🤓
+Antes disso, ele suportava apenas a palavra‑chave `example` com um único exemplo. Isso ainda é suportado pelo OpenAPI 3.1.0, mas é descontinuado e não faz parte do padrão JSON Schema. Portanto, você é incentivado a migrar de `example` para `examples`. 🤓
 
 Você pode ler mais no final desta página.
 
@@ -102,7 +80,7 @@ No entanto, <abbr title="2023-08-26">no momento em que isto foi escrito</abbr>,
 
 Antes do **JSON Schema** suportar `examples`, o OpenAPI já tinha suporte para um campo diferente também chamado `examples`.
 
-Esse `examples` específico do OpenAPI vai em outra seção da especificação. Ele fica nos **detalhes de cada função de operação de rota**, não dentro de cada JSON Schema.
+Esse `examples` **específico do OpenAPI** vai em outra seção da especificação OpenAPI. Ele fica nos **detalhes de cada *operação de rota***, não dentro de cada JSON Schema.
 
 E o Swagger UI tem suportado esse campo `examples` particular há algum tempo. Então, você pode usá-lo para **mostrar** diferentes **exemplos na UI da documentação**.
 
@@ -189,9 +167,9 @@ Depois, o JSON Schema adicionou um campo <a href="https://json-schema.org/draft/
 
 E então o novo OpenAPI 3.1.0 passou a se basear na versão mais recente (JSON Schema 2020-12), que incluiu esse novo campo `examples`.
 
-Agora, esse novo campo `examples` tem precedência sobre o antigo (e customizado) campo único `example`, que agora está descontinuado.
+E agora esse novo campo `examples` tem precedência sobre o antigo campo único (e customizado) `example`, que agora está descontinuado.
 
-Esse novo campo `examples` no JSON Schema é **apenas uma `list`** de exemplos, não um `dict` com metadados extras como nos outros lugares do OpenAPI (descritos acima).
+Esse novo campo `examples` no JSON Schema é **apenas uma `list`** de exemplos, não um dict com metadados extras como nos outros lugares do OpenAPI (descritos acima).
 
 /// info | Informação
 
@@ -213,7 +191,7 @@ Mas agora que o FastAPI 0.99.0 e superiores usam o OpenAPI 3.1.0, que usa o JSON
 
 ### Swagger UI e `examples` específicos do OpenAPI { #swagger-ui-and-openapi-specific-examples }
 
-Como o Swagger UI não suportava vários exemplos no JSON Schema (em 2023-08-26), os usuários não tinham uma forma de mostrar vários exemplos na documentação.
+Agora, como o Swagger UI não suportava vários exemplos no JSON Schema (em 2023-08-26), os usuários não tinham uma forma de mostrar vários exemplos na documentação.
 
 Para resolver isso, o FastAPI `0.103.0` **adicionou suporte** para declarar o mesmo antigo campo **específico do OpenAPI** `examples` com o novo parâmetro `openapi_examples`. 🤓
 

docs/pt/llm-prompt.md

@@ -10,6 +10,26 @@ Keep existing translations as they are if the term is already translated.
 
 When translating documentation into Portuguese, use neutral and widely understandable language. Although Portuguese originated in Portugal and has its largest number of speakers in Brazil, it is also an official language in several countries and regions, such as Equatorial Guinea, Mozambique, Angola, Cape Verde, and São Tomé and Príncipe. Avoid words or expressions that are specific to a single country or region.
 
+Only keep parentheses if they exist in the source text. Do not add parentheses to terms that do not have them.
+
+### Avoiding Repetition in Translation
+
+When translating sentences, avoid unnecessary repetition of words or phrases that are implied in context.
+- Merge repeated words naturally while keeping the meaning.
+- Do **not** introduce extra words to replace repeated phrases unnecessarily.
+- Keep translations fluent and concise, but maintain the original meaning.
+
+**Example:**
+
+Source:
+Let's see how that works and how to change it if you need to do that.
+
+Avoid translating literally as:
+Vamos ver como isso funciona e como alterar isso se você precisar fazer isso.
+
+Better translation:
+Vamos ver como isso funciona e como alterar se você precisar.
+
 ---
 
 For the next terms, use the following translations:
@@ -22,10 +42,11 @@ For the next terms, use the following translations:
 * /// note: /// note | Nota
 * /// tip: /// tip | Dica
 * /// warning: /// warning | Atenção
-* (you should): (você deveria)
+* you should: você deveria
 * async context manager: gerenciador de contexto assíncrono
 * autocomplete: autocompletar
 * autocompletion: preenchimento automático
+* auto-completion: preenchimento automático
 * bug: bug
 * context manager: gerenciador de contexto
 * cross domain: cross domain (do not translate to "domínio cruzado")

docs/ru/docs/_llm-test.md

@@ -1,8 +1,8 @@
 # Тестовый файл LLM { #llm-test-file }
 
-Этот документ проверяет, понимает ли <abbr title="Large Language Model – Большая языковая модель">LLM</abbr>, переводящая документацию, `general_prompt` в `scripts/translate.py` и языковой специфичный промпт в `docs/{language code}/llm-prompt.md`. Языковой специфичный промпт добавляется к `general_prompt`.
+Этот документ проверяет, понимает ли <abbr title="Large Language Model - Большая языковая модель">LLM</abbr>, переводящая документацию, `general_prompt` в `scripts/translate.py` и языковой специфичный промпт в `docs/{language code}/llm-prompt.md`. Языковой специфичный промпт добавляется к `general_prompt`.
 
-Тесты, добавленные здесь, увидят все создатели языковых промптов.
+Тесты, добавленные здесь, увидят все создатели языковых специфичных промптов.
 
 Использование:
 
@@ -11,7 +11,7 @@
 * Проверьте, всё ли в порядке в переводе.
 * При необходимости улучшите ваш языковой специфичный промпт, общий промпт или английский документ.
 * Затем вручную исправьте оставшиеся проблемы в переводе, чтобы он был хорошим.
-* Переведите заново, имея хороший перевод на месте. Идеальным результатом будет ситуация, когда LLM больше не вносит изменений в перевод. Это означает, что общий промпт и ваш языковой специфичный промпт максимально хороши (иногда он будет делать несколько, казалось бы, случайных изменений, причина в том, что <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">LLM — недетерминированные алгоритмы</a>).
+* Переведите заново, имея хороший перевод на месте. Идеальным результатом будет ситуация, когда LLM больше не вносит изменений в перевод. Это означает, что общий промпт и ваш языковой специфичный промпт настолько хороши, насколько это возможно (иногда он будет делать несколько, казалось бы, случайных изменений, причина в том, что <a href="https://doublespeak.chat/#/handbook#deterministic-output" class="external-link" target="_blank">LLM — недетерминированные алгоритмы</a>).
 
 Тесты:
 
@@ -197,10 +197,10 @@ works(foo="bar")  # Это работает 🎉
 
 ### abbr даёт полную расшифровку { #the-abbr-gives-a-full-phrase }
 
-* <abbr title="Getting Things Done – Как привести дела в порядок">GTD</abbr>
-* <abbr title="less than – меньше чем"><code>lt</code></abbr>
-* <abbr title="XML Web Token – XML веб‑токен">XWT</abbr>
-* <abbr title="Parallel Server Gateway Interface – Параллельный серверный интерфейс шлюза">PSGI</abbr>
+* <abbr title="Getting Things Done - Как привести дела в порядок">GTD</abbr>
+* <abbr title="less than - меньше чем"><code>lt</code></abbr>
+* <abbr title="XML Web Token - XML веб‑токен">XWT</abbr>
+* <abbr title="Parallel Server Gateway Interface - Параллельный серверный интерфейс шлюза">PSGI</abbr>
 
 ### abbr даёт объяснение { #the-abbr-gives-an-explanation }
 
@@ -209,8 +209,8 @@ works(foo="bar")  # Это работает 🎉
 
 ### abbr даёт полную расшифровку и объяснение { #the-abbr-gives-a-full-phrase-and-an-explanation }
 
-* <abbr title="Mozilla Developer Network – Сеть разработчиков Mozilla: документация для разработчиков, созданная командой Firefox">MDN</abbr>
-* <abbr title="Input/Output – Ввод/Вывод: чтение или запись на диск, сетевое взаимодействие.">I/O</abbr>.
+* <abbr title="Mozilla Developer Network - Сеть разработчиков Mozilla: документация для разработчиков, созданная командой Firefox">MDN</abbr>
+* <abbr title="Input/Output - Ввод/Вывод: чтение или запись на диск, сетевое взаимодействие.">I/O</abbr>.
 
 ////
 

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

@@ -14,7 +14,7 @@
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial001_py39.py hl[6] *}
 
-### Использование имени функции-обработчика пути как operationId { #using-the-path-operation-function-name-as-the-operationid }
+### Использование имени *функции-обработчика пути* как operationId { #using-the-path-operation-function-name-as-the-operationid }
 
 Если вы хотите использовать имена функций ваших API в качестве `operationId`, вы можете пройти по всем из них и переопределить `operation_id` каждой *операции пути* с помощью их `APIRoute.name`.
 
@@ -38,7 +38,7 @@
 
 ## Исключить из OpenAPI { #exclude-from-openapi }
 
-Чтобы исключить *операцию пути* из генерируемой схемы OpenAPI (а значит, и из автоматической документации), используйте параметр `include_in_schema` и установите его в `False`:
+Чтобы исключить *операцию пути* из генерируемой схемы OpenAPI (а значит, и из автоматических систем документации), используйте параметр `include_in_schema` и установите его в `False`:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial003_py39.py hl[6] *}
 
@@ -48,7 +48,7 @@
 
 Добавление `\f` (экранированного символа «form feed») заставит **FastAPI** обрезать текст, используемый для OpenAPI, в этой точке.
 
-Эта часть не попадёт в документацию, но другие инструменты (например, Sphinx) смогут использовать остальное.
+Это не отобразится в документации, но другие инструменты (например, Sphinx) смогут использовать остальное.
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial004_py310.py hl[17:27] *}
 
@@ -56,7 +56,7 @@
 
 Вы, вероятно, уже видели, как объявлять `response_model` и `status_code` для *операции пути*.
 
-Это определяет метаданные об основном ответе *операции пути*.
+Это определяет метаданные об основном HTTP-ответе *операции пути*.
 
 Также можно объявлять дополнительные ответы с их моделями, статус-кодами и т.д.
 
@@ -76,7 +76,7 @@
 
 Там есть `tags`, `parameters`, `requestBody`, `responses` и т.д.
 
-Эта спецификация OpenAPI, специфичная для *операции пути*, обычно генерируется автоматически **FastAPI**, но вы также можете её расширить.
+Эта специфичная для *операции пути* схема OpenAPI обычно генерируется автоматически **FastAPI**, но вы также можете её расширить.
 
 /// tip | Совет
 
@@ -129,13 +129,13 @@
 }
 ```
 
-### Пользовательская схема OpenAPI для операции пути { #custom-openapi-path-operation-schema }
+### Пользовательская схема OpenAPI для *операции пути* { #custom-openapi-path-operation-schema }
 
-Словарь в `openapi_extra` будет объединён с автоматически сгенерированной схемой OpenAPI для *операции пути*.
+Словарь в `openapi_extra` будет глубоко объединён с автоматически сгенерированной схемой OpenAPI для *операции пути*.
 
 Таким образом, вы можете добавить дополнительные данные к автоматически сгенерированной схеме.
 
-Например, вы можете решить читать и валидировать запрос своим кодом, не используя автоматические возможности FastAPI и Pydantic, но при этом захотите описать запрос в схеме OpenAPI.
+Например, вы можете решить читать и валидировать HTTP-запрос своим кодом, не используя автоматические возможности FastAPI и Pydantic, но при этом захотите описать HTTP-запрос в схеме OpenAPI.
 
 Это можно сделать с помощью `openapi_extra`:
 
@@ -149,52 +149,20 @@
 
 Используя тот же приём, вы можете воспользоваться Pydantic-моделью, чтобы определить JSON Schema, которая затем будет включена в пользовательский раздел схемы OpenAPI для *операции пути*.
 
-И вы можете сделать это, даже если тип данных в запросе — не JSON.
+И вы можете сделать это, даже если тип данных в HTTP-запросе — не JSON.
 
-Например, в этом приложении мы не используем встроенную функциональность FastAPI для извлечения JSON Schema из моделей Pydantic, равно как и автоматическую валидацию JSON. Мы объявляем тип содержимого запроса как YAML, а не JSON:
-
-//// tab | Pydantic v2
+Например, в этом приложении мы не используем встроенную функциональность FastAPI для извлечения JSON Schema из моделей Pydantic, равно как и автоматическую валидацию JSON. Мы объявляем тип содержимого HTTP-запроса как YAML, а не JSON:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
-
-////
-
-/// info | Информация
-
-В Pydantic версии 1 метод для получения JSON Schema модели назывался `Item.schema()`, в Pydantic версии 2 метод называется `Item.model_json_schema()`.
-
-///
-
 Тем не менее, хотя мы не используем встроенную функциональность по умолчанию, мы всё равно используем Pydantic-модель, чтобы вручную сгенерировать JSON Schema для данных, которые мы хотим получить в YAML.
 
-Затем мы работаем с запросом напрямую и извлекаем тело как `bytes`. Это означает, что FastAPI даже не попытается распарсить полезную нагрузку запроса как JSON.
+Затем мы работаем с HTTP-запросом напрямую и извлекаем тело как `bytes`. Это означает, что FastAPI даже не попытается распарсить полезную нагрузку HTTP-запроса как JSON.
 
-А затем в нашем коде мы напрямую парсим этот YAML и снова используем ту же Pydantic-модель для валидации YAML-содержимого:
-
-//// tab | Pydantic v2
+А затем в нашем коде мы напрямую парсим это содержимое YAML и снова используем ту же Pydantic-модель, чтобы валидировать YAML-содержимое:
 
 {* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
-
-////
-
-/// info | Информация
-
-В Pydantic версии 1 метод для парсинга и валидации объекта назывался `Item.parse_obj()`, в Pydantic версии 2 метод называется `Item.model_validate()`.
-
-///
-
 /// tip | Совет
 
 Здесь мы переиспользуем ту же Pydantic-модель.

docs/ru/docs/advanced/settings.md

@@ -46,12 +46,6 @@ $ pip install "fastapi[all]"
 
 </div>
 
-/// info | Информация
-
-В Pydantic v1 он входил в основной пакет. Теперь он распространяется как отдельный пакет, чтобы вы могли установить его только при необходимости.
-
-///
-
 ### Создание объекта `Settings` { #create-the-settings-object }
 
 Импортируйте `BaseSettings` из Pydantic и создайте подкласс, очень похожий на Pydantic‑модель.
@@ -60,24 +54,8 @@ $ pip install "fastapi[all]"
 
 Вы можете использовать все те же возможности валидации и инструменты, что и для Pydantic‑моделей, например разные типы данных и дополнительную валидацию через `Field()`.
 
-//// tab | Pydantic v2
-
 {* ../../docs_src/settings/tutorial001_py39.py hl[2,5:8,11] *}
 
-////
-
-//// tab | Pydantic v1
-
-/// info | Информация
-
-В Pydantic v1 вы бы импортировали `BaseSettings` напрямую из `pydantic`, а не из `pydantic_settings`.
-
-///
-
-{* ../../docs_src/settings/tutorial001_pv1_py39.py hl[2,5:8,11] *}
-
-////
-
 /// tip | Совет
 
 Если вам нужно что-то быстро скопировать и вставить, не используйте этот пример — воспользуйтесь последним ниже.
@@ -215,8 +193,6 @@ APP_NAME="ChimichangApp"
 
 Затем обновите ваш `config.py` так:
 
-//// tab | Pydantic v2
-
 {* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
 
 /// tip | Совет
@@ -225,26 +201,6 @@ APP_NAME="ChimichangApp"
 
 ///
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
-
-/// tip | Совет
-
-Класс `Config` используется только для конфигурации Pydantic. Подробнее см. <a href="https://docs.pydantic.dev/1.10/usage/model_config/" class="external-link" target="_blank">Pydantic Model Config</a>.
-
-///
-
-////
-
-/// info | Информация
-
-В Pydantic версии 1 конфигурация задавалась во внутреннем классе `Config`, в Pydantic версии 2 — в атрибуте `model_config`. Этот атрибут принимает `dict`, и чтобы получить автозавершение и ошибки «на лету», вы можете импортировать и использовать `SettingsConfigDict` для описания этого `dict`.
-
-///
-
 Здесь мы задаем параметр конфигурации `env_file` внутри вашего класса Pydantic `Settings` и устанавливаем значение равным имени файла dotenv, который хотим использовать.
 
 ### Создание `Settings` только один раз с помощью `lru_cache` { #creating-the-settings-only-once-with-lru-cache }

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

@@ -2,21 +2,23 @@
 
 Если у вас старое приложение FastAPI, возможно, вы используете Pydantic версии 1.
 
-FastAPI поддерживает и Pydantic v1, и v2 начиная с версии 0.100.0.
+FastAPI версии 0.100.0 поддерживал либо Pydantic v1, либо v2. Он использовал ту версию, которая была установлена.
 
-Если у вас был установлен Pydantic v2, использовался он. Если вместо этого был установлен Pydantic v1 — использовался он.
+FastAPI версии 0.119.0 добавил частичную поддержку Pydantic v1 изнутри Pydantic v2 (как `pydantic.v1`), чтобы упростить миграцию на v2.
 
-Сейчас Pydantic v1 объявлен устаревшим, и поддержка его будет удалена в следующих версиях FastAPI, поэтому вам следует **перейти на Pydantic v2**. Так вы получите последние возможности, улучшения и исправления.
+FastAPI 0.126.0 убрал поддержку Pydantic v1, при этом ещё некоторое время продолжал поддерживать `pydantic.v1`.
 
 /// warning | Предупреждение
 
-Кроме того, команда Pydantic прекратила поддержку Pydantic v1 для последних версий Python, начиная с **Python 3.14**.
+Команда Pydantic прекратила поддержку Pydantic v1 для последних версий Python, начиная с **Python 3.14**.
+
+Это включает `pydantic.v1`, который больше не поддерживается в Python 3.14 и выше.
 
 Если вы хотите использовать последние возможности Python, вам нужно убедиться, что вы используете Pydantic v2.
 
 ///
 
-Если у вас старое приложение FastAPI с Pydantic v1, здесь я покажу, как мигрировать на Pydantic v2, и **новые возможности в FastAPI 0.119.0**, которые помогут выполнить постепенную миграцию.
+Если у вас старое приложение FastAPI с Pydantic v1, здесь я покажу, как мигрировать на Pydantic v2, и **возможности FastAPI 0.119.0**, которые помогут выполнить постепенную миграцию.
 
 ## Официальное руководство { #official-guide }
 
@@ -38,13 +40,13 @@ FastAPI поддерживает и Pydantic v1, и v2 начиная с вер
 
 Вы можете использовать <a href="https://github.com/pydantic/bump-pydantic" class="external-link" target="_blank">`bump-pydantic`</a> от той же команды Pydantic.
 
-Этот инструмент поможет автоматически внести большую часть необходимых изменений в код.
+Этот инструмент поможет автоматически изменить большую часть кода, который нужно изменить.
 
-После этого запустите тесты и проверьте, что всё работает. Если да — на этом всё. 😎
+После этого вы можете запустить тесты и проверить, что всё работает. Если да — на этом всё. 😎
 
 ## Pydantic v1 в v2 { #pydantic-v1-in-v2 }
 
-Pydantic v2 включает всё из Pydantic v1 как подмодуль `pydantic.v1`.
+Pydantic v2 включает всё из Pydantic v1 как подмодуль `pydantic.v1`. Но это больше не поддерживается в версиях Python выше 3.13.
 
 Это означает, что вы можете установить последнюю версию Pydantic v2 и импортировать и использовать старые компоненты Pydantic v1 из этого подмодуля так, как если бы у вас был установлен старый Pydantic v1.
 
@@ -52,7 +54,7 @@ Pydantic v2 включает всё из Pydantic v1 как подмодуль `
 
 ### Поддержка FastAPI для Pydantic v1 внутри v2 { #fastapi-support-for-pydantic-v1-in-v2 }
 
-Начиная с FastAPI 0.119.0, есть также частичная поддержка Pydantic v1 в составе Pydantic v2, чтобы упростить миграцию на v2.
+Начиная с FastAPI 0.119.0, есть также частичная поддержка Pydantic v1 изнутри Pydantic v2, чтобы упростить миграцию на v2.
 
 Таким образом, вы можете обновить Pydantic до последней версии 2 и сменить импорты на подмодуль `pydantic.v1` — во многих случаях всё просто заработает.
 
@@ -106,7 +108,7 @@ graph TB
     style V2Field fill:#f9fff3
 ```
 
-В некоторых случаях можно использовать и модели Pydantic v1, и v2 в одной и той же операции пути (обработчике пути) вашего приложения FastAPI:
+В некоторых случаях можно использовать и модели Pydantic v1, и v2 в одной и той же **операции пути** (обработчике пути) вашего приложения FastAPI:
 
 {* ../../docs_src/pydantic_v1_in_v2/tutorial003_an_py310.py hl[2:3,6,12,21:22] *}
 
@@ -122,12 +124,12 @@ graph TB
 
 /// tip | Совет
 
-Сначала попробуйте `bump-pydantic`. Если тесты проходят и всё работает, вы справились одной командой. ✨
+Сначала попробуйте `bump-pydantic`: если тесты проходят и всё работает, вы справились одной командой. ✨
 
 ///
 
 Если `bump-pydantic` не подходит для вашего случая, вы можете использовать поддержку одновременной работы моделей Pydantic v1 и v2 в одном приложении, чтобы мигрировать на Pydantic v2 постепенно.
 
-Сначала обновите Pydantic до последней 2-й версии и измените импорты так, чтобы все ваши модели использовали `pydantic.v1`.
+Сначала вы можете обновить Pydantic до последней 2-й версии и изменить импорты так, чтобы все ваши модели использовали `pydantic.v1`.
 
-Затем начните мигрировать ваши модели с Pydantic v1 на v2 группами, поэтапно. 🚶
+Затем вы можете начать мигрировать ваши модели с Pydantic v1 на v2 группами, поэтапно. 🚶

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

@@ -2,7 +2,7 @@
 
 При использовании **Pydantic v2** сгенерированный OpenAPI становится чуть более точным и **корректным**, чем раньше. 😎
 
-На самом деле, в некоторых случаях в OpenAPI будет даже **две JSON схемы** для одной и той же Pydantic‑модели: для входа и для выхода — в зависимости от наличия **значений по умолчанию**.
+На самом деле, в некоторых случаях в OpenAPI будет даже **две JSON-схемы** для одной и той же Pydantic‑модели: для входа и для выхода — в зависимости от наличия **значений по умолчанию**.
 
 Посмотрим, как это работает, и как это изменить при необходимости.
 
@@ -34,7 +34,7 @@
 
 {* ../../docs_src/separate_openapi_schemas/tutorial001_py310.py hl[19] *}
 
-…то, поскольку у `description` есть значение по умолчанию, даже если вы **ничего не вернёте** для этого поля, оно всё равно будет иметь это **значение по умолчанию**.
+…то, поскольку у `description` есть значение по умолчанию, если вы **ничего не вернёте** для этого поля, оно всё равно будет иметь это **значение по умолчанию**.
 
 ### Модель для данных ответа { #model-for-output-response-data }
 
@@ -46,13 +46,13 @@
 
 Это означает, что у него **всегда будет какое‑то значение**, просто иногда это значение может быть `None` (или `null` в JSON).
 
-Следовательно, клиентам, использующим ваш API, не нужно проверять наличие этого значения: они могут **исходить из того, что поле всегда присутствует**, а в некоторых случаях имеет значение по умолчанию `None`.
+Это означает, что клиентам, использующим ваш API, не нужно проверять, существует ли это значение или нет: они могут **исходить из того, что поле всегда присутствует**, но в некоторых случаях оно будет иметь значение по умолчанию `None`.
 
 В OpenAPI это описывается тем, что поле помечается как **обязательное**, поскольку оно всегда присутствует.
 
 Из‑за этого JSON Schema для модели может отличаться в зависимости от использования для **входа** или **выхода**:
 
-* для **входа** `description` не будет обязательным
+* для **входа** `description` **не будет обязательным**
 * для **выхода** оно будет **обязательным** (и при этом может быть `None`, или, в терминах JSON, `null`)
 
 ### Выходная модель в документации { #model-for-output-in-docs }
@@ -81,9 +81,9 @@
 
 Однако бывают случаи, когда вы хотите иметь **одну и ту же схему для входа и выхода**.
 
-Главный сценарий — когда у вас уже есть сгенерированный клиентский код/SDK, и вы пока не хотите обновлять весь этот автогенерируемый код/SDK (рано или поздно вы это сделаете, но не сейчас).
+Главный сценарий — когда у вас уже есть сгенерированный клиентский код/SDK, и вы пока не хотите обновлять весь этот автогенерируемый клиентский код/SDK, вероятно, вы захотите сделать это в какой-то момент, но, возможно, не прямо сейчас.
 
-В таком случае вы можете отключить эту функциональность в FastAPI с помощью параметра `separate_input_output_schemas=False`.
+В таком случае вы можете отключить эту функциональность в **FastAPI** с помощью параметра `separate_input_output_schemas=False`.
 
 /// info | Информация
 
@@ -95,10 +95,8 @@
 
 ### Одна и та же схема для входной и выходной моделей в документации { #same-schema-for-input-and-output-models-in-docs }
 
-Теперь для этой модели будет одна общая схема и для входа, и для выхода — только `Item`, и в ней `description` будет **не обязательным**:
+И теперь для модели будет одна общая схема и для входа, и для выхода — только `Item`, и в ней `description` будет **не обязательным**:
 
 <div class="screenshot">
 <img src="/img/tutorial/separate-openapi-schemas/image05.png">
 </div>
-
-Это то же поведение, что и в Pydantic v1. 🤓

docs/ru/docs/index.md

@@ -5,10 +5,10 @@
 </style>
 
 <p align="center">
-  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+  <a href="https://fastapi.tiangolo.com/ru"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
 </p>
 <p align="center">
-    <em>Фреймворк FastAPI: высокая производительность, прост в изучении, быстрый в разработке, готов к продакшн</em>
+    <em>Фреймворк FastAPI: высокая производительность, прост в изучении, позволяет быстро писать код, готов к продакшн</em>
 </p>
 <p align="center">
 <a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
@@ -40,7 +40,7 @@ FastAPI — это современный, быстрый (высокопрои
 * **Скорость**: Очень высокая производительность, на уровне **NodeJS** и **Go** (благодаря Starlette и Pydantic). [Один из самых быстрых доступных фреймворков Python](#performance).
 * **Быстрота разработки**: Увеличьте скорость разработки фич примерно на 200–300%. *
 * **Меньше ошибок**: Сократите примерно на 40% количество ошибок, вызванных человеком (разработчиком). *
-* **Интуитивность**: Отличная поддержка редактора кода. <abbr title="также известное как: автодополнение, IntelliSense">Автозавершение</abbr> везде. Меньше времени на отладку.
+* **Интуитивность**: Отличная поддержка редактора кода. <abbr title="также известное как: автодополнение, автозавершение, IntelliSense">Автозавершение</abbr> везде. Меньше времени на отладку.
 * **Простота**: Разработан так, чтобы его было легко использовать и осваивать. Меньше времени на чтение документации.
 * **Краткость**: Минимизируйте дублирование кода. Несколько возможностей из каждого объявления параметров. Меньше ошибок.
 * **Надежность**: Получите код, готовый к продакшн. С автоматической интерактивной документацией.
@@ -117,6 +117,12 @@ FastAPI — это современный, быстрый (высокопрои
 
 ---
 
+## Мини-документальный фильм о FastAPI { #fastapi-mini-documentary }
+
+В конце 2025 года вышел <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">мини-документальный фильм о FastAPI</a>, вы можете посмотреть его онлайн:
+
+<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**, FastAPI для CLI { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
@@ -257,7 +263,7 @@ INFO:     Application startup complete.
 
 * Получает HTTP-запросы по _путям_ `/` и `/items/{item_id}`.
 * Оба _пути_ используют `GET` <em>операции</em> (также известные как HTTP _методы_).
-* _Путь_ `/items/{item_id}` имеет _параметр пути_ `item_id`, который должен быть `int`.
+* _Путь_ `/items/{item_id}` имеет _path-параметр_ `item_id`, который должен быть `int`.
 * _Путь_ `/items/{item_id}` имеет необязательный `str` _параметр запроса_ `q`.
 
 ### Интерактивная документация API { #interactive-api-docs }
@@ -278,9 +284,9 @@ INFO:     Application startup complete.
 
 ## Пример обновления { #example-upgrade }
 
-Теперь измените файл `main.py`, чтобы принимать тело запроса из `PUT` запроса.
+Теперь измените файл `main.py`, чтобы принимать тело запроса из `PUT` HTTP-запроса.
 
-Объявите тело, используя стандартные типы Python, спасибо Pydantic.
+Объявите тело запроса, используя стандартные типы Python, спасибо Pydantic.
 
 ```Python hl_lines="4  9-12  25-27"
 from typing import Union
@@ -318,7 +324,7 @@ def update_item(item_id: int, item: Item):
 
 Перейдите на <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
-* Интерактивная документация API будет автоматически обновлена, включая новое тело:
+* Интерактивная документация API будет автоматически обновлена, включая новое тело запроса:
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
@@ -334,13 +340,13 @@ def update_item(item_id: int, item: Item):
 
 Теперь откройте <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a>.
 
-* Альтернативная документация также отразит новый параметр запроса и тело:
+* Альтернативная документация также отразит новый параметр запроса и тело запроса:
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
 ### Подведём итоги { #recap }
 
-Итак, вы объявляете **один раз** типы параметров, тела запроса и т.д. как параметры функции.
+Итак, вы объявляете **один раз** типы параметров, тело запроса и т.д. как параметры функции.
 
 Вы делаете это с помощью стандартных современных типов Python.
 
@@ -390,13 +396,13 @@ item: Item
 
 Возвращаясь к предыдущему примеру кода, **FastAPI** будет:
 
-* Валидировать наличие `item_id` в пути для `GET` и `PUT` запросов.
-* Валидировать, что `item_id` имеет тип `int` для `GET` и `PUT` запросов.
+* Валидировать наличие `item_id` в пути для `GET` и `PUT` HTTP-запросов.
+* Валидировать, что `item_id` имеет тип `int` для `GET` и `PUT` HTTP-запросов.
     * Если это не так, клиент увидит полезную понятную ошибку.
-* Проверять, есть ли необязательный параметр запроса с именем `q` (например, `http://127.0.0.1:8000/items/foo?q=somequery`) для `GET` запросов.
+* Проверять, есть ли необязательный параметр запроса с именем `q` (например, `http://127.0.0.1:8000/items/foo?q=somequery`) для `GET` HTTP-запросов.
     * Поскольку параметр `q` объявлен с `= None`, он необязателен.
     * Без `None` он был бы обязательным (как тело запроса в случае с `PUT`).
-* Для `PUT` запросов к `/items/{item_id}` читать тело запроса как JSON:
+* Для `PUT` HTTP-запросов к `/items/{item_id}` читать тело запроса как JSON:
     * Проверять, что есть обязательный атрибут `name`, который должен быть `str`.
     * Проверять, что есть обязательный атрибут `price`, который должен быть `float`.
     * Проверять, что есть необязательный атрибут `is_offer`, который должен быть `bool`, если он присутствует.
@@ -435,11 +441,11 @@ item: Item
 
 Более полный пример с дополнительными возможностями см. в <a href="https://fastapi.tiangolo.com/ru/tutorial/">Учебник - Руководство пользователя</a>.
 
-**Осторожно, спойлер**: учебник - руководство включает:
+**Осторожно, спойлер**: учебник - руководство пользователя включает:
 
 * Объявление **параметров** из других источников: **HTTP-заголовки**, **cookies**, **поля формы** и **файлы**.
 * Как задать **ограничения валидации** вроде `maximum_length` или `regex`.
-* Очень мощную и простую в использовании систему **<abbr title="также известная как: компоненты, ресурсы, провайдеры, сервисы, инъекции">внедрения зависимостей</abbr>**.
+* Очень мощную и простую в использовании систему **<abbr title="также известна как: компоненты, ресурсы, провайдеры, сервисы, инъекции">внедрения зависимостей</abbr>**.
 * Безопасность и аутентификацию, включая поддержку **OAuth2** с **JWT токенами** и **HTTP Basic** аутентификацию.
 * Более продвинутые (но столь же простые) приёмы объявления **глубоко вложенных JSON-моделей** (спасибо Pydantic).
 * Интеграцию **GraphQL** с <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> и другими библиотеками.
@@ -524,11 +530,11 @@ FastAPI зависит от Pydantic и Starlette.
 
 * <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> — обязателен, если вы хотите использовать `TestClient`.
 * <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> — обязателен, если вы хотите использовать конфигурацию шаблонов по умолчанию.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> — обязателен, если вы хотите поддерживать <abbr title="преобразование строки, полученной из HTTP-запроса, в данные Python">«парсинг»</abbr> форм через `request.form()`.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - обязателен, если вы хотите поддерживать <abbr title="преобразование строки, полученной из HTTP-запроса, в данные Python">«парсинг»</abbr> форм через `request.form()`.
 
 Используется FastAPI:
 
-* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> — сервер, который загружает и обслуживает ваше приложение. Включает `uvicorn[standard]`, содержащий некоторые зависимости (например, `uvloop`), нужные для высокой производительности.
+* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> — сервер, который загружает и «отдаёт» ваше приложение. Включает `uvicorn[standard]`, содержащий некоторые зависимости (например, `uvloop`), нужные для высокой производительности.
 * `fastapi-cli[standard]` — чтобы предоставить команду `fastapi`.
     * Включает `fastapi-cloud-cli`, который позволяет развернуть ваше приложение FastAPI в <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>.
 

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

@@ -1,4 +1,4 @@
-# Большие приложения, в которых много файлов { #bigger-applications-multiple-files }
+# Большие приложения — несколько файлов { #bigger-applications-multiple-files }
 
 При построении приложения или веб-API нам редко удается поместить всё в один файл.
 
@@ -31,7 +31,7 @@
 
 /// tip | Подсказка
 
-Обратите внимание, что в каждом каталоге и подкаталоге имеется файл `__init__.py`
+Есть несколько файлов `__init__.py`: по одному в каждом каталоге или подкаталоге.
 
 Это как раз то, что позволяет импортировать код из одного файла в другой.
 
@@ -43,61 +43,63 @@ from app.routers import items
 
 ///
 
-* Всё помещается в каталоге `app`. В нём также находится пустой файл `app/__init__.py`. Таким образом, `app` является "Python-пакетом" (коллекцией модулей Python).
-* Он содержит файл `app/main.py`. Данный файл является частью пакета (т.е. находится внутри каталога, содержащего файл `__init__.py`), и, соответственно, он является модулем пакета: `app.main`.
+* Всё помещается в каталоге `app`. В нём также находится пустой файл `app/__init__.py`. Таким образом, `app` является "Python-пакетом" (коллекцией "Python-модулей"): `app`.
+* Он содержит файл `app/main.py`. Данный файл является частью Python-пакета (т.е. находится внутри каталога, содержащего файл `__init__.py`), и, соответственно, он является модулем этого пакета: `app.main`.
 * Он также содержит файл `app/dependencies.py`, который также, как и `app/main.py`, является модулем: `app.dependencies`.
-* Здесь также находится подкаталог `app/routers/`, содержащий `__init__.py`.  Он является суб-пакетом: `app.routers`.
-* Файл `app/routers/items.py` находится внутри пакета `app/routers/`. Таким образом, он является суб-модулем: `app.routers.items`.
-* Точно также `app/routers/users.py` является ещё одним суб-модулем: `app.routers.users`.
-* Подкаталог `app/internal/`, содержащий файл `__init__.py`, является ещё одним суб-пакетом: `app.internal`.
-* А файл `app/internal/admin.py` является ещё одним суб-модулем: `app.internal.admin`.
+* Здесь также находится подкаталог `app/routers/`, содержащий `__init__.py`. Он является Python-подпакетом: `app.routers`.
+* Файл `app/routers/items.py` находится внутри пакета `app/routers/`. Таким образом, он является подмодулем: `app.routers.items`.
+* Точно так же `app/routers/users.py` является ещё одним подмодулем: `app.routers.users`.
+* Подкаталог `app/internal/`, содержащий файл `__init__.py`, является ещё одним Python-подпакетом: `app.internal`.
+* А файл `app/internal/admin.py` является ещё одним подмодулем: `app.internal.admin`.
 
 <img src="/img/tutorial/bigger-applications/package.drawio.svg">
 
 Та же самая файловая структура приложения, но с комментариями:
 
-```
+```bash
 .
 ├── app                  # "app" пакет
 │   ├── __init__.py      # этот файл превращает "app" в "Python-пакет"
 │   ├── main.py          # модуль "main", напр.: import app.main
 │   ├── dependencies.py  # модуль "dependencies", напр.: import app.dependencies
-│   └── routers          # суб-пакет "routers"
-│   │   ├── __init__.py  # превращает "routers" в суб-пакет
-│   │   ├── items.py     # суб-модуль "items", напр.: import app.routers.items
-│   │   └── users.py     # суб-модуль "users", напр.: import app.routers.users
-│   └── internal         # суб-пакет "internal"
-│       ├── __init__.py  # превращает "internal" в суб-пакет
-│       └── admin.py     # суб-модуль "admin", напр.: import app.internal.admin
+│   └── routers          # подпакет "routers"
+│   │   ├── __init__.py  # превращает "routers" в подпакет
+│   │   ├── items.py     # подмодуль "items", напр.: import app.routers.items
+│   │   └── users.py     # подмодуль "users", напр.: import app.routers.users
+│   └── internal         # подпакет "internal"
+│       ├── __init__.py  # превращает "internal" в подпакет
+│       └── admin.py     # подмодуль "admin", напр.: import app.internal.admin
 ```
 
 ## `APIRouter` { #apirouter }
 
-Давайте предположим, что для работы с пользователями используется отдельный файл (суб-модуль) `/app/routers/users.py`.
+Давайте предположим, что для работы с пользователями используется отдельный файл (подмодуль) `/app/routers/users.py`.
 
-Для лучшей организации приложения, вы хотите отделить операции пути, связанные с пользователями, от остального кода.
+Вы хотите отделить *операции пути*, связанные с пользователями, от остального кода, чтобы сохранить порядок.
 
-Но так, чтобы эти операции по-прежнему оставались частью **FastAPI** приложения/веб-API (частью одного пакета)
+Но это всё равно часть того же приложения/веб-API на **FastAPI** (часть того же «Python-пакета»).
 
-С помощью  `APIRouter` вы можете создать *операции пути* (*эндпоинты*) для данного модуля.
+С помощью `APIRouter` вы можете создать *операции пути* для этого модуля.
 
 ### Импорт `APIRouter` { #import-apirouter }
 
-Точно также, как и в случае с классом `FastAPI`, вам нужно импортировать и создать объект класса `APIRouter`.
+Точно так же, как и в случае с классом `FastAPI`, вам нужно импортировать и создать его «экземпляр»:
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
 
-### Создание *эндпоинтов* с помощью `APIRouter` { #path-operations-with-apirouter }
+### *Операции пути* с `APIRouter` { #path-operations-with-apirouter }
 
-В дальнейшем используйте `APIRouter` для объявления *эндпоинтов*, точно также, как вы используете класс `FastAPI`:
+И затем вы используете его, чтобы объявить ваши *операции пути*.
+
+Используйте его так же, как вы использовали бы класс `FastAPI`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
 
-Вы можете думать об `APIRouter` как об "уменьшенной версии" класса FastAPI`.
+Вы можете думать об `APIRouter` как об «мини-классе `FastAPI`».
 
-`APIRouter` поддерживает все те же самые опции.
+Поддерживаются все те же опции.
 
-`APIRouter` поддерживает все те же самые параметры, такие как `parameters`, `responses`, `dependencies`, `tags`, и т. д.
+Все те же `parameters`, `responses`, `dependencies`, `tags` и т.д.
 
 /// tip | Подсказка
 
@@ -105,21 +107,21 @@ from app.routers import items
 
 ///
 
-Мы собираемся подключить данный `APIRouter` к нашему основному приложению на `FastAPI`, но сначала давайте проверим зависимости и создадим ещё один модуль с `APIRouter`.
+Мы собираемся подключить данный `APIRouter` к нашему основному приложению на `FastAPI`, но сначала давайте проверим зависимости и ещё один `APIRouter`.
 
 ## Зависимости { #dependencies }
 
-Нам понадобятся некоторые зависимости, которые мы будем использовать в разных местах нашего приложения.
+Мы видим, что нам понадобятся некоторые зависимости, которые будут использоваться в нескольких местах приложения.
 
-Мы поместим их в отдельный модуль `dependencies` (`app/dependencies.py`).
+Поэтому мы поместим их в отдельный модуль `dependencies` (`app/dependencies.py`).
 
-Теперь мы воспользуемся простой зависимостью, чтобы прочитать кастомизированный `X-Token` из заголовка:
+Теперь мы воспользуемся простой зависимостью, чтобы прочитать кастомный HTTP-заголовок `X-Token`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/dependencies.py hl[3,6:8] title["app/dependencies.py"] *}
 
 /// tip | Подсказка
 
-Для простоты мы воспользовались неким воображаемым заголовоком.
+Для простоты мы воспользовались выдуманным заголовком.
 
 В реальных случаях для получения наилучших результатов используйте интегрированные [утилиты безопасности](security/index.md){.internal-link target=_blank}.
 
@@ -127,30 +129,29 @@ from app.routers import items
 
 ## Ещё один модуль с `APIRouter` { #another-module-with-apirouter }
 
-Давайте также предположим, что у вас есть *эндпоинты*, отвечающие за обработку "items", и они находятся в модуле `app/routers/items.py`.
+Давайте также предположим, что у вас есть эндпоинты, отвечающие за обработку «items» в вашем приложении, и они находятся в модуле `app/routers/items.py`.
 
-У вас определены следующие *операции пути* (*эндпоинты*):
+У вас определены *операции пути* для:
 
 * `/items/`
 * `/items/{item_id}`
 
-Тут всё точно также, как и в ситуации с `app/routers/users.py`.
+Тут всё та же структура, как и в случае с `app/routers/users.py`.
 
-Но теперь мы хотим поступить немного умнее и слегка упростить код.
+Но мы хотим поступить умнее и слегка упростить код.
 
-Мы знаем, что все *эндпоинты* данного модуля имеют некоторые общие свойства:
+Мы знаем, что все *операции пути* этого модуля имеют одинаковые:
 
-* Префикс пути: `/items`.
-* Теги: (один единственный тег: `items`).
-* Дополнительные ответы (responses)
-* Зависимости: использование созданной нами зависимости `X-token`
+* `prefix` пути: `/items`.
+* `tags`: (один единственный тег: `items`).
+* Дополнительные `responses`.
+* `dependencies`: всем им нужна та зависимость `X-Token`, которую мы создали.
 
-Таким образом, вместо того чтобы добавлять все эти свойства в функцию каждого отдельного *эндпоинта*,
-мы добавим их в `APIRouter`.
+Таким образом, вместо того чтобы добавлять всё это в каждую *операцию пути*, мы можем добавить это в `APIRouter`.
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
 
-Так как каждый *эндпоинт* начинается с символа `/`:
+Так как путь каждой *операции пути* должен начинаться с `/`, как здесь:
 
 ```Python hl_lines="1"
 @router.get("/{item_id}")
@@ -162,73 +163,74 @@ async def read_item(item_id: str):
 
 В нашем случае префиксом является `/items`.
 
-Мы также можем добавить в наш маршрутизатор (router) список `тегов` (`tags`) и дополнительных `ответов` (`responses`), которые являются общими для каждого *эндпоинта*.
+Мы также можем добавить список `tags` и дополнительные `responses`, которые будут применяться ко всем *операциям пути*, включённым в этот маршрутизатор.
 
-И ещё мы можем добавить в наш маршрутизатор список `зависимостей`, которые должны вызываться при каждом обращении к *эндпоинтам*.
+И ещё мы можем добавить список `dependencies`, которые будут добавлены ко всем *операциям пути* в маршрутизаторе и будут выполняться/разрешаться для каждого HTTP-запроса к ним.
 
 /// tip | Подсказка
 
-Обратите внимание, что также, как и в случае с зависимостями в декораторах *эндпоинтов* ([зависимости в декораторах операций пути](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}), никакого значения в *функцию эндпоинта* передано не будет.
+Обратите внимание, что так же, как и в случае с [зависимостями в декораторах *операций пути*](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, никакое значение не будет передано в вашу *функцию-обработчик пути*.
 
 ///
 
-В результате мы получим следующие эндпоинты:
+В результате пути для items теперь такие:
 
 * `/items/`
 * `/items/{item_id}`
 
 ...как мы и планировали.
 
-* Они будут помечены тегами из заданного списка, в нашем случае это `"items"`.
-    * Эти теги особенно полезны для системы автоматической интерактивной документации (с использованием OpenAPI).
-* Каждый из них будет включать предопределенные ответы `responses`.
-* Каждый *эндпоинт* будет иметь список зависимостей (`dependencies`), исполняемых перед вызовом *эндпоинта*.
-    * Если вы определили зависимости в самой операции пути, **то она также будет выполнена**.
-    * Сначала выполняются зависимости маршрутизатора, затем вызываются [зависимости в декораторе](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, и, наконец, обычные параметрические зависимости.
-    * Вы также можете добавить [зависимости `Security` с `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+* Они будут помечены списком тегов, содержащим одну строку `"items"`.
+    * Эти «теги» особенно полезны для систем автоматической интерактивной документации (с использованием OpenAPI).
+* Все они будут включать предопределённые `responses`.
+* Все эти *операции пути* будут иметь список `dependencies`, вычисляемых/выполняемых перед ними.
+    * Если вы также объявите зависимости в конкретной *операции пути*, **они тоже будут выполнены**.
+    * Сначала выполняются зависимости маршрутизатора, затем [`dependencies` в декораторе](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, и затем обычные параметрические зависимости.
+    * Вы также можете добавить [`Security`-зависимости с `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
 
 /// tip | Подсказка
 
-Например, с помощью зависимостей в `APIRouter` мы можем потребовать аутентификации для доступа ко всей группе *эндпоинтов*, не указывая зависимости для каждой отдельной функции *эндпоинта*.
+Например, с помощью зависимостей в `APIRouter` мы можем потребовать аутентификации для доступа ко всей группе *операций пути*. Даже если зависимости не добавляются по отдельности к каждой из них.
 
 ///
 
 /// check | Заметка
 
-Параметры `prefix`, `tags`, `responses` и `dependencies` относятся к функционалу **FastAPI**, помогающему избежать дублирования кода.
+Параметры `prefix`, `tags`, `responses` и `dependencies` — это (как и во многих других случаях) просто возможность **FastAPI**, помогающая избежать дублирования кода.
 
 ///
 
 ### Импорт зависимостей { #import-the-dependencies }
 
-Наш код находится в модуле `app.routers.items` (файл `app/routers/items.py`).
+Этот код находится в модуле `app.routers.items`, в файле `app/routers/items.py`.
 
-И нам нужно вызвать функцию зависимости из модуля `app.dependencies` (файл `app/dependencies.py`).
+И нам нужно получить функцию зависимости из модуля `app.dependencies`, файла `app/dependencies.py`.
 
-Мы используем операцию относительного импорта `..` для импорта зависимости:
+Поэтому мы используем относительный импорт с `..` для зависимостей:
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[3] title["app/routers/items.py"] *}
 
-#### Как работает относительный импорт? { #how-relative-imports-work }
+#### Как работает относительный импорт { #how-relative-imports-work }
 
 /// tip | Подсказка
 
-Если вы прекрасно знаете, как работает импорт в Python, то переходите к следующему разделу.
+Если вы прекрасно знаете, как работает импорт, переходите к следующему разделу ниже.
 
 ///
 
-Одна точка `.`, как в данном примере:
+Одна точка `.`, как здесь:
 
 ```Python
 from .dependencies import get_token_header
 ```
+
 означает:
 
-* Начните с пакета, в котором находится данный модуль (файл `app/routers/items.py` расположен в каталоге `app/routers/`)...
-* ... найдите модуль `dependencies` (файл `app/routers/dependencies.py`)...
-* ... и импортируйте из него функцию `get_token_header`.
+* Начать в том же пакете, в котором находится этот модуль (файл `app/routers/items.py`) (каталог `app/routers/`)...
+* найти модуль `dependencies` (воображаемый файл `app/routers/dependencies.py`)...
+* и импортировать из него функцию `get_token_header`.
 
-К сожалению, такого файла не существует, и наши зависимости находятся в файле `app/dependencies.py`.
+Но такого файла не существует, наши зависимости находятся в файле `app/dependencies.py`.
 
 Вспомните, как выглядит файловая структура нашего приложения:
 
@@ -236,7 +238,7 @@ from .dependencies import get_token_header
 
 ---
 
-Две точки `..`, как в данном примере:
+Две точки `..`, как здесь:
 
 ```Python
 from ..dependencies import get_token_header
@@ -244,12 +246,12 @@ from ..dependencies import get_token_header
 
 означают:
 
-* Начните с пакета, в котором находится данный модуль (файл `app/routers/items.py` находится в каталоге `app/routers/`)...
-* ... перейдите в родительский пакет (каталог `app/`)...
-* ... найдите в нём модуль `dependencies` (файл `app/dependencies.py`)...
-* ... и импортируйте из него функцию `get_token_header`.
+* Начать в том же пакете, в котором находится этот модуль (файл `app/routers/items.py`) (каталог `app/routers/`)...
+* перейти в родительский пакет (каталог `app/`)...
+* и там найти модуль `dependencies` (файл `app/dependencies.py`)...
+* и импортировать из него функцию `get_token_header`.
 
-Это работает верно! 🎉
+Это работает корректно! 🎉
 
 ---
 
@@ -261,29 +263,29 @@ from ...dependencies import get_token_header
 
 то это бы означало:
 
-* Начните с пакета, в котором находится данный модуль (файл `app/routers/items.py` находится в каталоге `app/routers/`)...
-* ... перейдите в родительский пакет (каталог `app/`)...
-* ... затем перейдите в родительский пакет текущего пакета (такого пакета не существует, `app` находится на самом верхнем уровне 😱)...
-* ... найдите в нём модуль `dependencies` (файл `app/dependencies.py`)...
-* ... и импортируйте из него функцию `get_token_header`.
+* Начать в том же пакете, в котором находится этот модуль (файл `app/routers/items.py`) расположен в (каталоге `app/routers/`)...
+* перейти в родительский пакет (каталог `app/`)...
+* затем перейти в родительский пакет этого пакета (родительского пакета нет, `app` — верхний уровень 😱)...
+* и там найти модуль `dependencies` (файл `app/dependencies.py`)...
+* и импортировать из него функцию `get_token_header`.
 
-Это будет относиться к некоторому пакету, находящемуся на один уровень выше чем `app/` и содержащему свой собственный файл `__init__.py`. Но ничего такого у нас нет. Поэтому это приведет к ошибке в нашем примере. 🚨
+Это ссылалось бы на какой-то пакет выше `app/`, со своим файлом `__init__.py` и т.п. Но у нас такого нет. Поэтому это вызвало бы ошибку в нашем примере. 🚨
 
-Теперь вы знаете, как работает импорт в Python, и сможете использовать относительное импортирование в своих собственных приложениях любого уровня сложности. 🤓
+Но теперь вы знаете, как это работает, так что можете использовать относительные импорты в своих приложениях, независимо от того, насколько они сложные. 🤓
 
-### Добавление пользовательских тегов (`tags`), ответов (`responses`) и зависимостей (`dependencies`) { #add-some-custom-tags-responses-and-dependencies }
+### Добавление пользовательских `tags`, `responses` и `dependencies` { #add-some-custom-tags-responses-and-dependencies }
 
-Мы не будем добавлять префикс `/items` и список тегов `tags=["items"]` для каждого *эндпоинта*, т.к. мы уже их добавили с помощью `APIRouter`.
+Мы не добавляем префикс `/items` и `tags=["items"]` к каждой *операции пути*, потому что мы добавили их в `APIRouter`.
 
-Но помимо этого мы можем добавить новые теги для каждого отдельного *эндпоинта*, а также некоторые дополнительные ответы (`responses`), характерные для данного *эндпоинта*:
+Но мы всё равно можем добавить _ещё_ `tags`, которые будут применяться к конкретной *операции пути*, а также дополнительные `responses`, специфичные для этой *операции пути*:
 
 {* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[30:31] title["app/routers/items.py"] *}
 
 /// tip | Подсказка
 
-Последний *эндпоинт* будет иметь следующую комбинацию тегов: `["items", "custom"]`.
+Эта последняя операция пути будет иметь комбинацию тегов: `["items", "custom"]`.
 
-А также в его документации будут содержаться оба ответа: один для `404` и другой для `403`.
+И в документации у неё будут оба ответа: один для `404` и один для `403`.
 
 ///
 
@@ -293,29 +295,29 @@ from ...dependencies import get_token_header
 
 Именно сюда вы импортируете и именно здесь вы используете класс `FastAPI`.
 
-Это основной файл вашего приложения, который объединяет всё в одно целое.
+Это основной файл вашего приложения, который связывает всё воедино.
 
-И теперь, когда большая часть логики приложения разделена на отдельные модули, основной файл `app/main.py` будет достаточно простым.
+И так как большая часть вашей логики теперь будет находиться в отдельных специфичных модулях, основной файл будет довольно простым.
 
 ### Импорт `FastAPI` { #import-fastapi }
 
-Вы импортируете и создаете класс `FastAPI` как обычно.
+Вы импортируете и создаёте класс `FastAPI` как обычно.
 
-Мы даже можем объявить [глобальные зависимости](dependencies/global-dependencies.md){.internal-link target=_blank}, которые будут объединены с зависимостями для каждого отдельного маршрутизатора:
+И мы даже можем объявить [глобальные зависимости](dependencies/global-dependencies.md){.internal-link target=_blank}, которые будут объединены с зависимостями для каждого `APIRouter`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[1,3,7] title["app/main.py"] *}
 
 ### Импорт `APIRouter` { #import-the-apirouter }
 
-Теперь мы импортируем другие суб-модули, содержащие `APIRouter`:
+Теперь мы импортируем другие подмодули, содержащие `APIRouter`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[4:5] title["app/main.py"] *}
 
-Так как файлы `app/routers/users.py` и `app/routers/items.py` являются суб-модулями одного и того же Python-пакета `app`, то мы сможем их импортировать, воспользовавшись операцией относительного импорта `.`.
+Так как файлы `app/routers/users.py` и `app/routers/items.py` являются подмодулями, входящими в один и тот же Python-пакет `app`, мы можем использовать одну точку `.` для импорта через «относительные импорты».
 
-### Как работает импорт? { #how-the-importing-works }
+### Как работает импорт { #how-the-importing-works }
 
-Данная строка кода:
+Этот фрагмент:
 
 ```Python
 from .routers import items, users
@@ -323,15 +325,15 @@ from .routers import items, users
 
 означает:
 
-* Начните с пакета, в котором содержится данный модуль (файл `app/main.py` содержится в каталоге `app/`)...
-* ... найдите суб-пакет `routers` (каталог `app/routers/`)...
-* ... и из него импортируйте суб-модули `items` (файл `app/routers/items.py`) и `users` (файл `app/routers/users.py`)...
+* Начать в том же пакете, в котором находится этот модуль (файл `app/main.py`) расположен в (каталоге `app/`)...
+* найти подпакет `routers` (каталог `app/routers/`)...
+* и импортировать из него подмодули `items` (файл `app/routers/items.py`) и `users` (файл `app/routers/users.py`)...
 
-В модуле `items` содержится переменная `router` (`items.router`), та самая, которую мы создали в файле `app/routers/items.py`, она является объектом класса `APIRouter`.
+В модуле `items` будет переменная `router` (`items.router`). Это та же самая, которую мы создали в файле `app/routers/items.py`, это объект `APIRouter`.
 
-И затем мы сделаем то же самое для модуля `users`.
+И затем мы делаем то же самое для модуля `users`.
 
-Мы также могли бы импортировать и другим методом:
+Мы также могли бы импортировать их так:
 
 ```Python
 from app.routers import items, users
@@ -339,44 +341,44 @@ from app.routers import items, users
 
 /// info | Примечание
 
-Первая версия является примером относительного импорта:
+Первая версия — это «относительный импорт»:
 
 ```Python
 from .routers import items, users
 ```
 
-Вторая версия является примером абсолютного импорта:
+Вторая версия — это «абсолютный импорт»:
 
 ```Python
 from app.routers import items, users
 ```
 
-Узнать больше о пакетах и модулях в Python вы можете из <a href="https://docs.python.org/3/tutorial/modules.html" class="external-link" target="_blank">официальной документации Python о модулях</a>
+Чтобы узнать больше о Python-пакетах и модулях, прочитайте <a href="https://docs.python.org/3/tutorial/modules.html" class="external-link" target="_blank">официальную документацию Python о модулях</a>.
 
 ///
 
-### Избегайте конфликтов имен { #avoid-name-collisions }
+### Избегайте конфликтов имён { #avoid-name-collisions }
 
-Вместо того чтобы импортировать только переменную `router`, мы импортируем непосредственно суб-модуль `items`.
+Мы импортируем подмодуль `items` напрямую, вместо того чтобы импортировать только его переменную `router`.
 
-Мы делаем это потому, что у нас есть ещё одна переменная `router` в суб-модуле `users`.
+Это потому, что у нас также есть другая переменная с именем `router` в подмодуле `users`.
 
-Если бы мы импортировали их одну за другой, как показано в примере:
+Если бы мы импортировали их одну за другой, как здесь:
 
 ```Python
 from .routers.items import router
 from .routers.users import router
 ```
 
-то переменная `router` из `users` переписал бы переменную `router` из `items`, и у нас не было бы возможности использовать их одновременно.
+то `router` из `users` перезаписал бы `router` из `items`, и мы не смогли бы использовать их одновременно.
 
-Поэтому, для того чтобы использовать обе эти переменные в одном файле, мы импортировали соответствующие суб-модули:
+Поэтому, чтобы иметь возможность использовать обе в одном файле, мы импортируем подмодули напрямую:
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
 
-### Подключение маршрутизаторов (`APIRouter`) для `users` и для `items` { #include-the-apirouters-for-users-and-items }
+### Подключение `APIRouter` для `users` и `items` { #include-the-apirouters-for-users-and-items }
 
-Давайте подключим маршрутизаторы (`router`) из суб-модулей `users` и `items`:
+Теперь давайте подключим `router` из подмодулей `users` и `items`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[10:11] title["app/main.py"] *}
 
@@ -388,79 +390,78 @@ from .routers.users import router
 
 ///
 
-С помощью `app.include_router()` мы можем добавить каждый из маршрутизаторов (`APIRouter`) в основное приложение `FastAPI`.
+С помощью `app.include_router()` мы можем добавить каждый `APIRouter` в основное приложение `FastAPI`.
 
-Он подключит все маршруты заданного маршрутизатора к нашему приложению.
+Он включит все маршруты этого маршрутизатора как часть приложения.
 
 /// note | Технические детали
 
-Фактически, внутри он создаст все *операции пути* для каждой операции пути объявленной в `APIRouter`.
+Фактически, внутри он создаст *операцию пути* для каждой *операции пути*, объявленной в `APIRouter`.
 
-И под капотом всё будет работать так, как будто бы мы имеем дело с одним файлом приложения.
+Так что под капотом всё будет работать так, как будто всё было одним приложением.
 
 ///
 
 /// check | Заметка
 
-При подключении маршрутизаторов не стоит беспокоиться о производительности.
+При подключении маршрутизаторов не нужно беспокоиться о производительности.
 
-Операция подключения займёт микросекунды и понадобится только при запуске приложения.
+Это займёт микросекунды и произойдёт только при старте.
 
-Таким образом, это не повлияет на производительность. ⚡
+Так что это не повлияет на производительность. ⚡
 
 ///
 
-### Подключение `APIRouter` с пользовательскими префиксом (`prefix`), тегами (`tags`), ответами (`responses`), и зависимостями (`dependencies`) { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
+### Подключение `APIRouter` с пользовательскими `prefix`, `tags`, `responses` и `dependencies` { #include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies }
 
 Теперь давайте представим, что ваша организация передала вам файл `app/internal/admin.py`.
 
-Он содержит `APIRouter` с некоторыми *эндпоитами* администрирования, которые ваша организация использует для нескольких проектов.
+Он содержит `APIRouter` с некоторыми административными *операциями пути*, которые ваша организация использует в нескольких проектах.
 
-В данном примере это сделать очень просто. Но давайте предположим, что поскольку файл используется для нескольких проектов,
-то мы не можем модифицировать его, добавляя префиксы (`prefix`), зависимости (`dependencies`), теги (`tags`), и т.д. непосредственно в `APIRouter`:
+Для этого примера всё будет очень просто. Но допустим, что поскольку он используется совместно с другими проектами в организации, мы не можем модифицировать его и добавить `prefix`, `dependencies`, `tags` и т.д. непосредственно в `APIRouter`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/internal/admin.py hl[3] title["app/internal/admin.py"] *}
 
-Но, несмотря на это, мы хотим использовать кастомный префикс (`prefix`) для подключенного маршрутизатора (`APIRouter`), в результате чего, каждая *операция пути* будет начинаться с `/admin`. Также мы хотим защитить наш маршрутизатор с помощью зависимостей, созданных для нашего проекта. И ещё мы хотим включить теги (`tags`) и ответы (`responses`).
+Но мы всё равно хотим задать пользовательский `prefix` при подключении `APIRouter`, чтобы все его *операции пути* начинались с `/admin`, хотим защитить его с помощью `dependencies`, которые у нас уже есть для этого проекта, и хотим включить `tags` и `responses`.
 
-Мы можем применить все вышеперечисленные настройки, не изменяя начальный `APIRouter`. Нам всего лишь нужно передать нужные параметры в `app.include_router()`.
+Мы можем объявить всё это, не изменяя исходный `APIRouter`, передав эти параметры в `app.include_router()`:
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[14:17] title["app/main.py"] *}
 
-Таким образом, оригинальный `APIRouter` не будет модифицирован, и мы сможем использовать файл `app/internal/admin.py` сразу в нескольких проектах организации.
+Таким образом исходный `APIRouter` не будет модифицирован, и мы сможем использовать файл `app/internal/admin.py` сразу в нескольких проектах организации.
 
-В результате, в нашем приложении каждый *эндпоинт* модуля `admin` будет иметь:
+В результате в нашем приложении каждая из *операций пути* из модуля `admin` будет иметь:
 
 * Префикс `/admin`.
 * Тег `admin`.
 * Зависимость `get_token_header`.
 * Ответ `418`. 🍵
 
-Это будет иметь место исключительно для `APIRouter` в нашем приложении, и не затронет любой другой код, использующий его.
+Но это повлияет только на этот `APIRouter` в нашем приложении, а не на любой другой код, который его использует.
 
-Например, другие проекты, могут использовать тот же самый `APIRouter` с другими методами аутентификации.
+Так что, например, другие проекты могут использовать тот же `APIRouter` с другим методом аутентификации.
 
-### Подключение отдельного *эндпоинта* { #include-a-path-operation }
+### Подключение *операции пути* { #include-a-path-operation }
 
-Мы также можем добавить *эндпоинт* непосредственно в основное приложение `FastAPI`.
+Мы также можем добавлять *операции пути* напрямую в приложение `FastAPI`.
 
-Здесь мы это делаем ... просто, чтобы показать, что это возможно 🤷:
+Здесь мы делаем это... просто чтобы показать, что можем 🤷:
 
 {* ../../docs_src/bigger_applications/app_an_py39/main.py hl[21:23] title["app/main.py"] *}
 
-и это будет работать корректно вместе с другими *эндпоинтами*, добавленными с помощью `app.include_router()`.
+и это будет работать корректно вместе со всеми другими *операциями пути*, добавленными через `app.include_router()`.
 
-/// info | Сложные технические детали
+/// info | Очень технические детали
 
-**Примечание**: это сложная техническая деталь, которую, скорее всего, **вы можете пропустить**.
+**Примечание**: это очень техническая деталь, которую, вероятно, можно **просто пропустить**.
 
 ---
 
-Маршрутизаторы (`APIRouter`) не "монтируются" по-отдельности и не изолируются от остального приложения.
+`APIRouter` не «монтируются», они не изолированы от остального приложения.
 
-Это происходит потому, что нужно включить их *эндпоинты* в OpenAPI схему и в интерфейс пользователя.
+Это потому, что мы хотим включить их *операции пути* в OpenAPI-схему и пользовательские интерфейсы.
 
-В силу того, что мы не можем их изолировать и "примонтировать" независимо от остальных, *эндпоинты* клонируются (пересоздаются) и не подключаются напрямую.
+Так как мы не можем просто изолировать их и «смонтировать» независимо от остального, *операции пути* «клонируются» (пересоздаются), а не включаются напрямую.
 
 ///
 
@@ -480,24 +481,24 @@ $ fastapi dev app/main.py
 
 Откройте документацию по адресу <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a>.
 
-Вы увидите автоматическую API документацию. Она включает в себя маршруты из суб-модулей, используя верные маршруты, префиксы и теги:
+Вы увидите автоматическую документацию API, включая пути из всех подмодулей, с использованием корректных путей (и префиксов) и корректных тегов:
 
 <img src="/img/tutorial/bigger-applications/image01.png">
 
-## Подключение существующего маршрута через новый префикс (`prefix`) { #include-the-same-router-multiple-times-with-different-prefix }
+## Подключение одного и того же маршрутизатора несколько раз с разными `prefix` { #include-the-same-router-multiple-times-with-different-prefix }
 
-Вы можете использовать `.include_router()` несколько раз с одним и тем же маршрутом, применив различные префиксы.
+Вы можете использовать `.include_router()` несколько раз с *одним и тем же* маршрутизатором, используя разные префиксы.
 
-Это может быть полезным, если нужно предоставить доступ к одному и тому же API через различные префиксы, например, `/api/v1` и `/api/latest`.
+Это может быть полезно, например, чтобы предоставить доступ к одному и тому же API с разными префиксами, например `/api/v1` и `/api/latest`.
 
-Это продвинутый способ, который вам может и не пригодится. Мы приводим его на случай, если вдруг вам это понадобится.
+Это продвинутое использование, которое вам может и не понадобиться, но оно есть на случай, если понадобится.
 
-## Включение одного маршрутизатора (`APIRouter`) в другой { #include-an-apirouter-in-another }
+## Подключение `APIRouter` в другой `APIRouter` { #include-an-apirouter-in-another }
 
-Точно так же, как вы включаете `APIRouter` в приложение `FastAPI`, вы можете включить `APIRouter` в другой `APIRouter`:
+Точно так же, как вы можете подключить `APIRouter` к приложению `FastAPI`, вы можете подключить `APIRouter` к другому `APIRouter`, используя:
 
 ```Python
 router.include_router(other_router)
 ```
 
-Удостоверьтесь, что вы сделали это до того, как подключить маршрутизатор  (`router`) к вашему `FastAPI` приложению, и *эндпоинты* маршрутизатора `other_router` были также подключены.
+Убедитесь, что вы сделали это до подключения `router` к приложению `FastAPI`, чтобы *операции пути* из `other_router` также были подключены.

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

@@ -2,13 +2,13 @@
 
 ## Обновление с заменой при помощи `PUT` { #update-replacing-with-put }
 
-Для полного обновления элемента можно воспользоваться операцией <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
+Чтобы обновить элемент, вы можете использовать операцию <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PUT" class="external-link" target="_blank">HTTP `PUT`</a>.
 
 Вы можете использовать `jsonable_encoder`, чтобы преобразовать входные данные в данные, которые можно сохранить как JSON (например, в NoSQL-базе данных). Например, преобразование `datetime` в `str`.
 
 {* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
 
-`PUT` используется для получения данных, которые должны полностью заменить существующие данные.
+`PUT` используется для получения данных, которые должны заменить существующие данные.
 
 ### Предупреждение о замене { #warning-about-replacing }
 
@@ -24,11 +24,11 @@
 
 поскольку оно не включает уже сохраненный атрибут `"tax": 20.2`, входная модель примет значение по умолчанию `"tax": 10.5`.
 
-И данные будут сохранены с этим "новым" `tax`, равным `10,5`.
+И данные будут сохранены с этим «новым» `tax`, равным `10.5`.
 
 ## Частичное обновление с помощью `PATCH` { #partial-updates-with-patch }
 
-Также можно использовать <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> операцию для *частичного* обновления данных.
+Также можно использовать операцию <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/PATCH" class="external-link" target="_blank">HTTP `PATCH`</a> для *частичного* обновления данных.
 
 Это означает, что можно передавать только те данные, которые необходимо обновить, оставляя остальные нетронутыми.
 
@@ -46,19 +46,13 @@
 
 ### Использование параметра `exclude_unset` в Pydantic { #using-pydantics-exclude-unset-parameter }
 
-Если необходимо выполнить частичное обновление, то очень полезно использовать параметр `exclude_unset` в методе `.model_dump()` модели Pydantic.
+Если вы хотите получать частичные обновления, очень полезно использовать параметр `exclude_unset` в `.model_dump()` модели Pydantic.
 
 Например, `item.model_dump(exclude_unset=True)`.
 
-/// info | Информация
+В результате будет сгенерирован `dict`, содержащий только те данные, которые были заданы при создании модели `item`, без учета значений по умолчанию.
 
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он помечен как устаревший (но все еще поддерживается) и переименован в `.model_dump()`.
-
-Примеры здесь используют `.dict()` для совместимости с Pydantic v1, но если вы можете использовать Pydantic v2, лучше используйте `.model_dump()`.
-
-///
-
-В результате будет сгенерирован словарь, содержащий только те данные, которые были заданы при создании модели `item`, без учета значений по умолчанию. Затем вы можете использовать это для создания словаря только с теми данными, которые были установлены (отправлены в запросе), опуская значения по умолчанию:
+Затем вы можете использовать это для создания `dict` только с теми данными, которые были установлены (отправлены в запросе), опуская значения по умолчанию:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
 
@@ -66,14 +60,6 @@
 
 Теперь можно создать копию существующей модели, используя `.model_copy()`, и передать параметр `update` с `dict`, содержащим данные для обновления.
 
-/// info | Информация
-
-В Pydantic v1 метод назывался `.copy()`, в Pydantic v2 он помечен как устаревший (но все еще поддерживается) и переименован в `.model_copy()`.
-
-Примеры здесь используют `.copy()` для совместимости с Pydantic v1, но если вы можете использовать Pydantic v2, лучше используйте `.model_copy()`.
-
-///
-
 Например, `stored_item_model.model_copy(update=update_data)`:
 
 {* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
@@ -84,9 +70,9 @@
 
 * (Опционально) использовать `PATCH` вместо `PUT`.
 * Извлечь сохранённые данные.
-* Поместить эти данные в Pydantic модель.
+* Поместить эти данные в Pydantic-модель.
 * Сгенерировать `dict` без значений по умолчанию из входной модели (с использованием `exclude_unset`).
-    * Таким образом, можно обновлять только те значения, которые действительно установлены пользователем, вместо того чтобы переопределять значения, уже сохраненные в модели по умолчанию.
+    * Таким образом, можно обновлять только те значения, которые действительно установлены пользователем, вместо того чтобы переопределять уже сохраненные значения значениями по умолчанию из вашей модели.
 * Создать копию хранимой модели, обновив ее атрибуты полученными частичными обновлениями (с помощью параметра `update`).
 * Преобразовать скопированную модель в то, что может быть сохранено в вашей БД (например, с помощью `jsonable_encoder`).
     * Это сравнимо с повторным использованием метода модели `.model_dump()`, но при этом происходит проверка (и преобразование) значений в типы данных, которые могут быть преобразованы в JSON, например, `datetime` в `str`.
@@ -97,7 +83,7 @@
 
 /// tip | Подсказка
 
-Эту же технику можно использовать и для операции HTTP `PUT`.
+На самом деле эту же технику можно использовать и для операции HTTP `PUT`.
 
 Но в приведенном примере используется `PATCH`, поскольку он был создан именно для таких случаев использования.
 

docs/ru/docs/tutorial/body.md

@@ -32,9 +32,10 @@
 
 {* ../../docs_src/body/tutorial001_py310.py hl[5:9] *}
 
+
 Так же, как при объявлении параметров запроса: когда атрибут модели имеет значение по умолчанию, он не обязателен. Иначе он обязателен. Используйте `None`, чтобы сделать его просто необязательным.
 
-Например, модель выше описывает такой JSON "объект" (или Python `dict`):
+Например, модель выше описывает такой JSON "`object`" (или Python `dict`):
 
 ```JSON
 {
@@ -45,7 +46,7 @@
 }
 ```
 
-...так как `description` и `tax` являются необязательными (со значением по умолчанию `None`), такой JSON "объект" тоже будет корректным:
+...так как `description` и `tax` являются необязательными (со значением по умолчанию `None`), такой JSON "`object`" тоже будет корректным:
 
 ```JSON
 {
@@ -73,7 +74,7 @@
 * Передаст полученные данные в параметр `item`.
     * Поскольку внутри функции вы объявили его с типом `Item`, у вас будет поддержка со стороны редактора кода (автозавершение и т. п.) для всех атрибутов и их типов.
 * Сгенерирует определения <a href="https://json-schema.org" class="external-link" target="_blank">JSON Schema</a> для вашей модели; вы можете использовать их и в других местах, если это имеет смысл для вашего проекта.
-* Эти схемы будут частью сгенерированной схемы OpenAPI и будут использоваться автоматической документацией <abbr title="User Interfaces – Пользовательские интерфейсы">UIs</abbr>.
+* Эти схемы будут частью сгенерированной схемы OpenAPI и будут использоваться автоматической документацией <abbr title="User Interfaces - Пользовательские интерфейсы">UIs</abbr>.
 
 ## Автоматическая документация { #automatic-docs }
 
@@ -127,14 +128,6 @@ JSON Schema ваших моделей будет частью сгенериро
 
 {* ../../docs_src/body/tutorial002_py310.py *}
 
-/// info | Информация
-
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он был помечен как устаревший (но всё ещё поддерживается) и переименован в `.model_dump()`.
-
-Примеры здесь используют `.dict()` для совместимости с Pydantic v1, но если вы можете использовать Pydantic v2, используйте `.model_dump()`.
-
-///
-
 ## Тело запроса + параметры пути { #request-body-path-parameters }
 
 Вы можете одновременно объявить параметры пути и тело запроса.
@@ -143,6 +136,7 @@ JSON Schema ваших моделей будет частью сгенериро
 
 {* ../../docs_src/body/tutorial003_py310.py hl[15:16] *}
 
+
 ## Тело запроса + параметры пути + параметры запроса { #request-body-path-query-parameters }
 
 Вы также можете одновременно объявить параметры **тела**, **пути** и **запроса**.
@@ -153,7 +147,7 @@ JSON Schema ваших моделей будет частью сгенериро
 
 Параметры функции будут распознаны следующим образом:
 
-* Если параметр также объявлен в **пути**, он будет использоваться как параметр пути.
+* Если параметр также объявлен в **пути**, он будет использоваться как path-параметр.
 * Если параметр имеет **скалярный тип** (например, `int`, `float`, `str`, `bool` и т. п.), он будет интерпретирован как параметр **запроса**.
 * Если параметр объявлен как тип **модели Pydantic**, он будет интерпретирован как **тело** запроса.
 
@@ -161,7 +155,7 @@ JSON Schema ваших моделей будет частью сгенериро
 
 FastAPI понимает, что значение `q` не является обязательным из-за значения по умолчанию `= None`.
 
-Аннотации типов `str | None` (Python 3.10+) или `Union[str, None]` (Python 3.9+) не используются FastAPI для определения обязательности; он узнает, что параметр не обязателен, потому что у него есть значение по умолчанию `= None`.
+Аннотации типов `str | None` (Python 3.10+) или `Union` в `Union[str, None]` (Python 3.9+) не используются FastAPI для определения обязательности; он узнает, что параметр не обязателен, потому что у него есть значение по умолчанию `= None`.
 
 Но добавление аннотаций типов позволит вашему редактору кода лучше вас поддерживать и обнаруживать ошибки.
 
@@ -169,4 +163,4 @@ FastAPI понимает, что значение `q` не является об
 
 ## Без Pydantic { #without-pydantic }
 
-Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры **Body**. См. раздел документации [Тело — Несколько параметров: Единичные значения в теле](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.
+Если вы не хотите использовать модели Pydantic, вы также можете использовать параметры **Body**. См. раздел документации [Тело запроса - Несколько параметров: Единичные значения в теле](body-multiple-params.md#singular-values-in-body){.internal-link target=_blank}.

docs/ru/docs/tutorial/extra-models.md

@@ -22,21 +22,13 @@
 
 {* ../../docs_src/extra_models/tutorial001_py310.py hl[7,9,14,20,22,27:28,31:33,38:39] *}
 
-/// info | Информация
+### Про `**user_in.model_dump()` { #about-user-in-model-dump }
 
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он помечен как устаревший (но всё ещё поддерживается) и переименован в `.model_dump()`.
+#### `.model_dump()` из Pydantic { #pydantics-model-dump }
 
-В примерах здесь используется `.dict()` для совместимости с Pydantic v1, но если вы используете Pydantic v2, следует использовать `.model_dump()`.
+`user_in` — это Pydantic-модель класса `UserIn`.
 
-///
-
-### Про `**user_in.dict()` { #about-user-in-dict }
-
-#### `.dict()` из Pydantic { #pydantics-dict }
-
-`user_in` - это Pydantic-модель класса `UserIn`.
-
-У Pydantic-моделей есть метод `.dict()`, который возвращает `dict` с данными модели.
+У Pydantic-моделей есть метод `.model_dump()`, который возвращает `dict` с данными модели.
 
 Поэтому, если мы создадим Pydantic-объект `user_in` таким способом:
 
@@ -47,10 +39,10 @@ user_in = UserIn(username="john", password="secret", email="john.doe@example.com
 и затем вызовем:
 
 ```Python
-user_dict = user_in.dict()
+user_dict = user_in.model_dump()
 ```
 
-то теперь у нас есть `dict` с данными модели в переменной `user_dict` (это `dict` вместо объекта Pydantic-модели).
+то теперь у нас есть `dict` с данными в переменной `user_dict` (это `dict` вместо объекта Pydantic-модели).
 
 И если мы вызовем:
 
@@ -58,7 +50,7 @@ user_dict = user_in.dict()
 print(user_dict)
 ```
 
-мы можем получить `dict` с такими данными:
+мы получим Python `dict` с:
 
 ```Python
 {
@@ -71,7 +63,7 @@ print(user_dict)
 
 #### Распаковка `dict` { #unpacking-a-dict }
 
-Если мы возьмём `dict` наподобие `user_dict` и передадим его в функцию (или класс), используя `**user_dict`, Python распакует его. Он передаст ключи и значения `user_dict` напрямую как аргументы типа ключ-значение.
+Если мы возьмём `dict` наподобие `user_dict` и передадим его в функцию (или класс), используя `**user_dict`, Python его "распакует". Он передаст ключи и значения `user_dict` напрямую как аргументы типа ключ-значение.
 
 Поэтому, продолжая описанный выше пример с `user_dict`, написание такого кода:
 
@@ -79,7 +71,7 @@ print(user_dict)
 UserInDB(**user_dict)
 ```
 
-Будет работать так же, как примерно такой код:
+будет эквивалентно:
 
 ```Python
 UserInDB(
@@ -90,7 +82,7 @@ UserInDB(
 )
 ```
 
-Или, если для большей точности мы напрямую используем `user_dict` с любым потенциальным содержимым, то этот пример будет выглядеть так:
+Или, более точно, если использовать `user_dict` напрямую, с любым содержимым, которое он может иметь в будущем:
 
 ```Python
 UserInDB(
@@ -101,22 +93,22 @@ UserInDB(
 )
 ```
 
-#### Pydantic-модель из содержимого другой модели { #a-pydantic-model-from-the-contents-of-another }
+#### Pydantic-модель из содержимого другой { #a-pydantic-model-from-the-contents-of-another }
 
-Как в примере выше мы получили `user_dict` из `user_in.dict()`, этот код:
+Как в примере выше мы получили `user_dict` из `user_in.model_dump()`, этот код:
 
 ```Python
-user_dict = user_in.dict()
+user_dict = user_in.model_dump()
 UserInDB(**user_dict)
 ```
 
 будет равнозначен такому:
 
 ```Python
-UserInDB(**user_in.dict())
+UserInDB(**user_in.model_dump())
 ```
 
-...потому что `user_in.dict()` - это `dict`, и затем мы указываем, чтобы Python его "распаковал", когда передаём его в `UserInDB` и ставим перед ним `**`.
+...потому что `user_in.model_dump()` — это `dict`, и затем мы указываем, чтобы Python его "распаковал", когда передаём его в `UserInDB` с префиксом `**`.
 
 Таким образом мы получаем Pydantic-модель на основе данных из другой Pydantic-модели.
 
@@ -125,10 +117,10 @@ UserInDB(**user_in.dict())
 И затем, если мы добавим дополнительный именованный аргумент `hashed_password=hashed_password` как здесь:
 
 ```Python
-UserInDB(**user_in.dict(), hashed_password=hashed_password)
+UserInDB(**user_in.model_dump(), hashed_password=hashed_password)
 ```
 
-... то мы получим что-то подобное:
+...то в итоге получится что-то подобное:
 
 ```Python
 UserInDB(
@@ -142,13 +134,13 @@ UserInDB(
 
 /// warning | Предупреждение
 
-Вспомогательные функции `fake_password_hasher` и `fake_save_user` используются только для демонстрации возможного потока данных и, конечно, не обеспечивают настоящую безопасность.
+Вспомогательные дополнительные функции `fake_password_hasher` и `fake_save_user` используются только для демонстрации возможного потока данных и, конечно, не обеспечивают настоящую безопасность.
 
 ///
 
 ## Сократите дублирование { #reduce-duplication }
 
-Сокращение дублирования кода - это одна из главных идей **FastAPI**.
+Сокращение дублирования кода — это одна из главных идей **FastAPI**.
 
 Поскольку дублирование кода повышает риск появления багов, проблем с безопасностью, проблем десинхронизации кода (когда вы обновляете код в одном месте, но не обновляете в другом), и т.д.
 
@@ -166,7 +158,7 @@ UserInDB(
 
 ## `Union` или `anyOf` { #union-or-anyof }
 
-Вы можете определить ответ как `Union` из двух или более типов. Это означает, что ответ должен соответствовать одному из них.
+Вы можете объявить HTTP-ответ как `Union` из двух или более типов. Это означает, что HTTP-ответ может быть любым из них.
 
 Он будет определён в OpenAPI как `anyOf`.
 
@@ -174,7 +166,7 @@ UserInDB(
 
 /// note | Примечание
 
-При объявлении <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a>, сначала указывайте наиболее детальные типы, затем менее детальные. В примере ниже более детальный `PlaneItem` стоит перед `CarItem` в `Union[PlaneItem, CarItem]`.
+При объявлении <a href="https://docs.pydantic.dev/latest/concepts/types/#unions" class="external-link" target="_blank">`Union`</a> сначала указывайте наиболее специфичный тип, затем менее специфичный. В примере ниже более специфичный `PlaneItem` стоит перед `CarItem` в `Union[PlaneItem, CarItem]`.
 
 ///
 
@@ -192,19 +184,19 @@ UserInDB(
 some_variable: PlaneItem | CarItem
 ```
 
-Но если мы помещаем его в `response_model=PlaneItem | CarItem` мы получим ошибку, потому что Python попытается произвести **некорректную операцию** между `PlaneItem` и `CarItem` вместо того, чтобы интерпретировать это как аннотацию типа.
+Но если мы поместим это в присваивание `response_model=PlaneItem | CarItem`, мы получим ошибку, потому что Python попытается произвести **некорректную операцию** между `PlaneItem` и `CarItem` вместо того, чтобы интерпретировать это как аннотацию типа.
 
 ## Список моделей { #list-of-models }
 
-Таким же образом вы можете определять ответы как списки объектов.
+Таким же образом вы можете объявлять HTTP-ответы, возвращающие списки объектов.
 
-Для этого используйте `typing.List` из стандартной библиотеки Python (или просто `list` в Python 3.9 и выше):
+Для этого используйте стандартный `typing.List` в Python (или просто `list` в Python 3.9 и выше):
 
 {* ../../docs_src/extra_models/tutorial004_py39.py hl[18] *}
 
 ## Ответ с произвольным `dict` { #response-with-arbitrary-dict }
 
-Вы также можете определить ответ, используя произвольный одноуровневый `dict` и определяя только типы ключей и значений без использования Pydantic-моделей.
+Вы также можете объявить HTTP-ответ, используя обычный произвольный `dict`, объявив только тип ключей и значений, без использования Pydantic-модели.
 
 Это полезно, если вы заранее не знаете корректных названий полей/атрибутов (которые будут нужны при использовании Pydantic-модели).
 
@@ -214,6 +206,6 @@ some_variable: PlaneItem | CarItem
 
 ## Резюме { #recap }
 
-Используйте несколько Pydantic-моделей и свободно применяйте наследование для каждой из них.
+Используйте несколько Pydantic-моделей и свободно применяйте наследование для каждого случая.
 
-Вам не обязательно иметь единственную модель данных для каждой сущности, если эта сущность должна иметь возможность быть в разных "состояниях". Как в случае с "сущностью" пользователя, у которого есть состояния с полями `password`, `password_hash` и без пароля.
+Вам не обязательно иметь единственную модель данных для каждой сущности, если эта сущность должна иметь возможность быть в разных "состояниях". Как в случае с "сущностью" пользователя, у которого есть состояние, включающее `password`, `password_hash` и отсутствие пароля.

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

@@ -8,7 +8,7 @@
 
 Query-параметр `q` имеет тип `str | None`, это означает, что он имеет тип `str`, но также может быть `None`. Значение по умолчанию действительно `None`, поэтому FastAPI будет знать, что он не обязателен.
 
-/// note | Технические детали
+/// note | Примечание
 
 FastAPI поймёт, что значение `q` не обязательно, из‑за значения по умолчанию `= None`.
 
@@ -177,7 +177,7 @@ q: str = Query(default="rick")
 
 **Значение по умолчанию** у **параметра функции** — это **настоящее значение по умолчанию**, что более интуитивно для Python. 😌
 
-Вы можете **вызвать** эту же функцию в **других местах** без FastAPI, и она будет **работать как ожидается**. Если есть **обязательный** параметр (без значения по умолчанию), ваш **редактор кода** сообщит об ошибке, **Python** тоже пожалуется, если вы запустите её без передачи обязательного параметра.
+Вы можете **вызвать** эту же функцию в **других местах** без FastAPI, и она будет **работать как ожидается**. Если есть **обязательный** параметр (без значения по умолчанию), ваш **редактор** сообщит об ошибке, **Python** тоже пожалуется, если вы запустите её без передачи обязательного параметра.
 
 Если вы не используете `Annotated`, а применяете **(устаревший) стиль со значением по умолчанию**, то при вызове этой функции без FastAPI в **других местах** вам нужно **помнить** о том, что надо передать аргументы, чтобы всё работало корректно, иначе значения будут не такими, как вы ожидаете (например, вместо `str` будет `QueryInfo` или что-то подобное). И ни редактор, ни Python не будут ругаться при самом вызове функции — ошибка проявится лишь при операциях внутри.
 
@@ -191,7 +191,7 @@ q: str = Query(default="rick")
 
 ## Регулярные выражения { #add-regular-expressions }
 
-Вы можете определить <abbr title="Регулярное выражение (regex, regexp) — это последовательность символов, задающая шаблон поиска для строк.">регулярное выражение</abbr> `pattern`, которому должен соответствовать параметр:
+Вы можете определить <abbr title="Регулярное выражение (regex, regexp) - это последовательность символов, задающая шаблон поиска для строк.">регулярное выражение</abbr> `pattern`, которому должен соответствовать параметр:
 
 {* ../../docs_src/query_params_str_validations/tutorial004_an_py310.py hl[11] *}
 
@@ -205,20 +205,6 @@ q: str = Query(default="rick")
 
 Теперь вы знаете, что когда они понадобятся, вы сможете использовать их в **FastAPI**.
 
-### `regex` из Pydantic v1 вместо `pattern` { #pydantic-v1-regex-instead-of-pattern }
-
-До Pydantic версии 2 и до FastAPI 0.100.0 этот параметр назывался `regex`, а не `pattern`, но сейчас он устарел.
-
-Вы всё ещё можете встретить такой код:
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/query_params_str_validations/tutorial004_regex_an_py310.py hl[11] *}
-
-////
-
-Имейте в виду, что это устарело, и код следует обновить на использование нового параметра `pattern`. 🤓
-
 ## Значения по умолчанию { #default-values }
 
 Конечно, можно использовать и другие значения по умолчанию, не только `None`.
@@ -279,7 +265,7 @@ q: Annotated[str | None, Query(min_length=3)] = None
 http://localhost:8000/items/?q=foo&q=bar
 ```
 
-вы получите множественные значения query-параметра `q` (`foo` и `bar`) в виде Python-`list` внутри вашей *функции обработки пути*, в *параметре функции* `q`.
+вы получите множественные значения *query-параметров* `q` (`foo` и `bar`) в виде Python-`list` внутри вашей *функции-обработчика пути*, в *параметре функции* `q`.
 
 Таким образом, ответ на этот URL будет:
 
@@ -331,7 +317,7 @@ http://localhost:8000/items/
 
 {* ../../docs_src/query_params_str_validations/tutorial013_an_py39.py hl[9] *}
 
-/// note | Технические детали
+/// note | Примечание
 
 Имейте в виду, что в этом случае FastAPI не будет проверять содержимое списка.
 
@@ -345,7 +331,7 @@ http://localhost:8000/items/
 
 Эта информация будет включена в сгенерированную OpenAPI-схему и использована интерфейсами документации и внешними инструментами.
 
-/// note | Технические детали
+/// note | Примечание
 
 Помните, что разные инструменты могут иметь разный уровень поддержки OpenAPI.
 
@@ -415,7 +401,7 @@ http://127.0.0.1:8000/items/?item-query=foobaritems
 
 ///
 
-Например, эта кастомная проверка убеждается, что ID элемента начинается с `isbn-` для номера книги <abbr title="ISBN означает International Standard Book Number – Международный стандартный книжный номер">ISBN</abbr> или с `imdb-` для ID URL фильма на <abbr title="IMDB (Internet Movie Database) — веб‑сайт с информацией о фильмах">IMDB</abbr>:
+Например, эта кастомная проверка убеждается, что ID элемента начинается с `isbn-` для номера книги <abbr title="ISBN означает International Standard Book Number - Международный стандартный книжный номер">ISBN</abbr> или с `imdb-` для ID URL фильма на <abbr title="IMDB (Internet Movie Database) - веб‑сайт с информацией о фильмах">IMDB</abbr>:
 
 {* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
 
@@ -455,7 +441,7 @@ http://127.0.0.1:8000/items/?item-query=foobaritems
 
 Затем с `random.choice()` можно получить **случайное значение** из списка — то есть кортеж вида `(id, name)`. Это будет что‑то вроде `("imdb-tt0371724", "The Hitchhiker's Guide to the Galaxy")`.
 
-После этого мы **распаковываем** эти два значения кортежа в переменные `id` и `name`.
+После этого мы **присваиваем эти два значения** кортежа переменным `id` и `name`.
 
 Так что, если пользователь не передал ID элемента, он всё равно получит случайную рекомендацию.
 

docs/ru/docs/tutorial/response-model.md

@@ -6,11 +6,11 @@
 
 {* ../../docs_src/response_model/tutorial001_01_py310.py hl[16,21] *}
 
-FastAPI будет использовать этот тип ответа для:
+FastAPI будет использовать этот возвращаемый тип, чтобы:
 
-* **Валидации** возвращаемых данных.
-    * Если данные невалидны (например, отсутствует поле), это означает, что код *вашего* приложения работает некорректно и возвращает не то, что должен. В таком случае будет возвращена ошибка сервера вместо неправильных данных. Так вы и ваши клиенты можете быть уверены, что получите ожидаемые данные и ожидаемую структуру.
-* Добавления **JSON Schema** для ответа в OpenAPI *операции пути*.
+* **Валидировать** возвращаемые данные.
+    * Если данные невалидны (например, отсутствует поле), это означает, что код *вашего* приложения работает некорректно и возвращает не то, что должен. В таком случае будет возвращена ошибка сервера вместо неправильных данных. Так вы и ваши клиенты можете быть уверены, что получите ожидаемые данные и ожидаемую структуру данных.
+* Добавить **JSON Schema** для ответа в OpenAPI *операции пути*.
     * Это будет использовано **автоматической документацией**.
     * Это также будет использовано инструментами автоматической генерации клиентского кода.
 
@@ -23,7 +23,7 @@ FastAPI будет использовать этот тип ответа для:
 
 Бывают случаи, когда вам нужно или хочется возвращать данные, которые не в точности соответствуют объявленному типу.
 
-Например, вы можете хотеть **возвращать словарь (dict)** или объект из базы данных, но **объявить его как Pydantic-модель**. Тогда Pydantic-модель выполнит документирование данных, валидацию и т.п. для объекта, который вы вернули (например, словаря или объекта из базы данных).
+Например, вы можете хотеть **возвращать словарь** или объект из базы данных, но **объявить его как Pydantic-модель**. Тогда Pydantic-модель выполнит документирование данных, валидацию и т.п. для объекта, который вы вернули (например, словаря или объекта из базы данных).
 
 Если вы добавите аннотацию возвращаемого типа, инструменты и редакторы кода начнут жаловаться (и будут правы), что функция возвращает тип (например, dict), отличный от объявленного (например, Pydantic-модель).
 
@@ -47,13 +47,13 @@ FastAPI будет использовать этот тип ответа для:
 
 `response_model` принимает тот же тип, что вы бы объявили для поля Pydantic-модели, то есть это может быть одна Pydantic-модель, а может быть, например, `list` Pydantic-моделей, как `List[Item]`.
 
-FastAPI будет использовать `response_model` для документации, валидации и т. п., а также для **конвертации и фильтрации выходных данных** к объявленному типу.
+FastAPI будет использовать этот `response_model` для документирования, валидации данных и т.п., а также для **конвертации и фильтрации выходных данных** к объявленному типу.
 
 /// tip | Совет
 
-Если у вас в редакторе кода, mypy и т. п. включены строгие проверки типов, вы можете объявить возвращаемый тип функции как `Any`.
+Если у вас в редакторе кода, mypy и т.п. включены строгие проверки типов, вы можете объявить возвращаемый тип функции как `Any`.
 
-Так вы сообщите редактору, что намеренно возвращаете что угодно. Но FastAPI всё равно выполнит документацию данных, валидацию, фильтрацию и т.д. с помощью `response_model`.
+Так вы сообщите редактору, что намеренно возвращаете что угодно. Но FastAPI всё равно выполнит документирование, валидацию, фильтрацию данных и т.д. с помощью `response_model`.
 
 ///
 
@@ -61,7 +61,7 @@ FastAPI будет использовать `response_model` для докуме
 
 Если вы объявите и возвращаемый тип, и `response_model`, приоритет будет у `response_model`, именно его использует FastAPI.
 
-Так вы можете добавить корректные аннотации типов к своим функциям, даже если фактически возвращаете тип, отличный от модели ответа, чтобы ими пользовались редактор и инструменты вроде mypy. И при этом FastAPI продолжит выполнять валидацию данных, документацию и т.д. с использованием `response_model`.
+Так вы можете добавить корректные аннотации типов к своим функциям, даже если фактически возвращаете тип, отличный от модели ответа, чтобы ими пользовались редактор кода и инструменты вроде mypy. И при этом FastAPI продолжит выполнять валидацию данных, документацию и т.д. с использованием `response_model`.
 
 Вы также можете указать `response_model=None`, чтобы отключить создание модели ответа для данной *операции пути*. Это может понадобиться, если вы добавляете аннотации типов для вещей, не являющихся валидными полями Pydantic. Пример вы увидите ниже.
 
@@ -75,7 +75,7 @@ FastAPI будет использовать `response_model` для докуме
 
 Чтобы использовать `EmailStr`, сначала установите <a href="https://github.com/JoshData/python-email-validator" class="external-link" target="_blank">`email-validator`</a>.
 
-Создайте [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активируйте его и затем установите пакет, например:
+Убедитесь, что вы создали [виртуальное окружение](../virtual-environments.md){.internal-link target=_blank}, активировали его, а затем установите пакет, например:
 
 ```console
 $ pip install email-validator
@@ -105,7 +105,7 @@ $ pip install "pydantic[email]"
 
 ///
 
-## Добавить модель для ответа { #add-an-output-model }
+## Добавить выходную модель { #add-an-output-model }
 
 Вместо этого мы можем создать входную модель с паролем в открытом виде и выходную модель без него:
 
@@ -123,7 +123,7 @@ $ pip install "pydantic[email]"
 
 ### `response_model` или возвращаемый тип { #response-model-or-return-type }
 
-В этом случае, поскольку две модели различаются, если бы мы аннотировали возвращаемый тип функции как `UserOut`, редактор и инструменты пожаловались бы, что мы возвращаем неверный тип, так как это разные классы.
+В этом случае, поскольку две модели различаются, если бы мы аннотировали возвращаемый тип функции как `UserOut`, редактор кода и инструменты пожаловались бы, что мы возвращаем неверный тип, так как это разные классы.
 
 Поэтому в этом примере мы должны объявить тип ответа в параметре `response_model`.
 
@@ -135,33 +135,33 @@ $ pip install "pydantic[email]"
 
 Мы хотим, чтобы FastAPI продолжал **фильтровать** данные с помощью модели ответа. Так что, даже если функция возвращает больше данных, в ответ будут включены только поля, объявленные в модели ответа.
 
-В предыдущем примере, поскольку классы были разными, нам пришлось использовать параметр `response_model`. Но это также означает, что мы теряем поддержку от редактора и инструментов, проверяющих возвращаемый тип функции.
+В предыдущем примере, поскольку классы были разными, нам пришлось использовать параметр `response_model`. Но это также означает, что мы теряем поддержку от редактора кода и инструментов, проверяющих возвращаемый тип функции.
 
 Однако в большинстве таких случаев нам нужно лишь **отфильтровать/убрать** некоторые данные, как в этом примере.
 
-И в этих случаях мы можем использовать классы и наследование, чтобы воспользоваться **аннотациями типов** функций для лучшей поддержки в редакторе и инструментах и при этом получить **фильтрацию данных** от FastAPI.
+И в этих случаях мы можем использовать классы и наследование, чтобы воспользоваться **аннотациями типов** функций для лучшей поддержки в редакторе кода и инструментах и при этом получить **фильтрацию данных** от FastAPI.
 
 {* ../../docs_src/response_model/tutorial003_01_py310.py hl[7:10,13:14,18] *}
 
-Так мы получаем поддержку инструментов (редакторы, mypy) — код корректен с точки зрения типов — и одновременно получаем фильтрацию данных от FastAPI.
+Так мы получаем поддержку инструментов — редакторов кода и mypy, так как этот код корректен с точки зрения типов — и одновременно получаем фильтрацию данных от FastAPI.
 
 Как это работает? Давайте разберёмся. 🤓
 
 ### Аннотации типов и инструменты { #type-annotations-and-tooling }
 
-Сначала посмотрим, как это увидят редакторы, mypy и другие инструменты.
+Сначала посмотрим, как это увидят редактор кода, mypy и другие инструменты.
 
-`BaseUser` содержит базовые поля. Затем `UserIn` наследуется от `BaseUser` и добавляет поле `password`, то есть он включает все поля обеих моделей.
+`BaseUser` содержит базовые поля. Затем `UserIn` наследуется от `BaseUser` и добавляет поле `password`, то есть он будет включать все поля обеих моделей.
 
 Мы аннотируем возвращаемый тип функции как `BaseUser`, но фактически возвращаем экземпляр `UserIn`.
 
-Редактор, mypy и другие инструменты не будут возражать, потому что с точки зрения типов `UserIn` — подкласс `BaseUser`, что означает, что это *валидный* тип везде, где ожидается что-то, являющееся `BaseUser`.
+Редактор кода, mypy и другие инструменты не будут возражать, потому что с точки зрения типов `UserIn` — подкласс `BaseUser`, что означает, что это *валидный* тип везде, где ожидается что-то, являющееся `BaseUser`.
 
 ### Фильтрация данных FastAPI { #fastapi-data-filtering }
 
-Теперь, для FastAPI: он увидит возвращаемый тип и убедится, что то, что вы возвращаете, включает **только** поля, объявленные в этом типе.
+Теперь для FastAPI: он увидит возвращаемый тип и убедится, что то, что вы возвращаете, включает **только** поля, объявленные в этом типе.
 
-FastAPI делает несколько вещей внутри вместе с Pydantic, чтобы гарантировать, что те же правила наследования классов не используются для фильтрации возвращаемых данных, иначе вы могли бы вернуть гораздо больше данных, чем ожидали.
+FastAPI делает несколько вещей внутри вместе с Pydantic, чтобы гарантировать, что те же правила наследования классов не используются для фильтрации возвращаемых данных, иначе вы могли бы в итоге вернуть намного больше данных, чем ожидали.
 
 Таким образом вы получаете лучшее из обоих миров: аннотации типов с **поддержкой инструментов** и **фильтрацию данных**.
 
@@ -171,17 +171,17 @@ FastAPI делает несколько вещей внутри вместе с
 
 <img src="/img/tutorial/response-model/image01.png">
 
-И обе модели используются в интерактивной документации API:
+И обе модели будут использоваться в интерактивной документации API:
 
 <img src="/img/tutorial/response-model/image02.png">
 
 ## Другие аннотации возвращаемых типов { #other-return-type-annotations }
 
-Бывают случаи, когда вы возвращаете что-то, что не является валидным полем Pydantic, и аннотируете это в функции только ради поддержки инструментов (редактор, mypy и т. д.).
+Бывают случаи, когда вы возвращаете что-то, что не является валидным полем Pydantic, и аннотируете это в функции только ради поддержки инструментов (редактор кода, mypy и т.д.).
 
 ### Возврат Response напрямую { #return-a-response-directly }
 
-Самый распространённый случай — [возвращать Response напрямую, как описано далее в разделах для продвинутых](../advanced/response-directly.md){.internal-link target=_blank}.
+Самый распространённый случай — [возвращать Response напрямую, как описано далее в разделах документации для продвинутых](../advanced/response-directly.md){.internal-link target=_blank}.
 
 {* ../../docs_src/response_model/tutorial003_02_py39.py hl[8,10:11] *}
 
@@ -195,7 +195,7 @@ FastAPI делает несколько вещей внутри вместе с
 
 {* ../../docs_src/response_model/tutorial003_03_py39.py hl[8:9] *}
 
-Это тоже сработает, так как `RedirectResponse` — подкласс `Response`, и FastAPI автоматически обработает этот случай.
+Это тоже сработает, так как `RedirectResponse` — подкласс `Response`, и FastAPI автоматически обработает этот простой случай.
 
 ### Некорректные аннотации возвращаемых типов { #invalid-return-type-annotations }
 
@@ -209,15 +209,15 @@ FastAPI делает несколько вещей внутри вместе с
 
 ### Отключить модель ответа { #disable-response-model }
 
-Продолжая пример выше, вы можете не хотеть использовать стандартную валидацию данных, документацию, фильтрацию и т.д., выполняемые FastAPI.
+Продолжая пример выше, вы можете не хотеть использовать стандартные валидацию данных, документирование, фильтрацию и т.п., выполняемые FastAPI.
 
-Но при этом вы можете хотеть сохранить аннотацию возвращаемого типа в функции, чтобы пользоваться поддержкой инструментов (редакторы, проверки типов вроде mypy).
+Но при этом вы можете хотеть сохранить аннотацию возвращаемого типа в функции, чтобы пользоваться поддержкой инструментов вроде редакторов кода и инструментов проверки типов (например, mypy).
 
 В этом случае вы можете отключить генерацию модели ответа, установив `response_model=None`:
 
 {* ../../docs_src/response_model/tutorial003_05_py310.py hl[7] *}
 
-Так FastAPI пропустит генерацию модели ответа, и вы сможете использовать любые аннотации возвращаемых типов, не влияя на ваше приложение FastAPI. 🤓
+Так FastAPI пропустит генерацию модели ответа, и вы сможете использовать любые аннотации возвращаемых типов, которые вам нужны, без влияния на ваше приложение FastAPI. 🤓
 
 ## Параметры кодирования модели ответа { #response-model-encoding-parameters }
 
@@ -252,20 +252,6 @@ FastAPI делает несколько вещей внутри вместе с
 
 /// info | Информация
 
-В Pydantic v1 метод назывался `.dict()`, в Pydantic v2 он был помечен как устаревший (но всё ещё поддерживается) и переименован в `.model_dump()`.
-
-Примеры здесь используют `.dict()` для совместимости с Pydantic v1, но если вы используете Pydantic v2, применяйте `.model_dump()`.
-
-///
-
-/// info | Информация
-
-FastAPI использует метод `.dict()` у Pydantic-моделей с <a href="https://docs.pydantic.dev/1.10/usage/exporting_models/#modeldict" class="external-link" target="_blank">параметром `exclude_unset`</a>, чтобы добиться такого поведения.
-
-///
-
-/// info | Информация
-
 Вы также можете использовать:
 
 * `response_model_exclude_defaults=True`
@@ -312,7 +298,7 @@ FastAPI достаточно умен (на самом деле, это Pydantic
 
 Обратите внимание, что значения по умолчанию могут быть любыми, не только `None`.
 
-Это может быть список (`[]`), число с плавающей точкой `10.5` и т. д.
+Это может быть список (`[]`), число с плавающей точкой `10.5` и т.д.
 
 ///
 
@@ -346,7 +332,7 @@ FastAPI достаточно умен (на самом деле, это Pydantic
 
 #### Использование `list` вместо `set` { #using-lists-instead-of-sets }
 
-Если вы забыли использовать `set` и применили `list` или `tuple`, FastAPI всё равно преобразует это в `set`, и всё будет работать корректно:
+Если вы забыли использовать `set` и применили `list` или `tuple` вместо него, FastAPI всё равно преобразует это в `set`, и всё будет работать корректно:
 
 {* ../../docs_src/response_model/tutorial006_py310.py hl[29,35] *}
 

docs/ru/docs/tutorial/schema-extra-example.md

@@ -8,36 +8,14 @@
 
 Вы можете объявить `examples` для модели Pydantic, которые будут добавлены в сгенерированную JSON Schema.
 
-//// tab | Pydantic v2
-
 {* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
 
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/schema_extra_example/tutorial001_pv1_py310.py hl[13:23] *}
-
-////
-
 Эта дополнительная информация будет добавлена как есть в выходную **JSON Schema** этой модели и будет использоваться в документации API.
 
-//// tab | Pydantic v2
-
-В Pydantic версии 2 вы будете использовать атрибут `model_config`, который принимает `dict`, как описано в <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">Документации Pydantic: Конфигурация</a>.
+Вы можете использовать атрибут `model_config`, который принимает `dict`, как описано в <a href="https://docs.pydantic.dev/latest/api/config/" class="external-link" target="_blank">Документации Pydantic: Конфигурация</a>.
 
 Вы можете задать `"json_schema_extra"` с `dict`, содержащим любые дополнительные данные, которые вы хотите видеть в сгенерированной JSON Schema, включая `examples`.
 
-////
-
-//// tab | Pydantic v1
-
-В Pydantic версии 1 вы будете использовать внутренний класс `Config` и `schema_extra`, как описано в <a href="https://docs.pydantic.dev/1.10/usage/schema/#schema-customization" class="external-link" target="_blank">Документации Pydantic: Настройка схемы</a>.
-
-Вы можете задать `schema_extra` со `dict`, содержащим любые дополнительные данные, которые вы хотите видеть в сгенерированной JSON Schema, включая `examples`.
-
-////
-
 /// tip | Подсказка
 
 Вы можете использовать тот же приём, чтобы расширить JSON Schema и добавить свою собственную дополнительную информацию.
@@ -124,7 +102,7 @@ OpenAPI 3.1.0 (используется начиная с FastAPI 0.99.0) доб
 
 Ключи `dict` идентифицируют каждый пример, а каждое значение — это ещё один `dict`.
 
-Каждый конкретный пример‑`dict` в `examples` может содержать:
+Каждый конкретный пример `dict` в `examples` может содержать:
 
 * `summary`: Краткое описание примера.
 * `description`: Подробное описание, которое может содержать текст в Markdown.
@@ -135,7 +113,7 @@ OpenAPI 3.1.0 (используется начиная с FastAPI 0.99.0) доб
 
 {* ../../docs_src/schema_extra_example/tutorial005_an_py310.py hl[23:49] *}
 
-### OpenAPI-примеры  в UI документации { #openapi-examples-in-the-docs-ui }
+### OpenAPI-примеры в UI документации { #openapi-examples-in-the-docs-ui }
 
 С `openapi_examples`, добавленным в `Body()`, страница `/docs` будет выглядеть так:
 
@@ -213,7 +191,7 @@ OpenAPI также добавила поля `example` и `examples` в друг
 
 ### Swagger UI и специфичные для OpenAPI `examples` { #swagger-ui-and-openapi-specific-examples }
 
-Раньше, поскольку Swagger UI не поддерживал несколько примеров JSON Schema (по состоянию на 2023-08-26), у пользователей не было способа показать несколько примеров в документации.
+Теперь, поскольку Swagger UI не поддерживал несколько примеров JSON Schema (по состоянию на 2023-08-26), у пользователей не было способа показать несколько примеров в документации.
 
 Чтобы решить это, FastAPI `0.103.0` **добавил поддержку** объявления того же старого, **специфичного для OpenAPI**, поля `examples` с новым параметром `openapi_examples`. 🤓
 

docs/ru/llm-prompt.md

@@ -90,5 +90,12 @@ For the following technical terms, use these specific translations to ensure con
 * serve (meaning providing access to something): «отдавать» (or `предоставлять доступ к`)
 * recap (noun): резюме
 * utility function: вспомогательная функция
+* fast to code: позволяет быстро писать код
+* Tutorial - User Guide: Учебник - Руководство пользователя
+* submodule: подмодуль
+* subpackage: подпакет
+* router: роутер
+* building, deploying, accessing (when describing features of FastAPI Cloud): созданиe образа, развертывание и доступ
+* type checker tool: инструмент проверки типов
 
 Do not add whitespace in `т.д.`, `т.п.`.

docs/tr/docs/about/index.md

@@ -1,3 +1,3 @@
-# Hakkında
+# Hakkında { #about }
 
 FastAPI, tasarımı, ilham kaynağı ve daha fazlası hakkında. 🤓

docs/tr/docs/advanced/index.md

@@ -1,36 +1,21 @@
-# Gelişmiş Kullanıcı Rehberi
+# Gelişmiş Kullanıcı Rehberi { #advanced-user-guide }
 
-## Ek Özellikler
+## Ek Özellikler { #additional-features }
 
-[Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfası **FastAPI**'ın tüm ana özelliklerini tanıtmaya yetecektir.
+Ana [Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfası, **FastAPI**'ın tüm temel özelliklerini tanımanız için yeterli olmalıdır.
 
-İlerleyen bölümlerde diğer seçenekler, konfigürasyonlar ve ek özellikleri göreceğiz.
+Sonraki bölümlerde diğer seçenekleri, konfigürasyonları ve ek özellikleri göreceksiniz.
 
 /// tip | İpucu
 
 Sonraki bölümler **mutlaka "gelişmiş" olmak zorunda değildir**.
 
-Kullanım şeklinize bağlı olarak, çözümünüz bu bölümlerden birinde olabilir.
+Ve kullanım amacınıza bağlı olarak, çözüm bunlardan birinde olabilir.
 
 ///
 
-## Önce Öğreticiyi Okuyun
+## Önce Tutorial'ı Okuyun { #read-the-tutorial-first }
 
-[Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfasındaki bilgilerle **FastAPI**'nın çoğu özelliğini kullanabilirsiniz.
+Ana [Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfasındaki bilgilerle **FastAPI**'nın çoğu özelliğini yine de kullanabilirsiniz.
 
-Sonraki bölümler bu sayfayı okuduğunuzu ve bu ana fikirleri bildiğinizi varsayarak hazırlanmıştır.
-
-## Diğer Kurslar
-
-[Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfası ve bu **Gelişmiş Kullanıcı Rehberi**, öğretici bir kılavuz (bir kitap gibi) şeklinde yazılmıştır ve **FastAPI'ı öğrenmek** için yeterli olsa da, ek kurslarla desteklemek isteyebilirsiniz.
-
-Belki de öğrenme tarzınıza daha iyi uyduğu için başka kursları tercih edebilirsiniz.
-
-Bazı kurs sağlayıcıları ✨ [**FastAPI destekçileridir**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, bu FastAPI ve **ekosisteminin** sürekli ve sağlıklı bir şekilde **gelişmesini** sağlar.
-
-Ayrıca, size **iyi bir öğrenme deneyimi** sağlamakla kalmayıp, **iyi ve sağlıklı bir framework** olan FastAPI'a ve ve **topluluğuna** (yani size) olan gerçek bağlılıklarını gösterir.
-
-Onların kurslarını denemek isteyebilirsiniz:
-
-* <a href="https://training.talkpython.fm/fastapi-courses" class="external-link" target="_blank">Talk Python Training</a>
-* <a href="https://testdriven.io/courses/tdd-fastapi/" class="external-link" target="_blank">Test-Driven Development</a>
+Ve sonraki bölümler, onu zaten okuduğunuzu ve bu temel fikirleri bildiğinizi varsayar.

docs/tr/docs/advanced/security/index.md

@@ -1,6 +1,6 @@
-# Gelişmiş Güvenlik
+# Gelişmiş Güvenlik { #advanced-security }
 
-## Ek Özellikler
+## Ek Özellikler { #additional-features }
 
 [Tutorial - User Guide: Security](../../tutorial/security/index.md){.internal-link target=_blank} sayfasında ele alınanların dışında güvenlikle ilgili bazı ek özellikler vardır.
 
@@ -8,12 +8,12 @@
 
 Sonraki bölümler **mutlaka "gelişmiş" olmak zorunda değildir**.
 
-Kullanım şeklinize bağlı olarak, çözümünüz bu bölümlerden birinde olabilir.
+Ve kullanım durumunuza göre, çözüm bu bölümlerden birinde olabilir.
 
 ///
 
-## Önce Öğreticiyi Okuyun
+## Önce Öğreticiyi Okuyun { #read-the-tutorial-first }
 
-Sonraki bölümler [Tutorial - User Guide: Security](../../tutorial/security/index.md){.internal-link target=_blank} sayfasını okuduğunuzu varsayarak hazırlanmıştır.
+Sonraki bölümler, ana [Tutorial - User Guide: Security](../../tutorial/security/index.md){.internal-link target=_blank} sayfasını zaten okuduğunuzu varsayar.
 
-Bu bölümler aynı kavramlara dayanır, ancak bazı ek işlevsellikler sağlar.
+Hepsi aynı kavramlara dayanır, ancak bazı ek işlevselliklere izin verir.

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

@@ -1,13 +1,13 @@
-# WebSockets'i Test Etmek
+# WebSockets'i Test Etmek { #testing-websockets }
 
-WebSockets testi yapmak için `TestClient`'ı kullanabilirsiniz.
+WebSockets'i test etmek için aynı `TestClient`'ı kullanabilirsiniz.
 
-Bu işlem için, `TestClient`'ı bir `with` ifadesinde kullanarak WebSocket'e bağlanabilirsiniz:
+Bunun için `TestClient`'ı bir `with` ifadesinde kullanarak WebSocket'e bağlanırsınız:
 
-{* ../../docs_src/app_testing/tutorial002.py hl[27:31] *}
+{* ../../docs_src/app_testing/tutorial002_py39.py hl[27:31] *}
 
 /// note | Not
 
-Daha fazla detay için Starlette'in <a href="https://www.starlette.dev/staticfiles/" class="external-link" target="_blank">Websockets'i Test Etmek</a> dokümantasyonunu inceleyin.
+Daha fazla detay için Starlette'in <a href="https://www.starlette.dev/testclient/#testing-websocket-sessions" class="external-link" target="_blank">WebSockets'i test etme</a> dokümantasyonuna bakın.
 
 ///

docs/tr/docs/advanced/wsgi.md

@@ -1,32 +1,32 @@
-# WSGI - Flask, Django ve Daha Fazlasını FastAPI ile Kullanma
+# WSGI'yi Dahil Etme - Flask, Django ve Diğerleri { #including-wsgi-flask-django-others }
 
-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 bağlayabilirsiniz.
+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` ile Flask, Django vb. WSGI uygulamanızı sarmalayabilir ve FastAPI'ya bağlayabilirsiniz.
+Bunun için `WSGIMiddleware`'ı kullanabilir ve bunu WSGI uygulamanızı (örneğin Flask, Django vb.) sarmalamak için kullanabilirsiniz.
 
-## `WSGIMiddleware` Kullanımı
+## `WSGIMiddleware` Kullanımı { #using-wsgimiddleware }
 
-`WSGIMiddleware`'ı projenize dahil edin.
+`WSGIMiddleware`'ı import etmeniz gerekir.
 
-Ardından WSGI (örneğin Flask) uygulamanızı middleware ile sarmalayın.
+Ardından WSGI (örn. Flask) uygulamasını middleware ile sarmalayın.
 
-Son olarak da bir yol altında bağlama işlemini gerçekleştirin.
+Ve sonra bunu bir path'in altına mount edin.
 
-{* ../../docs_src/wsgi/tutorial001.py hl[2:3,23] *}
+{* ../../docs_src/wsgi/tutorial001_py39.py hl[2:3,3] *}
 
-## Kontrol Edelim
+## Kontrol Edelim { #check-it }
 
-Artık `/v1/` yolunun altındaki her istek Flask uygulaması tarafından işlenecektir.
+Artık `/v1/` path'i altındaki her request Flask uygulaması tarafından işlenecektir.
 
 Geri kalanı ise **FastAPI** tarafından işlenecektir.
 
-Eğer uygulamanızı çalıştırıp <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a> adresine giderseniz, Flask'tan gelen yanıtı göreceksiniz:
+Eğer uygulamanızı çalıştırıp <a href="http://localhost:8000/v1/" class="external-link" target="_blank">http://localhost:8000/v1/</a> adresine giderseniz, Flask'tan gelen response'u göreceksiniz:
 
 ```txt
 Hello, World from Flask!
 ```
 
-Eğer <a href="http://localhost:8000/v2/" class="external-link" target="_blank">http://localhost:8000/v2/</a> adresine giderseniz, FastAPI'dan gelen yanıtı göreceksiniz:
+Ve eğer <a href="http://localhost:8000/v2" class="external-link" target="_blank">http://localhost:8000/v2</a> adresine giderseniz, FastAPI'dan gelen response'u göreceksiniz:
 
 ```JSON
 {

docs/tr/docs/benchmarks.md

@@ -1,34 +1,34 @@
-# Kıyaslamalar
+# Kıyaslamalar { #benchmarks }
 
-Bağımsız TechEmpower kıyaslamaları gösteriyor ki <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">en hızlı Python frameworklerinden birisi</a> olan Uvicorn ile çalıştırılan **FastAPI** uygulamaları, sadece Starlette ve Uvicorn'dan daha düşük sıralamada (FastAPI bu frameworklerin üzerine kurulu) yer alıyor. (*)
+Bağımsız TechEmpower kıyaslamaları, Uvicorn altında çalışan **FastAPI** uygulamalarının <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">mevcut en hızlı Python frameworklerinden biri</a> olduğunu, yalnızca Starlette ve Uvicorn'un kendilerinin altında yer aldığını gösteriyor (FastAPI bunları dahili olarak kullanır).
 
 Fakat kıyaslamaları ve karşılaştırmaları incelerken şunları aklınızda bulundurmalısınız.
 
-## Kıyaslamalar ve Hız
+## Kıyaslamalar ve Hız { #benchmarks-and-speed }
 
-Kıyaslamaları incelediğinizde, farklı özelliklere sahip araçların eşdeğer olarak karşılaştırıldığını yaygın bir şekilde görebilirsiniz.
+Kıyaslamalara baktığınızda, farklı türlerdeki birkaç aracın eşdeğermiş gibi karşılaştırıldığını görmek yaygındır.
 
 Özellikle, (diğer birçok araç arasında) Uvicorn, Starlette ve FastAPI'ın birlikte karşılaştırıldığını görebilirsiniz.
 
-Aracın çözdüğü problem ne kadar basitse, performansı o kadar iyi olacaktır. Ancak kıyaslamaların çoğu, aracın sağladığı ek özellikleri test etmez.
+Aracın çözdüğü problem ne kadar basitse, elde edeceği performans o kadar iyi olur. Ayrıca kıyaslamaların çoğu, aracın sağladığı ek özellikleri test etmez.
 
 Hiyerarşi şöyledir:
 
 * **Uvicorn**: bir ASGI sunucusu
-    * **Starlette**: (Uvicorn'u kullanır) bir web mikroframeworkü
-        * **FastAPI**: (Starlette'i kullanır) veri doğrulama vb. çeşitli ek özelliklere sahip, API oluşturmak için kullanılan bir API mikroframeworkü
+    * **Starlette**: (Uvicorn'u kullanır) bir web mikroframework'ü
+        * **FastAPI**: (Starlette'i kullanır) veri doğrulama vb. ile API'lar oluşturmak için çeşitli ek özelliklere sahip bir API mikroframework'ü
 
 * **Uvicorn**:
-    * Sunucunun kendisi dışında ekstra bir kod içermediği için en iyi performansa sahip olacaktır.
-    * Doğrudan Uvicorn ile bir uygulama yazmazsınız. Bu, yazdığınız kodun en azından Starlette tarafından sağlanan tüm kodu (veya **FastAPI**) az çok içermesi gerektiği anlamına gelir. Eğer bunu yaptıysanız, son uygulamanız bir framework kullanmak ve uygulama kodlarını ve hataları en aza indirmekle aynı ek yüke sahip olacaktır.
-    * Eğer Uvicorn'u karşılaştırıyorsanız, Daphne, Hypercorn, uWSGI, vb. uygulama sunucuları ile karşılaştırın.
+    * Sunucunun kendisi dışında çok fazla ekstra kod içermediği için en iyi performansa sahip olacaktır.
+    * Uvicorn ile doğrudan bir uygulama yazmazsınız. Bu, kodunuzun en azından Starlette'in (veya **FastAPI**'ın) sağladığı kodun aşağı yukarı tamamını içermesi gerektiği anlamına gelir. Bunu yaparsanız, nihai uygulamanız; bir framework kullanmış olmanın ve uygulama kodunu ve bug'ları en aza indirmenin getirdiği ek yükle aynı ek yüke sahip olur.
+    * Uvicorn'u karşılaştırıyorsanız, Daphne, Hypercorn, uWSGI vb. application server'larla karşılaştırın.
 * **Starlette**:
-    * Uvicorn'dan sonraki en iyi performansa sahip olacaktır. İşin aslı, Starlette çalışmak için Uvicorn'u kullanıyor. Dolayısıyla, daha fazla kod çalıştırmaası gerektiğinden muhtemelen Uvicorn'dan sadece "daha yavaş" olabilir.
-    * Ancak yol bazlı yönlendirme vb. basit web uygulamaları oluşturmak için araçlar sağlar.
-    * Eğer Starlette'i karşılaştırıyorsanız, Sanic, Flask, Django, vb. frameworkler (veya mikroframeworkler) ile karşılaştırın.
+    * Uvicorn'dan sonra en iyi performansa sahip olacaktır. Aslında Starlette çalışmak için Uvicorn'u kullanır. Bu yüzden muhtemelen yalnızca daha fazla kod çalıştırmak zorunda kaldığı için Uvicorn'dan "daha yavaş" olabilir.
+    * Ancak path tabanlı routing vb. ile basit web uygulamaları oluşturmanız için araçlar sağlar.
+    * Starlette'i karşılaştırıyorsanız, Sanic, Flask, Django vb. web framework'lerle (veya mikroframework'lerle) karşılaştırın.
 * **FastAPI**:
-    * Starlette'in Uvicorn'u kullandığı ve ondan daha hızlı olamayacağı gibi, **FastAPI**'da Starlette'i kullanır, dolayısıyla ondan daha hızlı olamaz.
-    * FastAPI, Starlette'e ek olarak daha fazla özellik sunar. Bunlar veri doğrulama ve <abbr title="Dönüşüm: serialization, parsing, marshalling olarak da biliniyor">dönüşümü</abbr> gibi API'lar oluştururken neredeyse ve her zaman ihtiyaç duyduğunuz özelliklerdir. Ve bunu kullanarak, ücretsiz olarak otomatik dokümantasyon elde edersiniz (otomatik dokümantasyon çalışan uygulamalara ek yük getirmez, başlangıçta oluşturulur).
-    * FastAPI'ı kullanmadıysanız ve Starlette'i doğrudan kullandıysanız (veya başka bir araç, Sanic, Flask, Responder, vb.) tüm veri doğrulama ve dönüştürme araçlarını kendiniz geliştirmeniz gerekir. Dolayısıyla, son uygulamanız FastAPI kullanılarak oluşturulmuş gibi hâlâ aynı ek yüke sahip olacaktır. Çoğu durumda, uygulamalarda yazılan kodun büyük bir kısmını veri doğrulama ve dönüştürme kodları oluşturur.
-    * Dolayısıyla, FastAPI'ı kullanarak geliştirme süresinden, hatalardan, kod satırlarından tasarruf edersiniz ve kullanmadığınız durumda (birçok özelliği geliştirmek zorunda kalmakla birlikte) muhtemelen aynı performansı (veya daha iyisini) elde ederdiniz.
-    * Eğer FastAPI'ı karşılaştırıyorsanız, Flask-apispec, NestJS, Molten, vb. gibi veri doğrulama, dönüştürme ve dokümantasyon sağlayan bir web uygulaması frameworkü ile (veya araç setiyle) karşılaştırın.
+    * Starlette'in Uvicorn'u kullanıp ondan daha hızlı olamaması gibi, **FastAPI** da Starlette'i kullanır; dolayısıyla ondan daha hızlı olamaz.
+    * FastAPI, Starlette'in üzerine daha fazla özellik sağlar. API'lar oluştururken neredeyse her zaman ihtiyaç duyduğunuz veri doğrulama ve <abbr title="serialization - serileştirme">serialization</abbr> gibi özellikler. Ayrıca bunu kullanarak ücretsiz olarak otomatik dokümantasyon elde edersiniz (otomatik dokümantasyon, çalışan uygulamalara ek yük bile getirmez; startup'ta üretilir).
+    * FastAPI'ı kullanmayıp Starlette'i doğrudan kullansaydınız (veya Sanic, Flask, Responder vb. başka bir aracı), tüm veri doğrulama ve serialization işlemlerini kendiniz uygulamak zorunda kalırdınız. Dolayısıyla nihai uygulamanız, FastAPI kullanılarak inşa edilmiş olsaydı sahip olacağı ek yükle hâlâ aynı ek yüke sahip olurdu. Ve çoğu durumda, uygulamalarda yazılan en büyük kod miktarı veri doğrulama ve serialization kısmıdır.
+    * Bu nedenle FastAPI kullanarak geliştirme süresinden, bug'lardan, kod satırlarından tasarruf edersiniz; ayrıca muhtemelen, onu kullanmasaydınız (tüm bunları kodunuzda kendiniz uygulamak zorunda kalacağınız için) elde edeceğiniz performansın aynısını (veya daha iyisini) elde edersiniz.
+    * FastAPI'ı karşılaştırıyorsanız, Flask-apispec, NestJS, Molten vb. veri doğrulama, serialization ve dokümantasyon sağlayan bir web uygulaması framework'ü (veya araç seti) ile karşılaştırın. Entegre otomatik veri doğrulama, serialization ve dokümantasyona sahip framework'ler.

docs/tr/docs/deployment/cloud.md

@@ -1,13 +1,24 @@
-# FastAPI Uygulamasını Bulut Sağlayıcılar Üzerinde Yayınlama
+# Bulut Sağlayıcılar Üzerinde FastAPI Yayınlama { #deploy-fastapi-on-cloud-providers }
 
-FastAPI uygulamasını yayınlamak için hemen hemen **herhangi bir bulut sağlayıcıyı** kullanabilirsiniz.
+FastAPI uygulamanızı yayınlamak için neredeyse **herhangi bir bulut sağlayıcıyı** kullanabilirsiniz.
 
-Büyük bulut sağlayıcıların çoğu FastAPI uygulamasını yayınlamak için kılavuzlara sahiptir.
+Çoğu durumda, ana bulut sağlayıcıların FastAPI'yi onlarla birlikte yayınlamak için kılavuzları vardır.
 
-## Bulut Sağlayıcılar - Sponsorlar
+## FastAPI Cloud { #fastapi-cloud }
 
-Bazı bulut sağlayıcılar ✨ [**FastAPI destekçileridir**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨, bu FastAPI ve **ekosisteminin** sürekli ve sağlıklı bir şekilde **gelişmesini** sağlar.
+**<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.
 
-Ayrıca, size **iyi servisler** sağlamakla kalmayıp, **iyi ve sağlıklı bir framework** olan FastAPI'a bağlılıklarını gösterir.
+Bir API'yi minimum çabayla **oluşturma**, **yayınlama** ve **erişme** sürecini kolaylaştırır.
 
-Bu hizmetleri denemek ve kılavuzlarını incelemek isteyebilirsiniz.
+FastAPI ile uygulama geliştirirken elde edilen aynı **geliştirici deneyimini**, onları buluta **yayınlamaya** da taşır. 🎉
+
+FastAPI Cloud, *FastAPI and friends* açık kaynak projelerinin birincil sponsoru ve finansman sağlayıcısıdır. ✨
+
+## Bulut Sağlayıcılar - Sponsorlar { #cloud-providers-sponsors }
+
+Diğer bazı bulut sağlayıcılar da ✨ [**FastAPI'ye sponsor olur**](../help-fastapi.md#sponsor-the-author){.internal-link target=_blank} ✨. 🙇
+
+Kılavuzlarını takip etmek ve servislerini denemek için onları da değerlendirmek isteyebilirsiniz:
+
+* <a href="https://docs.render.com/deploy-fastapi?utm_source=deploydoc&utm_medium=referral&utm_campaign=fastapi" class="external-link" target="_blank">Render</a>
+* <a href="https://docs.railway.com/guides/fastapi?utm_medium=integration&utm_source=docs&utm_campaign=fastapi" class="external-link" target="_blank">Railway</a>

docs/tr/docs/deployment/index.md

@@ -1,21 +1,23 @@
-# Deployment (Yayınlama)
+# Deployment { #deployment }
 
-**FastAPI** uygulamasını deploy etmek oldukça kolaydır.
+**FastAPI** uygulamasını deploy etmek nispeten kolaydır.
 
-## Deployment Ne Anlama Gelir?
+## Deployment Ne Anlama Gelir? { #what-does-deployment-mean }
 
-Bir uygulamayı **deploy** etmek (yayınlamak), uygulamayı **kullanıcılara erişilebilir hale getirmek** için gerekli adımları gerçekleştirmek anlamına gelir.
+Bir uygulamayı **deploy** etmek, onu **kullanıcılara erişilebilir hale getirmek** için gerekli adımları gerçekleştirmek anlamına gelir.
 
-Bir **Web API** için bu süreç normalde uygulamayı **uzak bir makineye** yerleştirmeyi, iyi performans, kararlılık vb. özellikler sağlayan bir **sunucu programı** ile **kullanıcılarınızın** uygulamaya etkili ve kesintisiz bir şekilde **erişebilmesini** kapsar.
+Bir **web API** için bu süreç normalde uygulamayı **uzak bir makineye** yerleştirmeyi, iyi performans, kararlılık vb. özellikler sağlayan bir **sunucu programı** ile **kullanıcılarınızın** uygulamaya etkili ve kesintisiz bir şekilde, sorun yaşamadan **erişebilmesini** kapsar.
 
-Bu, kodu sürekli olarak değiştirdiğiniz, hata alıp hata giderdiğiniz, geliştirme sunucusunu durdurup yeniden başlattığınız vb. **geliştirme** aşamalarının tam tersidir.
+Bu, kodu sürekli olarak değiştirdiğiniz, bozup düzelttiğiniz, geliştirme sunucusunu durdurup yeniden başlattığınız vb. **geliştirme** aşamalarının tam tersidir.
 
-## Deployment Stratejileri
+## Deployment Stratejileri { #deployment-strategies }
 
-Kullanım durumunuza ve kullandığınız araçlara bağlı olarak bir kaç farklı yol izleyebilirsiniz.
+Kullanım durumunuza ve kullandığınız araçlara bağlı olarak bunu yapmanın birkaç yolu vardır.
 
-Bir dizi araç kombinasyonunu kullanarak kendiniz **bir sunucu yayınlayabilirsiniz**, yayınlama sürecinin bir kısmını sizin için gerçekleştiren bir **bulut hizmeti** veya diğer olası seçenekleri kullanabilirsiniz.
+Bir dizi araç kombinasyonunu kullanarak kendiniz **bir sunucu deploy edebilirsiniz**, yayınlama sürecinin bir kısmını sizin için gerçekleştiren bir **bulut hizmeti** veya diğer olası seçenekleri kullanabilirsiniz.
+
+Örneğin, FastAPI'nin arkasındaki ekip olarak, FastAPI uygulamalarını buluta mümkün olduğunca akıcı şekilde deploy etmeyi sağlamak için, FastAPI ile çalışmanın aynı geliştirici deneyimini sunarak <a href="https://fastapicloud.com" class="external-link" target="_blank">**FastAPI Cloud**</a>'u oluşturduk.
 
 **FastAPI** uygulamasını yayınlarken aklınızda bulundurmanız gereken ana kavramlardan bazılarını size göstereceğim (ancak bunların çoğu diğer web uygulamaları için de geçerlidir).
 
-Sonraki bölümlerde akılda tutulması gereken diğer ayrıntıları ve yayınlama tekniklerinden bazılarını göreceksiniz. ✨
+Sonraki bölümlerde akılda tutulması gereken diğer ayrıntıları ve bunu yapmaya yönelik bazı teknikleri göreceksiniz. ✨

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

@@ -1,39 +1,39 @@
-# Genel - Nasıl Yapılır - Tarifler
+# Genel - Nasıl Yapılır - Tarifler { #general-how-to-recipes }
 
-Bu sayfada genel ve sıkça sorulan sorular için dokümantasyonun diğer sayfalarına yönlendirmeler bulunmaktadır.
+Bu sayfada genel veya sık sorulan sorular için dokümantasyonun diğer bölümlerine çeşitli yönlendirmeler bulunmaktadır.
 
-## Veri Filtreleme - Güvenlik
+## Veri Filtreleme - Güvenlik { #filter-data-security }
 
-Döndürmeniz gereken veriden fazlasını döndürmediğinizden emin olmak için, [Tutorial - Response Model - Return Type](../tutorial/response-model.md){.internal-link target=_blank} sayfasını okuyun.
+Döndürmeniz gerekenden daha fazla veri döndürmediğinizden emin olmak için, [Tutorial - Response Model - Return Type](../tutorial/response-model.md){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## Dokümantasyon Etiketleri - OpenAPI
+## Dokümantasyon Etiketleri - OpenAPI { #documentation-tags-openapi }
 
-*Yol operasyonlarınıza* etiketler ekleyerek dokümantasyon arayüzünde gruplar halinde görünmesini sağlamak için, [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank} sayfasını okuyun.
+*path operation*'larınıza etiketler eklemek ve dokümantasyon arayüzünde gruplamak için, [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## Dokümantasyon Özeti ve Açıklaması - OpenAPI
+## Dokümantasyon Özeti ve Açıklaması - OpenAPI { #documentation-summary-and-description-openapi }
 
-*Yol operasyonlarınıza* özet ve açıklama ekleyip dokümantasyon arayüzünde görünmesini sağlamak için, [Tutorial - Path Operation Configurations - Summary and Description](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank} sayfasını okuyun.
+*path operation*'larınıza özet ve açıklama eklemek ve bunları dokümantasyon arayüzünde göstermek için, [Tutorial - Path Operation Configurations - Summary and Description](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## Yanıt Açıklaması Dokümantasyonu - OpenAPI
+## Dokümantasyon Yanıt Açıklaması - OpenAPI { #documentation-response-description-openapi }
 
-Dokümantasyon arayüzünde yer alan yanıt açıklamasını tanımlamak için, [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank} sayfasını okuyun.
+Dokümantasyon arayüzünde gösterilen response açıklamasını tanımlamak için, [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## *Yol Operasyonunu* Kullanımdan Kaldırma - OpenAPI
+## Dokümantasyonda Bir *Path Operation*'ı Kullanımdan Kaldırma - OpenAPI { #documentation-deprecate-a-path-operation-openapi }
 
-Bir *yol işlemi*ni kullanımdan kaldırmak ve bunu dokümantasyon arayüzünde göstermek için, [Tutorial - Path Operation Configurations - Deprecation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank} sayfasını okuyun.
+Bir *path operation*'ı kullanımdan kaldırmak ve bunu dokümantasyon arayüzünde göstermek için, [Tutorial - Path Operation Configurations - Deprecation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## Herhangi Bir Veriyi JSON Uyumlu Hale Getirme
+## Herhangi Bir Veriyi JSON Uyumlu Hale Getirme { #convert-any-data-to-json-compatible }
 
-Herhangi bir veriyi JSON uyumlu hale getirmek için, [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank} sayfasını okuyun.
+Herhangi bir veriyi JSON uyumlu hale getirmek için, [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## OpenAPI Meta Verileri - Dokümantasyon
+## OpenAPI Meta Verileri - Dokümantasyon { #openapi-metadata-docs }
 
-OpenAPI şemanıza lisans, sürüm, iletişim vb. meta veriler eklemek için, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md){.internal-link target=_blank} sayfasını okuyun.
+Lisans, sürüm, iletişim vb. dahil olmak üzere OpenAPI şemanıza meta veriler eklemek için, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## OpenAPI Bağlantı Özelleştirme
+## OpenAPI Özel URL { #openapi-custom-url }
 
-OpenAPI bağlantısını özelleştirmek (veya kaldırmak) için, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url){.internal-link target=_blank} sayfasını okuyun.
+OpenAPI URL'ini özelleştirmek (veya kaldırmak) için, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url){.internal-link target=_blank} dokümantasyonunu okuyun.
 
-## OpenAPI Dokümantasyon Bağlantıları
+## OpenAPI Dokümantasyon URL'leri { #openapi-docs-urls }
 
-Dokümantasyonu arayüzünde kullanılan bağlantıları güncellemek için, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls){.internal-link target=_blank} sayfasını okuyun.
+Otomatik olarak oluşturulan dokümantasyon kullanıcı arayüzlerinde kullanılan URL'leri güncellemek için, [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls){.internal-link target=_blank} dokümantasyonunu okuyun.

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

@@ -1,13 +1,13 @@
-# Nasıl Yapılır - Tarifler
+# Nasıl Yapılır - Tarifler { #how-to-recipes }
 
-Burada çeşitli konular hakkında farklı tarifler veya "nasıl yapılır" kılavuzları yer alıyor.
+Burada **çeşitli konular** hakkında farklı tarifler veya "nasıl yapılır" kılavuzları göreceksiniz.
 
-Bu fikirlerin büyük bir kısmı aşağı yukarı **bağımsız** olacaktır, çoğu durumda bunları sadece **projenize** hitap ediyorsa incelemelisiniz.
+Bu fikirlerin büyük bir kısmı aşağı yukarı **bağımsız** olacaktır ve çoğu durumda bunları yalnızca doğrudan **projenize** uygulanıyorsa incelemeniz yeterli olacaktır.
 
-Projeniz için ilginç ve yararlı görünen bir şey varsa devam edin ve inceleyin, aksi halde bunları atlayabilirsiniz.
+Projeniz için ilginç ve yararlı görünen bir şey varsa devam edin ve inceleyin; aksi halde muhtemelen bunları atlayabilirsiniz.
 
 /// tip | İpucu
 
-**FastAPI**'ı düzgün (ve önerilen) şekilde öğrenmek istiyorsanız [Öğretici - Kullanıcı Rehberi](../tutorial/index.md){.internal-link target=_blank}'ni bölüm bölüm okuyun.
+**FastAPI**'ı yapılandırılmış bir şekilde (önerilir) **öğrenmek** istiyorsanız bunun yerine [Öğretici - Kullanıcı Rehberi](../tutorial/index.md){.internal-link target=_blank}'ni bölüm bölüm okuyun.
 
 ///

docs/tr/docs/index.md

@@ -1,14 +1,14 @@
-# FastAPI
+# FastAPI { #fastapi }
 
 <style>
 .md-content .md-typeset h1 { display: none; }
 </style>
 
 <p align="center">
-  <a href="https://fastapi.tiangolo.com"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
+  <a href="https://fastapi.tiangolo.com/tr"><img src="https://fastapi.tiangolo.com/img/logo-margin/logo-teal.png" alt="FastAPI"></a>
 </p>
 <p align="center">
-    <em>FastAPI framework, yüksek performanslı, öğrenmesi oldukça kolay, kodlaması hızlı, kullanıma hazır</em>
+    <em>FastAPI framework, yüksek performanslı, öğrenmesi kolay, kodlaması hızlı, production'a hazır</em>
 </p>
 <p align="center">
 <a href="https://github.com/fastapi/fastapi/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster" target="_blank">
@@ -27,59 +27,65 @@
 
 ---
 
-**Dokümantasyon**: <a href="https://fastapi.tiangolo.com" target="_blank">https://fastapi.tiangolo.com</a>
+**Dokümantasyon**: <a href="https://fastapi.tiangolo.com/tr" target="_blank">https://fastapi.tiangolo.com</a>
 
 **Kaynak Kod**: <a href="https://github.com/fastapi/fastapi" target="_blank">https://github.com/fastapi/fastapi</a>
 
 ---
 
-FastAPI, Python 'nin standart <abbr title="Tip Belirteçleri: Type Hints">tip belirteçleri</abbr>ne dayalı, modern ve hızlı (yüksek performanslı) API'lar oluşturmak için kullanılabilecek web framework'tür.
+FastAPI, Python'un standart type hints'lerine dayalı olarak Python ile API'lar oluşturmak için kullanılan modern ve hızlı (yüksek performanslı) bir web framework'üdür.
 
 Temel özellikleri şunlardır:
 
-* **Hızlı**: Çok yüksek performanslı, **NodeJS** ve **Go** ile eşit düzeyde (Starlette ve Pydantic sayesinde). [En hızlı Python framework'lerinden bir tanesidir](#performans).
-* **Kodlaması Hızlı**: Geliştirme hızını yaklaşık %200 ile %300 aralığında arttırır. *
+* **Hızlı**: Çok yüksek performanslı, **NodeJS** ve **Go** ile eşit düzeyde (Starlette ve Pydantic sayesinde). [Mevcut en hızlı Python framework'lerinden biri](#performance).
+* **Kodlaması Hızlı**: Özellik geliştirme hızını yaklaşık %200 ile %300 aralığında artırır. *
 * **Daha az hata**: İnsan (geliştirici) kaynaklı hataları yaklaşık %40 azaltır. *
-* **Sezgisel**: Muhteşem bir editör desteği. Her yerde <abbr title="Otomatik Tamamlama: auto-complete, autocompletion, IntelliSense">otomatik tamamlama</abbr>. Hata ayıklama ile daha az zaman harcayacaksınız.
-* **Kolay**: Öğrenmesi ve kullanması kolay olacak şekilde tasarlandı. Doküman okuma ile daha az zaman harcayacaksınız.
-* **Kısa**: Kod tekrarı minimize edildi. Her parametre tanımlamasında birden fazla özellik ve daha az hatayla karşılaşacaksınız.
-* **Güçlü**: Otomatik ve etkileşimli dokümantasyon ile birlikte, kullanıma hazır kod elde edebilirsiniz.
-* **Standard öncelikli**: API'lar için açık standartlara dayalı (ve tamamen uyumlu); <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (eski adıyla Swagger) ve <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
+* **Sezgisel**: Harika bir editör desteği. Her yerde <abbr title="auto-complete, autocompletion, IntelliSense olarak da bilinir">Completion</abbr>. Hata ayıklamaya daha az zaman.
+* **Kolay**: Kullanımı ve öğrenmesi kolay olacak şekilde tasarlandı. Doküman okumaya daha az zaman.
+* **Kısa**: Kod tekrarını minimize eder. Her parametre tanımından birden fazla özellik. Daha az hata.
+* **Sağlam**: Production'a hazır kod elde edersiniz. Otomatik etkileşimli dokümantasyon ile birlikte.
+* **Standardlara dayalı**: API'lar için açık standartlara dayalıdır (ve tamamen uyumludur); <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> (önceden Swagger olarak biliniyordu) ve <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Schema</a>.
 
-<small>* ilgili kanılar, dahili geliştirme ekibinin geliştirdikleri ürünlere yaptıkları testlere dayanmaktadır.</small>
+<small>* tahmin, production uygulamalar geliştiren dahili bir geliştirme ekibinin yaptığı testlere dayanmaktadır.</small>
 
-## Sponsorlar
+## Sponsorlar { #sponsors }
 
 <!-- sponsors -->
 
-{% if sponsors %}
+### Keystone Sponsor { #keystone-sponsor }
+
+{% for sponsor in sponsors.keystone -%}
+<a href="{{ sponsor.url }}" target="_blank" title="{{ sponsor.title }}"><img src="{{ sponsor.img }}" style="border-radius:15px"></a>
+{% endfor -%}
+
+### Gold and Silver Sponsors { #gold-and-silver-sponsors }
+
 {% 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/tr/fastapi-people/#sponsors" class="external-link" target="_blank">Diğer Sponsorlar</a>
+<a href="https://fastapi.tiangolo.com/tr/fastapi-people/#sponsors" class="external-link" target="_blank">Diğer sponsorlar</a>
 
-## Görüşler
+## Görüşler { #opinions }
 
-"_[...] Bugünlerde **FastAPI**'ı çok fazla kullanıyorum. [...] Aslında bunu ekibimin **Microsoft'taki Machine Learning servislerinin** tamamında kullanmayı planlıyorum. Bunlardan bazıları **Windows**'un ana ürünlerine ve **Office** ürünlerine entegre ediliyor._"
+"_[...] Bugünlerde **FastAPI**'ı çok fazla kullanıyorum. [...] Aslında bunu ekibimin **Microsoft'taki ML servislerinin** tamamında kullanmayı planlıyorum. Bunlardan bazıları ana **Windows** ürününe ve bazı **Office** ürünlerine entegre ediliyor._"
 
 <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>
 
 ---
 
-"_**FastAPI**'ı **tahminlerimiz**'i sorgulanabilir hale getirecek bir **REST** sunucu oluşturmak için benimsedik/kullanmaya başladık._"
+"_**predictions** almak için sorgulanabilecek bir **REST** server oluşturmak amacıyla **FastAPI** kütüphanesini benimsedik. [Ludwig için]_"
 
 <div style="text-align: right; margin-right: 10%;">Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - <strong>Uber</strong> <a href="https://eng.uber.com/ludwig-v0-2/" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-"_**Netflix**, **kriz yönetiminde** orkestrasyon yapabilmek için geliştirdiği yeni framework'ü **Dispatch**'in, açık kaynak sürümünü paylaşmaktan gurur duyuyor. [**FastAPI** ile yapıldı.]_"
+"_**Netflix**, **kriz yönetimi** orkestrasyon framework'ümüz: **Dispatch**'in open-source sürümünü duyurmaktan memnuniyet duyar! [**FastAPI** ile geliştirildi]_"
 
 <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>
 
@@ -91,70 +97,68 @@ Temel özellikleri şunlardır:
 
 ---
 
-"_Dürüst olmak gerekirse, inşa ettiğiniz şey gerçekten sağlam ve profesyonel görünüyor. Birçok açıdan **Hug**'ın olmasını istediğim şey tam da bu - böyle bir şeyi inşa eden birini görmek gerçekten ilham verici._"
+"_Dürüst olmak gerekirse, inşa ettiğiniz şey gerçekten sağlam ve profesyonel görünüyor. Birçok açıdan, **Hug**'ın olmasını istediğim şey tam da bu - böyle bir şeyi inşa eden birini görmek gerçekten ilham verici._"
 
-<div style="text-align: right; margin-right: 10%;">Timothy Crosley - <strong><a href="http://www.hug.rest/" target="_blank">Hug</a>'ın Yaratıcısı</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><a href="https://github.com/hugapi/hug" target="_blank">Hug</a> yaratıcısı</strong> <a href="https://news.ycombinator.com/item?id=19455465" target="_blank"><small>(ref)</small></a></div>
 
 ---
 
-"_Eğer REST API geliştirmek için **modern bir framework** öğrenme arayışında isen, **FastAPI**'a bir göz at [...] Hızlı, kullanımı ve öğrenmesi kolay. [...]_"
+"_REST API'lar geliştirmek için **modern bir framework** öğrenmek istiyorsanız, **FastAPI**'a bir göz atın [...] Hızlı, kullanımı ve öğrenmesi kolay [...]_"
 
-"_**API** servislerimizi **FastAPI**'a taşıdık [...] Sizin de beğeneceğinizi düşünüyoruz. [...]_"
+"_**API**'larımız için **FastAPI**'a geçtik [...] Bence hoşunuza gidecek [...]_"
 
 <div style="text-align: right; margin-right: 10%;">Ines Montani - Matthew Honnibal - <strong><a href="https://explosion.ai" target="_blank">Explosion AI</a> kurucuları - <a href="https://spacy.io" target="_blank">spaCy</a> yaratıcıları</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>
 
 ---
 
-"_Python ile kullanıma hazır bir API oluşturmak isteyen herhangi biri için, **FastAPI**'ı şiddetle tavsiye ederim. **Harika tasarlanmış**, **kullanımı kolay** ve **yüksek ölçeklenebilir**, API odaklı geliştirme stratejimizin **ana bileşeni** haline geldi ve Virtual TAC Engineer gibi birçok otomasyon ve servisi yönetiyor._"
+"_Production'da Python API geliştirmek isteyen herkese **FastAPI**'ı şiddetle tavsiye ederim. **Harika tasarlanmış**, **kullanımı kolay** ve **yüksek ölçeklenebilir**; API-first geliştirme stratejimizin **kilit bir bileşeni** haline geldi ve Virtual TAC Engineer gibi birçok otomasyon ve servise güç veriyor._"
 
 <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>
 
 ---
 
-## Komut Satırı Uygulamalarının FastAPI'ı: **Typer**
+## FastAPI mini belgeseli { #fastapi-mini-documentary }
+
+2025'in sonunda yayınlanan bir <a href="https://www.youtube.com/watch?v=mpR8ngthqiE" class="external-link" target="_blank">FastAPI mini belgeseli</a> var, online olarak izleyebilirsiniz:
+
+<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>
+
+## CLI'ların FastAPI'ı: **Typer** { #typer-the-fastapi-of-clis }
 
 <a href="https://typer.tiangolo.com" target="_blank"><img src="https://typer.tiangolo.com/img/logo-margin/logo-margin-vector.svg" style="width: 20%;"></a>
 
-Eğer API yerine, terminalde kullanılmak üzere bir <abbr title="Komut Satırı: Command Line Interface">komut satırı uygulaması</abbr> geliştiriyorsanız <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>'a göz atabilirsiniz.
+Web API yerine terminalde kullanılacak bir <abbr title="Command Line Interface">CLI</abbr> uygulaması geliştiriyorsanız <a href="https://typer.tiangolo.com/" class="external-link" target="_blank">**Typer**</a>'a göz atın.
 
-**Typer** kısaca FastAPI'ın küçük kardeşi. Ve hedefi komut satırı uygulamalarının **FastAPI'ı** olmak. ⌨️ 🚀
+**Typer**, FastAPI'ın küçük kardeşi. Ve hedefi CLI'ların **FastAPI'ı** olmak. ⌨️ 🚀
 
-## Gereksinimler
+## Gereksinimler { #requirements }
 
 FastAPI iki devin omuzları üstünde duruyor:
 
-* Web tarafı için <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a>.
-* Data tarafı için <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>.
+* Web kısımları için <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a>.
+* Data kısımları için <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>.
 
-## Kurulum
+## Kurulum { #installation }
+
+Bir <a href="https://fastapi.tiangolo.com/tr/virtual-environments/" class="external-link" target="_blank">virtual environment</a> oluşturup etkinleştirelim ve ardından FastAPI'ı yükleyelim:
 
 <div class="termy">
 
 ```console
-$ pip install fastapi
+$ pip install "fastapi[standard]"
 
 ---> 100%
 ```
 
 </div>
 
-Uygulamamızı kullanılabilir hale getirmek için <a href="http://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a> ya da <a href="https://github.com/pgjones/hypercorn" class="external-link" target="_blank">Hypercorn</a> gibi bir ASGI sunucusuna ihtiyacımız olacak.
+**Not**: Tüm terminallerde çalıştığından emin olmak için `"fastapi[standard]"` ifadesini tırnak içinde yazdığınızdan emin olun.
 
-<div class="termy">
+## Örnek { #example }
 
-```console
-$ pip install "uvicorn[standard]"
+### Oluşturalım { #create-it }
 
----> 100%
-```
-
-</div>
-
-## Örnek
-
-### Kodu Oluşturalım
-
-* `main.py` adında bir dosya oluşturup içine şu kodu yapıştıralım:
+Şu içerikle `main.py` adında bir dosya oluşturalım:
 
 ```Python
 from typing import Union
@@ -175,9 +179,9 @@ def read_item(item_id: int, q: Union[str, None] = None):
 ```
 
 <details markdown="1">
-<summary>Ya da <code>async def</code>...</summary>
+<summary>Ya da <code>async def</code> kullanalım...</summary>
 
-Eğer kodunuzda `async` / `await` varsa, `async def` kullanalım:
+Eğer kodunuz `async` / `await` kullanıyorsa, `async def` kullanın:
 
 ```Python hl_lines="9  14"
 from typing import Union
@@ -199,22 +203,35 @@ async def read_item(item_id: int, q: Union[str, None] = None):
 
 **Not**:
 
-Eğer bu konu hakkında bilginiz yoksa <a href="https://fastapi.tiangolo.com/tr/async/#in-a-hurry" target="_blank">`async` ve `await`</a> dokümantasyonundaki _"Aceleniz mi var?"_ kısmını kontrol edebilirsiniz.
+Eğer bilmiyorsanız, dokümanlardaki <a href="https://fastapi.tiangolo.com/tr/async/#in-a-hurry" target="_blank">`async` ve `await`</a> hakkında _"Aceleniz mi var?"_ bölümüne bakın.
 
 </details>
 
-### Kodu Çalıştıralım
+### Çalıştıralım { #run-it }
 
-Sunucuyu aşağıdaki komutla çalıştıralım:
+Sunucuyu şu komutla çalıştıralım:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ fastapi dev main.py
 
+ ╭────────── 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 [28720]
-INFO:     Started server process [28722]
+INFO:     Started reloader process [2248755] using WatchFiles
+INFO:     Started server process [2248757]
 INFO:     Waiting for application startup.
 INFO:     Application startup complete.
 ```
@@ -222,54 +239,54 @@ INFO:     Application startup complete.
 </div>
 
 <details markdown="1">
-<summary><code>uvicorn main:app --reload</code> komutuyla ilgili...</summary>
+<summary><code>fastapi dev main.py</code> komutu hakkında...</summary>
 
-`uvicorn main:app` komutunu şu şekilde açıklayabiliriz:
+`fastapi dev` komutu, `main.py` dosyanızı okur, içindeki **FastAPI** uygulamasını algılar ve <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a> kullanarak bir server başlatır.
 
-* `main`: dosya olan `main.py` (yani Python "modülü").
-* `app`: ise `main.py` dosyasının içerisinde `app = FastAPI()` satırında oluşturduğumuz `FastAPI` nesnesi.
-* `--reload`: kod değişikliklerinin ardından sunucuyu otomatik olarak yeniden başlatır. Bu parameteyi sadece geliştirme aşamasında kullanmalıyız.
+Varsayılan olarak `fastapi dev`, local geliştirme için auto-reload etkin şekilde başlar.
+
+Daha fazla bilgi için <a href="https://fastapi.tiangolo.com/tr/fastapi-cli/" target="_blank">FastAPI CLI dokümantasyonu</a>'nu okuyabilirsiniz.
 
 </details>
 
-### Şimdi de Kontrol Edelim
+### Kontrol Edelim { #check-it }
 
-Tarayıcımızda şu bağlantıyı açalım <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>.
+Tarayıcınızda şu bağlantıyı açın: <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>.
 
-Aşağıdaki gibi bir JSON yanıtıyla karşılaşacağız:
+Şu JSON response'unu göreceksiniz:
 
 ```JSON
 {"item_id": 5, "q": "somequery"}
 ```
 
-Az önce oluşturduğumuz API:
+Artık şunları yapan bir API oluşturdunuz:
 
-* `/` ve `/items/{item_id}` <abbr title="Adres / Yol: Path ">_yollarına_</abbr> HTTP isteği alabilir.
-* İki _yolda_ `GET` <em>operasyonlarını</em> (HTTP _metodları_ olarak da bilinen) kabul ediyor.
-* `/items/{item_id}` _yolu_ `item_id` adında bir _yol parametresine_ sahip ve bu parametre `int` değer almak zorundadır.
-* `/items/{item_id}` _yolu_ `q` adında bir _yol parametresine_ sahip ve bu parametre opsiyonel olmakla birlikte, `str` değer almak zorundadır.
+* `/` ve `/items/{item_id}` _path_'lerinde HTTP request'leri alır.
+* Her iki _path_ de `GET` <em>operasyonlarını</em> (HTTP _method_'ları olarak da bilinir) kabul eder.
+* `/items/{item_id}` _path_'i, `int` olması gereken `item_id` adlı bir _path parameter_'a sahiptir.
+* `/items/{item_id}` _path_'i, opsiyonel `str` bir _query parameter_ olan `q`'ya sahiptir.
 
-### Etkileşimli API Dokümantasyonu
+### Etkileşimli API dokümantasyonu { #interactive-api-docs }
 
-Şimdi <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> bağlantısını açalım.
+Şimdi <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresine gidin.
 
-<a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a> tarafından sağlanan otomatik etkileşimli bir API dokümantasyonu göreceğiz:
+Otomatik etkileşimli API dokümantasyonunu göreceksiniz (<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ümantasyonu
+### Alternatif API dokümantasyonu { #alternative-api-docs }
 
-Şimdi <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> bağlantısını açalım.
+Ve şimdi <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> adresine gidin.
 
-<a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a> tarafından sağlanan otomatik dokümantasyonu göreceğiz:
+Alternatif otomatik dokümantasyonu göreceksiniz (<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)
 
-## Örneği Güncelleyelim
+## Örneği Güncelleyelim { #example-upgrade }
 
-Şimdi `main.py` dosyasını, `PUT` isteğiyle birlikte bir gövde alacak şekilde değiştirelim.
+Şimdi `main.py` dosyasını, `PUT` request'iyle gelen bir body alacak şekilde değiştirelim.
 
-<abbr title="Gövde: Body">Gövde</abbr>yi Pydantic sayesinde standart python tiplerini kullanarak tanımlayalım.
+Body'yi Pydantic sayesinde standart Python tiplerini kullanarak tanımlayalım.
 
 ```Python hl_lines="4  9-12  25-27"
 from typing import Union
@@ -301,174 +318,248 @@ def update_item(item_id: int, item: Item):
     return {"item_name": item.name, "item_id": item_id}
 ```
 
-Sunucu otomatik olarak yeniden başlamış olmalı (çünkü yukarıda `uvicorn` komutuyla birlikte `--reload` parametresini kullandık).
+`fastapi dev` server'ı otomatik olarak yeniden yüklemelidir.
 
-### Etkileşimli API Dokümantasyonundaki Değişimi Görelim
+### Etkileşimli API dokümantasyonu güncellemesi { #interactive-api-docs-upgrade }
 
-Şimdi <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> bağlantısına tekrar gidelim.
+Şimdi <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresine gidin.
 
-* Etkileşimli API dokümantasyonu, yeni gövdede dahil olmak üzere otomatik olarak güncellenmiş olacak:
+* Etkileşimli API dokümantasyonu, yeni body dahil olacak şekilde otomatik olarak güncellenecek:
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
-* "Try it out" butonuna tıklayalım, bu işlem API parametleri üzerinde değişiklik yapmamıza ve doğrudan API ile etkileşime geçmemize imkan sağlayacak:
+* "Try it out" butonuna tıklayın; parametreleri doldurmanıza ve API ile doğrudan etkileşime girmenize olanak sağlar:
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-04-swagger-03.png)
 
-* Şimdi "Execute" butonuna tıklayalım, kullanıcı arayüzü API'ımız ile bağlantı kurup parametreleri gönderecek ve sonucu ekranımıza getirecek:
+* Sonra "Execute" butonuna tıklayın; kullanıcı arayüzü API'nız ile iletişim kuracak, parametreleri gönderecek, sonuçları alacak ve ekranda gösterecek:
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
 
-### Alternatif API Dokümantasyonundaki Değişimi Görelim
+### Alternatif API dokümantasyonu güncellemesi { #alternative-api-docs-upgrade }
 
-Şimdi ise <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> bağlantısına tekrar gidelim.
+Ve şimdi <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> adresine gidin.
 
-* Alternatif dokümantasyonda yaptığımız değişiklikler ile birlikte yeni sorgu parametresi ve gövde bilgisi ile güncelemiş olacak:
+* Alternatif dokümantasyon da yeni query parameter ve body'yi yansıtacak:
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Özet
+### Özet { #recap }
 
-Özetlemek gerekirse, parametrelerin, gövdenin, vb. veri tiplerini fonksiyon parametreleri olarak **bir kere** tanımlıyoruz.
+Özetle, parametrelerin, body'nin vb. type'larını fonksiyon parametreleri olarak **bir kere** tanımlarsınız.
 
-Bu işlemi standart modern Python tipleriyle yapıyoruz.
+Bunu standart modern Python tipleriyle yaparsınız.
 
-Yeni bir sözdizimi yapısını, bir kütüphane özel metod veya sınıfları öğrenmeye gerek yoktur.
+Yeni bir syntax, belirli bir kütüphanenin method'larını ya da class'larını vb. öğrenmeniz gerekmez.
 
-Hepsi sadece **Python** standartlarına dayalıdır.
+Sadece standart **Python**.
 
-Örnek olarak, `int` tanımlamak için:
+Örneğin bir `int` için:
 
 ```Python
 item_id: int
 ```
 
-ya da daha kompleks herhangi bir python modelini tanımlayabiliriz, örneğin `Item` modeli için:
+ya da daha karmaşık bir `Item` modeli için:
 
 ```Python
 item: Item
 ```
 
-...ve sadece kısa bir parametre tipi belirterek elde ettiklerimiz:
+...ve bu tek tanımla şunları elde edersiniz:
 
-* Editör desteğiyle birlikte:
-    * Otomatik tamamlama.
-    * Tip kontrolü.
-* Veri Doğrulama:
-    * Veri geçerli değilse, otomatik olarak açıklayıcı hatalar gösterir.
-    * Çok <abbr title="Derin / İç içe: Nested">derin</abbr> JSON nesnelerinde bile doğrulama yapar.
-* Gelen verinin <abbr title="Dönüşüm: serialization, parsing, marshalling olarak da biliniyor">dönüşümünü</abbr> aşağıdaki veri tiplerini kullanarak gerçekleştirir:
+* Şunlar dahil editör desteği:
+    * Completion.
+    * Type kontrolleri.
+* Verinin doğrulanması:
+    * Veri geçersiz olduğunda otomatik ve anlaşılır hatalar.
+    * Çok derin iç içe JSON nesneleri için bile doğrulama.
+* Girdi verisinin <abbr title="serialization, parsing, marshalling olarak da bilinir">Dönüşümü</abbr>: network'ten gelen veriyi Python verisine ve type'larına çevirir. Şunlardan okur:
     * JSON.
-    * Yol parametreleri.
-    * Sorgu parametreleri.
-    * Çerezler.
-    * Headers.
-    * Formlar.
-    * Dosyalar.
-* Giden verinin <abbr title="Dönüşüm: serialization, parsing, marshalling olarak da biliniyor">dönüşümünü</abbr> aşağıdaki veri tiplerini kullanarak gerçekleştirir (JSON olarak):
-    * Python tiplerinin (`str`, `int`, `float`, `bool`, `list`, vb) dönüşümü.
-    * `datetime` nesnesi.
-    * `UUID` nesnesi.
+    * Path parameter'lar.
+    * Query parameter'lar.
+    * Cookie'ler.
+    * Header'lar.
+    * Form'lar.
+    * File'lar.
+* Çıktı verisinin <abbr title="serialization, parsing, marshalling olarak da bilinir">Dönüşümü</abbr>: Python verisini ve type'larını network verisine çevirir (JSON olarak):
+    * Python type'larını dönüştürür (`str`, `int`, `float`, `bool`, `list`, vb.).
+    * `datetime` nesneleri.
+    * `UUID` nesneleri.
     * Veritabanı modelleri.
-    * ve çok daha fazlası...
-* 2 alternatif kullanıcı arayüzü dahil olmak üzere, otomatik etkileşimli API dokümantasyonu sağlar:
+    * ...ve daha fazlası.
+* 2 alternatif kullanıcı arayüzü dahil otomatik etkileşimli API dokümantasyonu:
     * Swagger UI.
     * ReDoc.
 
 ---
 
-Az önceki örneğe geri dönelim, **FastAPI**'ın yapacaklarına bir bakış atalım:
+Önceki kod örneğine dönersek, **FastAPI** şunları yapacaktır:
 
-* `item_id`'nin `GET` ve `PUT` istekleri için, yolda olup olmadığının kontol edecek.
-* `item_id`'nin `GET` ve `PUT` istekleri için, tipinin `int` olduğunu doğrulayacak.
-    * Eğer değilse, sebebini belirten bir hata mesajı gösterecek.
-* Opsiyonel bir `q` parametresinin `GET` isteği içinde (`http://127.0.0.1:8000/items/foo?q=somequery` gibi) olup olmadığını kontrol edecek
-    * `q` parametresini `= None` ile oluşturduğumuz için, opsiyonel bir parametre olacak.
-    * Eğer `None` olmasa zorunlu bir parametre olacaktı (`PUT` metodunun gövdesinde olduğu gibi).
-* `PUT` isteği için `/items/{item_id}`'nin gövdesini, JSON olarak doğrulayıp okuyacak:
-    * `name` adında zorunlu bir parametre olup olmadığını ve varsa tipinin `str` olup olmadığını kontol edecek.
-    * `price` adında zorunlu bir parametre olup olmadığını ve varsa tipinin `float` olup olmadığını kontol edecek.
-    * `is_offer` adında opsiyonel bir parametre olup olmadığını ve varsa tipinin `float` olup olmadığını kontol edecek.
-    * Bunların hepsi en derin JSON nesnelerinde bile çalışacak.
-* Verilerin JSON'a ve JSON'ın python nesnesine dönüşümü otomatik olarak yapılacak.
-* Her şeyi OpenAPI ile uyumlu bir şekilde otomatik olarak dokümanlayacak ve bunlarda aşağıdaki gibi kullanılabilecek:
+* `GET` ve `PUT` request'leri için path'te `item_id` olduğunu doğrular.
+* `GET` ve `PUT` request'leri için `item_id`'nin type'ının `int` olduğunu doğrular.
+    * Değilse, client faydalı ve anlaşılır bir hata görür.
+* `GET` request'leri için `q` adlı opsiyonel bir query parameter olup olmadığını kontrol eder (`http://127.0.0.1:8000/items/foo?q=somequery` örneğindeki gibi).
+    * `q` parametresi `= None` ile tanımlandığı için opsiyoneldir.
+    * `None` olmasaydı zorunlu olurdu (tıpkı `PUT` örneğindeki body gibi).
+* `/items/{item_id}`'ye yapılan `PUT` request'leri için body'yi JSON olarak okur:
+    * `str` olması gereken, zorunlu `name` alanı olduğunu kontrol eder.
+    * `float` olması gereken, zorunlu `price` alanı olduğunu kontrol eder.
+    * Varsa, `bool` olması gereken opsiyonel `is_offer` alanını kontrol eder.
+    * Bunların hepsi çok derin iç içe JSON nesneleri için de çalışır.
+* JSON'a ve JSON'dan dönüşümü otomatik yapar.
+* Her şeyi OpenAPI ile dokümante eder; bu dokümantasyon şunlar tarafından kullanılabilir:
     * Etkileşimli dokümantasyon sistemleri.
-    * Bir çok programlama dili için otomatik istemci kodu üretim sistemleri.
-* İki ayrı etkileşimli dokümantasyon arayüzünü doğrudan sağlayacak.
+    * Birçok dil için otomatik client kodu üretim sistemleri.
+* 2 etkileşimli dokümantasyon web arayüzünü doğrudan sunar.
 
 ---
 
-Daha yeni başladık ama çalışma mantığını çoktan anlamış oldunuz.
+Daha yolun başındayız, ama bunun nasıl çalıştığı hakkında fikri kaptınız.
 
-Şimdi aşağıdaki satırı değiştirmeyi deneyin:
+Şu satırı değiştirmeyi deneyin:
 
 ```Python
     return {"item_name": item.name, "item_id": item_id}
 ```
 
-...bundan:
+...şundan:
 
 ```Python
         ... "item_name": item.name ...
 ```
 
-...buna:
+...şuna:
 
 ```Python
         ... "item_price": item.price ...
 ```
 
-...ve editörünün veri tiplerini bildiğini ve otomatik tamamladığını göreceksiniz:
+...ve editörünüzün alanları otomatik tamamladığını ve type'larını bildiğini görün:
 
 ![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
 
-Daha fazal özellik içeren, daha eksiksiz bir örnek için <a href="https://fastapi.tiangolo.com/tr/tutorial/">Öğretici - Kullanıcı Rehberi</a> sayfasını ziyaret edebilirsin.
+Daha fazla özellik içeren daha kapsamlı bir örnek için <a href="https://fastapi.tiangolo.com/tr/tutorial/">Öğretici - Kullanıcı Rehberi</a>'ne bakın.
 
-**Spoiler**: Öğretici - Kullanıcı rehberi şunları içerir:
+**Spoiler alert**: öğretici - kullanıcı rehberi şunları içerir:
 
-* **Parameterlerin**, **headers**, **çerezler**, **form alanları** ve **dosyalar** olarak tanımlanması.
-* `maximum_length` ya da `regex` gibi **doğrulama kısıtlamalarının** nasıl yapılabileceği.
-* Çok güçlü ve kullanımı kolay **<abbr title="Bağımlılık Enjeksiyonu: components, resources, providers, services, injectables olarak da biliniyor.">Bağımlılık Enjeksiyonu</abbr>** sistemi oluşturmayı.
-* Güvenlik ve kimlik doğrulama, **JWT tokenleri** ile **OAuth2** desteği, ve **HTTP Basic** doğrulaması.
-* İleri seviye fakat bir o kadarda basit olan **çok derin JSON modelleri** (Pydantic sayesinde).
-* **GraphQL** entegrasyonu: <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> ve diğer kütüphaneleri kullanarak.
-* Diğer ekstra özellikler (Starlette sayesinde):
-    * **WebSocketler**
-    * HTTPX ve `pytest` sayesinde aşırı kolay testler.
+* **parameter**'ların farklı yerlerden: **header**'lar, **cookie**'ler, **form alanları** ve **file**'lar olarak tanımlanması.
+* `maximum_length` ya da `regex` gibi **doğrulama kısıtlamalarının** nasıl ayarlanacağı.
+* Çok güçlü ve kullanımı kolay bir **<abbr title="components, resources, providers, services, injectables olarak da bilinir">Dependency Injection</abbr>** sistemi.
+* **JWT tokens** ve **HTTP Basic** auth ile **OAuth2** desteği dahil güvenlik ve kimlik doğrulama.
+* **Çok derin iç içe JSON modelleri** tanımlamak için daha ileri (ama aynı derecede kolay) teknikler (Pydantic sayesinde).
+* <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> ve diğer kütüphaneler ile **GraphQL** entegrasyonu.
+* Starlette sayesinde gelen birçok ek özellik:
+    * **WebSockets**
+    * HTTPX ve `pytest` tabanlı aşırı kolay testler
     * **CORS**
     * **Cookie Sessions**
     * ...ve daha fazlası.
 
-## Performans
+### Uygulamanızı deploy edin (opsiyonel) { #deploy-your-app-optional }
 
-Bağımsız TechEmpower kıyaslamaları gösteriyor ki, Uvicorn ile çalıştırılan **FastAPI** uygulamaları <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">en hızlı Python framework'lerinden birisi</a>, sadece Starlette ve Uvicorn'dan yavaş, ki FastAPI bunların üzerine kurulu bir kütüphanedir.
+İsterseniz FastAPI uygulamanızı <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>'a deploy edebilirsiniz; eğer henüz yapmadıysanız gidip bekleme listesine katılın. 🚀
 
-Daha fazla bilgi için, bu bölüme bir göz at <a href="https://fastapi.tiangolo.com/tr/benchmarks/" class="internal-link" target="_blank">Kıyaslamalar</a>.
+Zaten bir **FastAPI Cloud** hesabınız varsa (bekleme listesinden sizi davet ettiysek 😉), uygulamanızı tek bir komutla deploy edebilirsiniz.
 
-## Opsiyonel Gereksinimler
+Deploy etmeden önce, giriş yaptığınızdan emin olun:
 
-Pydantic tarafında kullanılan:
+<div class="termy">
+
+```console
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+Sonra uygulamanızı 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 bu URL'den erişebilirsiniz. ✨
+
+#### FastAPI Cloud hakkında { #about-fastapi-cloud }
+
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>**, **FastAPI**'ın arkasındaki aynı yazar ve ekip tarafından geliştirilmiştir.
+
+**Bir API'ı build etmek**, **deploy etmek** ve **erişmek** süreçlerini minimum eforla kolaylaştırır.
+
+FastAPI ile uygulama geliştirmenin sağladığı aynı **developer experience**'ı, onları cloud'a **deploy etmeye** de taşır. 🎉
+
+FastAPI Cloud, *FastAPI and friends* open source projelerinin ana sponsoru ve finansman sağlayıcısıdır. ✨
+
+#### Diğer cloud sağlayıcılarına deploy { #deploy-to-other-cloud-providers }
+
+FastAPI open source'tur ve standartlara dayanır. FastAPI uygulamalarını seçtiğiniz herhangi bir cloud sağlayıcısına deploy edebilirsiniz.
+
+FastAPI uygulamalarını onlarla deploy etmek için cloud sağlayıcınızın rehberlerini takip edin. 🤓
+
+## Performans { #performance }
+
+Bağımsız TechEmpower kıyaslamaları, Uvicorn altında çalışan **FastAPI** uygulamalarının <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">mevcut en hızlı Python framework'lerinden biri</a> olduğunu gösteriyor; sadece Starlette ve Uvicorn'un kendisinin gerisinde (FastAPI tarafından dahili olarak kullanılır). (*)
+
+Daha iyi anlamak için <a href="https://fastapi.tiangolo.com/tr/benchmarks/" class="internal-link" target="_blank">Kıyaslamalar</a> bölümüne bakın.
+
+## Bağımlılıklar { #dependencies }
+
+FastAPI, Pydantic ve Starlette'a bağımlıdır.
+
+### `standard` Bağımlılıkları { #standard-dependencies }
+
+FastAPI'ı `pip install "fastapi[standard]"` ile yüklediğinizde, opsiyonel bağımlılıkların `standard` grubuyla birlikte gelir:
+
+Pydantic tarafından kullanılanlar:
 
 * <a href="https://github.com/JoshData/python-email-validator" target="_blank"><code>email-validator</code></a> - email doğrulaması için.
+
+Starlette tarafından kullanılanlar:
+
+* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - `TestClient` kullanmak istiyorsanız gereklidir.
+* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - varsayılan template yapılandırmasını kullanmak istiyorsanız gereklidir.
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - `request.form()` ile, form <abbr title="HTTP request'inden gelen string'i Python verisine dönüştürme">"parsing"</abbr> desteği istiyorsanız gereklidir.
+
+FastAPI tarafından kullanılanlar:
+
+* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - uygulamanızı yükleyen ve servis eden server için. Buna, yüksek performanslı servis için gereken bazı bağımlılıkları (örn. `uvloop`) içeren `uvicorn[standard]` dahildir.
+* `fastapi-cli[standard]` - `fastapi` komutunu sağlamak için.
+    * Buna, FastAPI uygulamanızı <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>'a deploy etmenizi sağlayan `fastapi-cloud-cli` dahildir.
+
+### `standard` Bağımlılıkları Olmadan { #without-standard-dependencies }
+
+`standard` opsiyonel bağımlılıklarını dahil etmek istemiyorsanız, `pip install "fastapi[standard]"` yerine `pip install fastapi` ile kurabilirsiniz.
+
+### `fastapi-cloud-cli` Olmadan { #without-fastapi-cloud-cli }
+
+FastAPI'ı standard bağımlılıklarla ama `fastapi-cloud-cli` olmadan kurmak istiyorsanız, `pip install "fastapi[standard-no-fastapi-cloud-cli]"` ile yükleyebilirsiniz.
+
+### Ek Opsiyonel Bağımlılıklar { #additional-optional-dependencies }
+
+Yüklemek isteyebileceğiniz bazı ek bağımlılıklar da vardır.
+
+Ek opsiyonel Pydantic bağımlılıkları:
+
 * <a href="https://docs.pydantic.dev/latest/usage/pydantic_settings/" target="_blank"><code>pydantic-settings</code></a> - ayar yönetimi için.
-* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - Pydantic ile birlikte kullanılabilecek ek tipler için.
+* <a href="https://docs.pydantic.dev/latest/usage/types/extra_types/extra_types/" target="_blank"><code>pydantic-extra-types</code></a> - Pydantic ile kullanılacak ek type'lar için.
 
-Starlette tarafında kullanılan:
+Ek opsiyonel FastAPI bağımlılıkları:
 
-* <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - Eğer `TestClient` yapısını kullanacaksanız gereklidir.
-* <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - Eğer varsayılan template konfigürasyonunu kullanacaksanız gereklidir.
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - Eğer `request.form()` ile form <abbr title="HTTP isteği ile gelen string veriyi Python nesnesine çevirme.">dönüşümü</abbr> desteğini kullanacaksanız gereklidir.
-* <a href="https://pythonhosted.org/itsdangerous/" target="_blank"><code>itsdangerous</code></a> - `SessionMiddleware` desteği için gerekli.
-* <a href="https://pyyaml.org/wiki/PyYAMLDocumentation" target="_blank"><code>pyyaml</code></a> - `SchemaGenerator` desteği için gerekli (Muhtemelen FastAPI kullanırken ihtiyacınız olmaz).
+* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - `ORJSONResponse` kullanmak istiyorsanız gereklidir.
+* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - `UJSONResponse` kullanmak istiyorsanız gereklidir.
 
-Hem FastAPI hem de Starlette tarafından kullanılan:
+## Lisans { #license }
 
-* <a href="https://www.uvicorn.dev" target="_blank"><code>uvicorn</code></a> - oluşturduğumuz uygulamayı servis edecek web sunucusu görevini üstlenir.
-* <a href="https://github.com/ijl/orjson" target="_blank"><code>orjson</code></a> - `ORJSONResponse` kullanacaksanız gereklidir.
-* <a href="https://github.com/esnme/ultrajson" target="_blank"><code>ujson</code></a> - `UJSONResponse` kullanacaksanız gerekli.
-
-Bunların hepsini `pip install fastapi[all]` ile yükleyebilirsin.
-
-## Lisans
-
-Bu proje, MIT lisansı şartları altında lisanslanmıştır.
+Bu proje MIT lisansı şartları altında lisanslanmıştır.

docs/tr/docs/learn/index.md

@@ -1,5 +1,5 @@
-# Öğren
+# Öğren { #learn }
 
 **FastAPI** öğrenmek için giriş bölümleri ve öğreticiler burada yer alıyor.
 
-Burayı, bir **kitap**, bir **kurs**, ve FastAPI öğrenmenin **resmi** ve önerilen yolu olarak düşünülebilirsiniz. 😎
+Burayı, bir **kitap**, bir **kurs**, FastAPI öğrenmenin **resmi** ve önerilen yolu olarak düşünebilirsiniz. 😎

docs/tr/docs/project-generation.md

@@ -1,84 +1,28 @@
-# Proje oluşturma - Şablonlar
+# Full Stack FastAPI Şablonu { #full-stack-fastapi-template }
 
-Başlamak için bir proje oluşturucu kullanabilirsiniz, çünkü sizin için önceden yapılmış birçok başlangıç ​​kurulumu, güvenlik, veritabanı ve temel API endpoinlerini içerir.
+Şablonlar genellikle belirli bir kurulumla gelir, ancak esnek ve özelleştirilebilir olacak şekilde tasarlanırlar. Bu sayede şablonu projenizin gereksinimlerine göre değiştirip uyarlayabilir, çok iyi bir başlangıç noktası olarak kullanabilirsiniz. 🏁
 
-Bir proje oluşturucu, her zaman kendi ihtiyaçlarınıza göre güncellemeniz ve uyarlamanız gereken esnek bir kuruluma sahip olacaktır, ancak bu, projeniz için iyi bir başlangıç ​​noktası olabilir.
+Bu şablonu başlangıç için kullanabilirsiniz; çünkü ilk kurulumun, güvenliğin, veritabanının ve bazı API endpoint'lerinin önemli bir kısmı sizin için zaten hazırlanmıştır.
 
-## Full Stack FastAPI PostgreSQL
+GitHub Repository: <a href="https://github.com/tiangolo/full-stack-fastapi-template" class="external-link" target="_blank">Full Stack FastAPI Template</a>
 
-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>
+## Full Stack FastAPI Şablonu - Teknoloji Yığını ve Özellikler { #full-stack-fastapi-template-technology-stack-and-features }
 
-### Full Stack FastAPI PostgreSQL - Özellikler
-
-* Full **Docker** entegrasyonu (Docker based).
-* Docker Swarm Mode ile deployment.
-* **Docker Compose** entegrasyonu ve lokal geliştirme için optimizasyon.
-* Uvicorn ve Gunicorn ile **Production ready** Python web server'ı.
-* Python <a href="https://github.com/fastapi/fastapi" class="external-link" target="_blank">**FastAPI**</a> backend:
-    * **Hızlı**: **NodeJS** ve **Go** ile eşit, çok yüksek performans (Starlette ve Pydantic'e teşekkürler).
-    * **Sezgisel**: Editor desteğı. <abbr title="auto-complete, IntelliSense gibi isimlerle de bilinir">Otomatik tamamlama</abbr>. Daha az debugging.
-    * **Kolay**: Kolay öğrenip kolay kullanmak için tasarlandı. Daha az döküman okuma daha çok iş.
-    * **Kısa**: Minimum kod tekrarı. Her parametre bildiriminde birden çok özellik.
-    * **Güçlü**: Production-ready. Otomatik interaktif dökümantasyon.
-    * **Standartlara dayalı**: API'ler için açık standartlara dayanır (ve tamamen uyumludur): <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a> ve <a href="https://json-schema.org/" class="external-link" target="_blank">JSON Şeması</a>.
-    * <a href="https://fastapi.tiangolo.com/features/" class="external-link" target="_blank">**Birçok diger özelliği**</a> dahili otomatik doğrulama, serialization, interaktif dokümantasyon, OAuth2 JWT token ile authentication, vb.
-* **Güvenli şifreleme** .
-* **JWT token** kimlik doğrulama.
-* **SQLAlchemy** models (Flask dan bağımsızdır. Celery worker'ları ile kullanılabilir).
-* Kullanıcılar için temel başlangıç ​​modeli (gerektiği gibi değiştirin ve kaldırın).
-* **Alembic** migration.
-* **CORS** (Cross Origin Resource Sharing).
-* **Celery** worker'ları ile backend içerisinden seçilen işleri çalıştırabilirsiniz.
-* **Pytest**'e dayalı, Docker ile entegre REST backend testleri ile veritabanından bağımsız olarak tam API etkileşimini test edebilirsiniz. Docker'da çalıştığı için her seferinde sıfırdan yeni bir veri deposu oluşturabilir (böylece ElasticSearch, MongoDB, CouchDB veya ne istersen kullanabilirsin ve sadece API'nin çalışıp çalışmadığını test edebilirsin).
-* Atom Hydrogen veya Visual Studio Code Jupyter gibi uzantılarla uzaktan veya Docker içi geliştirme için **Jupyter Çekirdekleri** ile kolay Python entegrasyonu.
-* **Vue** ile frontend:
-    * Vue CLI ile oluşturulmuş.
-    * Dahili **JWT kimlik doğrulama**.
-    * Dahili Login.
-    * Login sonrası, Kontrol paneli.
-    * Kullanıcı oluşturma ve düzenleme kontrol paneli
-    * Kendi kendine kullanıcı sürümü.
-    * **Vuex**.
-    * **Vue-router**.
-    * **Vuetify** güzel material design kompanentleri için.
-    * **TypeScript**.
-    * **Nginx** tabanlı Docker sunucusu (Vue-router için yapılandırılmış).
-    * Docker ile multi-stage yapı, böylece kodu derlemeniz, kaydetmeniz veya işlemeniz gerekmez.
-    * Derleme zamanında Frontend testi (devre dışı bırakılabilir).
-    * Mümkün olduğu kadar modüler yapılmıştır, bu nedenle kutudan çıktığı gibi çalışır, ancak Vue CLI ile yeniden oluşturabilir veya ihtiyaç duyduğunuz şekilde oluşturabilir ve istediğinizi yeniden kullanabilirsiniz.
-* **PGAdmin** PostgreSQL database admin tool'u, PHPMyAdmin ve MySQL ile kolayca değiştirilebilir.
-* **Flower** ile Celery job'larını monitörleme.
-* **Traefik** ile backend ve frontend arasında yük dengeleme, böylece her ikisini de aynı domain altında, path ile ayrılmış, ancak farklı kapsayıcılar tarafından sunulabilirsiniz.
-* Let's Encrypt **HTTPS** sertifikalarının otomatik oluşturulması dahil olmak üzere Traefik entegrasyonu.
-* GitLab **CI** (sürekli entegrasyon), backend ve frontend testi dahil.
-
-## 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>
-
-⚠️ **UYARI** ⚠️
-
-Sıfırdan bir projeye başlıyorsanız alternatiflerine bakın.
-
-Örneğin,  <a href="https://github.com/tiangolo/full-stack-fastapi-postgresql" class="external-link" target="_blank">Full Stack FastAPI PostgreSQL</a> daha iyi bir alternatif olabilir, aktif olarak geliştiriliyor ve kullanılıyor. Ve yeni özellik ve ilerlemelere sahip.
-
-İsterseniz Couchbase tabanlı generator'ı kullanmakta özgürsünüz, hala iyi çalışıyor olmalı ve onunla oluşturulmuş bir projeniz varsa bu da sorun değil (ve muhtemelen zaten ihtiyaçlarınıza göre güncellediniz).
-
-Bununla ilgili daha fazla bilgiyi repo belgelerinde okuyabilirsiniz.
-
-## Full Stack FastAPI MongoDB
-
-... müsaitliğime ve diğer faktörlere bağlı olarak daha sonra gelebilir. 😅 🎉
-
-## Machine Learning modelleri, spaCy ve FastAPI
-
-GitHub: <a href="https://github.com/microsoft/cookiecutter-spacy-fastapi" class="external-link" target="_blank">https://github.com/microsoft/cookiecutter-spacy-fastapi</a>
-
-### Machine Learning modelleri, spaCy ve FastAPI - Features
-
-* **spaCy** NER model entegrasyonu.
-* **Azure Cognitive Search** yerleşik istek biçimi.
-* Uvicorn ve Gunicorn ile **Production ready** Python web server'ı.
-* Dahili **Azure DevOps** Kubernetes (AKS) CI/CD deployment.
-* **Multilingual**, Proje kurulumu sırasında spaCy'nin yerleşik dillerinden birini kolayca seçin.
-* **Esnetilebilir** diğer frameworkler (Pytorch, Tensorflow) ile de çalışır sadece spaCy değil.
+- ⚡ Python backend API için [**FastAPI**](https://fastapi.tiangolo.com/tr).
+  - 🧰 Python SQL veritabanı etkileşimleri (ORM) için [SQLModel](https://sqlmodel.tiangolo.com).
+  - 🔍 FastAPI'nin kullandığı; veri doğrulama ve ayarlar yönetimi için [Pydantic](https://docs.pydantic.dev).
+  - 💾 SQL veritabanı olarak [PostgreSQL](https://www.postgresql.org).
+- 🚀 frontend için [React](https://react.dev).
+  - 💃 TypeScript, hooks, Vite ve modern bir frontend stack'inin diğer parçalarını kullanır.
+  - 🎨 frontend component'leri için [Tailwind CSS](https://tailwindcss.com) ve [shadcn/ui](https://ui.shadcn.com).
+  - 🤖 Otomatik üretilen bir frontend client.
+  - 🧪 End-to-End testleri için [Playwright](https://playwright.dev).
+  - 🦇 Dark mode desteği.
+- 🐋 Geliştirme ve production için [Docker Compose](https://www.docker.com).
+- 🔒 Varsayılan olarak güvenli password hashing.
+- 🔑 JWT (JSON Web Token) authentication.
+- 📫 E-posta tabanlı şifre kurtarma.
+- ✅ [Pytest](https://pytest.org) ile testler.
+- 📞 Reverse proxy / load balancer olarak [Traefik](https://traefik.io).
+- 🚢 Docker Compose kullanarak deployment talimatları; otomatik HTTPS sertifikalarını yönetmek için bir frontend Traefik proxy'sini nasıl kuracağınız dahil.
+- 🏭 GitHub Actions tabanlı CI (continuous integration) ve CD (continuous deployment).

docs/tr/docs/python-types.md

@@ -1,76 +1,74 @@
-# Python Veri Tiplerine Giriş
+# Python Tiplerine Giriş { #python-types-intro }
 
-Python isteğe bağlı olarak "tip belirteçlerini" destekler.
+Python, isteğe bağlı "type hints" (diğer adıyla "type annotations") desteğine sahiptir.
 
- **"Tip belirteçleri"** bir değişkenin <abbr title="örneğin: str, int, float, bool">tipinin</abbr> belirtilmesine olanak sağlayan özel bir sözdizimidir.
+Bu **"type hints"** veya annotations, bir değişkenin <abbr title="örneğin: str, int, float, bool">type</abbr>'ını bildirmeye yarayan özel bir sözdizimidir.
 
-Değişkenlerin tiplerini belirterek editör ve araçlardan daha fazla destek alabilirsiniz.
+Değişkenleriniz için type bildirerek, editörler ve araçlar size daha iyi destek sağlayabilir.
 
-Bu  pythonda tip belirteçleri için **hızlı bir başlangıç / bilgi tazeleme** rehberidir . Bu rehber **FastAPI** kullanmak için gereken minimum konuyu kapsar ki bu da çok az bir miktardır.
+Bu, Python type hints hakkında sadece **hızlı bir eğitim / bilgi tazeleme** dokümanıdır. **FastAPI** ile kullanmak için gereken minimum bilgiyi kapsar... ki aslında bu çok azdır.
 
-**FastAPI' nin** tamamı bu tür tip belirteçleri ile donatılmıştır ve birçok avantaj sağlamaktadır.
+**FastAPI** tamamen bu type hints üzerine kuruludur; bunlar ona birçok avantaj ve fayda sağlar.
 
-**FastAPI** kullanmayacak olsanız bile tür belirteçleri hakkında bilgi edinmenizde fayda var.
+Ancak hiç **FastAPI** kullanmasanız bile, bunlar hakkında biraz öğrenmeniz size fayda sağlayacaktır.
 
 /// note | Not
 
-Python uzmanıysanız ve tip belirteçleri ilgili her şeyi zaten biliyorsanız, sonraki bölüme geçin.
+Eğer bir Python uzmanıysanız ve type hints hakkında her şeyi zaten biliyorsanız, sonraki bölüme geçin.
 
 ///
 
-## Motivasyon
+## Motivasyon { #motivation }
 
-Basit bir örnek ile başlayalım:
+Basit bir örnekle başlayalım:
 
-{* ../../docs_src/python_types/tutorial001.py *}
+{* ../../docs_src/python_types/tutorial001_py39.py *}
 
-
-Programın çıktısı:
+Bu programı çalıştırınca şu çıktıyı alırsınız:
 
 ```
 John Doe
 ```
 
-Fonksiyon sırayla şunları yapar:
+Fonksiyon şunları yapar:
 
 * `first_name` ve `last_name` değerlerini alır.
-* `title()` ile değişkenlerin ilk karakterlerini büyütür.
-* Değişkenleri aralarında bir boşlukla beraber <abbr title="Onları bir bütün olarak sırayla birleştirir.">Birleştirir</abbr>.
+* `title()` ile her birinin ilk harfini büyük harfe çevirir.
+* Ortada bir boşluk olacak şekilde <abbr title="Hepsini, tek bir bütün olacak şekilde bir araya koyar. İçerikler ardışık şekilde yer alır.">Concatenates</abbr> eder.
 
-{* ../../docs_src/python_types/tutorial001.py hl[2] *}
+{* ../../docs_src/python_types/tutorial001_py39.py hl[2] *}
 
-
-### Düzenle
+### Düzenleyelim { #edit-it }
 
 Bu çok basit bir program.
 
-Ama şimdi sıfırdan yazdığınızı hayal edin.
+Ama şimdi bunu sıfırdan yazdığınızı hayal edin.
 
-Bir noktada fonksiyonun tanımına başlayacaktınız, parametreleri hazır hale getirdiniz...
+Bir noktada fonksiyon tanımını yazmaya başlamış olacaktınız, parametreler hazır...
 
-Ama sonra "ilk harfi büyük harfe dönüştüren yöntemi" çağırmanız gerekir.
+Ama sonra "ilk harfi büyük harfe çeviren method"u çağırmanız gerekiyor.
 
- `upper` mıydı ? Yoksa  `uppercase`' mi? `first_uppercase`? `capitalize`?
+`upper` mıydı? `uppercase` miydi? `first_uppercase`? `capitalize`?
 
-Ardından, programcıların en iyi arkadaşı olan otomatik tamamlama ile denediniz.
+Sonra eski programcı dostuyla denersiniz: editör autocomplete.
 
-'first_name', ardından bir nokta ('.') yazıp otomatik tamamlamayı tetiklemek için 'Ctrl+Space' tuşlarına bastınız.
+Fonksiyonun ilk parametresi olan `first_name`'i yazarsınız, sonra bir nokta (`.`) ve ardından autocomplete'i tetiklemek için `Ctrl+Space`'e basarsınız.
 
-Ancak, ne yazık ki, yararlı hiçbir şey elde edemediniz:
+Ama ne yazık ki, işe yarar bir şey göremezsiniz:
 
 <img src="/img/python-types/image01.png">
 
-### Tipleri ekle
+### Tipleri ekleyelim { #add-types }
 
-Önceki sürümden sadece bir satırı değiştirelim.
+Önceki sürümden tek bir satırı değiştirelim.
 
-Tam olarak bu parçayı, işlevin parametrelerini  değiştireceğiz:
+Fonksiyonun parametreleri olan şu parçayı:
 
 ```Python
     first_name, last_name
 ```
 
-ve bu hale getireceğiz:
+şuna çevireceğiz:
 
 ```Python
     first_name: str, last_name: str
@@ -78,58 +76,55 @@ ve bu hale getireceğiz:
 
 Bu kadar.
 
-İşte bunlar "tip belirteçleri":
+Bunlar "type hints":
 
-{* ../../docs_src/python_types/tutorial002.py hl[1] *}
+{* ../../docs_src/python_types/tutorial002_py39.py hl[1] *}
 
-
-Bu, aşağıdaki gibi varsayılan değerleri bildirmekle aynı şey değildir:
+Bu, aşağıdaki gibi default değerler bildirmekle aynı şey değildir:
 
 ```Python
     first_name="john", last_name="doe"
 ```
 
-Bu tamamen farklı birşey
+Bu farklı bir şey.
 
-İki nokta üst üste (`:`) kullanıyoruz , eşittir (`=`) değil.
+Eşittir (`=`) değil, iki nokta (`:`) kullanıyoruz.
 
-Normalde tip belirteçleri eklemek, kod üzerinde olacakları değiştirmez.
+Ve type hints eklemek, normalde onlarsız ne oluyorsa onu değiştirmez.
 
-Şimdi programı sıfırdan birdaha yazdığınızı hayal edin.
+Ama şimdi, type hints ile o fonksiyonu oluşturmanın ortasında olduğunuzu tekrar hayal edin.
 
-Aynı noktada, `Ctrl+Space` ile otomatik tamamlamayı tetiklediniz  ve şunu görüyorsunuz:
+Aynı noktada, `Ctrl+Space` ile autocomplete'i tetiklemeye çalışırsınız ve şunu görürsünüz:
 
 <img src="/img/python-types/image02.png">
 
-Aradığınızı bulana kadar seçenekleri kaydırabilirsiniz:
+Bununla birlikte, seçenekleri görerek kaydırabilirsiniz; ta ki "tanıdık gelen" seçeneği bulana kadar:
 
 <img src="/img/python-types/image03.png">
 
-## Daha fazla motivasyon
+## Daha fazla motivasyon { #more-motivation }
 
-Bu fonksiyon, zaten tür belirteçlerine sahip:
+Şu fonksiyona bakın, zaten type hints içeriyor:
 
-{* ../../docs_src/python_types/tutorial003.py hl[1] *}
+{* ../../docs_src/python_types/tutorial003_py39.py hl[1] *}
 
-
-Editör değişkenlerin tiplerini bildiğinden, yalnızca otomatik tamamlama değil, hata kontrolleri de sağlar:
+Editör değişkenlerin tiplerini bildiği için, sadece completion değil, aynı zamanda hata kontrolleri de alırsınız:
 
 <img src="/img/python-types/image04.png">
 
-Artık `age` değişkenini `str(age)` olarak kullanmanız gerektiğini biliyorsunuz:
+Artık bunu düzeltmeniz gerektiğini, `age`'i `str(age)` ile string'e çevirmeniz gerektiğini biliyorsunuz:
 
-{* ../../docs_src/python_types/tutorial004.py hl[2] *}
+{* ../../docs_src/python_types/tutorial004_py39.py hl[2] *}
 
+## Tipleri bildirmek { #declaring-types }
 
-## Tip bildirme
+Type hints bildirmek için ana yeri az önce gördünüz: fonksiyon parametreleri.
 
-Az önce tip belirteçlerinin en çok kullanıldığı yeri gördünüz.
+Bu, **FastAPI** ile kullanırken de onları en çok kullanacağınız yerdir.
 
- **FastAPI**ile çalışırken tip belirteçlerini en çok kullanacağımız yer yine fonksiyonlardır.
+### Basit tipler { #simple-types }
 
-### Basit tipler
-
-Yalnızca `str` değil, tüm standart Python tiplerinin bildirebilirsiniz.
+Sadece `str` değil, tüm standart Python tiplerini bildirebilirsiniz.
 
 Örneğin şunları kullanabilirsiniz:
 
@@ -138,176 +133,332 @@ Yalnızca `str` değil, tüm standart Python tiplerinin bildirebilirsiniz.
 * `bool`
 * `bytes`
 
-{* ../../docs_src/python_types/tutorial005.py hl[1] *}
+{* ../../docs_src/python_types/tutorial005_py39.py hl[1] *}
 
+### Tip parametreleri ile Generic tipler { #generic-types-with-type-parameters }
 
-### Tip parametreleri ile Generic tipler
+`dict`, `list`, `set` ve `tuple` gibi, başka değerler içerebilen bazı veri yapıları vardır. Ve iç değerlerin kendi tipi de olabilir.
 
-"dict", "list", "set" ve "tuple" gibi diğer değerleri içerebilen bazı veri yapıları vardır. Ve dahili değerlerinin de tip belirtecleri olabilir.
+İç tipleri olan bu tiplere "**generic**" tipler denir. Ve bunları, iç tipleriyle birlikte bildirmek mümkündür.
 
-Bu tipleri ve dahili tpileri bildirmek için standart Python modülünü "typing" kullanabilirsiniz.
+Bu tipleri ve iç tipleri bildirmek için standart Python modülü `typing`'i kullanabilirsiniz. Bu modül, özellikle bu type hints desteği için vardır.
 
-Bu tür tip belirteçlerini desteklemek için özel olarak mevcuttur.
+#### Python'un daha yeni sürümleri { #newer-versions-of-python }
 
-#### `List`
+`typing` kullanan sözdizimi, Python 3.6'dan en yeni sürümlere kadar (Python 3.9, Python 3.10, vb. dahil) tüm sürümlerle **uyumludur**.
 
-Örneğin `str` değerlerden oluşan bir `list` tanımlayalım.
+Python geliştikçe, **daha yeni sürümler** bu type annotations için daha iyi destekle gelir ve çoğu durumda type annotations bildirmek için `typing` modülünü import edip kullanmanız bile gerekmez.
 
-From `typing`, import `List` (büyük harf olan `L` ile):
+Projeniz için daha yeni bir Python sürümü seçebiliyorsanız, bu ek sadelikten yararlanabilirsiniz.
 
-{* ../../docs_src/python_types/tutorial006.py hl[1] *}
+Tüm dokümanlarda her Python sürümüyle uyumlu örnekler vardır (fark olduğunda).
 
+Örneğin "**Python 3.6+**", Python 3.6 veya üstüyle (3.7, 3.8, 3.9, 3.10, vb. dahil) uyumludur. "**Python 3.9+**" ise Python 3.9 veya üstüyle (3.10 vb. dahil) uyumludur.
 
-Değişkenin tipini yine iki nokta üstüste (`:`) ile belirleyin.
+Eğer **Python'un en güncel sürümlerini** kullanabiliyorsanız, en güncel sürüme ait örnekleri kullanın; bunlar **en iyi ve en basit sözdizimine** sahip olur, örneğin "**Python 3.10+**".
 
-tip olarak `List` kullanın.
+#### List { #list }
 
-Liste, bazı dahili tipleri içeren bir tür olduğundan, bunları köşeli parantez içine alırsınız:
+Örneğin, `str`'lerden oluşan bir `list` olan bir değişken tanımlayalım.
 
-{* ../../docs_src/python_types/tutorial006.py hl[4] *}
+Değişkeni, aynı iki nokta (`:`) sözdizimiyle bildirin.
 
+Type olarak `list` yazın.
 
-/// tip | Ipucu
+`list`, bazı iç tipleri barındıran bir tip olduğundan, bunları köşeli parantez içine yazarsınız:
 
-Köşeli parantez içindeki bu dahili tiplere "tip parametreleri" denir.
+{* ../../docs_src/python_types/tutorial006_py39.py hl[1] *}
 
-Bu durumda `str`, `List`e iletilen tür parametresidir.
+/// info | Bilgi
+
+Köşeli parantez içindeki bu iç tiplere "type parameters" denir.
+
+Bu durumda `str`, `list`'e verilen type parameter'dır.
 
 ///
 
-Bunun anlamı şudur: "`items` değişkeni bir `list`tir ve bu listedeki öğelerin her biri bir `str`dir".
+Bu şu demektir: "`items` değişkeni bir `list` ve bu listedeki her bir öğe `str`".
 
-Bunu yaparak, düzenleyicinizin listedeki öğeleri işlerken bile destek sağlamasını sağlayabilirsiniz:
+Bunu yaparak, editörünüz listeden öğeleri işlerken bile destek sağlayabilir:
 
 <img src="/img/python-types/image05.png">
 
-Tip belirteçleri olmadan, bunu başarmak neredeyse imkansızdır.
+Tipler olmadan, bunu başarmak neredeyse imkansızdır.
 
-`item` değişkeninin `items` listesindeki öğelerden biri olduğuna dikkat edin.
+`item` değişkeninin, `items` listesindeki elemanlardan biri olduğuna dikkat edin.
 
-Ve yine, editör bunun bir `str` ​​olduğunu biliyor ve bunun için destek sağlıyor.
+Ve yine de editör bunun bir `str` olduğunu bilir ve buna göre destek sağlar.
 
-#### `Tuple` ve `Set`
+#### Tuple ve Set { #tuple-and-set }
 
-`Tuple` ve `set`lerin tiplerini bildirmek için de aynısını yapıyoruz:
-
-{* ../../docs_src/python_types/tutorial007.py hl[1,4] *}
-
-
-Bu şu anlama geliyor:
-
-* `items_t` değişkeni sırasıyla `int`, `int`, ve `str` tiplerinden oluşan bir `tuple` türündedir .
-* `items_s` ise her öğesi `bytes` türünde olan bir `set` örneğidir.
-
-#### `Dict`
-
-Bir `dict` tanımlamak için virgülle ayrılmış iki parametre verebilirsiniz.
-
-İlk tip parametresi `dict` değerinin `key` değeri içindir.
-
-İkinci parametre ise `dict` değerinin `value` değeri içindir:
-
-{* ../../docs_src/python_types/tutorial008.py hl[1,4] *}
+`tuple`'ları ve `set`'leri bildirmek için de aynısını yaparsınız:
 
+{* ../../docs_src/python_types/tutorial007_py39.py hl[1] *}
 
 Bu şu anlama gelir:
 
-*  `prices` değişkeni `dict` tipindedir:
-    *  `dict` değişkeninin `key` değeri  `str` tipindedir (herbir item'ın "name" değeri).
-    *  `dict` değişkeninin `value` değeri `float` tipindedir (lherbir item'ın "price" değeri).
+* `items_t` değişkeni 3 öğeli bir `tuple`'dır: bir `int`, bir başka `int` ve bir `str`.
+* `items_s` değişkeni bir `set`'tir ve her bir öğesi `bytes` tipindedir.
 
-#### `Optional`
+#### Dict { #dict }
 
-`Optional` bir değişkenin `str`gibi bir tipi olabileceğini ama isteğe bağlı olarak tipinin `None` olabileceğini belirtir:
+Bir `dict` tanımlamak için, virgülle ayrılmış 2 type parameter verirsiniz.
 
-```Python hl_lines="1  4"
-{!../../docs_src/python_types/tutorial009.py!}
+İlk type parameter, `dict`'in key'leri içindir.
+
+İkinci type parameter, `dict`'in value'ları içindir:
+
+{* ../../docs_src/python_types/tutorial008_py39.py hl[1] *}
+
+Bu şu anlama gelir:
+
+* `prices` değişkeni bir `dict`'tir:
+    * Bu `dict`'in key'leri `str` tipindedir (örneğin her bir öğenin adı).
+    * Bu `dict`'in value'ları `float` tipindedir (örneğin her bir öğenin fiyatı).
+
+#### Union { #union }
+
+Bir değişkenin **birkaç tipten herhangi biri** olabileceğini bildirebilirsiniz; örneğin bir `int` veya bir `str`.
+
+Python 3.6 ve üzeri sürümlerde (Python 3.10 dahil), `typing` içinden `Union` tipini kullanabilir ve köşeli parantez içine kabul edilecek olası tipleri yazabilirsiniz.
+
+Python 3.10'da ayrıca, olası tipleri <abbr title='also called "bitwise or operator", but that meaning is not relevant here'>vertical bar (`|`)</abbr> ile ayırabildiğiniz **yeni bir sözdizimi** de vardır.
+
+//// tab | Python 3.10+
+
+```Python hl_lines="1"
+{!> ../../docs_src/python_types/tutorial008b_py310.py!}
 ```
 
-`str` yerine `Optional[str]` kullanmak editorün bu değerin her zaman `str` tipinde değil bazen `None` tipinde de olabileceğini belirtir ve hataları tespit etmemizde yardımcı olur.
+////
 
-#### Generic tipler
+//// tab | Python 3.9+
 
-Köşeli parantez içinde tip parametreleri alan bu türler, örneğin:
+```Python hl_lines="1  4"
+{!> ../../docs_src/python_types/tutorial008b_py39.py!}
+```
 
-* `List`
-* `Tuple`
-* `Set`
-* `Dict`
+////
+
+Her iki durumda da bu, `item`'ın `int` veya `str` olabileceği anlamına gelir.
+
+#### Muhtemelen `None` { #possibly-none }
+
+Bir değerin `str` gibi bir tipi olabileceğini ama aynı zamanda `None` da olabileceğini bildirebilirsiniz.
+
+Python 3.6 ve üzeri sürümlerde (Python 3.10 dahil), `typing` modülünden `Optional` import edip kullanarak bunu bildirebilirsiniz.
+
+```Python hl_lines="1  4"
+{!../../docs_src/python_types/tutorial009_py39.py!}
+```
+
+Sadece `str` yerine `Optional[str]` kullanmak, aslında değer `None` olabilecekken her zaman `str` olduğunu varsaydığınız hataları editörün yakalamanıza yardımcı olmasını sağlar.
+
+`Optional[Something]`, aslında `Union[Something, None]` için bir kısayoldur; eşdeğerdirler.
+
+Bu aynı zamanda Python 3.10'da `Something | None` kullanabileceğiniz anlamına gelir:
+
+//// 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+ alternatif
+
+```Python hl_lines="1  4"
+{!> ../../docs_src/python_types/tutorial009b_py39.py!}
+```
+
+////
+
+#### `Union` veya `Optional` kullanmak { #using-union-or-optional }
+
+Python sürümünüz 3.10'un altındaysa, benim oldukça **öznel** bakış açıma göre küçük bir ipucu:
+
+* 🚨 `Optional[SomeType]` kullanmaktan kaçının
+* Bunun yerine ✨ **`Union[SomeType, None]` kullanın** ✨.
+
+İkisi eşdeğerdir ve altta aynı şeydir; ama ben `Optional` yerine `Union` önermeyi tercih ederim. Çünkü "**optional**" kelimesi değerin optional olduğunu ima ediyor gibi durur; ama gerçekte anlamı "değer `None` olabilir"dir. Değer optional olmasa ve hâlâ required olsa bile.
+
+Bence `Union[SomeType, None]` ne anlama geldiğini daha açık şekilde ifade ediyor.
+
+Bu, tamamen kelimeler ve isimlendirmelerle ilgili. Ancak bu kelimeler, sizin ve ekip arkadaşlarınızın kod hakkında nasıl düşündüğünü etkileyebilir.
+
+Örnek olarak şu fonksiyonu ele alalım:
+
+{* ../../docs_src/python_types/tutorial009c_py39.py hl[1,4] *}
+
+`name` parametresi `Optional[str]` olarak tanımlanmış, ama **optional değil**; parametre olmadan fonksiyonu çağıramazsınız:
+
+```Python
+say_hi()  # Oh, no, this throws an error! 😱
+```
+
+`name` parametresi **hâlâ required**'dır (*optional* değildir) çünkü bir default değeri yoktur. Yine de `name`, değer olarak `None` kabul eder:
+
+```Python
+say_hi(name=None)  # This works, None is valid 🎉
+```
+
+İyi haber şu ki, Python 3.10'a geçtiğinizde bununla uğraşmanız gerekmeyecek; çünkü tiplerin union'larını tanımlamak için doğrudan `|` kullanabileceksiniz:
+
+{* ../../docs_src/python_types/tutorial009c_py310.py hl[1,4] *}
+
+Ve böylece `Optional` ve `Union` gibi isimlerle de uğraşmanız gerekmeyecek. 😎
+
+#### Generic tipler { #generic-types }
+
+Köşeli parantez içinde type parameter alan bu tiplere **Generic types** veya **Generics** denir, örneğin:
+
+//// tab | Python 3.10+
+
+Aynı builtin tipleri generics olarak kullanabilirsiniz (köşeli parantez ve içindeki tiplerle):
+
+* `list`
+* `tuple`
+* `set`
+* `dict`
+
+Ve önceki Python sürümlerinde olduğu gibi `typing` modülünden:
+
+* `Union`
 * `Optional`
 * ...and others.
 
-**Generic types** yada  **Generics** olarak adlandırılır.
+Python 3.10'da, `Union` ve `Optional` generics'lerini kullanmaya alternatif olarak, tip union'larını bildirmek için <abbr title='also called "bitwise or operator", but that meaning is not relevant here'>vertical bar (`|`)</abbr> kullanabilirsiniz; bu çok daha iyi ve daha basittir.
 
-### Tip olarak Sınıflar
+////
 
-Bir değişkenin tipini bir sınıf ile bildirebilirsiniz.
+//// tab | Python 3.9+
 
-Diyelim ki  `name` değerine sahip `Person` sınıfınız var:
+Aynı builtin tipleri generics olarak kullanabilirsiniz (köşeli parantez ve içindeki tiplerle):
 
-{* ../../docs_src/python_types/tutorial010.py hl[1:3] *}
+* `list`
+* `tuple`
+* `set`
+* `dict`
 
+Ve `typing` modülünden gelen generics:
 
-Sonra bir değişkeni 'Person' tipinde tanımlayabilirsiniz:
+* `Union`
+* `Optional`
+* ...and others.
 
-{* ../../docs_src/python_types/tutorial010.py hl[6] *}
+////
 
+### Tip olarak sınıflar { #classes-as-types }
 
-Ve yine bütün editör desteğini alırsınız:
+Bir sınıfı da bir değişkenin tipi olarak bildirebilirsiniz.
+
+Örneğin, adı olan bir `Person` sınıfınız olsun:
+
+{* ../../docs_src/python_types/tutorial010_py39.py hl[1:3] *}
+
+Sonra bir değişkeni `Person` tipinde olacak şekilde bildirebilirsiniz:
+
+{* ../../docs_src/python_types/tutorial010_py39.py hl[6] *}
+
+Ve sonra, yine tüm editör desteğini alırsınız:
 
 <img src="/img/python-types/image06.png">
 
-## Pydantic modelleri
+Bunun "`one_person`, `Person` sınıfının bir **instance**'ıdır" anlamına geldiğine dikkat edin.
 
-<a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> veri doğrulaması yapmak için bir Python kütüphanesidir.
+"`one_person`, `Person` adlı **class**'tır" anlamına gelmez.
 
-Verilerin "biçimini" niteliklere sahip sınıflar olarak düzenlersiniz.
+## Pydantic modelleri { #pydantic-models }
 
-Ve her niteliğin bir türü vardır.
+<a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>, data validation yapmak için bir Python kütüphanesidir.
 
-Sınıfın bazı değerlerle bir örneğini oluşturursunuz ve değerleri doğrular, bunları uygun türe dönüştürür ve size tüm verileri içeren bir nesne verir.
+Verinin "shape"'ini attribute'lara sahip sınıflar olarak tanımlarsınız.
 
-Ve ortaya çıkan nesne üzerindeki bütün editör desteğini alırsınız.
+Ve her attribute'un bir tipi vardır.
 
-Resmi Pydantic dokümanlarından alınmıştır:
+Ardından o sınıfın bir instance'ını bazı değerlerle oluşturursunuz; bu değerleri doğrular, uygun tipe dönüştürür (gerekliyse) ve size tüm veriyi içeren bir nesne verir.
 
-{* ../../docs_src/python_types/tutorial011.py *}
+Ve bu ortaya çıkan nesne ile tüm editör desteğini alırsınız.
 
+Resmî Pydantic dokümanlarından bir örnek:
 
-/// info
+{* ../../docs_src/python_types/tutorial011_py310.py *}
 
-Daha fazla şey öğrenmek için <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic'i takip edin</a>.
+/// info | Bilgi
+
+Daha fazlasını öğrenmek için <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic'in dokümanlarına bakın</a>.
 
 ///
 
-**FastAPI** tamamen Pydantic'e dayanmaktadır.
+**FastAPI** tamamen Pydantic üzerine kuruludur.
 
-Daha fazlasini görmek için [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank}.
+Bunların pratikte nasıl çalıştığını [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank} içinde çok daha fazla göreceksiniz.
 
-##  **FastAPI** tip belirteçleri
+/// tip | İpucu
 
-**FastAPI** birkaç şey yapmak için bu tür tip belirteçlerinden faydalanır.
-
-**FastAPI** ile parametre tiplerini bildirirsiniz ve şunları elde edersiniz:
-
-* **Editor desteği**.
-* **Tip kontrolü**.
-
-...ve **FastAPI** aynı belirteçleri şunlar için de kullanıyor:
-
-* **Gereksinimleri tanımlama**:  request path parameters, query parameters, headers, bodies, dependencies, ve benzeri gereksinimlerden
-* **Verileri çevirme**: Gönderilen veri tipinden istenilen veri tipine çevirme.
-* **Verileri doğrulama**: Her gönderilen verinin:
-    * doğrulanması ve geçersiz olduğunda **otomatik hata** oluşturma.
-* OpenAPI kullanarak apinizi **Belgeleyin** :
-    * bu daha sonra otomatik etkileşimli dokümantasyon kullanıcı arayüzü tarafından kullanılır.
-
-Bütün bunlar kulağa soyut gelebilir. Merak etme. Tüm bunları çalışırken göreceksiniz. [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank}.
-
-Önemli olan, standart Python türlerini tek bir yerde kullanarak (daha fazla sınıf, dekoratör vb. eklemek yerine), **FastAPI**'nin bizim için işi yapmasını sağlamak.
-
-/// info
-
-Tüm öğreticiyi zaten okuduysanız ve türler hakkında daha fazla bilgi için geri döndüyseniz, iyi bir kaynak:<a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank"> the "cheat sheet" from `mypy`</a>.
+Pydantic, default value olmadan `Optional` veya `Union[Something, None]` kullandığınızda özel bir davranışa sahiptir; bununla ilgili daha fazla bilgiyi Pydantic dokümanlarında <a href="https://docs.pydantic.dev/2.3/usage/models/#required-fields" class="external-link" target="_blank">Required Optional fields</a> bölümünde okuyabilirsiniz.
+
+///
+
+## Metadata Annotations ile Type Hints { #type-hints-with-metadata-annotations }
+
+Python'da ayrıca, `Annotated` kullanarak bu type hints içine **ek <abbr title="Veri hakkında veri; bu durumda type hakkında bilgi, örneğin bir açıklama.">metadata</abbr>** koymayı sağlayan bir özellik de vardır.
+
+Python 3.9'dan itibaren `Annotated`, standart kütüphanenin bir parçasıdır; bu yüzden `typing` içinden import edebilirsiniz.
+
+{* ../../docs_src/python_types/tutorial013_py39.py hl[1,4] *}
+
+Python'un kendisi bu `Annotated` ile bir şey yapmaz. Editörler ve diğer araçlar için tip hâlâ `str`'dir.
+
+Ama **FastAPI**'ye uygulamanızın nasıl davranmasını istediğinize dair ek metadata sağlamak için `Annotated` içindeki bu alanı kullanabilirsiniz.
+
+Hatırlanması gereken önemli nokta: `Annotated`'a verdiğiniz **ilk *type parameter***, **gerçek tip**tir. Geri kalanı ise diğer araçlar için metadatadır.
+
+Şimdilik, sadece `Annotated`'ın var olduğunu ve bunun standart Python olduğunu bilmeniz yeterli. 😎
+
+İleride bunun ne kadar **güçlü** olabildiğini göreceksiniz.
+
+/// tip | İpucu
+
+Bunun **standart Python** olması, editörünüzde mümkün olan **en iyi developer experience**'ı almaya devam edeceğiniz anlamına gelir; kodu analiz etmek ve refactor etmek için kullandığınız araçlarla da, vb. ✨
+
+Ayrıca kodunuzun pek çok başka Python aracı ve kütüphanesiyle çok uyumlu olacağı anlamına gelir. 🚀
+
+///
+
+## **FastAPI**'de type hints { #type-hints-in-fastapi }
+
+**FastAPI**, birkaç şey yapmak için bu type hints'ten faydalanır.
+
+**FastAPI** ile type hints kullanarak parametreleri bildirirsiniz ve şunları elde edersiniz:
+
+* **Editör desteği**.
+* **Tip kontrolleri**.
+
+...ve **FastAPI** aynı bildirimleri şunlar için de kullanır:
+
+* **Gereksinimleri tanımlamak**: request path parameters, query parameters, headers, bodies, dependencies, vb.
+* **Veriyi dönüştürmek**: request'ten gerekli tipe.
+* **Veriyi doğrulamak**: her request'ten gelen veriyi:
+    * Veri geçersiz olduğunda client'a dönen **otomatik hatalar** üretmek.
+* OpenAPI kullanarak API'yi **dokümante etmek**:
+    * bu, daha sonra otomatik etkileşimli dokümantasyon kullanıcı arayüzleri tarafından kullanılır.
+
+Bunların hepsi kulağa soyut gelebilir. Merak etmeyin. Tüm bunları [Tutorial - User Guide](tutorial/index.md){.internal-link target=_blank} içinde çalışırken göreceksiniz.
+
+Önemli olan, standart Python tiplerini tek bir yerde kullanarak (daha fazla sınıf, decorator vb. eklemek yerine), **FastAPI**'nin sizin için işin büyük kısmını yapmasıdır.
+
+/// info | Bilgi
+
+Tüm tutorial'ı zaten bitirdiyseniz ve tipler hakkında daha fazlasını görmek için geri döndüyseniz, iyi bir kaynak: <a href="https://mypy.readthedocs.io/en/latest/cheat_sheet_py3.html" class="external-link" target="_blank">`mypy`'nin "cheat sheet"i</a>.
 
 ///

docs/tr/docs/resources/index.md

@@ -1,3 +1,3 @@
-# Kaynaklar
+# Kaynaklar { #resources }
 
-Ek kaynaklar, dış bağlantılar, makaleler ve daha fazlası. ✈️
+Ek kaynaklar, dış bağlantılar ve daha fazlası. ✈️

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

@@ -1,35 +1,45 @@
-# Çerez (Cookie) Parametreleri
+# Çerez (Cookie) Parametreleri { #cookie-parameters }
 
-`Query` (Sorgu) ve `Path` (Yol) parametrelerini tanımladığınız şekilde çerez parametreleri tanımlayabilirsiniz.
+`Query` ve `Path` parametrelerini tanımladığınız şekilde Cookie parametreleri tanımlayabilirsiniz.
 
-## Import `Cookie`
+## `Cookie`'yi Import Edin { #import-cookie }
 
-Öncelikle, `Cookie`'yi projenize dahil edin:
+Öncelikle, `Cookie`'yi import edin:
 
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[3] *}
 
-## `Cookie` Parametrelerini Tanımlayın
+## `Cookie` Parametrelerini Tanımlayın { #declare-cookie-parameters }
 
-Çerez parametrelerini `Path` veya `Query` tanımlaması yapar gibi tanımlayın.
+Ardından, `Path` ve `Query` ile aynı yapıyı kullanarak Cookie parametrelerini tanımlayın.
 
-İlk değer varsayılan değerdir; tüm ekstra doğrulama veya belirteç parametrelerini kullanabilirsiniz:
+Varsayılan değeri ve tüm ekstra doğrulama veya annotation parametrelerini tanımlayabilirsiniz:
 
 {* ../../docs_src/cookie_params/tutorial001_an_py310.py hl[9] *}
 
 /// note | Teknik Detaylar
 
-`Cookie` sınıfı `Path` ve `Query` sınıflarının kardeşidir. Diğerleri gibi `Param` sınıfını miras alan bir sınıftır.
+`Cookie`, `Path` ve `Query`'nin "kardeş" sınıfıdır. O da aynı ortak `Param` sınıfından miras alır.
 
-Ancak `fastapi`'dan projenize dahil ettiğiniz `Query`, `Path`, `Cookie` ve diğerleri aslında özel sınıflar döndüren birer fonksiyondur.
+Ancak `fastapi`'dan `Query`, `Path`, `Cookie` ve diğerlerini import ettiğinizde, bunlar aslında özel sınıflar döndüren fonksiyonlardır, bunu unutmayın.
 
 ///
 
 /// info | Bilgi
 
-Çerez tanımlamak için `Cookie` sınıfını kullanmanız gerekmektedir, aksi taktirde parametreler sorgu parametreleri olarak yorumlanır.
+Çerezleri tanımlamak için `Cookie` kullanmanız gerekir, aksi halde parametreler query parametreleri olarak yorumlanır.
 
 ///
 
-## Özet
+/// info | Bilgi
 
-Çerez tanımlamalarını `Cookie` sınıfını kullanarak `Query` ve `Path` tanımlar gibi tanımlayın.
+**Tarayıcılar çerezleri** özel şekillerde ve arka planda işlediği için, **JavaScript**'in onlara dokunmasına kolayca izin **vermezler**.
+
+`/docs` adresindeki **API docs UI**'a giderseniz, *path operation*'larınız için çerezlerin **dokümantasyonunu** görebilirsiniz.
+
+Ancak **veriyi doldurup** "Execute" düğmesine tıklasanız bile, docs UI **JavaScript** ile çalıştığı için çerezler gönderilmez ve herhangi bir değer yazmamışsınız gibi bir **hata** mesajı görürsünüz.
+
+///
+
+## Özet { #recap }
+
+`Query` ve `Path` ile aynı ortak deseni kullanarak, çerezleri `Cookie` ile tanımlayın.

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

@@ -1,102 +1,118 @@
-# İlk Adımlar
+# İlk Adımlar { #first-steps }
 
 En sade FastAPI dosyası şu şekilde görünür:
 
-{* ../../docs_src/first_steps/tutorial001.py *}
+{* ../../docs_src/first_steps/tutorial001_py39.py *}
 
-Yukarıdaki içeriği bir `main.py` dosyasına kopyalayalım.
+Yukarıdakini `main.py` adlı bir dosyaya kopyalayın.
 
-Uygulamayı çalıştıralım:
+Canlı sunucuyu çalıştırın:
 
 <div class="termy">
 
 ```console
-$ uvicorn main:app --reload
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
 
-<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.
+  <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>
 
-/// note | Not
-
-`uvicorn main:app` komutunu şu şekilde açıklayabiliriz:
-
-* `main`: dosya olan `main.py` (yani Python "modülü").
-* `app`: ise `main.py` dosyasının içerisinde `app = FastAPI()` satırında oluşturduğumuz `FastAPI` nesnesi.
-* `--reload`: kod değişikliklerinin ardından sunucuyu otomatik olarak yeniden başlatır. Bu parameteyi sadece geliştirme aşamasında kullanmalıyız.
-
-///
-
-Çıktı olarak şöyle bir satır ile karşılaşacaksınız:
+Çıktıda, şuna benzer bir satır göreceksiniz:
 
 ```hl_lines="4"
 INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
 ```
 
-Bu satır, yerel makinenizde uygulamanızın çalıştığı bağlantıyı gösterir.
+Bu satır, uygulamanızın yerel makinenizde hangi URL'de sunulduğunu gösterir.
 
-### Kontrol Edelim
+### Kontrol Edelim { #check-it }
 
-Tarayıcınızı açıp <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a> bağlantısına gidin.
+Tarayıcınızı açıp <a href="http://127.0.0.1:8000" class="external-link" target="_blank">http://127.0.0.1:8000</a> adresine gidin.
 
-Şu şekilde bir JSON yanıtı ile karşılaşacağız:
+Şu şekilde bir JSON response göreceksiniz:
 
 ```JSON
 {"message": "Hello World"}
 ```
 
-### Etkileşimli API Dokümantasyonu
+### Etkileşimli API Dokümantasyonu { #interactive-api-docs }
 
-Şimdi <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> bağlantısını açalım.
+Şimdi <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresine gidin.
 
-<a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a> tarafından sağlanan otomatik etkileşimli bir API dokümantasyonu göreceğiz:
+Otomatik etkileşimli API dokümantasyonunu ( <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Swagger UI</a> tarafından sağlanan) göreceksiniz:
 
 ![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
 
-### Alternatif API Dokümantasyonu
+### Alternatif API Dokümantasyonu { #alternative-api-docs }
 
-Şimdi <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> bağlantısını açalım.
+Ve şimdi <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> adresine gidin.
 
-<a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a> tarafından sağlanan otomatik dokümantasyonu göreceğiz:
+Alternatif otomatik dokümantasyonu ( <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a> tarafından sağlanan) göreceksiniz:
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
 
-### OpenAPI
+### OpenAPI { #openapi }
 
-**FastAPI**, **OpenAPI** standardını kullanarak tüm API'ınızın tamamını tanımlayan bir "şema" oluşturur.
+**FastAPI**, API'ları tanımlamak için **OpenAPI** standardını kullanarak tüm API'nızın tamamını içeren bir "şema" üretir.
 
-#### "Şema"
+#### "Şema" { #schema }
 
-"Şema", bir şeyin tanımı veya açıklamasıdır. Geliştirilen koddan ziyade soyut bir açıklamadır.
+"Şema", bir şeyin tanımı veya açıklamasıdır. Onu uygulayan kod değil, sadece soyut bir açıklamadır.
 
-#### API "Şeması"
+#### API "şeması" { #api-schema }
 
-Bu durumda, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a>, API şemasını nasıl tanımlayacağınızı belirten bir şartnamedir.
+Bu durumda, <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank">OpenAPI</a>, API'nızın şemasını nasıl tanımlayacağınızı belirleyen bir şartnamedir.
 
-Bu şema tanımı, API yollarınızla birlikte yollarınızın aldığı olası parametreler gibi tanımlamaları içerir.
+Bu şema tanımı, API path'leriniz, alabilecekleri olası parametreler vb. şeyleri içerir.
 
-#### Veri "Şeması"
+#### Veri "şeması" { #data-schema }
 
 "Şema" terimi, JSON içeriği gibi bazı verilerin şeklini de ifade edebilir.
 
-Bu durumda, JSON özellikleri ve sahip oldukları veri türleri gibi anlamlarına gelir.
+Bu durumda, JSON attribute'ları ve sahip oldukları veri türleri vb. anlamına gelir.
 
-#### OpenAPI ve JSON Şema
+#### OpenAPI ve JSON Schema { #openapi-and-json-schema }
 
-OpenAPI, API'niz için bir API şeması tanımlar. Ve bu şema, JSON veri şemaları standardı olan **JSON Şema** kullanılarak API'niz tarafından gönderilen ve alınan verilerin tanımlarını (veya "şemalarını") içerir.
+OpenAPI, API'nız için bir API şeması tanımlar. Ve bu şema, JSON veri şemaları standardı olan **JSON Schema** kullanılarak API'nız tarafından gönderilen ve alınan verilerin tanımlarını (veya "şemalarını") içerir.
 
-#### `openapi.json` Dosyasına Göz At
+#### `openapi.json` Dosyasına Göz At { #check-the-openapi-json }
 
-Ham OpenAPI şemasının nasıl göründüğünü merak ediyorsanız, FastAPI otomatik olarak tüm API'ınızın tanımlamalarını içeren bir JSON (şeması) oluşturur.
+Ham OpenAPI şemasının nasıl göründüğünü merak ediyorsanız, FastAPI otomatik olarak tüm API'nızın açıklamalarını içeren bir JSON (şema) üretir.
 
-Bu şemayı direkt olarak <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a> bağlantısından görüntüleyebilirsiniz.
+Bunu doğrudan şuradan görebilirsiniz: <a href="http://127.0.0.1:8000/openapi.json" class="external-link" target="_blank">http://127.0.0.1:8000/openapi.json</a>.
 
-Aşağıdaki gibi başlayan bir JSON ile karşılaşacaksınız:
+Şuna benzer bir şekilde başlayan bir JSON gösterecektir:
 
 ```JSON
 {
@@ -119,79 +135,87 @@ Aşağıdaki gibi başlayan bir JSON ile karşılaşacaksınız:
 ...
 ```
 
-#### OpenAPI Ne İşe Yarar?
+#### OpenAPI Ne İşe Yarar? { #what-is-openapi-for }
 
-OpenAPI şeması, FastAPI projesinde bulunan iki etkileşimli dokümantasyon sistemine güç veren şeydir.
+OpenAPI şeması, dahil edilen iki etkileşimli dokümantasyon sistemine güç veren şeydir.
 
-OpenAPI'ya dayalı düzinelerce alternatif etkileşimli dokümantasyon aracı mevcuttur. **FastAPI** ile oluşturulmuş uygulamanıza bu alternatiflerden herhangi birini kolayca ekleyebilirsiniz.
+Ve OpenAPI tabanlı düzinelerce alternatif vardır. **FastAPI** ile oluşturulmuş uygulamanıza bu alternatiflerden herhangi birini kolayca ekleyebilirsiniz.
 
-Ayrıca, API'ınızla iletişim kuracak önyüz, mobil veya IoT uygulamaları gibi istemciler için otomatik olarak kod oluşturabilirsiniz.
+Ayrıca, API'nızla iletişim kuran istemciler için otomatik olarak kod üretmekte de kullanabilirsiniz. Örneğin frontend, mobil veya IoT uygulamaları.
 
-## Adım Adım Özetleyelim
+### Uygulamanızı Yayınlayın (opsiyonel) { #deploy-your-app-optional }
 
-### Adım 1: `FastAPI`yı Projemize Dahil Edelim
+İsterseniz FastAPI uygulamanızı <a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>'a deploy edebilirsiniz; henüz katılmadıysanız gidip bekleme listesine yazılın. 🚀
 
-{* ../../docs_src/first_steps/tutorial001.py hl[1] *}
+Zaten bir **FastAPI Cloud** hesabınız varsa (bekleme listesinden sizi davet ettiysek 😉), uygulamanızı tek komutla deploy edebilirsiniz.
 
-`FastAPI`, API'niz için tüm işlevselliği sağlayan bir Python sınıfıdır.
+Deploy etmeden önce giriş yaptığınızdan emin olun:
+
+<div class="termy">
+
+```console
+$ fastapi login
+
+You are logged in to FastAPI Cloud 🚀
+```
+
+</div>
+
+Ardından uygulamanızı 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>
+
+Bu kadar! Artık uygulamanıza o URL üzerinden erişebilirsiniz. ✨
+
+## Adım Adım Özetleyelim { #recap-step-by-step }
+
+### Adım 1: `FastAPI` import edin { #step-1-import-fastapi }
+
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[1] *}
+
+`FastAPI`, API'nız için tüm işlevselliği sağlayan bir Python class'ıdır.
 
 /// note | Teknik Detaylar
 
-`FastAPI` doğrudan `Starlette`'i miras alan bir sınıftır.
+`FastAPI`, doğrudan `Starlette`'ten miras alan bir class'tır.
 
 <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a>'in tüm işlevselliğini `FastAPI` ile de kullanabilirsiniz.
 
 ///
 
-### Adım 2: Bir `FastAPI` "Örneği" Oluşturalım
+### Adım 2: bir `FastAPI` "instance"ı oluşturun { #step-2-create-a-fastapi-instance }
 
-{* ../../docs_src/first_steps/tutorial001.py hl[3] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[3] *}
 
-Burada `app` değişkeni `FastAPI` sınıfının bir örneği olacaktır.
+Burada `app` değişkeni `FastAPI` class'ının bir "instance"ı olacaktır.
 
-Bu, tüm API'yı oluşturmak için ana etkileşim noktası olacaktır.
+Bu, tüm API'nızı oluşturmak için ana etkileşim noktası olacaktır.
 
-Bu `app` değişkeni, `uvicorn` komutunda atıfta bulunulan değişkenin ta kendisidir.
+### Adım 3: bir *path operation* oluşturun { #step-3-create-a-path-operation }
 
-<div class="termy">
+#### Path { #path }
 
-```console
-$ uvicorn main:app --reload
+Buradaki "Path", URL'in ilk `/` işaretinden başlayarak son kısmını ifade eder.
 
-<span style="color: green;">INFO</span>:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
-```
-
-</div>
-
-Uygulamanızı aşağıdaki gibi oluşturursanız:
-
-{* ../../docs_src/first_steps/tutorial002.py hl[3] *}
-
-Ve bunu `main.py` dosyasına yerleştirirseniz eğer `uvicorn` komutunu şu şekilde çalıştırabilirsiniz:
-
-<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>
-
-### Adım 3: Bir *Yol Operasyonu* Oluşturalım
-
-#### <abbr title="Yol: Path">Yol</abbr>
-
-Burada "yol" bağlantıda bulunan ilk `/` ile başlayan ve sonrasında gelen kısmı ifade eder.
-
-Yani, şu şekilde bir bağlantıda:
+Yani, şu şekilde bir URL'de:
 
 ```
 https://example.com/items/foo
 ```
 
-... yol şöyle olur:
+...path şöyle olur:
 
 ```
 /items/foo
@@ -199,77 +223,77 @@ https://example.com/items/foo
 
 /// info | Bilgi
 
-"Yol" genellikle "<abbr title="Endpoint: Bitim Noktası">endpoint</abbr>" veya "<abbr title="Route: Yönlendirme/Yön">route</abbr>" olarak adlandırılır.
+Bir "path" genellikle "endpoint" veya "route" olarak da adlandırılır.
 
 ///
 
-Bir API oluştururken, "yol", "kaynaklar" ile "endişeleri" ayırmanın ana yöntemidir.
+Bir API oluştururken, "path", "concerns" ve "resources" ayrımını yapmanın ana yoludur.
 
-#### Operasyonlar
+#### Operation { #operation }
 
-Burada "operasyon" HTTP "metodlarından" birini ifade eder.
+Burada "Operation", HTTP "method"larından birini ifade eder.
 
-Bunlardan biri:
+Şunlardan biri:
 
 * `POST`
 * `GET`
 * `PUT`
 * `DELETE`
 
-...veya daha az kullanılan diğerleri:
+...ve daha egzotik olanlar:
 
 * `OPTIONS`
 * `HEAD`
 * `PATCH`
 * `TRACE`
 
-HTTP protokolünde, bu "metodlardan" birini (veya daha fazlasını) kullanarak her bir yol ile iletişim kurabilirsiniz.
+HTTP protokolünde, her bir path ile bu "method"lardan biri (veya birden fazlası) ile iletişim kurabilirsiniz.
 
 ---
 
-API oluştururkan, belirli bir amaca hizmet eden belirli HTTP metodlarını kullanırsınız.
+API oluştururken, normalde belirli bir aksiyon için bu spesifik HTTP method'larını kullanırsınız.
 
-Normalde kullanılan:
+Normalde şunları kullanırsınız:
 
-* `POST`: veri oluşturmak.
-* `GET`: veri okumak.
-* `PUT`: veriyi güncellemek.
-* `DELETE`: veriyi silmek.
+* `POST`: veri oluşturmak için.
+* `GET`: veri okumak için.
+* `PUT`: veriyi güncellemek için.
+* `DELETE`: veriyi silmek için.
 
-Bu nedenle, OpenAPI'da HTTP metodlarından her birine "operasyon" denir.
+Bu nedenle, OpenAPI'da HTTP method'larının her birine "operation" denir.
 
-Biz de onları "**operasyonlar**" olarak adlandıracağız.
+Biz de bunlara "**operation**" diyeceğiz.
 
-#### Bir *Yol Operasyonu Dekoratörü* Tanımlayalım
+#### Bir *path operation decorator* tanımlayın { #define-a-path-operation-decorator }
 
-{* ../../docs_src/first_steps/tutorial001.py hl[6] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[6] *}
 
-`@app.get("/")` dekoratörü, **FastAPI**'a hemen altındaki fonksiyonun aşağıdaki durumlardan sorumlu olduğunu söyler:
+`@app.get("/")`, **FastAPI**'a hemen altındaki fonksiyonun şuraya giden request'leri ele almakla sorumlu olduğunu söyler:
 
-* <abbr title="Bir HTTP GET metodu"><code>get</code> operasyonu</abbr> ile
-* `/` yoluna gelen istekler
+* path `/`
+* <abbr title="bir HTTP GET method'u"><code>get</code> operation</abbr> kullanarak
 
 /// info | `@decorator` Bilgisi
 
-Python'da `@something` sözdizimi "<abbr title="Decorator">dekoratör</abbr>" olarak adlandırılır.
+Python'daki `@something` söz dizimi "decorator" olarak adlandırılır.
 
-Dekoratörler, dekoratif bir şapka gibi (sanırım terim buradan geliyor) fonksiyonların üzerlerine yerleştirilirler.
+Onu bir fonksiyonun üstüne koyarsınız. Güzel, dekoratif bir şapka gibi (sanırım terim de buradan geliyor).
 
-Bir "dekoratör" hemen altında bulunan fonksiyonu alır ve o fonksiyon ile bazı işlemler gerçekleştirir.
+Bir "decorator", altındaki fonksiyonu alır ve onunla bir şey yapar.
 
-Bizim durumumuzda, kullandığımız dekoratör, **FastAPI**'a altındaki fonksiyonun `/` yoluna gelen `get` metodlu isteklerden sorumlu olduğunu söyler.
+Bizim durumumuzda bu decorator, **FastAPI**'a altındaki fonksiyonun **path** `/` ile **operation** `get`'e karşılık geldiğini söyler.
 
-Bu bir **yol operasyonu dekoratörüdür**.
+Bu, "**path operation decorator**"dır.
 
 ///
 
-Ayrıca diğer operasyonları da kullanabilirsiniz:
+Diğer operation'ları da kullanabilirsiniz:
 
 * `@app.post()`
 * `@app.put()`
 * `@app.delete()`
 
-Daha az kullanılanları da kullanabilirsiniz:
+Ve daha egzotik olanları:
 
 * `@app.options()`
 * `@app.head()`
@@ -278,58 +302,79 @@ Daha az kullanılanları da kullanabilirsiniz:
 
 /// tip | İpucu
 
-Her işlemi (HTTP metod) istediğiniz gibi kullanmakta özgürsünüz.
+Her bir operation'ı (HTTP method'unu) istediğiniz gibi kullanmakta özgürsünüz.
 
-**FastAPI** herhangi bir özel amacı veya anlamı olması konusunda ısrarcı olmaz.
+**FastAPI** herhangi bir özel anlamı zorunlu kılmaz.
 
 Buradaki bilgiler bir gereklilik değil, bir kılavuz olarak sunulmaktadır.
 
-Mesela GraphQL kullanırkan genelde tüm işlemleri yalnızca `POST` operasyonunu kullanarak gerçekleştirirsiniz.
+Örneğin GraphQL kullanırken, normalde tüm aksiyonları yalnızca `POST` operation'ları kullanarak gerçekleştirirsiniz.
 
 ///
 
-### Adım 4: **Yol Operasyonu Fonksiyonunu** Tanımlayın
+### Adım 4: **path operation function**'ı tanımlayın { #step-4-define-the-path-operation-function }
 
-Aşağıdaki, bizim **yol operasyonu fonksiyonumuzdur**:
+Bu bizim "**path operation function**"ımız:
 
-* **yol**: `/`
-* **operasyon**: `get`
-* **fonksiyon**: "dekoratör"ün (`@app.get("/")`'in) altındaki fonksiyondur.
+* **path**: `/`.
+* **operation**: `get`.
+* **function**: "decorator"ün altındaki fonksiyondur (`@app.get("/")`'in altındaki).
 
-{* ../../docs_src/first_steps/tutorial001.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[7] *}
 
 Bu bir Python fonksiyonudur.
 
-Bu fonksiyon bir `GET` işlemi kullanılarak "`/`" bağlantısına bir istek geldiğinde **FastAPI** tarafından çağrılır.
+**FastAPI**, "`/`" URL'ine `GET` operation kullanarak bir request aldığında bu fonksiyonu çağıracaktır.
 
-Bu durumda bu fonksiyon bir `async` fonksiyondur.
+Bu durumda, bu bir `async` fonksiyondur.
 
 ---
 
-Bu fonksiyonu `async def` yerine normal bir fonksiyon olarak da tanımlayabilirsiniz.
+Bunu `async def` yerine normal bir fonksiyon olarak da tanımlayabilirsiniz:
 
-{* ../../docs_src/first_steps/tutorial003.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial003_py39.py hl[7] *}
 
 /// note | Not
 
-Eğer farkı bilmiyorsanız, [Async: *"Aceleniz mi var?"*](../async.md#in-a-hurry){.internal-link target=_blank} sayfasını kontrol edebilirsiniz.
+Eğer farkı bilmiyorsanız, [Async: *"Aceleniz mi var?"*](../async.md#in-a-hurry){.internal-link target=_blank} sayfasına bakın.
 
 ///
 
-### Adım 5: İçeriği Geri Döndürün
+### Adım 5: içeriği döndürün { #step-5-return-the-content }
 
-{* ../../docs_src/first_steps/tutorial001.py hl[8] *}
+{* ../../docs_src/first_steps/tutorial001_py39.py hl[8] *}
 
-Bir `dict`, `list` veya `str`, `int` gibi tekil değerler döndürebilirsiniz.
+Bir `dict`, `list`, `str`, `int` vb. tekil değerler döndürebilirsiniz.
 
-Ayrıca, Pydantic modelleri de döndürebilirsiniz (bu konu ileriki aşamalarda irdelenecektir).
+Ayrıca Pydantic modelleri de döndürebilirsiniz (bununla ilgili daha fazlasını ileride göreceksiniz).
 
-Otomatik olarak JSON'a dönüştürülecek (ORM'ler vb. dahil) başka birçok nesne ve model vardır. En beğendiklerinizi kullanmayı deneyin, yüksek ihtimalle destekleniyordur.
+Otomatik olarak JSON'a dönüştürülecek (ORM'ler vb. dahil) başka birçok nesne ve model vardır. En sevdiğiniz nesne/model'leri kullanmayı deneyin; büyük ihtimalle zaten destekleniyordur.
 
-## Özet
+### Adım 6: Deploy edin { #step-6-deploy-it }
 
-* `FastAPI`'yı projemize dahil ettik.
-* Bir `app` örneği oluşturduk.
-* Bir **yol operasyonu dekoratörü** (`@app.get("/")` gibi) yazdık.
-* Bir **yol operasyonu fonksiyonu** (`def root(): ...` gibi) yazdık.
-* Geliştirme sunucumuzu (`uvicorn main:app --reload` gibi) çalıştırdık.
+Uygulamanızı tek komutla **<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>**'a deploy edin: `fastapi deploy`. 🎉
+
+#### FastAPI Cloud Hakkında { #about-fastapi-cloud }
+
+**<a href="https://fastapicloud.com" class="external-link" target="_blank">FastAPI Cloud</a>**, **FastAPI**'ın arkasındaki aynı yazar ve ekip tarafından geliştirilmiştir.
+
+Minimum eforla bir API'ı **oluşturma**, **deploy etme** ve **erişme** sürecini sadeleştirir.
+
+FastAPI ile uygulama geliştirirken yaşadığınız aynı **developer experience**'ı, onları buluta **deploy etme** aşamasına da taşır. 🎉
+
+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 edin { #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ı onlarla deploy etmek için cloud sağlayıcınızın kılavuzlarını takip edin. 🤓
+
+## Özet { #recap }
+
+* `FastAPI` import edin.
+* Bir `app` instance'ı oluşturun.
+* `@app.get("/")` gibi decorator'ları kullanarak bir **path operation decorator** yazın.
+* Bir **path operation function** tanımlayın; örneğin `def root(): ...`.
+* `fastapi dev` komutunu kullanarak geliştirme sunucusunu çalıştırın.
+* İsterseniz `fastapi deploy` ile uygulamanızı deploy edin.

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

@@ -1,34 +1,34 @@
-# Yol Parametreleri
+# Yol Parametreleri { #path-parameters }
 
-Yol "parametrelerini" veya "değişkenlerini" Python <abbr title="String Biçimleme: Format String">string biçimlemede</abbr> kullanılan sözdizimi ile tanımlayabilirsiniz.
+Python <abbr title="String Biçimleme: Format String">string biçimlemede</abbr> kullanılan sözdizimiyle path "parametreleri"ni veya "değişkenleri"ni tanımlayabilirsiniz:
 
-{* ../../docs_src/path_params/tutorial001.py hl[6:7] *}
+{* ../../docs_src/path_params/tutorial001_py39.py hl[6:7] *}
 
-Yol parametresi olan `item_id`'nin değeri, fonksiyonunuza `item_id` argümanı olarak aktarılacaktır.
+Path parametresi `item_id`'nin değeri, fonksiyonunuza `item_id` argümanı olarak aktarılacaktır.
 
-Eğer bu örneği çalıştırıp <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> sayfasına giderseniz, şöyle bir çıktı ile karşılaşırsınız:
+Yani, bu örneği çalıştırıp <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> adresine giderseniz, şöyle bir response görürsünüz:
 
 ```JSON
 {"item_id":"foo"}
 ```
 
-## Tip İçeren Yol Parametreleri
+## Tip İçeren Yol Parametreleri { #path-parameters-with-types }
 
-Standart Python tip belirteçlerini kullanarak yol parametresinin tipini fonksiyonun içerisinde tanımlayabilirsiniz.
+Standart Python tip belirteçlerini kullanarak path parametresinin tipini fonksiyonun içinde tanımlayabilirsiniz:
 
-{* ../../docs_src/path_params/tutorial002.py hl[7] *}
+{* ../../docs_src/path_params/tutorial002_py39.py hl[7] *}
 
-Bu durumda, `item_id` bir `int` olarak tanımlanacaktır.
+Bu durumda, `item_id` bir `int` olarak tanımlanır.
 
 /// check | Ek bilgi
 
-Bu sayede, fonksiyon içerisinde hata denetimi, kod tamamlama gibi konularda editör desteğine kavuşacaksınız.
+Bu sayede, fonksiyon içinde hata denetimi, kod tamamlama vb. konularda editör desteğine kavuşursunuz.
 
 ///
 
-## Veri <abbr title="Dönüşüm: serialization, parsing ve marshalling olarak da biliniyor">Dönüşümü</abbr>
+## Veri <abbr title="also known as: endpoints, routes">conversion</abbr> { #data-conversion }
 
-Eğer bu örneği çalıştırıp tarayıcınızda <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a> sayfasını açarsanız, şöyle bir yanıt ile karşılaşırsınız:
+Bu örneği çalıştırıp tarayıcınızda <a href="http://127.0.0.1:8000/items/3" class="external-link" target="_blank">http://127.0.0.1:8000/items/3</a> adresini açarsanız, şöyle bir response görürsünüz:
 
 ```JSON
 {"item_id":3}
@@ -36,15 +36,15 @@ Eğer bu örneği çalıştırıp tarayıcınızda <a href="http://127.0.0.1:800
 
 /// check | Ek bilgi
 
-Dikkatinizi çekerim ki, fonksiyonunuzun aldığı (ve döndürdüğü) değer olan `3` bir string `"3"` değil aksine bir Python `int`'idir.
+Dikkat edin: fonksiyonunuzun aldığı (ve döndürdüğü) değer olan `3`, string `"3"` değil, bir Python `int`'idir.
 
-Bu tanımlamayla birlikte, **FastAPI** size otomatik istek <abbr title="HTTP isteği ile birlikte gelen string'i Python verisine dönüştürme">"ayrıştırma"</abbr> özelliği sağlar.
+Yani, bu tip tanımıyla birlikte **FastAPI** size otomatik request <abbr title="HTTP isteği ile birlikte gelen string'i Python verisine dönüştürme">"parsing"</abbr> sağlar.
 
 ///
 
-## Veri Doğrulama
+## Veri Doğrulama { #data-validation }
 
-Eğer tarayıcınızda <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> sayfasını açarsanız, şuna benzer güzel bir HTTP hatası ile karşılaşırsınız:
+Ancak tarayıcınızda <a href="http://127.0.0.1:8000/items/foo" class="external-link" target="_blank">http://127.0.0.1:8000/items/foo</a> adresine giderseniz, şuna benzer güzel bir HTTP hatası görürsünüz:
 
 ```JSON
 {
@@ -62,141 +62,135 @@ Eğer tarayıcınızda <a href="http://127.0.0.1:8000/items/foo" class="external
 }
 ```
 
-Çünkü burada `item_id` yol parametresi `int` tipinde bir değer beklerken `"foo"` yani `string` tipinde bir değer almıştı.
+çünkü path parametresi `item_id`, `int` olmayan `"foo"` değerine sahipti.
 
-Aynı hata <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> sayfasında olduğu gibi `int` yerine `float` bir değer verseydik de ortaya çıkardı.
+Aynı hata, şu örnekte olduğu gibi `int` yerine `float` verirseniz de ortaya çıkar: <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 | Ek bilgi
 
-Böylece, aynı Python tip tanımlaması ile birlikte, **FastAPI** veri doğrulama özelliği sağlar.
+Yani, aynı Python tip tanımıyla birlikte **FastAPI** size veri doğrulama sağlar.
 
-Dikkatinizi çekerim ki, karşılaştığınız hata, doğrulamanın geçersiz olduğu mutlak noktayı da açık bir şekilde belirtiyor.
+Dikkat edin: hata ayrıca doğrulamanın geçmediği noktayı da açıkça belirtir.
 
-Bu özellik, API'ınızla iletişime geçen kodu geliştirirken ve ayıklarken inanılmaz derecede yararlı olacaktır.
+Bu, API'ınızla etkileşime giren kodu geliştirirken ve debug ederken inanılmaz derecede faydalıdır.
 
 ///
 
-## Dokümantasyon
+## Dokümantasyon { #documentation }
 
-Ayrıca, tarayıcınızı <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresinde açarsanız, aşağıdaki gibi otomatik ve interaktif bir API dökümantasyonu ile karşılaşırsınız:
+Tarayıcınızı <a href="http://127.0.0.1:8000/docs" class="external-link" target="_blank">http://127.0.0.1:8000/docs</a> adresinde açtığınızda, aşağıdaki gibi otomatik ve interaktif bir API dokümantasyonu görürsünüz:
 
 <img src="/img/tutorial/path-params/image01.png">
 
 /// check | Ek bilgi
 
-Üstelik, sadece aynı Python tip tanımlaması ile, **FastAPI** size otomatik ve interaktif (Swagger UI ile entegre) bir dokümantasyon sağlar.
+Yine, sadece aynı Python tip tanımıyla **FastAPI** size otomatik ve interaktif dokümantasyon (Swagger UI entegrasyonuyla) sağlar.
 
-Dikkatinizi çekerim ki, yol parametresi integer olarak tanımlanmıştır.
+Dikkat edin: path parametresi integer olarak tanımlanmıştır.
 
 ///
 
-## Standartlara Dayalı Avantajlar, Alternatif Dokümantasyon
+## Standartlara Dayalı Avantajlar, Alternatif Dokümantasyon { #standards-based-benefits-alternative-documentation }
 
-Oluşturulan şema <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a> standardına uygun olduğu için birçok uyumlu araç mevcuttur.
+Üretilen şema <a href="https://github.com/OAI/OpenAPI-Specification/blob/master/versions/3.1.0.md" class="external-link" target="_blank">OpenAPI</a> standardından geldiği için birçok uyumlu araç vardır.
 
-Bu sayede, **FastAPI**'ın bizzat kendisi <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> sayfasından erişebileceğiniz alternatif (ReDoc kullanan) bir API dokümantasyonu sağlar:
+Bu nedenle **FastAPI**'ın kendisi, <a href="http://127.0.0.1:8000/redoc" class="external-link" target="_blank">http://127.0.0.1:8000/redoc</a> adresinden erişebileceğiniz alternatif bir API dokümantasyonu (ReDoc kullanarak) sağlar:
 
 <img src="/img/tutorial/path-params/image02.png">
 
-Aynı şekilde, farklı diller için kod türetme araçları da dahil olmak üzere çok sayıda uyumlu araç bulunur.
+Aynı şekilde, birçok uyumlu araç vardır. Birçok dil için kod üretme araçları da buna dahildir.
 
-## Pydantic
+## Pydantic { #pydantic }
 
-Tüm veri doğrulamaları <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> tarafından arka planda gerçekleştirilir, bu sayede tüm avantajlardan faydalanabilirsiniz. Böylece, emin ellerde olduğunuzu hissedebilirsiniz.
+Tüm veri doğrulamaları, arka planda <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> tarafından gerçekleştirilir; böylece onun tüm avantajlarından faydalanırsınız. Ve emin ellerde olduğunuzu bilirsiniz.
 
-Aynı tip tanımlamalarını `str`, `float`, `bool` ve diğer karmaşık veri tipleri ile kullanma imkanınız vardır.
+Aynı tip tanımlarını `str`, `float`, `bool` ve daha birçok karmaşık veri tipiyle kullanabilirsiniz.
 
-Bunlardan birkaçı, bu eğitimin ileriki bölümlerinde irdelenmiştir.
+Bunların birkaçı, eğitimin sonraki bölümlerinde ele alınacaktır.
 
-## Sıralama Önem Arz Eder
+## Sıralama Önemlidir { #order-matters }
 
-*Yol operasyonları* tasarlarken sabit yol barındıran durumlar ile karşılaşabilirsiniz.
+*Path operation*'lar oluştururken sabit bir path'e sahip olduğunuz durumlarla karşılaşabilirsiniz.
 
-Farz edelim ki `/users/me` yolu geçerli kullanıcı hakkında bilgi almak için kullanılıyor olsun.
+Örneğin `/users/me`'nin, geçerli kullanıcı hakkında veri almak için kullanıldığını varsayalım.
 
-Benzer şekilde `/users/{user_id}` gibi tanımlanmış ve belirli bir kullanıcı hakkında veri almak için kullanıcının ID bilgisini kullanan bir yolunuz da mevcut olabilir.
+Sonra belirli bir kullanıcı hakkında, kullanıcı ID'si ile veri almak için `/users/{user_id}` şeklinde bir path'iniz de olabilir.
 
-*Yol operasyonları* sıralı bir şekilde gözden geçirildiğinden dolayı `/users/me` yolunun `/users/{user_id}` yolundan önce tanımlanmış olmasından emin olmanız gerekmektedir:
+*Path operation*'lar sırayla değerlendirildiği için, `/users/me` için olan path'in `/users/{user_id}` olandan önce tanımlandığından emin olmanız gerekir:
 
-{* ../../docs_src/path_params/tutorial003.py hl[6,11] *}
+{* ../../docs_src/path_params/tutorial003_py39.py hl[6,11] *}
 
-Aksi halde, `/users/{user_id}` yolu `"me"` değerinin `user_id` parametresi için gönderildiğini "düşünerek" `/users/me` ile de eşleşir.
+Aksi halde, `/users/{user_id}` için olan path, `"me"` değerini `user_id` parametresi olarak aldığını "düşünerek" `/users/me` için de eşleşir.
 
-Benzer şekilde, bir yol operasyonunu yeniden tanımlamanız mümkün değildir:
+Benzer şekilde, bir path operation'ı yeniden tanımlayamazsınız:
 
-{* ../../docs_src/path_params/tutorial003b.py hl[6,11] *}
+{* ../../docs_src/path_params/tutorial003b_py39.py hl[6,11] *}
 
-Yol, ilk kısım ile eşleştiğinden dolayı her koşulda ilk yol operasyonu kullanılacaktır.
+Path önce eşleştiği için her zaman ilk olan kullanılır.
 
-## Ön Tanımlı Değerler
+## Ön Tanımlı Değerler { #predefined-values }
 
-Eğer *yol parametresi* alan bir *yol operasyonunuz* varsa ve alabileceği *yol parametresi* değerlerinin ön tanımlı olmasını istiyorsanız, standart Python <abbr title="Enumeration">`Enum`</abbr> tipini kullanabilirsiniz.
+Bir *path operation*'ınız *path parameter* alıyorsa ama olası geçerli *path parameter* değerlerinin önceden tanımlı olmasını istiyorsanız, standart bir Python <abbr title="Enumeration">`Enum`</abbr> kullanabilirsiniz.
 
-### Bir `Enum` Sınıfı Oluşturalım
+### Bir `Enum` Sınıfı Oluşturalım { #create-an-enum-class }
 
-`Enum` sınıfını projemize dahil edip `str` ile `Enum` sınıflarını miras alan bir alt sınıf yaratalım.
+`Enum`'u import edin ve `str` ile `Enum`'dan miras alan bir alt sınıf oluşturun.
 
-`str` sınıfı miras alındığından dolayı, API dokümanı, değerlerin `string` tipinde olması gerektiğini anlayabilecek ve doğru bir şekilde işlenecektir.
+`str`'den miras aldığınızda API dokümanları değerlerin `string` tipinde olması gerektiğini anlayabilir ve doğru şekilde render edebilir.
 
-Sonrasında, sınıf içerisinde, mevcut ve geçerli değerler olacak olan sabit değerli özelliklerini oluşturalım:
+Sonra, kullanılabilir geçerli değerler olacak sabit değerli class attribute'ları oluşturun:
 
-{* ../../docs_src/path_params/tutorial005.py hl[1,6:9] *}
-
-/// info | Bilgi
-
-3.4 sürümünden beri <a href="https://docs.python.org/3/library/enum.html" class="external-link" target="_blank">enumerationlar (ya da enumlar) Python'da mevcuttur</a>.
-
-///
+{* ../../docs_src/path_params/tutorial005_py39.py hl[1,6:9] *}
 
 /// tip | İpucu
 
-Merak ediyorsanız söyleyeyim, "AlexNet", "ResNet" ve "LeNet" isimleri Makine Öğrenmesi <abbr title="Teknik olarak, Derin Öğrenme model mimarileri">modellerini</abbr> temsil eder.
+Merak ediyorsanız: "AlexNet", "ResNet" ve "LeNet", Makine Öğrenmesi <abbr title="Technically, Deep Learning model architectures">modelleri</abbr>nin sadece isimleridir.
 
 ///
 
-### Bir *Yol Parametresi* Tanımlayalım
+### Bir *Path Parameter* Tanımlayalım { #declare-a-path-parameter }
 
-Sonrasında, yarattığımız enum sınıfını (`ModelName`) kullanarak tip belirteci aracılığıyla bir *yol parametresi* oluşturalım:
+Ardından oluşturduğunuz enum sınıfını (`ModelName`) kullanarak tip belirteciyle bir *path parameter* oluşturun:
 
-{* ../../docs_src/path_params/tutorial005.py hl[16] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[16] *}
 
-### Dokümana Göz Atalım
+### Dokümana Göz Atalım { #check-the-docs }
 
-*Yol parametresi* için mevcut değerler ön tanımlı olduğundan dolayı, interaktif döküman onları güzel bir şekilde gösterebilir:
+*Path parameter* için kullanılabilir değerler ön tanımlı olduğu için, interaktif dokümanlar bunları güzelce gösterebilir:
 
 <img src="/img/tutorial/path-params/image03.png">
 
-### Python *Enumerationları* ile Çalışmak
+### Python *Enumeration*'ları ile Çalışmak { #working-with-python-enumerations }
 
-*Yol parametresinin* değeri bir *enumeration üyesi* olacaktır.
+*Path parameter*'ın değeri bir *enumeration member* olacaktır.
 
-#### *Enumeration Üyelerini* Karşılaştıralım
+#### *Enumeration Member*'ları Karşılaştıralım { #compare-enumeration-members }
 
-Parametreyi, yarattığınız enum olan `ModelName` içerisindeki *enumeration üyesi* ile karşılaştırabilirsiniz:
+Bunu, oluşturduğunuz enum `ModelName` içindeki *enumeration member* ile karşılaştırabilirsiniz:
 
-{* ../../docs_src/path_params/tutorial005.py hl[17] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[17] *}
 
-#### *Enumeration Değerini* Edinelim
+#### *Enumeration Value*'yu Alalım { #get-the-enumeration-value }
 
-`model_name.value` veya genel olarak `your_enum_member.value` tanımlarını kullanarak (bu durumda bir `str` olan) gerçek değere ulaşabilirsiniz:
+Gerçek değeri (bu durumda bir `str`) `model_name.value` ile veya genel olarak `your_enum_member.value` ile alabilirsiniz:
 
-{* ../../docs_src/path_params/tutorial005.py hl[20] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[20] *}
 
 /// tip | İpucu
 
-`"lenet"` değerine `ModelName.lenet.value` tanımı ile de ulaşabilirsiniz.
+`"lenet"` değerine `ModelName.lenet.value` ile de erişebilirsiniz.
 
 ///
 
-#### *Enumeration Üyelerini* Döndürelim
+#### *Enumeration Member*'ları Döndürelim { #return-enumeration-members }
 
-JSON gövdesine (örneğin bir `dict`) gömülü olsalar bile *yol operasyonundaki* *enum üyelerini* döndürebilirsiniz.
+*Path operation*'ınızdan, bir JSON body'nin içine gömülü olsalar bile (ör. bir `dict`) *enum member*'ları döndürebilirsiniz.
 
-Bu üyeler istemciye iletilmeden önce kendilerine karşılık gelen değerlerine (bu durumda string) dönüştürüleceklerdir:
+İstemciye dönmeden önce, karşılık gelen değerlerine (bu durumda string) dönüştürülürler:
 
-{* ../../docs_src/path_params/tutorial005.py hl[18,21,23] *}
+{* ../../docs_src/path_params/tutorial005_py39.py hl[18,21,23] *}
 
-İstemci tarafında şuna benzer bir JSON yanıtı ile karşılaşırsınız:
+İstemcinizde şöyle bir JSON response alırsınız:
 
 ```JSON
 {
@@ -205,53 +199,53 @@ Bu üyeler istemciye iletilmeden önce kendilerine karşılık gelen değerlerin
 }
 ```
 
-## Yol İçeren Yol Parametreleri
+## Path İçeren Path Parametreleri { #path-parameters-containing-paths }
 
-Farz edelim ki elinizde `/files/{file_path}` isminde bir *yol operasyonu* var.
+Diyelim ki `/files/{file_path}` path'ine sahip bir *path operation*'ınız var.
 
-Fakat `file_path` değerinin `home/johndoe/myfile.txt` gibi bir *yol* barındırmasını istiyorsunuz.
+Ama `file_path`'in kendisinin `home/johndoe/myfile.txt` gibi bir *path* içermesi gerekiyor.
 
-Sonuç olarak, oluşturmak istediğin URL `/files/home/johndoe/myfile.txt` gibi bir şey olacaktır.
+Böylece, o dosyanın URL'si şu şekilde olur: `/files/home/johndoe/myfile.txt`.
 
-### OpenAPI Desteği
+### OpenAPI Desteği { #openapi-support }
 
-Test etmesi ve tanımlaması zor senaryolara sebebiyet vereceğinden dolayı OpenAPI, *yol* barındıran *yol parametrelerini* tanımlayacak bir çözüm sunmuyor.
+OpenAPI, içinde bir *path* barındıracak bir *path parameter* tanımlamak için bir yöntem desteklemez; çünkü bu, test etmesi ve tanımlaması zor senaryolara yol açabilir.
 
-Ancak bunu, Starlette kütüphanesinin dahili araçlarından birini kullanarak **FastAPI**'da gerçekleştirebilirsiniz.
+Yine de, Starlette'in dahili araçlarından birini kullanarak bunu **FastAPI**'da yapabilirsiniz.
 
-Parametrenin bir yol içermesi gerektiğini belirten herhangi bir doküman eklemememize rağmen dokümanlar yine de çalışacaktır.
+Ve dokümanlar, parametrenin bir path içermesi gerektiğini söyleyen herhangi bir dokümantasyon eklemese bile çalışmaya devam eder.
 
-### Yol Dönüştürücü
+### Path Dönüştürücü { #path-convertor }
 
-Direkt olarak Starlette kütüphanesinden gelen bir opsiyon sayesinde aşağıdaki gibi *yol* içeren bir *yol parametresi* bağlantısı tanımlayabilirsiniz:
+Starlette'ten doğrudan gelen bir seçenekle, *path* içeren bir *path parameter*'ı şu URL ile tanımlayabilirsiniz:
 
 ```
 /files/{file_path:path}
 ```
 
-Bu durumda, parametrenin adı `file_path` olacaktır ve son kısım olan `:path` kısmı, parametrenin herhangi bir *yol* ile eşleşmesi gerektiğini belirtecektir.
+Bu durumda parametrenin adı `file_path`'tir ve son kısım olan `:path`, parametrenin herhangi bir *path* ile eşleşmesi gerektiğini söyler.
 
-Böylece şunun gibi bir kullanım yapabilirsiniz:
+Yani şununla kullanabilirsiniz:
 
-{* ../../docs_src/path_params/tutorial004.py hl[6] *}
+{* ../../docs_src/path_params/tutorial004_py39.py hl[6] *}
 
 /// tip | İpucu
 
-Parametrenin başında `/home/johndoe/myfile.txt` yolunda olduğu gibi (`/`) işareti ile birlikte kullanmanız gerektiği durumlar olabilir.
+Parametrenin başında `/home/johndoe/myfile.txt` örneğinde olduğu gibi bir eğik çizgi (`/`) ile başlaması gerekebilir.
 
-Bu durumda, URL, `files` ile `home` arasında iki eğik çizgiye (`//`) sahip olup `/files//home/johndoe/myfile.txt` gibi gözükecektir.
+Bu durumda URL, `files` ile `home` arasında çift eğik çizgi (`//`) olacak şekilde `/files//home/johndoe/myfile.txt` olur.
 
 ///
 
-## Özet
+## Özet { #recap }
 
-**FastAPI** ile kısa, sezgisel ve standart Python tip tanımlamaları kullanarak şunları elde edersiniz:
+**FastAPI** ile kısa, sezgisel ve standart Python tip tanımlarını kullanarak şunları elde edersiniz:
 
-* Editör desteği: hata denetimi, otomatik tamamlama, vb.
-* Veri "<abbr title="HTTP isteği ile birlikte gelen string'i Python verisine dönüştürme">dönüştürme</abbr>"
+* Editör desteği: hata denetimleri, otomatik tamamlama vb.
+* Veri "<abbr title="HTTP isteği ile birlikte gelen string'i Python verisine dönüştürme">parsing</abbr>"
 * Veri doğrulama
-* API tanımlamaları ve otomatik dokümantasyon
+* API annotation ve otomatik dokümantasyon
 
-Ve sadece, bunları bir kez tanımlamanız yeterli.
+Ve bunları sadece bir kez tanımlamanız yeterlidir.
 
-Diğer frameworkler ile karşılaştırıldığında (ham performans dışında), üstte anlatılan durum muhtemelen **FastAPI**'ın göze çarpan başlıca avantajıdır.
+Bu, (ham performans dışında) **FastAPI**'ın alternatif framework'lere kıyasla muhtemelen en görünür ana avantajıdır.

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

@@ -1,83 +1,83 @@
-# Sorgu Parametreleri
+# Sorgu Parametreleri { #query-parameters }
 
-Fonksiyonda yol parametrelerinin parçası olmayan diğer tanımlamalar otomatik olarak "sorgu" parametresi olarak yorumlanır.
+Fonksiyonda path parametrelerinin parçası olmayan diğer parametreleri tanımladığınızda, bunlar otomatik olarak "query" parametreleri olarak yorumlanır.
 
-{* ../../docs_src/query_params/tutorial001.py hl[9] *}
+{* ../../docs_src/query_params/tutorial001_py39.py hl[9] *}
 
-Sorgu, bağlantıdaki `?` kısmından sonra gelen ve `&` işareti ile ayrılan anahtar-değer çiftlerinin oluşturduğu bir kümedir.
+Query, bir URL'de `?` işaretinden sonra gelen ve `&` karakterleriyle ayrılan anahtar-değer çiftlerinin kümesidir.
 
-Örneğin, aşağıdaki bağlantıda:
+Örneğin, şu URL'de:
 
 ```
 http://127.0.0.1:8000/items/?skip=0&limit=10
 ```
 
-...sorgu parametreleri şunlardır:
+...query parametreleri şunlardır:
 
-* `skip`: değeri `0`'dır
-* `limit`: değeri `10`'dır
+* `skip`: değeri `0`
+* `limit`: değeri `10`
 
-Parametreler bağlantının bir parçası oldukları için doğal olarak string olarak değerlendirilirler.
+URL'nin bir parçası oldukları için "doğal olarak" string'tirler.
 
-Fakat, Python tipleri ile tanımlandıkları zaman (yukarıdaki örnekte `int` oldukları gibi), parametreler o tiplere dönüştürülür ve o tipler çerçevesinde doğrulanırlar.
+Ancak, bunları Python tipleriyle (yukarıdaki örnekte `int` olarak) tanımladığınızda, o tipe dönüştürülürler ve o tipe göre doğrulanırlar.
 
-Yol parametreleri için geçerli olan her türlü işlem aynı şekilde sorgu parametreleri için de geçerlidir:
+Path parametreleri için geçerli olan aynı süreç query parametreleri için de geçerlidir:
 
-* Editör desteği (şüphesiz)
-* Veri "<abbr title="HTTP isteği ile birlikte gelen string'i Python verisine dönüştürme">ayrıştırma</abbr>"
+* Editör desteği (tabii ki)
+* Veri <abbr title="converting the string that comes from an HTTP request into Python data">"parsing"</abbr>
 * Veri doğrulama
 * Otomatik dokümantasyon
 
-## Varsayılanlar
+## Varsayılanlar { #defaults }
 
-Sorgu parametreleri, adres yolunun sabit bir parçası olmadıklarından dolayı isteğe bağlı ve varsayılan değere sahip olabilirler.
+Query parametreleri path'in sabit bir parçası olmadığından, opsiyonel olabilir ve varsayılan değerlere sahip olabilir.
 
-Yukarıdaki örnekte `skip=0` ve `limit=10` varsayılan değere sahiplerdir.
+Yukarıdaki örnekte varsayılan değerleri `skip=0` ve `limit=10`'dur.
 
-Yani, aşağıdaki bağlantıya gitmek:
+Yani şu URL'ye gitmek:
 
 ```
 http://127.0.0.1:8000/items/
 ```
 
-şu adrese gitmek ile aynı etkiye sahiptir:
+şuraya gitmekle aynı olur:
 
 ```
 http://127.0.0.1:8000/items/?skip=0&limit=10
 ```
 
-Ancak, mesela şöyle bir adresi ziyaret ederseniz:
+Ancak örneğin şuraya giderseniz:
 
 ```
 http://127.0.0.1:8000/items/?skip=20
 ```
 
-Fonksiyonunuzdaki parametre değerleri aşağıdaki gibi olacaktır:
+Fonksiyonunuzdaki parametre değerleri şöyle olacaktır:
 
-* `skip=20`: çünkü bağlantıda böyle tanımlandı.
-* `limit=10`: çünkü varsayılan değer buydu.
+* `skip=20`: çünkü URL'de siz ayarladınız
+* `limit=10`: çünkü varsayılan değer oydu
 
-## İsteğe Bağlı Parametreler
+## İsteğe bağlı parametreler { #optional-parameters }
 
-Aynı şekilde, varsayılan değerlerini `None` olarak atayarak isteğe bağlı parametreler tanımlayabilirsiniz:
+Aynı şekilde, varsayılan değerlerini `None` yaparak isteğe bağlı query parametreleri tanımlayabilirsiniz:
 
 {* ../../docs_src/query_params/tutorial002_py310.py hl[7] *}
 
-Bu durumda, `q` fonksiyon parametresi isteğe bağlı olacak ve varsayılan değer olarak `None` alacaktır.
+Bu durumda, fonksiyon parametresi `q` isteğe bağlı olur ve varsayılan olarak `None` olur.
 
 /// check | Ek bilgi
 
-Ayrıca, dikkatinizi çekerim ki; **FastAPI**, `item_id` parametresinin bir yol parametresi olduğunu ve `q` parametresinin yol değil bir sorgu parametresi olduğunu fark edecek kadar beceriklidir.
+Ayrıca, **FastAPI** path parametresi olan `item_id`'nin bir path parametresi olduğunu ve `q`'nun path olmadığını fark edecek kadar akıllıdır; dolayısıyla bu bir query parametresidir.
 
 ///
 
-## Sorgu Parametresi Tip Dönüşümü
+## Sorgu parametresi tip dönüşümü { #query-parameter-type-conversion }
 
-Aşağıda görüldüğü gibi dönüştürülmek üzere `bool` tipleri de tanımlayabilirsiniz:
+`bool` tipleri de tanımlayabilirsiniz, ve bunlar dönüştürülür:
 
 {* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}
 
-Bu durumda, eğer şu adrese giderseniz:
+Bu durumda, şuraya giderseniz:
 
 ```
 http://127.0.0.1:8000/items/foo?short=1
@@ -107,38 +107,38 @@ veya
 http://127.0.0.1:8000/items/foo?short=yes
 ```
 
-veya adres, herhangi farklı bir harf varyasyonu içermesi durumuna rağmen (büyük harf, sadece baş harfi büyük kelime, vb.) fonksiyonunuz, `bool` tipli `short` parametresini `True` olarak algılayacaktır. Aksi halde `False` olarak algılanacaktır.
+veya başka herhangi bir büyük/küçük harf varyasyonunda (tamamı büyük, ilk harf büyük, vb.), fonksiyonunuz `short` parametresini `bool` değeri `True` olarak görecektir. Aksi halde `False` olarak görür.
 
 
-## Çoklu Yol ve Sorgu Parametreleri
+## Çoklu path ve query parametreleri { #multiple-path-and-query-parameters }
 
-**FastAPI** neyin ne olduğunu ayırt edebileceğinden dolayı aynı anda birden fazla yol ve sorgu parametresi tanımlayabilirsiniz.
+Aynı anda birden fazla path parametresi ve query parametresi tanımlayabilirsiniz; **FastAPI** hangisinin hangisi olduğunu bilir.
 
-Ve parametreleri, herhangi bir sıraya koymanıza da gerek yoktur.
+Ayrıca bunları belirli bir sırayla tanımlamanız gerekmez.
 
-İsimlerine göre belirleneceklerdir:
+İsme göre tespit edilirler:
 
 {* ../../docs_src/query_params/tutorial004_py310.py hl[6,8] *}
 
-## Zorunlu Sorgu Parametreleri
+## Zorunlu query parametreleri { #required-query-parameters }
 
-Türü yol olmayan bir parametre (şu ana kadar sadece sorgu parametrelerini gördük) için varsayılan değer tanımlarsanız o parametre zorunlu olmayacaktır.
+Path olmayan parametreler (şimdilik sadece query parametrelerini gördük) için varsayılan değer tanımladığınızda, bu parametre zorunlu olmaz.
 
-Parametre için belirli bir değer atamak istemeyip parametrenin sadece isteğe bağlı olmasını istiyorsanız değerini `None` olarak atayabilirsiniz.
+Belirli bir değer eklemek istemiyor ama sadece opsiyonel olmasını istiyorsanız, varsayılanı `None` olarak ayarlayın.
 
-Fakat, bir sorgu parametresini zorunlu yapmak istiyorsanız varsayılan bir değer atamamanız yeterli olacaktır:
+Ancak bir query parametresini zorunlu yapmak istediğinizde, herhangi bir varsayılan değer tanımlamamanız yeterlidir:
 
-{* ../../docs_src/query_params/tutorial005.py hl[6:7] *}
+{* ../../docs_src/query_params/tutorial005_py39.py hl[6:7] *}
 
-Burada `needy` parametresi `str` tipinden oluşan zorunlu bir sorgu parametresidir.
+Burada query parametresi `needy`, `str` tipinde zorunlu bir query parametresidir.
 
-Eğer tarayıcınızda şu bağlantıyı:
+Tarayıcınızda şöyle bir URL açarsanız:
 
 ```
 http://127.0.0.1:8000/items/foo-item
 ```
 
-...`needy` parametresini eklemeden açarsanız şuna benzer bir hata ile karşılaşırsınız:
+...zorunlu `needy` parametresini eklemeden, şuna benzer bir hata görürsünüz:
 
 ```JSON
 {
@@ -156,13 +156,13 @@ http://127.0.0.1:8000/items/foo-item
 }
 ```
 
-`needy` zorunlu bir parametre olduğundan dolayı bağlantıda tanımlanması gerekir:
+`needy` zorunlu bir parametre olduğundan, URL'de ayarlamanız gerekir:
 
 ```
 http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
 ```
 
-...bu iş görür:
+...bu çalışır:
 
 ```JSON
 {
@@ -171,11 +171,11 @@ http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
 }
 ```
 
-Ve elbette, bazı parametreleri zorunlu, bazılarını varsayılan değerli ve bazılarını tamamen opsiyonel olarak tanımlayabilirsiniz:
+Ve elbette, bazı parametreleri zorunlu, bazılarını varsayılan değerli, bazılarını da tamamen isteğe bağlı olarak tanımlayabilirsiniz:
 
 {* ../../docs_src/query_params/tutorial006_py310.py hl[8] *}
 
-Bu durumda, 3 tane sorgu parametresi var olacaktır:
+Bu durumda, 3 tane query parametresi vardır:
 
 * `needy`, zorunlu bir `str`.
 * `skip`, varsayılan değeri `0` olan bir `int`.
@@ -183,6 +183,6 @@ Bu durumda, 3 tane sorgu parametresi var olacaktır:
 
 /// tip | İpucu
 
-Ayrıca, [Yol Parametrelerinde](path-params.md#on-tanml-degerler){.internal-link target=_blank} de kullanıldığı şekilde `Enum` sınıfından faydalanabilirsiniz.
+[Path Parametreleri](path-params.md#predefined-values){.internal-link target=_blank} ile aynı şekilde `Enum`'ları da kullanabilirsiniz.
 
 ///

docs/tr/docs/tutorial/request-forms.md

@@ -1,69 +1,73 @@
-# Form Verisi
+# Form Verisi { #form-data }
 
-İstek gövdesinde JSON verisi yerine form alanlarını karşılamanız gerketiğinde `Form` sınıfını kullanabilirsiniz.
+JSON yerine form alanlarını almanız gerektiğinde `Form` kullanabilirsiniz.
 
 /// info | Bilgi
 
-Formları kullanmak için öncelikle <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a> paketini indirmeniz gerekmektedir.
+Formları kullanmak için önce <a href="https://github.com/Kludex/python-multipart" class="external-link" target="_blank">`python-multipart`</a> paketini kurun.
 
-Örneğin `pip install python-multipart`.
+Bir [virtual environment](../virtual-environments.md){.internal-link target=_blank} oluşturduğunuzdan, onu etkinleştirdiğinizden emin olun ve ardından örneğin şöyle kurun:
+
+```console
+$ pip install python-multipart
+```
 
 ///
 
-## `Form` Sınıfını Projenize Dahil Edin
+## `Form`'u Import Edin { #import-form }
 
-`Form` sınıfını `fastapi`'den projenize dahil edin:
+`Form`'u `fastapi`'den import edin:
 
 {* ../../docs_src/request_forms/tutorial001_an_py39.py hl[3] *}
 
-## `Form` Parametrelerini Tanımlayın
+## `Form` Parametrelerini Tanımlayın { #define-form-parameters }
 
 Form parametrelerini `Body` veya `Query` için yaptığınız gibi oluşturun:
 
 {* ../../docs_src/request_forms/tutorial001_an_py39.py hl[9] *}
 
-Örneğin, OAuth2 spesifikasyonunun kullanılabileceği ("şifre akışı" olarak adlandırılan) yollardan birinde, form alanları olarak <abbr title="Kullanıcı Adı: Username">"username"</abbr> ve <abbr title="Şifre: Password">"password"</abbr> gönderilmesi gerekir.
+Örneğin OAuth2 spesifikasyonunun kullanılabileceği ("password flow" olarak adlandırılan) yollardan birinde, form alanları olarak bir `username` ve `password` göndermek zorunludur.
 
-Bu <abbr title="Spesifikasyon: Specification">spesifikasyon</abbr> form alanlarını adlandırırken isimlerinin birebir `username` ve `password` olmasını ve JSON verisi yerine form verisi olarak gönderilmesini gerektirir.
+<abbr title="specification - spesifikasyon">spec</abbr>, alanların adının tam olarak `username` ve `password` olmasını ve JSON değil form alanları olarak gönderilmesini gerektirir.
 
-`Form` sınıfıyla tanımlama yaparken `Body`, `Query`, `Path` ve `Cookie` sınıflarında kullandığınız aynı validasyon, örnekler, isimlendirme (örneğin `username` yerine `user-name` kullanımı) ve daha fazla konfigurasyonu kullanabilirsiniz.
+`Form` ile `Body` (ve `Query`, `Path`, `Cookie`) ile yaptığınız aynı konfigürasyonları tanımlayabilirsiniz; validasyon, örnekler, alias (örn. `username` yerine `user-name`) vb. dahil.
 
 /// info | Bilgi
 
-`Form` doğrudan `Body` sınıfını miras alan bir sınıftır.
+`Form`, doğrudan `Body`'den miras alan bir sınıftır.
 
 ///
 
 /// tip | İpucu
 
-Form gövdelerini tanımlamak için `Form` sınıfını kullanmanız gerekir; çünkü bu olmadan parametreler sorgu parametreleri veya gövde (JSON) parametreleri olarak yorumlanır.
+Form gövdelerini tanımlamak için `Form`'u açıkça kullanmanız gerekir; çünkü bunu yapmazsanız parametreler query parametreleri veya body (JSON) parametreleri olarak yorumlanır.
 
 ///
 
-## "Form Alanları" Hakkında
+## "Form Alanları" Hakkında { #about-form-fields }
 
-HTML formlarının (`<form></form>`) verileri sunucuya gönderirken JSON'dan farklı özel bir kodlama kullanır.
+HTML formlarının (`<form></form>`) verileri sunucuya gönderme şekli normalde bu veri için JSON'dan farklı "özel" bir encoding kullanır.
 
-**FastAPI** bu verilerin JSON yerine doğru şekilde okunmasını sağlayacaktır.
+**FastAPI** bu veriyi JSON yerine doğru yerden okuyacaktır.
 
 /// note | Teknik Detaylar
 
-Form verileri normalde `application/x-www-form-urlencoded` medya tipiyle kodlanır.
+Formlardan gelen veri normalde "media type" `application/x-www-form-urlencoded` kullanılarak encode edilir.
 
-Ancak form içerisinde dosyalar yer aldığında `multipart/form-data` olarak kodlanır. Bir sonraki bölümde dosyaların işlenmesi hakkında bilgi edineceksiniz.
+Ancak form dosyalar içerdiğinde `multipart/form-data` olarak encode edilir. Dosyaları ele almayı bir sonraki bölümde okuyacaksınız.
 
-Form kodlama türleri ve form alanları hakkında daha fazla bilgi edinmek istiyorsanız <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> web docs for <code>POST</code></a> sayfasını ziyaret edebilirsiniz.
+Bu encoding'ler ve form alanları hakkında daha fazla okumak isterseniz, <a href="https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods/POST" class="external-link" target="_blank"><abbr title="Mozilla Developer Network">MDN</abbr> web docs for <code>POST</code></a> sayfasına gidin.
 
 ///
 
 /// warning | Uyarı
 
-*Yol operasyonları* içerisinde birden fazla `Form` parametresi tanımlayabilirsiniz ancak bunlarla birlikte JSON verisi kabul eden `Body` alanları tanımlayamazsınız çünkü bu durumda istek gövdesi `application/json` yerine `application/x-www-form-urlencoded` ile kodlanmış olur.
+Bir *path operation* içinde birden fazla `Form` parametresi tanımlayabilirsiniz, ancak JSON olarak almayı beklediğiniz `Body` alanlarını da ayrıca tanımlayamazsınız; çünkü bu durumda request'in body'si `application/json` yerine `application/x-www-form-urlencoded` ile encode edilmiş olur.
 
-Bu **FastAPI**'ın getirdiği bir kısıtlama değildir, HTTP protokolünün bir parçasıdır.
+Bu **FastAPI**'ın bir kısıtlaması değildir, HTTP protokolünün bir parçasıdır.
 
 ///
 
-## Özet
+## Özet { #recap }
 
-Form verisi girdi parametreleri tanımlamak için `Form` sınıfını kullanın.
+Form verisi girdi parametrelerini tanımlamak için `Form` kullanın.

docs/tr/docs/tutorial/static-files.md

@@ -1,40 +1,40 @@
-# Statik Dosyalar
+# Statik Dosyalar { #static-files }
 
-`StaticFiles`'ı kullanarak statik dosyaları bir yol altında sunabilirsiniz.
+`StaticFiles` kullanarak bir dizindeki statik dosyaları otomatik olarak sunabilirsiniz.
 
-## `StaticFiles` Kullanımı
+## `StaticFiles` Kullanımı { #use-staticfiles }
 
-* `StaticFiles` sınıfını projenize dahil edin.
-* Bir `StaticFiles()` örneğini belirli bir yola bağlayın.
+* `StaticFiles`'ı import edin.
+* Belirli bir path'te bir `StaticFiles()` örneğini "mount" edin.
 
-{* ../../docs_src/static_files/tutorial001.py hl[2,6] *}
+{* ../../docs_src/static_files/tutorial001_py39.py hl[2,6] *}
 
 /// note | Teknik Detaylar
 
-Projenize dahil etmek için `from starlette.staticfiles import StaticFiles` kullanabilirsiniz.
+`from starlette.staticfiles import StaticFiles` da kullanabilirsiniz.
 
-**FastAPI**, geliştiricilere kolaylık sağlamak amacıyla `starlette.staticfiles`'ı `fastapi.staticfiles` olarak sağlar. Ancak `StaticFiles` sınıfı aslında doğrudan Starlette'den gelir.
+**FastAPI**, geliştirici olarak size kolaylık olsun diye `starlette.staticfiles`'ı `fastapi.staticfiles` olarak da sağlar. Ancak aslında doğrudan Starlette'den gelir.
 
 ///
 
-### Bağlama (Mounting) Nedir?
+### "Mounting" Nedir { #what-is-mounting }
 
-"Bağlamak", belirli bir yola tamamen "bağımsız" bir uygulama eklemek anlamına gelir ve ardından tüm alt yollara gelen istekler bu uygulama tarafından işlenir.
+"Mounting", belirli bir path'te tamamen "bağımsız" bir uygulama eklemek ve sonrasında tüm alt path'leri handle etmesini sağlamak demektir.
 
-Bu, bir `APIRouter` kullanmaktan farklıdır çünkü bağlanmış bir uygulama tamamen bağımsızdır. Ana uygulamanızın OpenAPI ve dokümanlar, bağlanmış uygulamadan hiçbir şey içermez, vb.
+Bu, bir `APIRouter` kullanmaktan farklıdır; çünkü mount edilen uygulama tamamen bağımsızdır. Ana uygulamanızın OpenAPI ve docs'ları, mount edilen uygulamadan hiçbir şey içermez, vb.
 
-[Advanced User Guide](../advanced/index.md){.internal-link target=_blank} bölümünde daha fazla bilgi edinebilirsiniz.
+Bununla ilgili daha fazla bilgiyi [Advanced User Guide](../advanced/index.md){.internal-link target=_blank} içinde okuyabilirsiniz.
 
-## Detaylar
+## Detaylar { #details }
 
-`"/static"` ifadesi, bu "alt uygulamanın" "bağlanacağı" alt yolu belirtir. Bu nedenle, `"/static"` ile başlayan her yol, bu uygulama tarafından işlenir.
+İlk `"/static"`, bu "alt uygulamanın" "mount" edileceği alt path'i ifade eder. Dolayısıyla `"/static"` ile başlayan herhangi bir path bunun tarafından handle edilir.
 
-`directory="static"` ifadesi, statik dosyalarınızı içeren dizinin adını belirtir.
+`directory="static"`, statik dosyalarınızı içeren dizinin adını ifade eder.
 
-`name="static"` ifadesi, alt uygulamanın **FastAPI** tarafından kullanılacak ismini belirtir.
+`name="static"`, **FastAPI**'nin dahili olarak kullanabileceği bir isim verir.
 
-Bu parametrelerin hepsi "`static`"den farklı olabilir, bunları kendi uygulamanızın ihtiyaçlarına göre belirleyebilirsiniz.
+Bu parametrelerin hepsi "`static`" ile aynı olmak zorunda değildir; kendi uygulamanızın ihtiyaçlarına ve özel detaylarına göre ayarlayın.
 
-## Daha Fazla Bilgi
+## Daha Fazla Bilgi { #more-info }
 
-Daha fazla detay ve seçenek için <a href="https://www.starlette.dev/staticfiles/" class="external-link" target="_blank">Starlette'in Statik Dosyalar hakkındaki dokümantasyonunu</a> incelleyin.
+Daha fazla detay ve seçenek için <a href="https://www.starlette.dev/staticfiles/" class="external-link" target="_blank">Starlette'in Statik Dosyalar hakkındaki dokümanlarını</a> inceleyin.

docs/tr/llm-prompt.md

@@ -4,10 +4,16 @@ Translate to Turkish (Türkçe).
 
 Language code: tr.
 
+### Core principle
+
+Don't translate word-by-word. Rewrite naturally in Turkish as if writing the doc from scratch. Preserve meaning, but prioritize fluency over literal accuracy.
+
 ### Grammar and tone
 
 - Use instructional Turkish, consistent with existing Turkish docs.
-- Use imperative/guide language when appropriate (e.g. “açalım”, “gidin”, “kopyalayalım”).
+- Use imperative/guide language (e.g. "açalım", "gidin", "kopyalayalım", "bir bakalım").
+- Avoid filler words and overly long sentences.
+- Ensure sentences make sense in Turkish context — adjust structure, conjunctions, and verb forms as needed for natural flow (e.g. use "Ancak" instead of "Ve" when connecting contrasting sentences, use "-maktadır/-mektedir" for formal statements).
 
 ### Headings
 
@@ -15,13 +21,23 @@ Language code: tr.
 
 ### Quotes
 
-- Alıntı stili mevcut Türkçe dokümanlarla tutarlı tutun (genellikle metin içinde ASCII tırnak işaretleri kullanılır).
-- Satır içi kod, kod blokları, URL'ler veya dosya yolları içindeki tırnak işaretlerini asla değiştirmeyin.
+- Keep quote style consistent with existing Turkish docs (typically ASCII quotes in text).
+- Never modify quotes inside inline code, code blocks, URLs, or file paths.
 
 ### Ellipsis
 
-- Üç nokta (...) stili mevcut Türkçe dokümanlarla tutarlı tutun.
-- Kod, URL veya CLI örneklerindeki `...` ifadesini asla değiştirmeyin.
+- Keep ellipsis style (`...`) consistent with existing Turkish docs.
+- Never modify `...` in code, URLs, or CLI examples.
+
+### Consistency
+
+- Use the same translation for the same term throughout the document.
+- If you translate a concept one way, keep it consistent across all occurrences.
+
+### Links and references
+
+- Never modify link syntax like `{.internal-link target=_blank}`.
+- Keep markdown link structure intact: `[text](url){.internal-link}`.
 
 ### Preferred translations / glossary
 

docs/uk/docs/alternatives.md

@@ -1,8 +1,8 @@
-# Альтернативи, натхнення та порівняння
+# Альтернативи, натхнення та порівняння { #alternatives-inspiration-and-comparisons }
 
-Що надихнуло на створення **FastAPI**, який він у порінянні з іншими альтернативами та чого він у них навчився.
+Що надихнуло **FastAPI**, як він порівнюється з альтернативами та чого він у них навчився.
 
-## Вступ
+## Вступ { #intro }
 
 **FastAPI** не існувало б, якби не попередні роботи інших.
 
@@ -12,17 +12,17 @@
 
 Але в якийсь момент не було іншого виходу, окрім створення чогось, що надавало б усі ці функції, взявши найкращі ідеї з попередніх інструментів і поєднавши їх найкращим чином, використовуючи мовні функції, які навіть не були доступні раніше (Python 3.6+ підказки типів).
 
-## Попередні інструменти
+## Попередні інструменти { #previous-tools }
 
-### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a>
+### <a href="https://www.djangoproject.com/" class="external-link" target="_blank">Django</a> { #django }
 
 Це найпопулярніший фреймворк Python, який користується широкою довірою. Він використовується для створення таких систем, як Instagram.
 
 Він відносно тісно пов’язаний з реляційними базами даних (наприклад, MySQL або PostgreSQL), тому мати базу даних NoSQL (наприклад, Couchbase, MongoDB, Cassandra тощо) як основний механізм зберігання не дуже просто.
 
-Він був створений для створення HTML у серверній частині, а не для створення API, які використовуються сучасним інтерфейсом (як-от React, Vue.js і Angular) або іншими системами (як-от <abbr title="Internet of Things">IoT</abbr > пристрої), які спілкуються з ним.
+Він був створений для створення HTML у серверній частині, а не для створення API, які використовуються сучасним інтерфейсом (як-от React, Vue.js і Angular) або іншими системами (як-от <abbr title="Internet of Things - Інтернет речей">IoT</abbr> пристрої), які спілкуються з ним.
 
-### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a>
+### <a href="https://www.django-rest-framework.org/" class="external-link" target="_blank">Django REST Framework</a> { #django-rest-framework }
 
 Фреймворк Django REST був створений як гнучкий інструментарій для створення веб-інтерфейсів API використовуючи Django в основі, щоб покращити його можливості API.
 
@@ -42,7 +42,7 @@ Django REST Framework створив Том Крісті. Той самий тв
 
 ///
 
-### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a>
+### <a href="https://flask.palletsprojects.com" class="external-link" target="_blank">Flask</a> { #flask }
 
 Flask — це «мікрофреймворк», він не включає інтеграцію бази даних, а також багато речей, які за замовчуванням є в Django.
 
@@ -64,7 +64,7 @@ Flask — це «мікрофреймворк», він не включає ін
 
 ///
 
-### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a>
+### <a href="https://requests.readthedocs.io" class="external-link" target="_blank">Requests</a> { #requests }
 
 **FastAPI** насправді не є альтернативою **Requests**. Сфера їх застосування дуже різна.
 
@@ -88,12 +88,12 @@ Requests мають дуже простий та інтуїтивно зрозу
 response = requests.get("http://example.com/some/url")
 ```
 
-Відповідна операція *роуту* API FastAPI може виглядати так:
+Відповідна операція шляху API FastAPI може виглядати так:
 
 ```Python hl_lines="1"
 @app.get("/some/url")
 def read_url():
-     return {"message": "Hello World"}
+    return {"message": "Hello World"}
 ```
 
 Зверніть увагу на схожість у `requests.get(...)` і `@app.get(...)`.
@@ -101,12 +101,12 @@ def read_url():
 /// check | Надихнуло **FastAPI** на
 
 * Майте простий та інтуїтивно зрозумілий API.
- * Використовуйте імена (операції) методів HTTP безпосередньо, простим та інтуїтивно зрозумілим способом.
- * Розумні параметри за замовчуванням, але потужні налаштування.
+* Використовуйте імена (операції) методів HTTP безпосередньо, простим та інтуїтивно зрозумілим способом.
+* Розумні параметри за замовчуванням, але потужні налаштування.
 
 ///
 
-### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI /OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a>
+### <a href="https://swagger.io/" class="external-link" target="_blank">Swagger</a> / <a href="https://github.com/OAI/OpenAPI-Specification/" class="external-link" target="_blank">OpenAPI</a> { #swagger-openapi }
 
 Головною функцією, яку я хотів від Django REST Framework, була автоматична API документація.
 
@@ -124,18 +124,18 @@ def read_url():
 
  Інтегрувати інструменти інтерфейсу на основі стандартів:
 
- * <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Інтерфейс Swagger</a>
- * <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>
+* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank">Інтерфейс Swagger</a>
+* <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank">ReDoc</a>
 
  Ці два було обрано через те, що вони досить популярні та стабільні, але, виконавши швидкий пошук, ви можете знайти десятки додаткових альтернативних інтерфейсів для OpenAPI (які можна використовувати з **FastAPI**).
 
 ///
 
-### Фреймворки REST для Flask
+### Фреймворки REST для Flask { #flask-rest-frameworks }
 
 Існує кілька фреймворків Flask REST, але, витративши час і роботу на їх дослідження, я виявив, що багато з них припинено або залишено, з кількома постійними проблемами, які зробили їх непридатними.
 
-### <a href="https://marshmallow.readthedocs.io/en/stable/" class="external-link" target="_blank">Marshmallow</a>
+### <a href="https://marshmallow.readthedocs.io/en/stable/" class="external-link" target="_blank">Marshmallow</a> { #marshmallow }
 
 Однією з головних функцій, необхідних для систем API, є "<abbr title="також звана marshalling, conversion">серіалізація</abbr>", яка бере дані з коду (Python) і перетворює їх на щось, що можна надіслати через мережу. Наприклад, перетворення об’єкта, що містить дані з бази даних, на об’єкт JSON. Перетворення об’єктів `datetime` на строки тощо.
 
@@ -153,7 +153,7 @@ Marshmallow створено для забезпечення цих функці
 
 ///
 
-### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a>
+### <a href="https://webargs.readthedocs.io/en/latest/" class="external-link" target="_blank">Webargs</a> { #webargs }
 
 Іншою важливою функцією, необхідною для API, є <abbr title="читання та перетворення даних Python">аналіз</abbr> даних із вхідних запитів.
 
@@ -175,7 +175,7 @@ Webargs був створений тими ж розробниками Marshmall
 
 ///
 
-### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a>
+### <a href="https://apispec.readthedocs.io/en/stable/" class="external-link" target="_blank">APISpec</a> { #apispec }
 
 Marshmallow і Webargs забезпечують перевірку, аналіз і серіалізацію як плагіни.
 
@@ -205,7 +205,7 @@ APISpec був створений тими ж розробниками Marshmall
 
 ///
 
-### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a>
+### <a href="https://flask-apispec.readthedocs.io/en/latest/" class="external-link" target="_blank">Flask-apispec</a> { #flask-apispec }
 
 Це плагін Flask, який об’єднує Webargs, Marshmallow і APISpec.
 
@@ -237,13 +237,13 @@ Flask-apispec був створений тими ж розробниками Mar
 
 ///
 
-### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (та <a href="https://angular.io/ " class="external-link" target="_blank">Angular</a>)
+### <a href="https://nestjs.com/" class="external-link" target="_blank">NestJS</a> (та <a href="https://angular.io/" class="external-link" target="_blank">Angular</a>) { #nestjs-and-angular }
 
 Це навіть не Python, NestJS — це фреймворк NodeJS JavaScript (TypeScript), натхненний Angular.
 
 Це досягає чогось подібного до того, що можна зробити з Flask-apispec.
 
-Він має інтегровану систему впровадження залежностей, натхненну Angular two. Він потребує попередньої реєстрації «injectables» (як і всі інші системи впровадження залежностей, які я знаю), тому це збільшує багатослівність та повторення коду.
+Він має інтегровану систему впровадження залежностей, натхненну Angular 2. Він потребує попередньої реєстрації «injectables» (як і всі інші системи впровадження залежностей, які я знаю), тому це збільшує багатослівність та повторення коду.
 
 Оскільки параметри описані за допомогою типів TypeScript (подібно до підказок типу Python), підтримка редактора досить хороша.
 
@@ -259,7 +259,7 @@ Flask-apispec був створений тими ж розробниками Mar
 
 ///
 
-### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a>
+### <a href="https://sanic.readthedocs.io/en/latest/" class="external-link" target="_blank">Sanic</a> { #sanic }
 
 Це був один із перших надзвичайно швидких фреймворків Python на основі `asyncio`. Він був дуже схожий на Flask.
 
@@ -279,7 +279,7 @@ Flask-apispec був створений тими ж розробниками Mar
 
 ///
 
-### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a>
+### <a href="https://falconframework.org/" class="external-link" target="_blank">Falcon</a> { #falcon }
 
 Falcon — ще один високопродуктивний фреймворк Python, він розроблений як мінімальний і працює як основа інших фреймворків, таких як Hug.
 
@@ -297,7 +297,7 @@ Falcon — ще один високопродуктивний фреймворк
 
 ///
 
-### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a>
+### <a href="https://moltenframework.com/" class="external-link" target="_blank">Molten</a> { #molten }
 
 Я відкрив для себе Molten на перших етапах створення **FastAPI**. І він має досить схожі ідеї:
 
@@ -321,7 +321,7 @@ Falcon — ще один високопродуктивний фреймворк
 
 ///
 
-### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a>
+### <a href="https://github.com/hugapi/hug" class="external-link" target="_blank">Hug</a> { #hug }
 
 Hug був одним із перших фреймворків, який реалізував оголошення типів параметрів API за допомогою підказок типу Python. Це була чудова ідея, яка надихнула інші інструменти зробити те саме.
 
@@ -351,7 +351,7 @@ Hug надихнув частину APIStar і був одним із найбі
 
 ///
 
-### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (<= 0,5)
+### <a href="https://github.com/encode/apistar" class="external-link" target="_blank">APIStar</a> (<= 0,5) { #apistar-0-5 }
 
 Безпосередньо перед тим, як вирішити створити **FastAPI**, я знайшов сервер **APIStar**. Він мав майже все, що я шукав, і мав чудовий дизайн.
 
@@ -379,9 +379,9 @@ Hug надихнув частину APIStar і був одним із найбі
 
 APIStar створив Том Крісті. Той самий хлопець, який створив:
 
- * Django REST Framework
- * Starlette (на якому базується **FastAPI**)
- * Uvicorn (використовується Starlette і **FastAPI**)
+* Django REST Framework
+* Starlette (на якому базується **FastAPI**)
+* Uvicorn (використовується Starlette і **FastAPI**)
 
 ///
 
@@ -393,13 +393,15 @@ APIStar створив Том Крісті. Той самий хлопець, я
 
  І після тривалого пошуку подібної структури та тестування багатьох різних альтернатив, APIStar став найкращим доступним варіантом.
 
- Потім APIStar перестав існувати як сервер, і було створено Starlette, який став новою кращою основою для такої системи. Це стало останнім джерелом натхнення для створення **FastAPI**. Я вважаю **FastAPI** «духовним спадкоємцем» APIStar, удосконалюючи та розширюючи функції, систему введення тексту та інші частини на основі досвіду, отриманого від усіх цих попередніх інструментів.
+ Потім APIStar перестав існувати як сервер, і було створено Starlette, який став новою кращою основою для такої системи. Це стало останнім джерелом натхнення для створення **FastAPI**.
+
+ Я вважаю **FastAPI** «духовним спадкоємцем» APIStar, удосконалюючи та розширюючи функції, систему типізації та інші частини на основі досвіду, отриманого від усіх цих попередніх інструментів.
 
 ///
 
-## Використовується **FastAPI**
+## Використовується **FastAPI** { #used-by-fastapi }
 
-### <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a>
+### <a href="https://docs.pydantic.dev/" class="external-link" target="_blank">Pydantic</a> { #pydantic }
 
 Pydantic — це бібліотека для визначення перевірки даних, серіалізації та документації (за допомогою схеми JSON) на основі підказок типу Python.
 
@@ -415,9 +417,9 @@ Pydantic — це бібліотека для визначення переві
 
 ///
 
-### <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a>
+### <a href="https://www.starlette.dev/" class="external-link" target="_blank">Starlette</a> { #starlette }
 
-Starlette — це легкий фреймворк/набір інструментів <abbr title="The new standard for build asynchronous Python web">ASGI</abbr>, який ідеально підходить для створення високопродуктивних asyncio сервісів.
+Starlette — це легкий фреймворк/набір інструментів <abbr title="Новий стандарт для створення асинхронних Python вебзастосунків">ASGI</abbr>, який ідеально підходить для створення високопродуктивних asyncio сервісів.
 
 Він дуже простий та інтуїтивно зрозумілий. Його розроблено таким чином, щоб його можна було легко розширювати та мати модульні компоненти.
 
@@ -460,7 +462,7 @@ ASGI — це новий «стандарт», який розробляєтьс
 
 ///
 
-### <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a>
+### <a href="https://www.uvicorn.dev/" class="external-link" target="_blank">Uvicorn</a> { #uvicorn }
 
 Uvicorn — це блискавичний сервер ASGI, побудований на uvloop і httptools.
 
@@ -472,12 +474,12 @@ Uvicorn — це блискавичний сервер ASGI, побудован
 
 Основний веб-сервер для запуску програм **FastAPI**.
 
- Ви можете поєднати його з Gunicorn, щоб мати асинхронний багатопроцесний сервер.
+ Ви також можете використати параметр командного рядка `--workers`, щоб мати асинхронний багатопроцесний сервер.
 
  Додаткову інформацію див. у розділі [Розгортання](deployment/index.md){.internal-link target=_blank}.
 
 ///
 
-## Орієнтири та швидкість
+## Орієнтири та швидкість { #benchmarks-and-speed }
 
 Щоб зрозуміти, порівняти та побачити різницю між Uvicorn, Starlette і FastAPI, перегляньте розділ про [Бенчмарки](benchmarks.md){.internal-link target=_blank}.

docs/uk/docs/fastapi-cli.md

@@ -1,83 +1,75 @@
-# FastAPI CLI
+# FastAPI CLI { #fastapi-cli }
 
-**FastAPI CLI** це програма командного рядка, яку Ви можете використовувати, щоб обслуговувати Ваш додаток FastAPI, керувати Вашими FastApi проектами, тощо.
+**FastAPI CLI** — це програма командного рядка, яку ви можете використовувати, щоб обслуговувати ваш застосунок FastAPI, керувати вашим проєктом FastAPI тощо.
 
-Коли Ви встановлюєте FastApi (тобто виконуєте `pip install "fastapi[standard]"`), Ви також встановлюєте пакунок `fastapi-cli`, цей пакунок надає команду `fastapi` в терміналі.
+Коли ви встановлюєте FastAPI (наприклад, за допомогою `pip install "fastapi[standard]"`), він включає пакет під назвою `fastapi-cli`, цей пакет надає команду `fastapi` у терміналі.
 
-Для запуску Вашого FastAPI проекту для розробки, Ви можете скористатись командою `fastapi dev`:
+Щоб запустити ваш застосунок FastAPI для розробки, ви можете використати команду `fastapi dev`:
 
 <div class="termy">
 
 ```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:single">main.py</u>
-<font color="#3465A4">INFO    </font> Using path <font color="#3465A4">main.py</font>
-<font color="#3465A4">INFO    </font> Resolved absolute path <font color="#75507B">/home/user/code/awesomeapp/</font><font color="#AD7FA8">main.py</font>
-<font color="#3465A4">INFO    </font> Searching for package file structure from directories with <font color="#3465A4">__init__.py</font> files
-<font color="#3465A4">INFO    </font> Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
 
- ╭─ <font color="#8AE234"><b>Python module file</b></font> ─╮
- │                      │
- │  🐍 main.py          │
- │                      │
- ╰──────────────────────╯
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
 
-<font color="#3465A4">INFO    </font> Importing module <font color="#4E9A06">main</font>
-<font color="#3465A4">INFO    </font> Found importable FastAPI app
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
 
- ╭─ <font color="#8AE234"><b>Importable FastAPI app</b></font> ─╮
- │                          │
- │  <span style="background-color:#272822"><font color="#FF4689">from</font></span><span style="background-color:#272822"><font color="#F8F8F2"> main </font></span><span style="background-color:#272822"><font color="#FF4689">import</font></span><span style="background-color:#272822"><font color="#F8F8F2"> app</font></span><span style="background-color:#272822">  </span>  │
- │                          │
- ╰──────────────────────────╯
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
 
-<font color="#3465A4">INFO    </font> Using import string <font color="#8AE234"><b>main:app</b></font>
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
 
- <span style="background-color:#C4A000"><font color="#2E3436">╭────────── FastAPI CLI - Development mode ───────────╮</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Serving at: http://127.0.0.1:8000                  │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  API docs: http://127.0.0.1:8000/docs               │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Running in development mode, for production use:   │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  </font></span><span style="background-color:#C4A000"><font color="#555753"><b>fastapi run</b></font></span><span style="background-color:#C4A000"><font color="#2E3436">                                        │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">╰─────────────────────────────────────────────────────╯</font></span>
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
 
-<font color="#4E9A06">INFO</font>:     Will watch for changes in these directories: [&apos;/home/user/code/awesomeapp&apos;]
-<font color="#4E9A06">INFO</font>:     Uvicorn running on <b>http://127.0.0.1:8000</b> (Press CTRL+C to quit)
-<font color="#4E9A06">INFO</font>:     Started reloader process [<font color="#34E2E2"><b>2265862</b></font>] using <font color="#34E2E2"><b>WatchFiles</b></font>
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">2265873</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
+      <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` це **FastAPI CLI**.
+Програма командного рядка під назвою `fastapi` — це **FastAPI CLI**.
 
-FastAPI CLI приймає шлях до Вашої Python програми (напр. `main.py`) і автоматично виявляє екземпляр `FastAPI` (зазвичай названий `app`), обирає коректний процес імпорту, а потім обслуговує його.
+FastAPI CLI бере шлях до вашої Python-програми (наприклад, `main.py`) і автоматично виявляє екземпляр `FastAPI` (зазвичай з назвою `app`), визначає правильний процес імпорту, а потім обслуговує його.
 
-Натомість, для запуску у продакшн використовуйте `fastapi run`. 🚀
+Натомість, для продакшн ви використали б `fastapi run`. 🚀
 
-Всередині **FastAPI CLI** використовує <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>, високопродуктивний, production-ready, ASGI cервер. 😎
+Внутрішньо **FastAPI CLI** використовує <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>, високопродуктивний, production-ready, ASGI сервер. 😎
 
-## `fastapi dev`
+## `fastapi dev` { #fastapi-dev }
 
-Використання `fastapi dev` ініціює режим розробки.
+Запуск `fastapi dev` ініціює режим розробки.
 
-За замовчуванням, **автоматичне перезавантаження** увімкнене, автоматично перезавантажуючи сервер кожного разу, коли Ви змінюєте Ваш код. Це ресурсо-затратно, та може бути менш стабільним, ніж коли воно вимкнене. Ви повинні використовувати його тільки під час розробки. Воно також слухає IP-адресу `127.0.0.1`, що є IP Вашого девайсу для самостійної комунікації з самим собою (`localhost`).
+За замовчуванням **auto-reload** увімкнено, і сервер автоматично перезавантажується, коли ви вносите зміни у ваш код. Це ресурсоємно та може бути менш стабільним, ніж коли його вимкнено. Вам слід використовувати це лише для розробки. Також він слухає IP-адресу `127.0.0.1`, яка є IP-адресою для того, щоб ваша машина могла взаємодіяти лише сама з собою (`localhost`).
 
-## `fastapi run`
+## `fastapi run` { #fastapi-run }
 
-Виконання `fastapi run` запустить FastAPI у продакшн-режимі за замовчуванням.
+Виконання `fastapi run` за замовчуванням запускає FastAPI у продакшн-режимі.
 
-За замовчуванням, **автоматичне перезавантаження** вимкнене. Воно також прослуховує IP-адресу `0.0.0.0`, що означає всі доступні IP адреси, тим самим даючи змогу будь-кому комунікувати з девайсом. Так Ви зазвичай будете запускати його у продакшн, наприклад у контейнері.
+За замовчуванням **auto-reload** вимкнено. Також він слухає IP-адресу `0.0.0.0`, що означає всі доступні IP-адреси, таким чином він буде публічно доступним для будь-кого, хто може взаємодіяти з машиною. Зазвичай саме так ви запускатимете його в продакшн, наприклад у контейнері.
 
-В більшості випадків Ви можете (і маєте) мати "termination proxy", який обробляє HTTPS для Вас, це залежить від способу розгортання вашого додатку, Ваш провайдер може зробити це для Вас, або Вам потрібно налаштувати його самостійно.
+У більшості випадків ви (і вам слід) матимете «termination proxy», який обробляє HTTPS для вас зверху; це залежатиме від того, як ви розгортаєте ваш застосунок: ваш провайдер може зробити це за вас, або вам може знадобитися налаштувати це самостійно.
 
-/// tip
+/// tip | Порада
 
-Ви можете дізнатись більше про це у [документації про розгортування](deployment/index.md){.internal-link target=_blank}.
+Ви можете дізнатися більше про це в [документації з розгортання](deployment/index.md){.internal-link target=_blank}.
 
 ///

docs/uk/docs/features.md

@@ -1,21 +1,21 @@
-# Функціональні можливості
+# Функціональні можливості { #features }
 
-## Функціональні можливості FastAPI
+## Функціональні можливості FastAPI { #fastapi-features }
 
 **FastAPI** надає вам такі можливості:
 
-### Використання відкритих стандартів
+### На основі відкритих стандартів { #based-on-open-standards }
 
 * <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> для створення API, включаючи оголошення <abbr title="також відомі як: endpoints, маршрути">шляхів</abbr>, <abbr title="також відомі як HTTP-методи, наприклад, POST, GET, PUT, DELETE">операцій</abbr>, параметрів, тіл запитів, безпеки тощо.
 * Автоматична документація моделей даних за допомогою <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a> (оскільки OpenAPI базується саме на JSON Schema).
 * Розроблено на основі цих стандартів після ретельного аналізу, а не як додатковий рівень поверх основної архітектури.
-* Це також дає змогу автоматично **генерувати код клієнта** багатьма мовами.
+* Це також дає змогу використовувати автоматичну **генерацію клієнтського коду** багатьма мовами.
 
-### Автоматична генерація документації
+### Автоматична документація { #automatic-docs }
 
-Інтерактивна документація API та вебінтерфейс для його дослідження. Оскільки фреймворк базується на OpenAPI, є кілька варіантів, два з яких включені за замовчуванням.
+Інтерактивна документація API та вебінтерфейси для його дослідження. Оскільки фреймворк базується на OpenAPI, є кілька варіантів, 2 з яких включені за замовчуванням.
 
-* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a> — дозволяє інтерактивно переглядати API, викликати та тестувати його прямо у браузері.
+* <a href="https://github.com/swagger-api/swagger-ui" class="external-link" target="_blank"><strong>Swagger UI</strong></a> — з інтерактивним дослідженням, викликом і тестуванням вашого API прямо з браузера.
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
@@ -23,23 +23,25 @@
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-### Тільки сучасний Python
+### Лише сучасний Python { #just-modern-python }
 
-FastAPI використовує стандартні **типи Python** (завдяки Pydantic). Вам не потрібно вивчати новий синтаксис — лише стандартний сучасний Python.
+Усе базується на стандартних оголошеннях **типів Python** (завдяки Pydantic). Жодного нового синтаксису для вивчення. Лише стандартний сучасний Python.
 
-Якщо вам потрібне коротке нагадування про використання типів у Python (навіть якщо ви не використовуєте FastAPI), перегляньте короткий підручник: [Вступ до типів Python](python-types.md){.internal-link target=_blank}.
+Якщо вам потрібно 2-хвилинне нагадування про те, як використовувати типи Python (навіть якщо ви не використовуєте FastAPI), перегляньте короткий підручник: [Типи Python](python-types.md){.internal-link target=_blank}.
 
-Ось приклад стандартного Python-коду з типами:
+Ви пишете стандартний Python з типами:
 
 ```Python
 from datetime import date
+
 from pydantic import BaseModel
 
-# Оголошення змінної як str
-# з підтримкою автодоповнення у редакторі
+# Оголосіть змінну як str
+# та отримайте підтримку редактора всередині функції
 def main(user_id: str):
     return user_id
 
+
 # Модель Pydantic
 class User(BaseModel):
     id: int
@@ -47,7 +49,7 @@ class User(BaseModel):
     joined: date
 ```
 
-Приклад використання цієї моделі:
+Далі це можна використовувати так:
 
 ```Python
 my_user: User = User(id=3, name="John Doe", joined="2018-07-19")
@@ -65,19 +67,21 @@ my_second_user: User = User(**second_user_data)
 
 `**second_user_data` означає:
 
-Передати ключі та значення словника `second_user_data` як аргументи у вигляді "ключ-значення", еквівалентно `User(id=4, name="Mary", joined="2018-11-30")`.
+Передати ключі та значення словника `second_user_data` безпосередньо як аргументи у вигляді «ключ-значення», еквівалентно: `User(id=4, name="Mary", joined="2018-11-30")`
 
 ///
 
-### Підтримка редакторів (IDE)
+### Підтримка редакторів (IDE) { #editor-support }
 
-Фреймворк спроєктований так, щоб бути легким і інтуїтивно зрозумілим. Усі рішення тестувалися у різних редакторах ще до початку розробки, щоб забезпечити найкращий досвід програмування.
+Увесь фреймворк спроєктовано так, щоб ним було легко та інтуїтивно користуватися; усі рішення тестувалися у кількох редакторах ще до початку розробки, щоб забезпечити найкращий досвід розробки.
 
-За результатами опитувань розробників Python <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">однією з найпопулярніших функцій є "автодоповнення"</a>.
+З опитувань розробників Python зрозуміло <a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank">що однією з найуживаніших функцій є «автодоповнення»</a>.
 
-**FastAPI** повністю підтримує автодоповнення у всіх місцях, тому вам рідко доведеться повертатися до документації.
+Увесь фреймворк **FastAPI** побудований так, щоб це забезпечити. Автодоповнення працює всюди.
 
-Приклад автодоповнення у редакторах:
+Вам рідко доведеться повертатися до документації.
+
+Ось як ваш редактор може вам допомогти:
 
 * у <a href="https://code.visualstudio.com/" class="external-link" target="_blank">Visual Studio Code</a>:
 
@@ -87,17 +91,25 @@ my_second_user: User = User(**second_user_data)
 
 ![editor support](https://fastapi.tiangolo.com/img/pycharm-completion.png)
 
-### Короткий код
-FastAPI має розумні налаштування **за замовчуванням**, але всі параметри можна налаштовувати відповідно до ваших потреб. Однак за замовчуванням все "просто працює".
+Ви отримаєте автодоповнення в коді, який раніше могли вважати навіть неможливим. Наприклад, для ключа `price` всередині JSON body (який міг бути вкладеним), що надходить із запиту.
+
+Більше не доведеться вводити неправильні назви ключів, постійно повертатися до документації або прокручувати вгору-вниз, щоб знайти, чи ви зрештою використали `username` чи `user_name`.
+
+### Короткий код { #short }
+
+FastAPI має розумні **налаштування за замовчуванням** для всього, з можливістю конфігурації всюди. Усі параметри можна точно налаштувати під ваші потреби та визначити потрібний вам API.
+
+Але за замовчуванням усе **«просто працює»**.
+
+### Валідація { #validation }
 
-### Валідація
 * Підтримка валідації для більшості (або всіх?) **типів даних Python**, зокрема:
     * JSON-об'єктів (`dict`).
-    * JSON-списків (`list`) з визначенням типів елементів.
-    * Рядків (`str`) із мінімальною та максимальною довжиною.
-    * Чисел (`int`, `float`) з обмеженнями мінімальних та максимальних значень тощо.
+    * JSON-масивів (`list`) із визначенням типів елементів.
+    * Полів-рядків (`str`) із визначенням мінімальної та максимальної довжини.
+    * Чисел (`int`, `float`) з мінімальними та максимальними значеннями тощо.
 
-* Валідація складніших типів, таких як:
+* Валідація для більш екзотичних типів, як-от:
     * URL.
     * Email.
     * UUID.
@@ -105,55 +117,55 @@ FastAPI має розумні налаштування **за замовчува
 
 Уся валідація виконується через надійний та перевірений **Pydantic**.
 
-### Безпека та автентифікація
+### Безпека та автентифікація { #security-and-authentication }
 
-**FastAPI** підтримує вбудовану автентифікацію та авторизацію, без прив’язки до конкретних баз даних чи моделей даних.
+Інтегровані безпека та автентифікація. Без жодних компромісів із базами даних чи моделями даних.
 
-Підтримуються всі схеми безпеки OpenAPI, включаючи:
+Підтримуються всі схеми безпеки, визначені в OpenAPI, включно з:
 
 * HTTP Basic.
-* **OAuth2** (також із підтримкою **JWT-токенів**). Див. підручник: [OAuth2 із JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
+* **OAuth2** (також із підтримкою **JWT tokens**). Перегляньте підручник: [OAuth2 із JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
 * Ключі API в:
     * Заголовках.
     * Параметрах запиту.
     * Cookies тощо.
 
-А також усі можливості безпеки від Starlette (зокрема **сесійні cookies**).
+А також усі можливості безпеки від Starlette (зокрема **session cookies**).
 
-Усі вони створені як багаторазові інструменти та компоненти, які легко інтегруються з вашими системами, сховищами даних, реляційними та NoSQL базами даних тощо.
+Усе це зроблено як багаторазові інструменти та компоненти, які легко інтегруються з вашими системами, сховищами даних, реляційними та NoSQL базами даних тощо.
 
-### Впровадження залежностей
+### Впровадження залежностей { #dependency-injection }
 
-**FastAPI** містить надзвичайно просту у використанні, але потужну систему впровадження залежностей.
+FastAPI містить надзвичайно просту у використанні, але надзвичайно потужну систему <abbr title='також відоме як: "components", "resources", "services", "providers"'><strong>Dependency Injection</strong></abbr>.
 
-* Залежності можуть мати власні залежності, утворюючи ієрархію або **"граф залежностей"**.
-* Усі залежності автоматично керуються фреймворком.
-* Усі залежності можуть отримувати дані з запитів і розширювати **обмеження операції за шляхом** та автоматичну документацію.
-* **Автоматична валідація** навіть для параметрів *операцій шляху*, визначених у залежностях.
-* Підтримка складних систем автентифікації користувачів, **з'єднань із базами даних** тощо.
-* **Жодних обмежень** щодо використання баз даних, фронтендів тощо, але водночас проста інтеграція з усіма ними.
+* Навіть залежності можуть мати власні залежності, утворюючи ієрархію або **«граф» залежностей**.
+* Усе **автоматично обробляється** фреймворком.
+* Усі залежності можуть вимагати дані із запитів і **розширювати обмеження операції шляху** та автоматичну документацію.
+* **Автоматична валідація** навіть для параметрів *операції шляху*, визначених у залежностях.
+* Підтримка складних систем автентифікації користувачів, **підключень до баз даних** тощо.
+* **Жодних компромісів** із базами даних, фронтендами тощо. Але проста інтеграція з усіма ними.
 
-### Немає обмежень на "плагіни"
+### Необмежені «плагіни» { #unlimited-plug-ins }
 
-Або іншими словами, вони не потрібні – просто імпортуйте та використовуйте необхідний код.
+Інакше кажучи, вони не потрібні — імпортуйте та використовуйте код, який вам потрібен.
 
-Будь-яка інтеграція спроєктована настільки просто (з використанням залежностей), що ви можете створити "плагін" для свого застосунку всього у 2 рядках коду, використовуючи ту саму структуру та синтаксис, що й для ваших *операцій шляху*.
+Будь-яка інтеграція спроєктована так, щоб її було дуже просто використовувати (із залежностями), тож ви можете створити «плагін» для свого застосунку у 2 рядках коду, використовуючи ту саму структуру та синтаксис, що й для ваших *операцій шляху*.
 
-### Протестовано
+### Протестовано { #tested }
 
 * 100% <abbr title="Обсяг коду, що автоматично тестується">покриття тестами</abbr>.
 * 100% <abbr title="Анотації типів у Python, завдяки яким ваш редактор і зовнішні інструменти можуть надавати кращу підтримку">анотована типами</abbr> кодова база.
-* Використовується у робочих середовищах.
+* Використовується в production-застосунках.
 
-## Можливості Starlette
+## Можливості Starlette { #starlette-features }
 
 **FastAPI** повністю сумісний із (та побудований на основі) <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>. Тому будь-який додатковий код Starlette, який ви маєте, також працюватиме.
 
-**FastAPI** фактично є підкласом **Starlette**. Тому, якщо ви вже знайомі зі Starlette або використовуєте його, більшість функціональності працюватиме так само.
+`FastAPI` фактично є підкласом `Starlette`. Тому, якщо ви вже знайомі зі Starlette або використовуєте його, більшість функціональності працюватиме так само.
 
-З **FastAPI** ви отримуєте всі можливості **Starlette** (адже FastAPI — це, по суті, Starlette на стероїдах):
+З **FastAPI** ви отримуєте всі можливості **Starlette** (адже FastAPI — це просто Starlette на стероїдах):
 
-* Разюча продуктивність. Це <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">один із найшвидших фреймворків на Python</a>, на рівні з **NodeJS** і **Go**.
+* Разюча продуктивність. Це <a href="https://github.com/encode/starlette#performance" class="external-link" target="_blank">один із найшвидших доступних Python-фреймворків, на рівні з **NodeJS** і **Go**</a>.
 * Підтримка **WebSocket**.
 * Фонові задачі у процесі.
 * Події запуску та завершення роботи.
@@ -163,27 +175,27 @@ FastAPI має розумні налаштування **за замовчува
 * 100% покриття тестами.
 * 100% анотована типами кодова база.
 
-## Можливості Pydantic
+## Можливості Pydantic { #pydantic-features }
 
 **FastAPI** повністю сумісний із (та побудований на основі) <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>. Тому будь-який додатковий код Pydantic, який ви маєте, також працюватиме.
 
-Включаючи зовнішні бібліотеки, побудовані також на Pydantic, такі як <abbr title="Object-Relational Mapper">ORM</abbr>, <abbr title="Object-Document Mapper">ODM</abbr> для баз даних.
+Включно із зовнішніми бібліотеками, які також базуються на Pydantic, як-от <abbr title="Object-Relational Mapper - Об'єктно-реляційний відображувач">ORM</abbr>-и, <abbr title="Object-Document Mapper - Об'єктно-документний відображувач">ODM</abbr>-и для баз даних.
 
-Це також означає, що в багатьох випадках ви можете передати той самий об'єкт, який отримуєте з запиту, **безпосередньо в базу даних**, оскільки все автоматично перевіряється.
+Це також означає, що в багатьох випадках ви можете передати той самий об'єкт, який отримуєте із запиту, **безпосередньо в базу даних**, оскільки все автоматично перевіряється.
 
-Те ж саме відбувається й у зворотному напрямку — у багатьох випадках ви можете просто передати об'єкт, який отримуєте з бази даних, **безпосередньо клієнту**.
+Те саме застосовується й у зворотному напрямку — у багатьох випадках ви можете просто передати об'єкт, який отримуєте з бази даних, **безпосередньо клієнту**.
 
 З **FastAPI** ви отримуєте всі можливості **Pydantic** (адже FastAPI базується на Pydantic для обробки всіх даних):
 
-* **Ніякої плутанини** :
-    * Не потрібно вчити нову мову для визначення схем.
+* **Ніякої плутанини**:
+    * Не потрібно вчити нову мікромову для визначення схем.
     * Якщо ви знаєте типи Python, ви знаєте, як використовувати Pydantic.
-* Легко працює з вашим **<abbr title="Інтегроване середовище розробки, схоже на редактор коду">IDE</abbr>/<abbr title="Програма, яка перевіряє помилки в коді">лінтером</abbr>/мозком**:
-    * Оскільки структури даних Pydantic є просто екземплярами класів, які ви визначаєте; автодоповнення, лінтинг, mypy і ваша інтуїція повинні добре працювати з вашими перевіреними даними.
-* Валідація **складних структур**:
-    * Використання ієрархічних моделей Pydantic. Python `typing`, `List` і `Dict` тощо.
-    * Валідатори дозволяють чітко і просто визначати, перевіряти й документувати складні схеми даних у вигляді JSON-схеми.
-    * Ви можете мати глибоко **вкладені JSON об'єкти** та перевірити та анотувати їх всі.
+* Легко працює з вашим **<abbr title="Integrated Development Environment - Інтегроване середовище розробки: схоже на код-редактор">IDE</abbr>/<abbr title="Програма, що перевіряє код на помилки">linter</abbr>/мозком**:
+    * Оскільки структури даних pydantic є просто екземплярами класів, які ви визначаєте; автодоповнення, лінтинг, mypy і ваша інтуїція повинні добре працювати з вашими перевіреними даними.
+* Валідує **складні структури**:
+    * Використання ієрархічних моделей Pydantic, Python `typing`’s `List` і `Dict` тощо.
+    * Валідатори дають змогу складні схеми даних чітко й просто визначати, перевіряти й документувати як JSON Schema.
+    * Ви можете мати глибоко **вкладені JSON** об'єкти, і всі вони будуть валідовані та анотовані.
 * **Розширюваність**:
-    * Pydantic дозволяє визначати користувацькі типи даних або розширювати валідацію методами в моделі декоратором `validator`.
+    * Pydantic дозволяє визначати користувацькі типи даних або ви можете розширити валідацію методами в моделі, позначеними декоратором validator.
 * 100% покриття тестами.