+
## WebSockets client
### In production
diff --git a/docs/en/docs/async.md b/docs/en/docs/async.md
index 43473c822309d..c14a2cbb70ea8 100644
--- a/docs/en/docs/async.md
+++ b/docs/en/docs/async.md
@@ -26,7 +26,7 @@ async def read_results():
---
-If you are using a third party library that communicates with something (a database, an API, the file system, etc) and doesn't have support for using `await`, (this is currently the case for most database libraries), then declare your *path operation functions* as normally, with just `def`, like:
+If you are using a third party library that communicates with something (a database, an API, the file system, etc.) and doesn't have support for using `await`, (this is currently the case for most database libraries), then declare your *path operation functions* as normally, with just `def`, like:
```Python hl_lines="2"
@app.get('/')
@@ -45,7 +45,7 @@ If you just don't know, use normal `def`.
---
-**Note**: you can mix `def` and `async def` in your *path operation functions* as much as you need and define each one using the best option for you. FastAPI will do the right thing with them.
+**Note**: You can mix `def` and `async def` in your *path operation functions* as much as you need and define each one using the best option for you. FastAPI will do the right thing with them.
Anyway, in any of the cases above, FastAPI will still work asynchronously and be extremely fast.
@@ -136,6 +136,9 @@ You and your crush eat the burgers and have a nice time. ✨
+!!! info
+ Beautiful illustrations by Ketrina Thompson. 🎨
+
---
Imagine you are the computer / program 🤖 in that story.
@@ -196,6 +199,9 @@ You just eat them, and you are done. ⏹
There was not much talk or flirting as most of the time was spent waiting 🕙 in front of the counter. 😞
+!!! info
+ Beautiful illustrations by Ketrina Thompson. 🎨
+
---
In this scenario of the parallel burgers, you are a computer / program 🤖 with two processors (you and your crush), both waiting 🕙 and dedicating their attention ⏯ to be "waiting on the counter" 🕙 for a long time.
@@ -232,11 +238,7 @@ This "waiting" 🕙 is measured in microseconds, but still, summing it all, it's
That's why it makes a lot of sense to use asynchronous ⏸🔀⏯ code for web APIs.
-Most of the existing popular Python frameworks (including Flask and Django) were created before the new asynchronous features in Python existed. So, the ways they can be deployed support parallel execution and an older form of asynchronous execution that is not as powerful as the new capabilities.
-
-Even though the main specification for asynchronous web Python (ASGI) was developed at Django, to add support for WebSockets.
-
-That kind of asynchronicity is what made NodeJS popular (even though NodeJS is not parallel) and that's the strength of Go as a programming language.
+This kind of asynchronicity is what made NodeJS popular (even though NodeJS is not parallel) and that's the strength of Go as a programming language.
And that's the same level of performance you get with **FastAPI**.
@@ -395,7 +397,7 @@ All that is what powers FastAPI (through Starlette) and what makes it have such
These are very technical details of how **FastAPI** works underneath.
- If you have quite some technical knowledge (co-routines, threads, blocking, etc) and are curious about how FastAPI handles `async def` vs normal `def`, go ahead.
+ If you have quite some technical knowledge (co-routines, threads, blocking, etc.) and are curious about how FastAPI handles `async def` vs normal `def`, go ahead.
### Path operation functions
diff --git a/docs/en/docs/contributing.md b/docs/en/docs/contributing.md
index b3a2ff506cf1a..39d7dd19304dd 100644
--- a/docs/en/docs/contributing.md
+++ b/docs/en/docs/contributing.md
@@ -84,7 +84,17 @@ To check it worked, use:
If it shows the `pip` binary at `env/bin/pip` then it worked. 🎉
+Make sure you have the latest pip version on your virtual environment to avoid errors on the next steps:
+
!!! tip
Every time you install a new package with `pip` under that environment, activate the environment again.
diff --git a/docs/en/docs/features.md b/docs/en/docs/features.md
index e4672d5329347..02bb3ac1f2322 100644
--- a/docs/en/docs/features.md
+++ b/docs/en/docs/features.md
@@ -195,6 +195,6 @@ With **FastAPI** you get all of **Pydantic**'s features (as FastAPI is based on
* Use of hierarchical Pydantic models, Python `typing`’s `List` and `Dict`, etc.
* And validators allow complex data schemas to be clearly and easily defined, checked and documented as JSON Schema.
* You can have deeply **nested JSON** objects and have them all validated and annotated.
-* **Extendible**:
+* **Extensible**:
* Pydantic allows custom data types to be defined or you can extend validation with methods on a model decorated with the validator decorator.
* 100% test coverage.
diff --git a/docs/en/docs/img/sponsors/docarray-top-banner.svg b/docs/en/docs/img/sponsors/docarray-top-banner.svg
index c48a3312b81a1..b2eca354437e6 100644
--- a/docs/en/docs/img/sponsors/docarray-top-banner.svg
+++ b/docs/en/docs/img/sponsors/docarray-top-banner.svg
@@ -1 +1 @@
-
+
diff --git a/docs/en/docs/index.md b/docs/en/docs/index.md
index 14a63c126f785..afdd62ceec01c 100644
--- a/docs/en/docs/index.md
+++ b/docs/en/docs/index.md
@@ -32,7 +32,6 @@ FastAPI is a modern, fast (high-performance), web framework for building APIs wi
The key features are:
* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
-
* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
@@ -129,7 +128,7 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
+You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
diff --git a/docs/en/docs/python-types.md b/docs/en/docs/python-types.md
index 963fcaf1cd580..3d22ee620af0d 100644
--- a/docs/en/docs/python-types.md
+++ b/docs/en/docs/python-types.md
@@ -158,7 +158,7 @@ The syntax using `typing` is **compatible** with all versions, from Python 3.6 t
As Python advances, **newer versions** come with improved support for these type annotations and in many cases you won't even need to import and use the `typing` module to declare the type annotations.
-If you can chose a more recent version of Python for your project, you will be able to take advantage of that extra simplicity. See some examples below.
+If you can choose a more recent version of Python for your project, you will be able to take advantage of that extra simplicity. See some examples below.
#### List
@@ -267,7 +267,7 @@ You can declare that a variable can be any of **several types**, for example, an
In Python 3.6 and above (including Python 3.10) you can use the `Union` type from `typing` and put inside the square brackets the possible types to accept.
-In Python 3.10 there's also an **alternative syntax** were you can put the possible types separated by a vertical bar (`|`).
+In Python 3.10 there's also an **alternative syntax** where you can put the possible types separated by a vertical bar (`|`).
=== "Python 3.6 and above"
@@ -326,7 +326,7 @@ If you are using a Python version below 3.10, here's a tip from my very **subjec
Both are equivalent and underneath they are the same, but I would recommend `Union` instead of `Optional` because the word "**optional**" would seem to imply that the value is optional, and it actually means "it can be `None`", even if it's not optional and is still required.
-I think `Union[str, SomeType]` is more explicit about what it means.
+I think `Union[SomeType, None]` is more explicit about what it means.
It's just about the words and names. But those words can affect how you and your teammates think about the code.
@@ -372,7 +372,7 @@ These types that take type parameters in square brackets are called **Generic ty
=== "Python 3.9 and above"
- You can use the same builtin types as generics (with square brakets and types inside):
+ You can use the same builtin types as generics (with square brackets and types inside):
* `list`
* `tuple`
@@ -387,7 +387,7 @@ These types that take type parameters in square brackets are called **Generic ty
=== "Python 3.10 and above"
- You can use the same builtin types as generics (with square brakets and types inside):
+ You can use the same builtin types as generics (with square brackets and types inside):
* `list`
* `tuple`
diff --git a/docs/en/docs/release-notes.md b/docs/en/docs/release-notes.md
index 6cd2a298c5d47..120b374e2cf98 100644
--- a/docs/en/docs/release-notes.md
+++ b/docs/en/docs/release-notes.md
@@ -2,10 +2,250 @@
## Latest Changes
-* ✨ Add illustrations for Concurrent burgers and Parallel burgers. PR [#5277](https://github.com/tiangolo/fastapi/pull/5277) by [@tiangolo](https://github.com/tiangolo).
+
+## 0.83.0
+
+🚨 This is probably the last release (or one of the last releases) to support Python 3.6. 🔥
+
+Python 3.6 reached the [end-of-life and is no longer supported by Python](https://www.python.org/downloads/release/python-3615/) since around a year ago.
+
+You hopefully updated to a supported version of Python a while ago. If you haven't, you really should.
+
+### Features
+
+* ✨ Add support in `jsonable_encoder` for include and exclude with dataclasses. PR [#4923](https://github.com/tiangolo/fastapi/pull/4923) by [@DCsunset](https://github.com/DCsunset).
+
+### 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).
+
+### Docs
+
+* 📝 Update `SECURITY.md`. PR [#5377](https://github.com/tiangolo/fastapi/pull/5377) by [@Kludex](https://github.com/Kludex).
+
+### Internal
+
+* ⬆ [pre-commit.ci] pre-commit autoupdate. PR [#5352](https://github.com/tiangolo/fastapi/pull/5352) by [@pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci).
+
+## 0.82.0
+
+🚨 This is probably the last release (or one of the last releases) to support Python 3.6. 🔥
+
+Python 3.6 reached the [end-of-life and is no longer supported by Python](https://www.python.org/downloads/release/python-3615/) since around a year ago.
+
+You hopefully updated to a supported version of Python a while ago. If you haven't, you really should.
+
+### Features
+
+* ✨ Export `WebSocketState` in `fastapi.websockets`. PR [#4376](https://github.com/tiangolo/fastapi/pull/4376) by [@matiuszka](https://github.com/matiuszka).
+* ✨ Support Python internal description on Pydantic model's docstring. PR [#3032](https://github.com/tiangolo/fastapi/pull/3032) by [@Kludex](https://github.com/Kludex).
+* ✨ Update `ORJSONResponse` to support non `str` keys and serializing Numpy arrays. PR [#3892](https://github.com/tiangolo/fastapi/pull/3892) by [@baby5](https://github.com/baby5).
+
+### Fixes
+
+* 🐛 Allow exit code for dependencies with `yield` to always execute, by removing capacity limiter for them, to e.g. allow closing DB connections without deadlocks. PR [#5122](https://github.com/tiangolo/fastapi/pull/5122) by [@adriangb](https://github.com/adriangb).
+* 🐛 Fix FastAPI People GitHub Action: set HTTPX timeout for GraphQL query request. PR [#5222](https://github.com/tiangolo/fastapi/pull/5222) by [@iudeen](https://github.com/iudeen).
+* 🐛 Make sure a parameter defined as required is kept required in OpenAPI even if defined as optional in another dependency. PR [#4319](https://github.com/tiangolo/fastapi/pull/4319) by [@cd17822](https://github.com/cd17822).
+* 🐛 Fix support for path parameters in WebSockets. PR [#3879](https://github.com/tiangolo/fastapi/pull/3879) by [@davidbrochart](https://github.com/davidbrochart).
+
+### Docs
+
+* ✏ Update Hypercorn link, now pointing to GitHub. PR [#5346](https://github.com/tiangolo/fastapi/pull/5346) by [@baconfield](https://github.com/baconfield).
+* ✏ Tweak wording in `docs/en/docs/advanced/dataclasses.md`. PR [#3698](https://github.com/tiangolo/fastapi/pull/3698) by [@pfackeldey](https://github.com/pfackeldey).
+* 📝 Add note about Python 3.10 `X | Y` operator in explanation about Response Models. PR [#5307](https://github.com/tiangolo/fastapi/pull/5307) by [@MendyLanda](https://github.com/MendyLanda).
+* 📝 Add link to New Relic article: "How to monitor FastAPI application performance using Python agent". PR [#5260](https://github.com/tiangolo/fastapi/pull/5260) by [@sjyothi54](https://github.com/sjyothi54).
+* 📝 Update docs for `ORJSONResponse` with details about improving performance. PR [#2615](https://github.com/tiangolo/fastapi/pull/2615) by [@falkben](https://github.com/falkben).
+* 📝 Add docs for creating a custom Response class. PR [#5331](https://github.com/tiangolo/fastapi/pull/5331) by [@tiangolo](https://github.com/tiangolo).
+* 📝 Add tip about using alias for form data fields. PR [#5329](https://github.com/tiangolo/fastapi/pull/5329) by [@tiangolo](https://github.com/tiangolo).
+
+### Translations
+
+* 🌐 Add Russian translation for `docs/ru/docs/features.md`. PR [#5315](https://github.com/tiangolo/fastapi/pull/5315) by [@Xewus](https://github.com/Xewus).
+* 🌐 Update Chinese translation for `docs/zh/docs/tutorial/request-files.md`. PR [#4529](https://github.com/tiangolo/fastapi/pull/4529) by [@ASpathfinder](https://github.com/ASpathfinder).
+* 🌐 Add Chinese translation for `docs/zh/docs/tutorial/encoder.md`. PR [#4969](https://github.com/tiangolo/fastapi/pull/4969) by [@Zssaer](https://github.com/Zssaer).
+* 🌐 Fix MkDocs file line for Portuguese translation of `background-task.md`. PR [#5242](https://github.com/tiangolo/fastapi/pull/5242) by [@ComicShrimp](https://github.com/ComicShrimp).
+
+### Internal
+
+* 👥 Update FastAPI People. PR [#5347](https://github.com/tiangolo/fastapi/pull/5347) by [@github-actions[bot]](https://github.com/apps/github-actions).
+* ⬆ Bump dawidd6/action-download-artifact from 2.22.0 to 2.23.0. PR [#5321](https://github.com/tiangolo/fastapi/pull/5321) by [@dependabot[bot]](https://github.com/apps/dependabot).
+* ⬆ [pre-commit.ci] pre-commit autoupdate. PR [#5318](https://github.com/tiangolo/fastapi/pull/5318) by [@pre-commit-ci[bot]](https://github.com/apps/pre-commit-ci).
+* ✏ Fix a small code highlight line error. PR [#5256](https://github.com/tiangolo/fastapi/pull/5256) by [@hjlarry](https://github.com/hjlarry).
+* ♻ Internal small refactor, move `operation_id` parameter position in delete method for consistency with the code. PR [#4474](https://github.com/tiangolo/fastapi/pull/4474) by [@hiel](https://github.com/hiel).
+* 🔧 Update sponsors, disable ImgWhale. PR [#5338](https://github.com/tiangolo/fastapi/pull/5338) by [@tiangolo](https://github.com/tiangolo).
+
+## 0.81.0
+
+### Features
+
+* ✨ Add ReDoc `
+
+**FastAPI** n'existerait pas sans le travail antérieur d'autres personnes.
+
+Il y a eu de nombreux outils créés auparavant qui ont contribué à inspirer sa création.
+
+J'ai évité la création d'un nouveau framework pendant plusieurs années. J'ai d'abord essayé de résoudre toutes les fonctionnalités couvertes par **FastAPI** en utilisant de nombreux frameworks, plug-ins et outils différents.
+
+Mais à un moment donné, il n'y avait pas d'autre option que de créer quelque chose qui offre toutes ces fonctionnalités, en prenant les meilleures idées des outils précédents, et en les combinant de la meilleure façon possible, en utilisant des fonctionnalités du langage qui n'étaient même pas disponibles auparavant (annotations de type pour Python 3.6+).
+
+
```console
-$ pip install fastapi[all]
+$ pip install "fastapi[all]"
---> 100%
```
@@ -64,7 +64,7 @@ $ pip install fastapi[all]
Também instale o `uvicorn` para funcionar como servidor:
```
- pip install uvicorn[standard]
+ pip install "uvicorn[standard]"
```
E o mesmo para cada dependência opcional que você quiser usar.
diff --git a/docs/pt/docs/tutorial/query-params.md b/docs/pt/docs/tutorial/query-params.md
new file mode 100644
index 0000000000000..1897243961b73
--- /dev/null
+++ b/docs/pt/docs/tutorial/query-params.md
@@ -0,0 +1,224 @@
+# Parâmetros de Consulta
+
+Quando você declara outros parâmetros na função que não fazem parte dos parâmetros da rota, esses parâmetros são automaticamente interpretados como parâmetros de "consulta".
+
+```Python hl_lines="9"
+{!../../../docs_src/query_params/tutorial001.py!}
+```
+
+A consulta é o conjunto de pares chave-valor que vai depois de `?` na URL, separado pelo caractere `&`.
+
+Por exemplo, na URL:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+...os parâmetros da consulta são:
+
+* `skip`: com o valor `0`
+* `limit`: com o valor `10`
+
+Como eles são parte da URL, eles são "naturalmente" strings.
+
+Mas quando você declara eles com os tipos do Python (no exemplo acima, como `int`), eles são convertidos para aquele tipo e validados em relação a ele.
+
+Todo o processo que era aplicado para parâmetros de rota também é aplicado para parâmetros de consulta:
+
+* Suporte do editor (obviamente)
+* "Parsing" de dados
+* Validação de dados
+* Documentação automática
+
+## Valores padrão
+
+Como os parâmetros de consulta não são uma parte fixa da rota, eles podem ser opcionais e podem ter valores padrão.
+
+No exemplo acima eles tem valores padrão de `skip=0` e `limit=10`.
+
+Então, se você for até a URL:
+
+```
+http://127.0.0.1:8000/items/
+```
+
+Seria o mesmo que ir para:
+
+```
+http://127.0.0.1:8000/items/?skip=0&limit=10
+```
+
+Mas, se por exemplo você for para:
+
+```
+http://127.0.0.1:8000/items/?skip=20
+```
+
+Os valores dos parâmetros na sua função serão:
+
+* `skip=20`: Por que você definiu isso na URL
+* `limit=10`: Por que esse era o valor padrão
+
+## Parâmetros opcionais
+
+Da mesma forma, você pode declarar parâmetros de consulta opcionais, definindo o valor padrão para `None`:
+
+=== "Python 3.6 and above"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/query_params/tutorial002.py!}
+ ```
+
+=== "Python 3.10 and above"
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/query_params/tutorial002_py310.py!}
+ ```
+
+Nesse caso, o parâmetro da função `q` será opcional, e `None` será o padrão.
+
+!!! check "Verificar"
+ Você também pode notar que o **FastAPI** é esperto o suficiente para perceber que o parâmetro da rota `item_id` é um parâmetro da rota, e `q` não é, portanto, `q` é o parâmetro de consulta.
+
+
+## Conversão dos tipos de parâmetros de consulta
+
+Você também pode declarar tipos `bool`, e eles serão convertidos:
+
+=== "Python 3.6 and above"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/query_params/tutorial003.py!}
+ ```
+
+=== "Python 3.10 and above"
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/query_params/tutorial003_py310.py!}
+ ```
+
+Nesse caso, se você for para:
+
+```
+http://127.0.0.1:8000/items/foo?short=1
+```
+
+ou
+
+```
+http://127.0.0.1:8000/items/foo?short=True
+```
+
+ou
+
+```
+http://127.0.0.1:8000/items/foo?short=true
+```
+
+ou
+
+```
+http://127.0.0.1:8000/items/foo?short=on
+```
+
+ou
+
+```
+http://127.0.0.1:8000/items/foo?short=yes
+```
+
+ou qualquer outra variação (tudo em maiúscula, primeira letra em maiúscula, etc), a sua função vai ver o parâmetro `short` com um valor `bool` de `True`. Caso contrário `False`.
+
+## Múltiplos parâmetros de rota e consulta
+
+Você pode declarar múltiplos parâmetros de rota e parâmetros de consulta ao mesmo tempo, o **FastAPI** vai saber o quê é o quê.
+
+E você não precisa declarar eles em nenhuma ordem específica.
+
+Eles serão detectados pelo nome:
+
+=== "Python 3.6 and above"
+
+ ```Python hl_lines="8 10"
+ {!> ../../../docs_src/query_params/tutorial004.py!}
+ ```
+
+=== "Python 3.10 and above"
+
+ ```Python hl_lines="6 8"
+ {!> ../../../docs_src/query_params/tutorial004_py310.py!}
+ ```
+
+## Parâmetros de consulta obrigatórios
+
+Quando você declara um valor padrão para parâmetros que não são de rota (até agora, nós vimos apenas parâmetros de consulta), então eles não são obrigatórios.
+
+Caso você não queira adicionar um valor específico mas queira apenas torná-lo opcional, defina o valor padrão como `None`.
+
+Porém, quando você quiser fazer com que o parâmetro de consulta seja obrigatório, você pode simplesmente não declarar nenhum valor como padrão.
+
+```Python hl_lines="6-7"
+{!../../../docs_src/query_params/tutorial005.py!}
+```
+
+Aqui o parâmetro de consulta `needy` é um valor obrigatório, do tipo `str`.
+
+Se você abrir no seu navegador a URL:
+
+```
+http://127.0.0.1:8000/items/foo-item
+```
+
+... sem adicionar o parâmetro obrigatório `needy`, você verá um erro como:
+
+```JSON
+{
+ "detail": [
+ {
+ "loc": [
+ "query",
+ "needy"
+ ],
+ "msg": "field required",
+ "type": "value_error.missing"
+ }
+ ]
+}
+```
+
+Como `needy` é um parâmetro obrigatório, você precisaria defini-lo na URL:
+
+```
+http://127.0.0.1:8000/items/foo-item?needy=sooooneedy
+```
+
+...isso deve funcionar:
+
+```JSON
+{
+ "item_id": "foo-item",
+ "needy": "sooooneedy"
+}
+```
+
+E claro, você pode definir alguns parâmetros como obrigatórios, alguns possuindo um valor padrão, e outros sendo totalmente opcionais:
+
+=== "Python 3.6 and above"
+
+ ```Python hl_lines="10"
+ {!> ../../../docs_src/query_params/tutorial006.py!}
+ ```
+
+=== "Python 3.10 and above"
+
+ ```Python hl_lines="8"
+ {!> ../../../docs_src/query_params/tutorial006_py310.py!}
+ ```
+Nesse caso, existem 3 parâmetros de consulta:
+
+* `needy`, um `str` obrigatório.
+* `skip`, um `int` com o valor padrão `0`.
+* `limit`, um `int` opcional.
+
+!!! tip "Dica"
+ Você também poderia usar `Enum` da mesma forma que com [Path Parameters](path-params.md#predefined-values){.internal-link target=_blank}.
diff --git a/docs/pt/docs/tutorial/security/first-steps.md b/docs/pt/docs/tutorial/security/first-steps.md
new file mode 100644
index 0000000000000..ed07d1c963102
--- /dev/null
+++ b/docs/pt/docs/tutorial/security/first-steps.md
@@ -0,0 +1,181 @@
+# Segurança - Primeiros Passos
+
+Vamos imaginar que você tem a sua API **backend** em algum domínio.
+
+E você tem um **frontend** em outro domínio ou em um path diferente no mesmo domínio (ou em uma aplicação mobile).
+
+E você quer uma maneira de o frontend autenticar o backend, usando um **username** e **senha**.
+
+Nós podemos usar o **OAuth2** junto com o **FastAPI**.
+
+Mas, vamos poupar-lhe o tempo de ler toda a especificação apenas para achar as pequenas informações que você precisa.
+
+Vamos usar as ferramentas fornecidas pela **FastAPI** para lidar com segurança.
+
+## Como Parece
+
+Vamos primeiro usar o código e ver como funciona, e depois voltaremos para entender o que está acontecendo.
+
+## Crie um `main.py`
+Copie o exemplo em um arquivo `main.py`:
+
+```Python
+{!../../../docs_src/security/tutorial001.py!}
+```
+
+## Execute-o
+
+!!! informação
+ Primeiro, instale `python-multipart`.
+
+ Ex: `pip install python-multipart`.
+
+ Isso ocorre porque o **OAuth2** usa "dados de um formulário" para mandar o **username** e **senha**.
+
+Execute esse exemplo com:
+
+
+
+```console
+$ uvicorn main:app --reload
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+## Verifique-o
+
+Vá até a documentação interativa em: http://127.0.0.1:8000/docs.
+
+Você verá algo deste tipo:
+
+
+
+!!! marque o "botão de Autorizar!"
+ Você já tem um novo "botão de autorizar!".
+
+ E seu *path operation* tem um pequeno cadeado no canto superior direito que você pode clicar.
+
+E se você clicar, você terá um pequeno formulário de autorização para digitar o `username` e `senha` (e outros campos opcionais):
+
+
+
+!!! nota
+ Não importa o que você digita no formulário, não vai funcionar ainda. Mas nós vamos chegar lá.
+
+Claro que este não é o frontend para os usuários finais, mas é uma ótima ferramenta automática para documentar interativamente toda sua API.
+
+Pode ser usado pelo time de frontend (que pode ser você no caso).
+
+Pode ser usado por aplicações e sistemas third party (de terceiros).
+
+E também pode ser usada por você mesmo, para debugar, checar e testar a mesma aplicação.
+
+## O Fluxo da `senha`
+
+Agora vamos voltar um pouco e entender o que é isso tudo.
+
+O "fluxo" da `senha` é um dos caminhos ("fluxos") definidos no OAuth2, para lidar com a segurança e autenticação.
+
+OAuth2 foi projetado para que o backend ou a API pudesse ser independente do servidor que autentica o usuário.
+
+Mas nesse caso, a mesma aplicação **FastAPI** irá lidar com a API e a autenticação.
+
+Então, vamos rever de um ponto de vista simplificado:
+
+* O usuário digita o `username` e a `senha` no frontend e aperta `Enter`.
+* O frontend (rodando no browser do usuário) manda o `username` e a `senha` para uma URL específica na sua API (declarada com `tokenUrl="token"`).
+* A API checa aquele `username` e `senha`, e responde com um "token" (nós não implementamos nada disso ainda).
+ * Um "token" é apenas uma string com algum conteúdo que nós podemos utilizar mais tarde para verificar o usuário.
+ * Normalmente, um token é definido para expirar depois de um tempo.
+ * Então, o usuário terá que se logar de novo depois de um tempo.
+ * E se o token for roubado, o risco é menor. Não é como se fosse uma chave permanente que vai funcionar para sempre (na maioria dos casos).
+ * O frontend armazena aquele token temporariamente em algum lugar.
+ * O usuário clica no frontend para ir à outra seção daquele frontend do aplicativo web.
+ * O frontend precisa buscar mais dados daquela API.
+ * Mas precisa de autenticação para aquele endpoint em específico.
+ * Então, para autenticar com nossa API, ele manda um header de `Autorização` com o valor `Bearer` mais o token.
+ * Se o token contém `foobar`, o conteúdo do header de `Autorização` será: `Bearer foobar`.
+
+## **FastAPI**'s `OAuth2PasswordBearer`
+
+**FastAPI** fornece várias ferramentas, em diferentes níveis de abstração, para implementar esses recursos de segurança.
+
+Neste exemplo, nós vamos usar o **OAuth2** com o fluxo de **Senha**, usando um token **Bearer**. Fazemos isso usando a classe `OAuth2PasswordBearer`.
+
+!!! informação
+ Um token "bearer" não é a única opção.
+
+ Mas é a melhor no nosso caso.
+
+ E talvez seja a melhor para a maioria dos casos, a não ser que você seja um especialista em OAuth2 e saiba exatamente o porquê de existir outras opções que se adequam melhor às suas necessidades.
+
+ Nesse caso, **FastAPI** também fornece as ferramentas para construir.
+
+Quando nós criamos uma instância da classe `OAuth2PasswordBearer`, nós passamos pelo parâmetro `tokenUrl` Esse parâmetro contém a URL que o client (o frontend rodando no browser do usuário) vai usar para mandar o `username` e `senha` para obter um token.
+
+```Python hl_lines="6"
+{!../../../docs_src/security/tutorial001.py!}
+```
+
+!!! dica
+ Esse `tokenUrl="token"` se refere a uma URL relativa que nós não criamos ainda. Como é uma URL relativa, é equivalente a `./token`.
+
+ Porque estamos usando uma URL relativa, se sua API estava localizada em `https://example.com/`, então irá referir-se à `https://example.com/token`. Mas se sua API estava localizada em `https://example.com/api/v1/`, então irá referir-se à `https://example.com/api/v1/token`.
+
+ Usar uma URL relativa é importante para garantir que sua aplicação continue funcionando, mesmo em um uso avançado tipo [Atrás de um Proxy](../../advanced/behind-a-proxy.md){.internal-link target=_blank}.
+
+Esse parâmetro não cria um endpoint / *path operation*, mas declara que a URL `/token` vai ser aquela que o client deve usar para obter o token. Essa informação é usada no OpenAPI, e depois na API Interativa de documentação de sistemas.
+
+Em breve também criaremos o atual path operation.
+
+!!! informação
+ Se você é um "Pythonista" muito rigoroso, você pode não gostar do estilo do nome do parâmetro `tokenUrl` em vez de `token_url`.
+
+ Isso ocorre porque está utilizando o mesmo nome que está nas especificações do OpenAPI. Então, se você precisa investigar mais sobre qualquer um desses esquemas de segurança, você pode simplesmente copiar e colar para encontrar mais informações sobre isso.
+
+A variável `oauth2_scheme` é um instância de `OAuth2PasswordBearer`, mas também é um "callable".
+
+Pode ser chamada de:
+
+```Python
+oauth2_scheme(some, parameters)
+```
+
+Então, pode ser usado com `Depends`.
+
+## Use-o
+
+Agora você pode passar aquele `oauth2_scheme` em uma dependência com `Depends`.
+
+```Python hl_lines="10"
+{!../../../docs_src/security/tutorial001.py!}
+```
+
+Esse dependência vai fornecer uma `str` que é atribuído ao parâmetro `token da *função do path operation*
+
+A **FastAPI** saberá que pode usar essa dependência para definir um "esquema de segurança" no esquema da OpenAPI (e na documentação da API automática).
+
+!!! informação "Detalhes técnicos"
+ **FastAPI** saberá que pode usar a classe `OAuth2PasswordBearer` (declarada na dependência) para definir o esquema de segurança na OpenAPI porque herda de `fastapi.security.oauth2.OAuth2`, que por sua vez herda de `fastapi.security.base.Securitybase`.
+
+ Todos os utilitários de segurança que se integram com OpenAPI (e na documentação da API automática) herdam de `SecurityBase`, é assim que **FastAPI** pode saber como integrá-los no OpenAPI.
+
+## O que ele faz
+
+Ele irá e olhará na requisição para aquele header de `Autorização`, verificará se o valor é `Bearer` mais algum token, e vai retornar o token como uma `str`
+
+Se ele não ver o header de `Autorização` ou o valor não tem um token `Bearer`, vai responder com um código de erro 401 (`UNAUTHORIZED`) diretamente.
+
+Você nem precisa verificar se o token existe para retornar um erro. Você pode ter certeza de que se a sua função for executada, ela terá um `str` nesse token.
+
+Você já pode experimentar na documentação interativa:
+
+
+
+Não estamos verificando a validade do token ainda, mas isso já é um começo
+
+## Recapitulando
+
+Então, em apenas 3 ou 4 linhas extras, você já tem alguma forma primitiva de segurança.
diff --git a/docs/pt/mkdocs.yml b/docs/pt/mkdocs.yml
index 3fb834bed9982..59ee3cc88aabe 100644
--- a/docs/pt/mkdocs.yml
+++ b/docs/pt/mkdocs.yml
@@ -64,13 +64,17 @@ nav:
- tutorial/index.md
- tutorial/first-steps.md
- tutorial/path-params.md
+ - tutorial/query-params.md
- tutorial/body.md
- tutorial/body-fields.md
- tutorial/extra-data-types.md
- tutorial/query-params-str-validations.md
- tutorial/cookie-params.md
+ - tutorial/header-params.md
+ - tutorial/handling-errors.md
- Segurança:
- tutorial/security/index.md
+ - tutorial/background-tasks.md
- Guia de Usuário Avançado:
- advanced/index.md
- Implantação:
diff --git a/docs/ru/docs/deployment/versions.md b/docs/ru/docs/deployment/versions.md
new file mode 100644
index 0000000000000..91b9038e9f3f2
--- /dev/null
+++ b/docs/ru/docs/deployment/versions.md
@@ -0,0 +1,87 @@
+# О версиях FastAPI
+
+**FastAPI** уже используется в продакшене во многих приложениях и системах. Покрытие тестами поддерживается на уровне 100%. Однако его разработка все еще продолжается.
+
+Часто добавляются новые функции, регулярно исправляются баги, код продолжает постоянно совершенствоваться.
+
+По указанным причинам текущие версии до сих пор `0.x.x`. Это говорит о том, что каждая версия может содержать обратно несовместимые изменения, следуя соглашению о Семантическом Версионировании.
+
+Уже сейчас вы можете создавать приложения в продакшене, используя **FastAPI** (и скорее всего так и делаете), главное убедиться в том, что вы используете версию, которая корректно работает с вашим кодом.
+
+## Закрепите вашу версию `fastapi`
+
+Первым делом вам следует "закрепить" конкретную последнюю используемую версию **FastAPI**, которая корректно работает с вашим приложением.
+
+Например, в своём приложении вы используете версию `0.45.0`.
+
+Если вы используете файл `requirements.txt`, вы можете указать версию следующим способом:
+
+```txt
+fastapi==0.45.0
+```
+
+это означает, что вы будете использовать именно версию `0.45.0`.
+
+Или вы можете закрепить версию следующим способом:
+
+```txt
+fastapi>=0.45.0,<0.46.0
+```
+
+это значит, что вы используете версии `0.45.0` или выше, но меньше чем `0.46.0`. Например, версия `0.45.2` все еще будет подходить.
+
+Если вы используете любой другой инструмент для управления зависимостями, например Poetry, Pipenv или др., у них у всех имеется способ определения специфической версии для ваших пакетов.
+
+## Доступные версии
+
+Вы можете посмотреть доступные версии (например, проверить последнюю на данный момент) в [примечаниях к выпуску](../release-notes.md){.internal-link target=_blank}.
+
+## О версиях
+
+Следуя соглашению о Семантическом Версионировании, любые версии ниже `1.0.0` потенциально могут добавить обратно несовместимые изменения.
+
+FastAPI следует соглашению в том, что любые изменения "ПАТЧ"-версии предназначены для исправления багов и внесения обратно совместимых изменений.
+
+!!! Подсказка
+ "ПАТЧ" - это последнее число. Например, в `0.2.3`, ПАТЧ-версия - это `3`.
+
+Итак, вы можете закрепить версию следующим образом:
+
+```txt
+fastapi>=0.45.0,<0.46.0
+```
+
+Обратно несовместимые изменения и новые функции добавляются в "МИНОРНЫЕ" версии.
+
+!!! Подсказка
+ "МИНОРНАЯ" версия - это число в середине. Например, в `0.2.3` МИНОРНАЯ версия - это `2`.
+
+## Обновление версий FastAPI
+
+Вам следует добавить тесты для вашего приложения.
+
+С помощью **FastAPI** это очень просто (благодаря Starlette), см. документацию: [Тестирование](../tutorial/testing.md){.internal-link target=_blank}
+
+После создания тестов вы можете обновить свою версию **FastAPI** до более новой. После этого следует убедиться, что ваш код работает корректно, запустив тесты.
+
+Если все работает корректно, или после внесения необходимых изменений все ваши тесты проходят, только тогда вы можете закрепить вашу новую версию `fastapi`.
+
+## О Starlette
+
+Не следует закреплять версию `starlette`.
+
+Разные версии **FastAPI** будут использовать более новые версии Starlette.
+
+Так что решение об используемой версии Starlette, вы можете оставить **FastAPI**.
+
+## О Pydantic
+
+Pydantic включает свои собственные тесты для **FastAPI**, так что новые версии Pydantic (выше `1.0.0`) всегда совместимы с FastAPI.
+
+Вы можете закрепить любую версию Pydantic, которая вам подходит, выше `1.0.0` и ниже `2.0.0`.
+
+Например:
+
+```txt
+pydantic>=1.2.0,<2.0.0
+```
diff --git a/docs/ru/docs/features.md b/docs/ru/docs/features.md
new file mode 100644
index 0000000000000..0cec4eee2a012
--- /dev/null
+++ b/docs/ru/docs/features.md
@@ -0,0 +1,203 @@
+# Основные свойства
+
+## Основные свойства FastAPI
+
+**FastAPI** предлагает вам следующее:
+
+### Использование открытых стандартов
+
+* OpenAPI для создания API, включая объявления операций пути, параметров, тела запроса, безопасности и т.д.
+
+
+* Автоматическое документирование моделей данных в соответствии с JSON Schema (так как спецификация OpenAPI сама основана на JSON Schema).
+* Разработан, придерживаясь этих стандартов, после тщательного их изучения. Эти стандарты изначально включены во фреймфорк, а не являются дополнительной надстройкой.
+* Это также позволяет использовать автоматическую **генерацию клиентского кода** на многих языках.
+
+### Автоматически генерируемая документация
+
+Интерактивная документация для API и исследования пользовательских веб-интерфейсов. Поскольку этот фреймворк основан на OpenAPI, существует несколько вариантов документирования, 2 из которых включены по умолчанию.
+
+* Swagger UI, с интерактивным взаимодействием, вызывает и тестирует ваш API прямо из браузера.
+
+![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
+
+* Альтернативная документация API в ReDoc.
+
+![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
+
+### Только современный Python
+
+Все эти возможности основаны на стандартных **аннотациях типов Python 3.6** (благодаря Pydantic). Не нужно изучать новый синтаксис. Только лишь стандартный современный Python.
+
+Если вам нужно освежить знания, как использовать аннотации типов в Python (даже если вы не используете FastAPI), выделите 2 минуты и просмотрите краткое руководство: [Введение в аннотации типов Python¶
+](python-types.md){.internal-link target=_blank}.
+
+Вы пишете на стандартном Python с аннотациями типов:
+
+```Python
+from datetime import date
+
+from pydantic import BaseModel
+
+# Объявляем параметр user_id с типом `str`
+# и получаем поддержку редактора внутри функции
+def main(user_id: str):
+ return user_id
+
+
+# Модель Pydantic
+class User(BaseModel):
+ id: int
+ name: str
+ joined: date
+```
+
+Это можно использовать так:
+
+```Python
+my_user: User = User(id=3, name="John Doe", joined="2018-07-19")
+
+second_user_data = {
+ "id": 4,
+ "name": "Mary",
+ "joined": "2018-11-30",
+}
+
+my_second_user: User = User(**second_user_data)
+```
+
+!!! Информация
+ `**second_user_data` означает:
+
+ Передать ключи и значения словаря `second_user_data`, в качестве аргументов типа "ключ-значение", это эквивалентно: `User(id=4, name="Mary", joined="2018-11-30")` .
+
+### Поддержка редакторов (IDE)
+
+Весь фреймворк был продуман так, чтобы быть простым и интуитивно понятным в использовании, все решения были проверены на множестве редакторов еще до начала разработки, чтобы обеспечить наилучшие условия при написании кода.
+
+В опросе Python-разработчиков было выяснено, что наиболее часто используемой функцией редакторов, является "автодополнение".
+
+Вся структура **FastAPI** основана на удовлетворении этой возможности. Автодополнение работает везде.
+
+Вам редко нужно будет возвращаться к документации.
+
+Вот как ваш редактор может вам помочь:
+
+* в Visual Studio Code:
+
+![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
+
+* в PyCharm:
+
+![editor support](https://fastapi.tiangolo.com/img/pycharm-completion.png)
+
+Вы будете получать автодополнение кода даже там, где вы считали это невозможным раньше.
+Как пример, ключ `price` внутри тела JSON (который может быть вложенным), приходящего в запросе.
+
+Больше никаких неправильных имён ключей, метания по документации или прокручивания кода вверх и вниз, в попытках узнать - использовали вы ранее `username` или `user_name`.
+
+### Краткость
+FastAPI имеет продуманные значения **по умолчанию** для всего, с произвольными настройками везде. Все параметры могут быть тонко подстроены так, чтобы делать то, что вам нужно и определять необходимый вам API.
+
+Но, по умолчанию, всё это **"и так работает"**.
+
+### Проверка значений
+
+* Проверка значений для большинства (или всех?) **типов данных** Python, включая:
+ * Объекты JSON (`dict`).
+ * Массивы JSON (`list`) с установленными типами элементов.
+ * Строковые (`str`) поля с ограничением минимальной и максимальной длины.
+ * Числа (`int`, `float`) с минимальными и максимальными значениями и т.п.
+
+* Проверка для более экзотических типов, таких как:
+ * URL.
+ * Email.
+ * UUID.
+ * ...и другие.
+
+Все проверки обрабатываются хорошо зарекомендовавшим себя и надежным **Pydantic**.
+
+### Безопасность и аутентификация
+
+Встроеные функции безопасности и аутентификации. Без каких-либо компромиссов с базами данных или моделями данных.
+
+Все схемы безопасности, определённые в OpenAPI, включая:
+
+* HTTP Basic.
+* **OAuth2** (также с **токенами JWT**). Ознакомьтесь с руководством [OAuth2 с JWT](tutorial/security/oauth2-jwt.md){.internal-link target=_blank}.
+* Ключи API в:
+ * Заголовках.
+ * Параметрах запросов.
+ * Cookies и т.п.
+
+Вдобавок все функции безопасности от Starlette (включая **сессионные cookies**).
+
+Все инструменты и компоненты спроектированы для многократного использования и легко интегрируются с вашими системами, хранилищами данных, реляционными и NoSQL базами данных и т. д.
+
+### Внедрение зависимостей
+
+FastAPI включает в себя чрезвычайно простую в использовании, но чрезвычайно мощную систему Внедрения зависимостей.
+
+* Даже зависимости могут иметь зависимости, создавая иерархию или **"графы" зависимостей**.
+* Всё **автоматически обрабатывается** фреймворком.
+* Все зависимости могут запрашивать данные из запросов и **дополнять операции пути** ограничениями и автоматической документацией.
+* **Автоматическая проверка** даже для параметров *операций пути*, определенных в зависимостях.
+* Поддержка сложных систем аутентификации пользователей, **соединений с базами данных** и т.д.
+* **Никаких компромиссов** с базами данных, интерфейсами и т.д. Но легкая интеграция со всеми ними.
+
+### Нет ограничений на "Плагины"
+
+Или, другими словами, нет сложностей с ними, импортируйте и используйте нужный вам код.
+
+Любая интеграция разработана настолько простой в использовании (с зависимостями), что вы можете создать "плагин" для своего приложения в пару строк кода, используя ту же структуру и синтаксис, что и для ваших *операций пути*.
+
+### Проверен
+
+* 100% покрытие тестами.
+* 100% аннотирование типов в кодовой базе.
+* Используется в реально работающих приложениях.
+
+## Основные свойства Starlette
+
+**FastAPI** основан на Starlette и полностью совместим с ним. Так что, любой дополнительный код Starlette, который у вас есть, будет также работать.
+
+На самом деле, `FastAPI` - это класс, унаследованный от `Starlette`. Таким образом, если вы уже знаете или используете Starlette, большая часть функционала будет работать так же.
+
+С **FastAPI** вы получаете все возможности **Starlette** (так как FastAPI это всего лишь Starlette на стероидах):
+
+* Серьёзно впечатляющая производительность. Это один из самых быстрых фреймворков на Python, наравне с приложениями использующими **NodeJS** или **Go**.
+* Поддержка **WebSocket**.
+* Фоновые задачи для процессов.
+* События запуска и выключения.
+* Тестовый клиент построен на библиотеке `requests`.
+* **CORS**, GZip, статические файлы, потоковые ответы.
+* Поддержка **сессий и cookie**.
+* 100% покрытие тестами.
+* 100% аннотирование типов в кодовой базе.
+
+## Особенности и возможности Pydantic
+
+**FastAPI** основан на Pydantic и полностью совместим с ним. Так что, любой дополнительный код Pydantic, который у вас есть, будет также работать.
+
+Включая внешние библиотеки, также основанные на Pydantic, такие как: ORM'ы, ODM'ы для баз данных.
+
+Это также означает, что во многих случаях вы можете передавать тот же объект, который получили из запроса, **непосредственно в базу данных**, так как всё проверяется автоматически.
+
+И наоборот, во многих случаях вы можете просто передать объект, полученный из базы данных, **непосредственно клиенту**.
+
+С **FastAPI** вы получаете все возможности **Pydantic** (так как, FastAPI основан на Pydantic, для обработки данных):
+
+* **Никакой нервотрёпки** :
+ * Не нужно изучать новых схем в микроязыках.
+ * Если вы знаете аннотации типов в Python, вы знаете, как использовать Pydantic.
+* Прекрасно сочетается с вашими **IDE/linter/мозгом**:
+ * Потому что структуры данных pydantic - это всего лишь экземпляры классов, определённых вами. Автодополнение, проверка кода, mypy и ваша интуиция - всё будет работать с вашими проверенными данными.
+* **Быстродействие**:
+ * В тестовых замерах Pydantic быстрее, чем все другие проверенные библиотеки.
+* Проверка **сложных структур**:
+ * Использование иерархических моделей Pydantic; `List`, `Dict` и т.п. из модуля `typing` (входит в стандартную библиотеку Python).
+ * Валидаторы позволяют четко и легко определять, проверять и документировать сложные схемы данных в виде JSON Schema.
+ * У вас могут быть глубоко **вложенные объекты JSON** и все они будут проверены и аннотированы.
+* **Расширяемость**:
+ * Pydantic позволяет определять пользовательские типы данных или расширять проверку методами модели, с помощью проверочных декораторов.
+* 100% покрытие тестами.
diff --git a/docs/ru/docs/index.md b/docs/ru/docs/index.md
index 57dfd20d1961e..24f547ecc0f59 100644
--- a/docs/ru/docs/index.md
+++ b/docs/ru/docs/index.md
@@ -1,50 +1,48 @@
-
-{!../../../docs/missing-translation.md!}
-
-
- FastAPI framework, high performance, easy to learn, fast to code, ready for production
+ Готовый к внедрению высокопроизводительный фреймворк, простой в изучении и разработке.
---
-**Documentation**: https://fastapi.tiangolo.com
+**Документация**: https://fastapi.tiangolo.com
-**Source Code**: https://github.com/tiangolo/fastapi
+**Исходный код**: https://github.com/tiangolo/fastapi
---
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
-
-The key features are:
+FastAPI — это современный, быстрый (высокопроизводительный) веб-фреймворк для создания API используя Python 3.6+, в основе которого лежит стандартная аннотация типов Python.
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
+Ключевые особенности:
-* **Fast to code**: Increase the speed to develop features by about 200% to 300%. *
-* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
-* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
-* **Easy**: Designed to be easy to use and learn. Less time reading docs.
-* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
-* **Robust**: Get production-ready code. With automatic interactive documentation.
-* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
+* **Скорость**: Очень высокая производительность, на уровне **NodeJS** и **Go** (благодаря Starlette и Pydantic). [Один из самых быстрых фреймворков Python](#_10).
+* **Быстрота разработки**: Увеличьте скорость разработки примерно на 200–300%. *
+* **Меньше ошибок**: Сократите примерно на 40% количество ошибок, вызванных человеком (разработчиком). *
+* **Интуитивно понятный**: Отличная поддержка редактора. Автозавершение везде. Меньше времени на отладку.
+* **Лёгкость**: Разработан так, чтобы его было легко использовать и осваивать. Меньше времени на чтение документации.
+* **Краткость**: Сведите к минимуму дублирование кода. Каждый объявленный параметр - определяет несколько функций. Меньше ошибок.
+* **Надежность**: Получите готовый к работе код. С автоматической интерактивной документацией.
+* **На основе стандартов**: Основан на открытых стандартах API и полностью совместим с ними: OpenAPI (ранее известном как Swagger) и JSON Schema.
-* estimation based on tests on an internal development team, building production applications.
+* оценка на основе тестов внутренней команды разработчиков, создающих производственные приложения.
-## Sponsors
+## Спонсоры
@@ -59,66 +57,66 @@ The key features are:
-Other sponsors
+Другие спонсоры
-## 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._"
+"_В последнее время я много где использую **FastAPI**. [...] На самом деле я планирую использовать его для всех **сервисов машинного обучения моей команды в Microsoft**. Некоторые из них интегрируются в основной продукт **Windows**, а некоторые — в продукты **Office**._"
---
-"_We adopted the **FastAPI** library to spawn a **REST** server that can be queried to obtain **predictions**. [for Ludwig]_"
+"_Мы использовали библиотеку **FastAPI** для создания сервера **REST**, к которому можно делать запросы для получения **прогнозов**. [для Ludwig]_"
Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala - Uber(ref)
---
-"_**Netflix** is pleased to announce the open-source release of our **crisis management** orchestration framework: **Dispatch**! [built with **FastAPI**]_"
+"_**Netflix** рада объявить о выпуске опенсорсного фреймворка для оркестровки **антикризисного управления**: **Dispatch**! [создана с помощью **FastAPI**]_"
Kevin Glisson, Marc Vilanova, Forest Monsen - Netflix(ref)
---
-"_I’m over the moon excited about **FastAPI**. It’s so fun!_"
+"_Я в полном восторге от **FastAPI**. Это так весело!_"
---
-"_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._"
+"_Честно говоря, то, что вы создали, выглядит очень солидно и отполировано. Во многих смыслах я хотел, чтобы **Hug** был именно таким — это действительно вдохновляет, когда кто-то создаёт такое._"
---
-"_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 [...]_"
+"_Если вы хотите изучить какой-нибудь **современный фреймворк** для создания REST API, ознакомьтесь с **FastAPI** [...] Он быстрый, лёгкий и простой в изучении [...]_"
-"_We've switched over to **FastAPI** for our **APIs** [...] I think you'll like it [...]_"
+"_Мы перешли на **FastAPI** для наших **API** [...] Я думаю, вам тоже понравится [...]_"
---
-## **Typer**, the FastAPI of CLIs
+## **Typer**, интерфейс командной строки для FastAPI
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
+Если вы создаете приложение CLI для использования в терминале вместо веб-API, ознакомьтесь с **Typer**.
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
+**Typer** — младший брат FastAPI. И он предназначен для использования в качестве **интерфейса командной строки для FastAPI**. ⌨️ 🚀
-## Requirements
+## Зависимости
Python 3.7+
-FastAPI stands on the shoulders of giants:
+FastAPI стоит на плечах гигантов:
-* Starlette for the web parts.
-* Pydantic for the data parts.
+* Starlette для части связанной с вебом.
+* Pydantic для части связанной с данными.
-## Installation
+## Установка
@@ -130,23 +128,23 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
+Вам также понадобится сервер ASGI для производства, такой как Uvicorn или Hypercorn.
-## Example
+## Пример
-### Create it
+### Создание
-* Create a file `main.py` with:
+* Создайте файл `main.py` со следующим содержимым:
```Python
from typing import Union
@@ -167,9 +165,9 @@ def read_item(item_id: int, q: Union[str, None] = None):
```
-Or use async def...
+Или используйте async def...
-If your code uses `async` / `await`, use `async def`:
+Если ваш код использует `async` / `await`, используйте `async def`:
```Python hl_lines="9 14"
from typing import Union
@@ -189,15 +187,15 @@ async def read_item(item_id: int, q: Union[str, None] = None):
return {"item_id": item_id, "q": q}
```
-**Note**:
+**Примечание**:
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
+Если вы не знаете, проверьте раздел _"Торопитесь?"_ в документации об `async` и `await`.
-### Run it
+### Запуск
-Run the server with:
+Запустите сервер с помощью:
-About the command uvicorn main:app --reload...
+О команде uvicorn main:app --reload...
-The command `uvicorn main:app` refers to:
+Команда `uvicorn main:app` относится к:
-* `main`: the file `main.py` (the Python "module").
-* `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
-* `--reload`: make the server restart after code changes. Only do this for development.
+* `main`: файл `main.py` (модуль Python).
+* `app`: объект, созданный внутри `main.py` с помощью строки `app = FastAPI()`.
+* `--reload`: перезапуск сервера после изменения кода. Делайте это только во время разработки.
-### Check it
+### Проверка
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
+Откройте браузер на http://127.0.0.1:8000/items/5?q=somequery.
-You will see the JSON response as:
+Вы увидите следующий JSON ответ:
```JSON
{"item_id": 5, "q": "somequery"}
```
-You already created an API that:
+Вы уже создали API, который:
-* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
-* Both _paths_ take `GET` operations (also known as HTTP _methods_).
-* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
-* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
+* Получает HTTP-запросы по _путям_ `/` и `/items/{item_id}`.
+* И первый и второй _путь_ используют `GET` операции (также известные как HTTP _методы_).
+* _путь_ `/items/{item_id}` имеет _параметр пути_ `item_id`, который должен быть `int`.
+* _путь_ `/items/{item_id}` имеет необязательный `str` _параметр запроса_ `q`.
-### Interactive API docs
+### Интерактивная документация по API
-Now go to http://127.0.0.1:8000/docs.
+Перейдите на http://127.0.0.1:8000/docs.
-You will see the automatic interactive API documentation (provided by Swagger UI):
+Вы увидите автоматическую интерактивную документацию API (предоставленную Swagger UI):
![Swagger UI](https://fastapi.tiangolo.com/img/index/index-01-swagger-ui-simple.png)
-### Alternative API docs
+### Альтернативная документация по API
-And now, go to http://127.0.0.1:8000/redoc.
+А теперь перейдите на http://127.0.0.1:8000/redoc.
-You will see the alternative automatic documentation (provided by ReDoc):
+Вы увидите альтернативную автоматическую документацию (предоставленную ReDoc):
![ReDoc](https://fastapi.tiangolo.com/img/index/index-02-redoc-simple.png)
-## Example upgrade
+## Пример обновления
-Now modify the file `main.py` to receive a body from a `PUT` request.
+Теперь измените файл `main.py`, чтобы получить тело ответа из `PUT` запроса.
-Declare the body using standard Python types, thanks to Pydantic.
+Объявите тело, используя стандартную типизацию Python, спасибо Pydantic.
```Python hl_lines="4 9-12 25-27"
from typing import Union
@@ -293,174 +291,173 @@ def update_item(item_id: int, item: Item):
return {"item_name": item.name, "item_id": item_id}
```
-The server should reload automatically (because you added `--reload` to the `uvicorn` command above).
+Сервер должен перезагрузиться автоматически (потому что вы добавили `--reload` к команде `uvicorn` выше).
-### Interactive API docs upgrade
+### Интерактивное обновление документации API
-Now go to http://127.0.0.1:8000/docs.
+Перейдите на http://127.0.0.1:8000/docs.
-* The interactive API documentation will be automatically updated, including the new body:
+* Интерактивная документация API будет автоматически обновляться, включая новое тело:
![Swagger UI](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
+* Нажмите на кнопку "Try it out", это позволит вам заполнить параметры и напрямую взаимодействовать с API:
![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-04-swagger-03.png)
-* Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
+* Затем нажмите кнопку "Execute", пользовательский интерфейс свяжется с вашим API, отправит параметры, получит результаты и отобразит их на экране:
![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-05-swagger-04.png)
-### Alternative API docs upgrade
+### Альтернативное обновление документации API
-And now, go to http://127.0.0.1:8000/redoc.
+А теперь перейдите на http://127.0.0.1:8000/redoc.
-* The alternative documentation will also reflect the new query parameter and body:
+* Альтернативная документация также будет отражать новый параметр и тело запроса:
![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
-### Recap
+### Подведём итоги
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
+Таким образом, вы объявляете **один раз** типы параметров, тело и т. д. в качестве параметров функции.
-You do that with standard modern Python types.
+Вы делаете это испльзуя стандартную современную типизацию Python.
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
+Вам не нужно изучать новый синтаксис, методы или классы конкретной библиотеки и т. д.
-Just standard **Python 3.6+**.
+Только стандартный **Python 3.6+**.
-For example, for an `int`:
+Например, для `int`:
```Python
item_id: int
```
-or for a more complex `Item` model:
+или для более сложной модели `Item`:
```Python
item: Item
```
-...and with that single declaration you get:
+... и с этим единственным объявлением вы получаете:
-* Editor support, including:
- * Completion.
- * Type checks.
-* Validation of data:
- * Automatic and clear errors when the data is invalid.
- * Validation even for deeply nested JSON objects.
-* Conversion of input data: coming from the network to Python data and types. Reading from:
+* Поддержка редактора, в том числе:
+ * Автозавершение.
+ * Проверка типов.
+* Валидация данных:
+ * Автоматические и четкие ошибки, когда данные недействительны.
+ * Проверка даже для глубоко вложенных объектов JSON.
+* Преобразование входных данных: поступающие из сети в объекты Python с соблюдением типов. Чтение из:
* JSON.
- * Path parameters.
- * Query parameters.
+ * Параметров пути.
+ * Параметров запроса.
* Cookies.
- * Headers.
- * Forms.
- * Files.
-* Conversion of output data: converting from Python data and types to network data (as JSON):
- * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
- * `datetime` objects.
- * `UUID` objects.
- * Database models.
- * ...and many more.
-* Automatic interactive API documentation, including 2 alternative user interfaces:
+ * Заголовков.
+ * Форм.
+ * Файлов.
+* Преобразование выходных данных: преобразование объектов Python в данные передаваемые по сети интернет (такие как JSON):
+ * Преобразование типов Python (`str`, `int`, `float`, `bool`, `list`, и т.д.).
+ * Объекты `datetime`.
+ * Объекты `UUID`.
+ * Модели баз данных.
+ * ...и многое другое.
+* Автоматическая интерактивная документация по API, включая 2 альтернативных пользовательских интерфейса:
* Swagger UI.
* ReDoc.
---
-Coming back to the previous code example, **FastAPI** will:
-
-* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
-* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
- * If it is not, the client will see a useful, clear error.
-* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
- * As the `q` parameter is declared with `= None`, it is optional.
- * Without the `None` it would be required (as is the body in the case with `PUT`).
-* For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
- * Check that it has a required attribute `name` that should be a `str`.
- * Check that it has a required attribute `price` that has to be a `float`.
- * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
- * All this would also work for deeply nested JSON objects.
-* Convert from and to JSON automatically.
-* Document everything with OpenAPI, that can be used by:
- * Interactive documentation systems.
- * Automatic client code generation systems, for many languages.
-* Provide 2 interactive documentation web interfaces directly.
+Возвращаясь к предыдущему примеру кода, **FastAPI** будет:
+
+* Проверять наличие `item_id` в пути для запросов `GET` и `PUT`.
+* Проверять, что `item_id` имеет тип `int` для запросов `GET` и `PUT`.
+ * Если это не так, клиент увидит полезную чёткую ошибку.
+* Проверять, есть ли необязательный параметр запроса с именем `q` (например, `http://127.0.0.1:8000/items/foo?q=somequery`) для `GET` запросов.
+ * Поскольку параметр `q` объявлен с `= None`, он является необязательным.
+ * Без `None` он был бы необходим (как тело в случае с `PUT`).
+* Для `PUT` запросов к `/items/{item_id}` читать тело как JSON:
+ * Проверять, что у него есть обязательный атрибут `name`, который должен быть `str`.
+ * Проверять, что у него есть обязательный атрибут `price`, который должен быть `float`.
+ * Проверять, что у него есть необязательный атрибут `is_offer`, который должен быть `bool`, если он присутствует.
+ * Все это также будет работать для глубоко вложенных объектов JSON.
+* Преобразовывать из и в JSON автоматически.
+* Документировать с помощью OpenAPI все, что может быть использовано:
+ * Системы интерактивной документации.
+ * Системы автоматической генерации клиентского кода для многих языков.
+* Обеспечит 2 интерактивных веб-интерфейса документации напрямую.
---
-We just scratched the surface, but you already get the idea of how it all works.
+Мы только немного копнули поверхность, но вы уже поняли, как все это работает.
-Try changing the line with:
+Попробуйте изменить строку с помощью:
```Python
return {"item_name": item.name, "item_id": item_id}
```
-...from:
+...из:
```Python
... "item_name": item.name ...
```
-...to:
+...в:
```Python
... "item_price": item.price ...
```
-...and see how your editor will auto-complete the attributes and know their types:
+... и посмотрите, как ваш редактор будет автоматически заполнять атрибуты и узнавать их типы:
![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
-For a more complete example including more features, see the Tutorial - User Guide.
+Более полный пример с дополнительными функциями см. в Учебное руководство - Руководство пользователя.
-**Spoiler alert**: the tutorial - user guide includes:
+**Осторожно, спойлер**: руководство пользователя включает в себя:
-* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
-* How to set **validation constraints** as `maximum_length` or `regex`.
-* A very powerful and easy to use **Dependency Injection** system.
-* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
-* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
-* Many extra features (thanks to Starlette) as:
- * **WebSockets**
- * **GraphQL**
- * extremely easy tests based on `requests` and `pytest`
+* Объявление **параметров** из других мест, таких как: **заголовки**, **cookies**, **поля формы** и **файлы**.
+* Как установить **ограничительные проверки** такие как `maximum_length` или `regex`.
+* Очень мощная и простая в использовании система **внедрения зависимостей**.
+* Безопасность и аутентификация, включая поддержку **OAuth2** с **токенами JWT** и **HTTP Basic** аутентификацию.
+* Более продвинутые (но столь же простые) методы объявления **глубоко вложенных моделей JSON** (спасибо Pydantic).
+* **GraphQL** интеграция с Strawberry и другими библиотеками.
+* Множество дополнительных функций (благодаря Starlette), таких как:
+ * **Веб-сокеты**
+ * очень простые тесты на основе `requests` и `pytest`
* **CORS**
- * **Cookie Sessions**
- * ...and more.
+ * **Cookie сеансы(сессии)**
+ * ...и многое другое.
-## Performance
+## Производительность
-Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
+Независимые тесты TechEmpower показывают приложения **FastAPI**, работающие под управлением Uvicorn, как один из самых быстрых доступных фреймворков Python, уступающий только самим Starlette и Uvicorn (используемых внутри FastAPI). (*)
-To understand more about it, see the section Benchmarks.
+Чтобы узнать больше об этом, см. раздел Тесты производительности.
-## Optional Dependencies
+## Необязательные зависимости
-Used by Pydantic:
+Используется Pydantic:
-* ujson - for faster JSON "parsing".
-* email_validator - for email validation.
+* ujson - для более быстрого JSON "парсинга".
+* email_validator - для проверки электронной почты.
-Used by Starlette:
+Используется Starlette:
-* requests - Required if you want to use the `TestClient`.
-* jinja2 - Required if you want to use the default template configuration.
-* python-multipart - Required if you want to support form "parsing", with `request.form()`.
-* itsdangerous - Required for `SessionMiddleware` support.
-* pyyaml - Required for Starlette's `SchemaGenerator` support (you probably don't need it with FastAPI).
-* graphene - Required for `GraphQLApp` support.
-* ujson - Required if you want to use `UJSONResponse`.
+* requests - Обязательно, если вы хотите использовать `TestClient`.
+* jinja2 - Обязательно, если вы хотите использовать конфигурацию шаблона по умолчанию.
+* python-multipart - Обязательно, если вы хотите поддерживать форму "парсинга" с помощью `request.form()`.
+* itsdangerous - Обязательно, для поддержки `SessionMiddleware`.
+* pyyaml - Обязательно, для поддержки `SchemaGenerator` Starlette (возможно, вам это не нужно с FastAPI).
+* ujson - Обязательно, если вы хотите использовать `UJSONResponse`.
-Used by FastAPI / Starlette:
+Используется FastAPI / Starlette:
-* uvicorn - for the server that loads and serves your application.
-* orjson - Required if you want to use `ORJSONResponse`.
+* uvicorn - сервер, который загружает и обслуживает ваше приложение.
+* orjson - Обязательно, если вы хотите использовать `ORJSONResponse`.
-You can install all of these with `pip install fastapi[all]`.
+Вы можете установить все это с помощью `pip install "fastapi[all]"`.
-## License
+## Лицензия
-This project is licensed under the terms of the MIT license.
+Этот проект распространяется на условиях лицензии MIT.
diff --git a/docs/ru/docs/tutorial/background-tasks.md b/docs/ru/docs/tutorial/background-tasks.md
new file mode 100644
index 0000000000000..e608f6c8f3010
--- /dev/null
+++ b/docs/ru/docs/tutorial/background-tasks.md
@@ -0,0 +1,102 @@
+# Фоновые задачи
+
+Вы можете создавать фоновые задачи, которые будут выполнятся *после* возвращения ответа сервером.
+
+Это может быть полезно для функций, которые должны выполниться после получения запроса, но ожидание их выполнения необязательно для пользователя.
+
+К примеру:
+
+* Отправка писем на почту после выполнения каких-либо действий:
+ * Т.к. соединение с почтовым сервером и отправка письма идут достаточно "долго" (несколько секунд), вы можете отправить ответ пользователю, а отправку письма выполнить в фоне.
+* Обработка данных:
+ * К примеру, если вы получаете файл, который должен пройти через медленный процесс, вы можете отправить ответ "Accepted" (HTTP 202) и отправить работу с файлом в фон.
+
+## Использование класса `BackgroundTasks`
+
+Сначала импортируйте `BackgroundTasks`, потом добавьте в функцию параметр с типом `BackgroundTasks`:
+
+```Python hl_lines="1 13"
+{!../../../docs_src/background_tasks/tutorial001.py!}
+```
+
+**FastAPI** создаст объект класса `BackgroundTasks` для вас и запишет его в параметр.
+
+## Создание функции для фоновой задачи
+
+Создайте функцию, которую хотите запустить в фоне.
+
+Это совершенно обычная функция, которая может принимать параметры.
+
+Она может быть как асинхронной `async def`, так и обычной `def` функцией, **FastAPI** знает, как правильно ее выполнить.
+
+В нашем примере фоновая задача будет вести запись в файл (симулируя отправку письма).
+
+Так как операция записи не использует `async` и `await`, мы определим ее как обычную `def`:
+
+```Python hl_lines="6-9"
+{!../../../docs_src/background_tasks/tutorial001.py!}
+```
+
+## Добавление фоновой задачи
+
+Внутри функции вызовите метод `.add_task()` у объекта *background tasks* и передайте ему функцию, которую хотите выполнить в фоне:
+
+```Python hl_lines="14"
+{!../../../docs_src/background_tasks/tutorial001.py!}
+```
+
+`.add_task()` принимает следующие аргументы:
+
+* Функцию, которая будет выполнена в фоне (`write_notification`). Обратите внимание, что передается объект функции, без скобок.
+* Любое упорядоченное количество аргументов, которые принимает функция (`email`).
+* Любое количество именованных аргументов, которые принимает функция (`message="some notification"`).
+
+## Встраивание зависимостей
+
+Класс `BackgroundTasks` также работает с системой встраивания зависимостей, вы можете определить `BackgroundTasks` на разных уровнях: как параметр функции, как завимость, как подзависимость и так далее.
+
+**FastAPI** знает, что нужно сделать в каждом случае и как переиспользовать тот же объект `BackgroundTasks`, так чтобы все фоновые задачи собрались и запустились вместе в фоне:
+
+=== "Python 3.6 и выше"
+
+ ```Python hl_lines="13 15 22 25"
+ {!> ../../../docs_src/background_tasks/tutorial002.py!}
+ ```
+
+=== "Python 3.10 и выше"
+
+ ```Python hl_lines="11 13 20 23"
+ {!> ../../../docs_src/background_tasks/tutorial002_py310.py!}
+ ```
+
+В этом примере сообщения будут записаны в `log.txt` *после* того, как ответ сервера был отправлен.
+
+Если бы в запросе была очередь `q`, она бы первой записалась в `log.txt` фоновой задачей (потому что вызывается в зависимости `get_query`).
+
+После другая фоновая задача, которая была сгенерирована в функции, запишет сообщение из параметра `email`.
+
+## Технические детали
+
+Класс `BackgroundTasks` основан на `starlette.background`.
+
+Он интегрирован в FastAPI, так что вы можете импортировать его прямо из `fastapi` и избежать случайного импорта `BackgroundTask` (без `s` на конце) из `starlette.background`.
+
+При использовании `BackgroundTasks` (а не `BackgroundTask`), вам достаточно только определить параметр функции с типом `BackgroundTasks` и **FastAPI** сделает все за вас, также как при использовании объекта `Request`.
+
+Вы все равно можете использовать `BackgroundTask` из `starlette` в FastAPI, но вам придется самостоятельно создавать объект фоновой задачи и вручную обработать `Response` внутри него.
+
+Вы можете подробнее изучить его в Официальной документации Starlette для BackgroundTasks.
+
+## Предостережение
+
+Если вам нужно выполнить тяжелые вычисления в фоне, которым необязательно быть запущенными в одном процессе с приложением **FastAPI** (к примеру, вам не нужны обрабатываемые переменные или вы не хотите делиться памятью процесса и т.д.), вы можете использовать более серьезные инструменты, такие как Celery.
+
+Их тяжелее настраивать, также им нужен брокер сообщений наподобие RabbitMQ или Redis, но зато они позволяют вам запускать фоновые задачи в нескольких процессах и даже на нескольких серверах.
+
+Для примера, посмотрите [Project Generators](../project-generation.md){.internal-link target=_blank}, там есть проект с уже настроенным Celery.
+
+Но если вам нужен доступ к общим переменным и объектам вашего **FastAPI** приложения или вам нужно выполнять простые фоновые задачи (наподобие отправки письма из примера) вы можете просто использовать `BackgroundTasks`.
+
+## Резюме
+
+Для создания фоновых задач вам необходимо импортировать `BackgroundTasks` и добавить его в функцию, как параметр с типом `BackgroundTasks`.
diff --git a/docs/ru/mkdocs.yml b/docs/ru/mkdocs.yml
index 2150d5c19f80c..381775ac6d849 100644
--- a/docs/ru/mkdocs.yml
+++ b/docs/ru/mkdocs.yml
@@ -58,7 +58,14 @@ nav:
- tr: /tr/
- uk: /uk/
- zh: /zh/
+- features.md
+- python-types.md
+- Учебник - руководство пользователя:
+ - tutorial/background-tasks.md
+- external-links.md
- async.md
+- Развёртывание:
+ - deployment/versions.md
markdown_extensions:
- toc:
permalink: true
diff --git a/docs/sq/docs/index.md b/docs/sq/docs/index.md
index db4120d5e9766..e799ff8d580e0 100644
--- a/docs/sq/docs/index.md
+++ b/docs/sq/docs/index.md
@@ -135,7 +135,7 @@ You will also need an ASGI server, for production such as
```console
-$ pip install uvicorn[standard]
+$ pip install "uvicorn[standard]"
---> 100%
```
diff --git a/docs/tr/docs/index.md b/docs/tr/docs/index.md
index b1c54c63febaa..73caa6d61072c 100644
--- a/docs/tr/docs/index.md
+++ b/docs/tr/docs/index.md
@@ -143,7 +143,7 @@ Uygulamanı kullanılabilir hale getirmek için
```console
-$ pip install uvicorn[standard]
+$ pip install "uvicorn[standard]"
---> 100%
```
diff --git a/docs/uk/docs/index.md b/docs/uk/docs/index.md
index db4120d5e9766..e799ff8d580e0 100644
--- a/docs/uk/docs/index.md
+++ b/docs/uk/docs/index.md
@@ -135,7 +135,7 @@ You will also need an ASGI server, for production such as
```console
-$ pip install uvicorn[standard]
+$ pip install "uvicorn[standard]"
---> 100%
```
diff --git a/docs/zh/docs/advanced/response-cookies.md b/docs/zh/docs/advanced/response-cookies.md
new file mode 100644
index 0000000000000..3e53c53191a4c
--- /dev/null
+++ b/docs/zh/docs/advanced/response-cookies.md
@@ -0,0 +1,47 @@
+# 响应Cookies
+
+## 使用 `Response` 参数
+
+你可以在 *路径函数* 中定义一个类型为 `Response`的参数,这样你就可以在这个临时响应对象中设置cookie了。
+
+```Python hl_lines="1 8-9"
+{!../../../docs_src/response_cookies/tutorial002.py!}
+```
+
+而且你还可以根据你的需要响应不同的对象,比如常用的 `dict`,数据库model等。
+
+如果你定义了 `response_model`,程序会自动根据`response_model`来过滤和转换你响应的对象。
+
+**FastAPI** 会使用这个 *临时* 响应对象去装在这些cookies信息 (同样还有headers和状态码等信息), 最终会将这些信息和通过`response_model`转化过的数据合并到最终的响应里。
+
+你也可以在depend中定义`Response`参数,并设置cookie和header。
+
+## 直接响应 `Response`
+
+你还可以在直接响应`Response`时直接创建cookies。
+
+你可以参考[Return a Response Directly](response-directly.md){.internal-link target=_blank}来创建response
+
+然后设置Cookies,并返回:
+
+```Python hl_lines="10-12"
+{!../../../docs_src/response_cookies/tutorial001.py!}
+```
+
+!!! tip
+ 需要注意,如果你直接反馈一个response对象,而不是使用`Response`入参,FastAPI则会直接反馈你封装的response对象。
+
+ 所以你需要确保你响应数据类型的正确性,如:你可以使用`JSONResponse`来兼容JSON的场景。
+
+ 同时,你也应当仅反馈通过`response_model`过滤过的数据。
+
+### 更多信息
+
+!!! note "技术细节"
+ 你也可以使用`from starlette.responses import Response` 或者 `from starlette.responses import JSONResponse`。
+
+ 为了方便开发者,**FastAPI** 封装了相同数据类型,如`starlette.responses` 和 `fastapi.responses`。不过大部分response对象都是直接引用自Starlette。
+
+ 因为`Response`对象可以非常便捷的设置headers和cookies,所以 **FastAPI** 同时也封装了`fastapi.Response`。
+
+如果你想查看所有可用的参数和选项,可以参考 Starlette帮助文档
diff --git a/docs/zh/docs/index.md b/docs/zh/docs/index.md
index 797032c865f22..3898beaee0677 100644
--- a/docs/zh/docs/index.md
+++ b/docs/zh/docs/index.md
@@ -131,7 +131,7 @@ $ pip install fastapi