diff --git a/docs/ja/docs/deployment/manually.md b/docs/ja/docs/deployment/manually.md
index 67010a66f..449aea31e 100644
--- a/docs/ja/docs/deployment/manually.md
+++ b/docs/ja/docs/deployment/manually.md
@@ -25,7 +25,7 @@
=== "Hypercorn"
- *
-Na serwerze produkcyjnym będziesz także potrzebował serwera ASGI, np.
.
+Na serwerze produkcyjnym będziesz także potrzebował serwera ASGI, np.
@@ -330,7 +328,7 @@ Robisz to tak samo jak ze standardowymi typami w Pythonie.
Nie musisz sie uczyć żadnej nowej składni, metod lub klas ze specyficznych bibliotek itp.
-Po prostu standardowy **Python 3.8+**.
+Po prostu standardowy **Python**.
Na przykład, dla danych typu `int`:
diff --git a/docs/pt/docs/advanced/additional-responses.md b/docs/pt/docs/advanced/additional-responses.md
new file mode 100644
index 000000000..7c7d22611
--- /dev/null
+++ b/docs/pt/docs/advanced/additional-responses.md
@@ -0,0 +1,240 @@
+# Retornos Adicionais no OpenAPI
+
+!!! warning "Aviso"
+ Este é um tema bem avançado.
+
+ Se você está começando com o **FastAPI**, provavelmente você não precisa disso.
+
+Você pode declarar retornos adicionais, com códigos de status adicionais, media types, descrições, etc.
+
+Essas respostas adicionais serão incluídas no esquema do OpenAPI, e também aparecerão na documentação da API.
+
+Porém para as respostas adicionais, você deve garantir que está retornando um `Response` como por exemplo o `JSONResponse` diretamente, junto com o código de status e o conteúdo.
+
+## Retorno Adicional com `model`
+
+Você pode fornecer o parâmetro `responses` aos seus *decoradores de caminho*.
+
+Este parâmetro recebe um `dict`, as chaves são os códigos de status para cada retorno, como por exemplo `200`, e os valores são um outro `dict` com a informação de cada um deles.
+
+Cada um desses `dict` de retorno pode ter uma chave `model`, contendo um modelo do Pydantic, assim como o `response_model`.
+
+O **FastAPI** pegará este modelo, gerará o esquema JSON dele e incluirá no local correto do OpenAPI.
+
+Por exemplo, para declarar um outro retorno com o status code `404` e um modelo do Pydantic chamado `Message`, você pode escrever:
+
+```Python hl_lines="18 22"
+{!../../../docs_src/additional_responses/tutorial001.py!}
+```
+
+!!! note "Nota"
+ Lembre-se que você deve retornar o `JSONResponse` diretamente.
+
+!!! info "Informação"
+ A chave `model` não é parte do OpenAPI.
+
+ O **FastAPI** pegará o modelo do Pydantic, gerará o `JSON Schema`, e adicionará no local correto.
+
+ O local correto é:
+
+ * Na chave `content`, que tem como valor um outro objeto JSON (`dict`) que contém:
+ * Uma chave com o media type, como por exemplo `application/json`, que contém como valor um outro objeto JSON, contendo::
+ * Uma chave `schema`, que contém como valor o JSON Schema do modelo, sendo este o local correto.
+ * O **FastAPI** adiciona aqui a referência dos esquemas JSON globais que estão localizados em outro lugar, ao invés de incluí-lo diretamente. Deste modo, outras aplicações e clientes podem utilizar estes esquemas JSON diretamente, fornecer melhores ferramentas de geração de código, etc.
+
+O retorno gerado no OpenAI para esta *operação de caminho* será:
+
+```JSON hl_lines="3-12"
+{
+ "responses": {
+ "404": {
+ "description": "Additional Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Message"
+ }
+ }
+ }
+ },
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/Item"
+ }
+ }
+ }
+ },
+ "422": {
+ "description": "Validation Error",
+ "content": {
+ "application/json": {
+ "schema": {
+ "$ref": "#/components/schemas/HTTPValidationError"
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+Os esquemas são referenciados em outro local dentro do esquema OpenAPI:
+
+```JSON hl_lines="4-16"
+{
+ "components": {
+ "schemas": {
+ "Message": {
+ "title": "Message",
+ "required": [
+ "message"
+ ],
+ "type": "object",
+ "properties": {
+ "message": {
+ "title": "Message",
+ "type": "string"
+ }
+ }
+ },
+ "Item": {
+ "title": "Item",
+ "required": [
+ "id",
+ "value"
+ ],
+ "type": "object",
+ "properties": {
+ "id": {
+ "title": "Id",
+ "type": "string"
+ },
+ "value": {
+ "title": "Value",
+ "type": "string"
+ }
+ }
+ },
+ "ValidationError": {
+ "title": "ValidationError",
+ "required": [
+ "loc",
+ "msg",
+ "type"
+ ],
+ "type": "object",
+ "properties": {
+ "loc": {
+ "title": "Location",
+ "type": "array",
+ "items": {
+ "type": "string"
+ }
+ },
+ "msg": {
+ "title": "Message",
+ "type": "string"
+ },
+ "type": {
+ "title": "Error Type",
+ "type": "string"
+ }
+ }
+ },
+ "HTTPValidationError": {
+ "title": "HTTPValidationError",
+ "type": "object",
+ "properties": {
+ "detail": {
+ "title": "Detail",
+ "type": "array",
+ "items": {
+ "$ref": "#/components/schemas/ValidationError"
+ }
+ }
+ }
+ }
+ }
+ }
+}
+```
+
+## Media types adicionais para o retorno principal
+
+Você pode utilizar o mesmo parâmetro `responses` para adicionar diferentes media types para o mesmo retorno principal.
+
+Por exemplo, você pode adicionar um media type adicional de `image/png`, declarando que a sua *operação de caminho* pode retornar um objeto JSON (com o media type `application/json`) ou uma imagem PNG:
+
+```Python hl_lines="19-24 28"
+{!../../../docs_src/additional_responses/tutorial002.py!}
+```
+
+!!! note "Nota"
+ Note que você deve retornar a imagem utilizando um `FileResponse` diretamente.
+
+!!! info "Informação"
+ A menos que você especifique um media type diferente explicitamente em seu parâmetro `responses`, o FastAPI assumirá que o retorno possui o mesmo media type contido na classe principal de retorno (padrão `application/json`).
+
+ Porém se você especificou uma classe de retorno com o valor `None` como media type, o FastAPI utilizará `application/json` para qualquer retorno adicional que possui um modelo associado.
+
+## Combinando informações
+
+Você também pode combinar informações de diferentes lugares, incluindo os parâmetros `response_model`, `status_code`, e `responses`.
+
+Você pode declarar um `response_model`, utilizando o código de status padrão `200` (ou um customizado caso você precise), e depois adicionar informações adicionais para esse mesmo retorno em `responses`, diretamente no esquema OpenAPI.
+
+O **FastAPI** manterá as informações adicionais do `responses`, e combinará com o esquema JSON do seu modelo.
+
+Por exemplo, você pode declarar um retorno com o código de status `404` que utiliza um modelo do Pydantic que possui um `description` customizado.
+
+E um retorno com o código de status `200` que utiliza o seu `response_model`, porém inclui um `example` customizado:
+
+```Python hl_lines="20-31"
+{!../../../docs_src/additional_responses/tutorial003.py!}
+```
+
+Isso será combinado e incluído em seu OpenAPI, e disponibilizado na documentação da sua API:
+
+
+
+## Combinar retornos predefinidos e personalizados
+
+Você pode querer possuir alguns retornos predefinidos que são aplicados para diversas *operações de caminho*, porém você deseja combinar com retornos personalizados que são necessários para cada *operação de caminho*.
+
+Para estes casos, você pode utilizar a técnica do Python de "desempacotamento" de um `dict` utilizando `**dict_to_unpack`:
+
+```Python
+old_dict = {
+ "old key": "old value",
+ "second old key": "second old value",
+}
+new_dict = {**old_dict, "new key": "new value"}
+```
+
+Aqui, o `new_dict` terá todos os pares de chave-valor do `old_dict` mais o novo par de chave-valor:
+
+```Python
+{
+ "old key": "old value",
+ "second old key": "second old value",
+ "new key": "new value",
+}
+```
+
+Você pode utilizar essa técnica para reutilizar alguns retornos predefinidos nas suas *operações de caminho* e combiná-las com personalizações adicionais.
+
+Por exemplo:
+
+```Python hl_lines="13-17 26"
+{!../../../docs_src/additional_responses/tutorial004.py!}
+```
+
+## Mais informações sobre retornos OpenAPI
+
+Para verificar exatamente o que você pode incluir nos retornos, você pode conferir estas seções na especificação do OpenAPI:
+
+*
Objeto de Retorno OpenAPI, inclui o `Response Object`.
+*
Objeto de Retorno OpenAPI, você pode incluir qualquer coisa dele diretamente em cada retorno dentro do seu parâmetro `responses`. Incluindo `description`, `headers`, `content` (dentro dele que você declara diferentes media types e esquemas JSON), e `links`.
diff --git a/docs/pt/docs/advanced/additional-status-codes.md b/docs/pt/docs/advanced/additional-status-codes.md
new file mode 100644
index 000000000..a7699b324
--- /dev/null
+++ b/docs/pt/docs/advanced/additional-status-codes.md
@@ -0,0 +1,69 @@
+# Códigos de status adicionais
+
+Por padrão, o **FastAPI** retornará as respostas utilizando o `JSONResponse`, adicionando o conteúdo do retorno da sua *operação de caminho* dentro do `JSONResponse`.
+
+Ele usará o código de status padrão ou o que você definir na sua *operação de caminho*.
+
+## Códigos de status adicionais
+
+Caso você queira retornar códigos de status adicionais além do código principal, você pode fazer isso retornando um `Response` diretamente, como por exemplo um `JSONResponse`, e definir os códigos de status adicionais diretamente.
+
+Por exemplo, vamos dizer que você deseja ter uma *operação de caminho* que permita atualizar itens, e retornar um código de status HTTP 200 "OK" quando for bem sucedido.
+
+Mas você também deseja aceitar novos itens. E quando os itens não existiam, ele os cria, e retorna o código de status HTTP 201 "Created.
+
+Para conseguir isso, importe `JSONResponse` e retorne o seu conteúdo diretamente, definindo o `status_code` que você deseja:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="4 25"
+ {!> ../../../docs_src/additional_status_codes/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="4 25"
+ {!> ../../../docs_src/additional_status_codes/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="4 26"
+ {!> ../../../docs_src/additional_status_codes/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Faça uso da versão `Annotated` quando possível.
+
+ ```Python hl_lines="2 23"
+ {!> ../../../docs_src/additional_status_codes/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Faça uso da versão `Annotated` quando possível.
+
+ ```Python hl_lines="4 25"
+ {!> ../../../docs_src/additional_status_codes/tutorial001.py!}
+ ```
+
+!!! warning "Aviso"
+ Quando você retorna um `Response` diretamente, como no exemplo acima, ele será retornado diretamente.
+
+ Ele não será serializado com um modelo, etc.
+
+ Garanta que ele tenha toda informação que você deseja, e que os valores sejam um JSON válido (caso você esteja usando `JSONResponse`).
+
+!!! note "Detalhes técnicos"
+ Você também pode utilizar `from starlette.responses import JSONResponse`.
+
+ O **FastAPI** disponibiliza o `starlette.responses` como `fastapi.responses` apenas por conveniência para você, o programador. Porém a maioria dos retornos disponíveis vem diretamente do Starlette. O mesmo com `status`.
+
+## OpenAPI e documentação da API
+
+Se você retorna códigos de status adicionais e retornos diretamente, eles não serão incluídos no esquema do OpenAPI (a documentação da API), porque o FastAPI não tem como saber de antemão o que será retornado.
+
+Mas você pode documentar isso no seu código, utilizando: [Retornos Adicionais](additional-responses.md){.internal-link target=_blank}.
diff --git a/docs/pt/docs/advanced/advanced-dependencies.md b/docs/pt/docs/advanced/advanced-dependencies.md
new file mode 100644
index 000000000..58887f9c8
--- /dev/null
+++ b/docs/pt/docs/advanced/advanced-dependencies.md
@@ -0,0 +1,138 @@
+# Dependências avançadas
+
+## Dependências parametrizadas
+
+Todas as dependências que vimos até agora são funções ou classes fixas.
+
+Mas podem ocorrer casos onde você deseja ser capaz de definir parâmetros na dependência, sem ter a necessidade de declarar diversas funções ou classes.
+
+Vamos imaginar que queremos ter uma dependência que verifica se o parâmetro de consulta `q` possui um valor fixo.
+
+Porém nós queremos poder parametrizar o conteúdo fixo.
+
+## Uma instância "chamável"
+
+Em Python existe uma maneira de fazer com que uma instância de uma classe seja um "chamável".
+
+Não propriamente a classe (que já é um chamável), mas a instância desta classe.
+
+Para fazer isso, nós declaramos o método `__call__`:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="12"
+ {!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="11"
+ {!> ../../../docs_src/dependencies/tutorial011_an.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Prefira utilizar a versão `Annotated` se possível.
+
+ ```Python hl_lines="10"
+ {!> ../../../docs_src/dependencies/tutorial011.py!}
+ ```
+
+Neste caso, o `__call__` é o que o **FastAPI** utilizará para verificar parâmetros adicionais e sub dependências, e isso é o que será chamado para passar o valor ao parâmetro na sua *função de operação de rota* posteriormente.
+
+## Parametrizar a instância
+
+E agora, nós podemos utilizar o `__init__` para declarar os parâmetros da instância que podemos utilizar para "parametrizar" a dependência:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="8"
+ {!> ../../../docs_src/dependencies/tutorial011_an.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Prefira utilizar a versão `Annotated` se possível.
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/dependencies/tutorial011.py!}
+ ```
+
+Neste caso, o **FastAPI** nunca tocará ou se importará com o `__init__`, nós vamos utilizar diretamente em nosso código.
+
+## Crie uma instância
+
+Nós poderíamos criar uma instância desta classe com:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="18"
+ {!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="17"
+ {!> ../../../docs_src/dependencies/tutorial011_an.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Prefira utilizar a versão `Annotated` se possível.
+
+ ```Python hl_lines="16"
+ {!> ../../../docs_src/dependencies/tutorial011.py!}
+ ```
+
+E deste modo nós podemos "parametrizar" a nossa dependência, que agora possui `"bar"` dentro dele, como o atributo `checker.fixed_content`.
+
+## Utilize a instância como dependência
+
+Então, nós podemos utilizar este `checker` em um `Depends(checker)`, no lugar de `Depends(FixedContentQueryChecker)`, porque a dependência é a instância, `checker`, e não a própria classe.
+
+E quando a dependência for resolvida, o **FastAPI** chamará este `checker` como:
+
+```Python
+checker(q="somequery")
+```
+
+...e passar o que quer que isso retorne como valor da dependência em nossa *função de operação de rota* como o parâmetro `fixed_content_included`:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="22"
+ {!> ../../../docs_src/dependencies/tutorial011_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="21"
+ {!> ../../../docs_src/dependencies/tutorial011_an.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Prefira utilizar a versão `Annotated` se possível.
+
+ ```Python hl_lines="20"
+ {!> ../../../docs_src/dependencies/tutorial011.py!}
+ ```
+
+!!! tip "Dica"
+ Tudo isso parece não ser natural. E pode não estar muito claro ou aparentar ser útil ainda.
+
+ Estes exemplos são intencionalmente simples, porém mostram como tudo funciona.
+
+ Nos capítulos sobre segurança, existem funções utilitárias que são implementadas desta maneira.
+
+ Se você entendeu tudo isso, você já sabe como essas funções utilitárias para segurança funcionam por debaixo dos panos.
diff --git a/docs/pt/docs/advanced/async-tests.md b/docs/pt/docs/advanced/async-tests.md
new file mode 100644
index 000000000..4ccc0c452
--- /dev/null
+++ b/docs/pt/docs/advanced/async-tests.md
@@ -0,0 +1,95 @@
+# Testes Assíncronos
+
+Você já viu como testar as suas aplicações **FastAPI** utilizando o `TestClient` que é fornecido. Até agora, você viu apenas como escrever testes síncronos, sem utilizar funções `async`.
+
+Ser capaz de utilizar funções assíncronas em seus testes pode ser útil, por exemplo, quando você está realizando uma consulta em seu banco de dados de maneira assíncrona. Imagine que você deseja testar realizando requisições para a sua aplicação FastAPI e depois verificar que a sua aplicação inseriu corretamente as informações no banco de dados, ao utilizar uma biblioteca assíncrona para banco de dados.
+
+Vamos ver como nós podemos fazer isso funcionar.
+
+## pytest.mark.anyio
+
+Se quisermos chamar funções assíncronas em nossos testes, as nossas funções de teste precisam ser assíncronas. O AnyIO oferece um plugin bem legal para isso, que nos permite especificar que algumas das nossas funções de teste precisam ser chamadas de forma assíncrona.
+
+## HTTPX
+
+Mesmo que a sua aplicação **FastAPI** utilize funções normais com `def` no lugar de `async def`, ela ainda é uma aplicação `async` por baixo dos panos.
+
+O `TestClient` faz algumas mágicas para invocar a aplicação FastAPI assíncrona em suas funções `def` normais, utilizando o pytest padrão. Porém a mágica não acontece mais quando nós estamos utilizando dentro de funções assíncronas. Ao executar os nossos testes de forma assíncrona, nós não podemos mais utilizar o `TestClient` dentro das nossas funções de teste.
+
+O `TestClient` é baseado no
HTTPX, e felizmente nós podemos utilizá-lo diretamente para testar a API.
+
+## Exemplo
+
+Para um exemplos simples, vamos considerar uma estrutura de arquivos semelhante ao descrito em [Bigger Applications](../tutorial/bigger-applications.md){.internal-link target=_blank} e [Testing](../tutorial/testing.md){.internal-link target=_blank}:
+
+```
+.
+├── app
+│ ├── __init__.py
+│ ├── main.py
+│ └── test_main.py
+```
+
+O arquivo `main.py` teria:
+
+```Python
+{!../../../docs_src/async_tests/main.py!}
+```
+
+O arquivo `test_main.py` teria os testes para para o arquivo `main.py`, ele poderia ficar assim:
+
+```Python
+{!../../../docs_src/async_tests/test_main.py!}
+```
+
+## Executá-lo
+
+Você pode executar os seus testes normalmente via:
+
+
+
+```console
+$ pytest
+
+---> 100%
+```
+
+
+
+## Em Detalhes
+
+O marcador `@pytest.mark.anyio` informa ao pytest que esta função de teste deve ser invocada de maneira assíncrona:
+
+```Python hl_lines="7"
+{!../../../docs_src/async_tests/test_main.py!}
+```
+
+!!! tip "Dica"
+ Note que a função de teste é `async def` agora, no lugar de apenas `def` como quando estávamos utilizando o `TestClient` anteriormente.
+
+Então podemos criar um `AsyncClient` com a aplicação, e enviar requisições assíncronas para ela utilizando `await`.
+
+```Python hl_lines="9-10"
+{!../../../docs_src/async_tests/test_main.py!}
+```
+
+Isso é equivalente a:
+
+```Python
+response = client.get('/')
+```
+
+...que nós utilizamos para fazer as nossas requisições utilizando o `TestClient`.
+
+!!! tip "Dica"
+ Note que nós estamos utilizando async/await com o novo `AsyncClient` - a requisição é assíncrona.
+
+!!! warning "Aviso"
+ Se a sua aplicação depende dos eventos de vida útil (*lifespan*), o `AsyncClient` não acionará estes eventos. Para garantir que eles são acionados, utilize o `LifespanManager` do
florimondmanca/asgi-lifespan.
+
+## Outras Chamadas de Funções Assíncronas
+
+Como a função de teste agora é assíncrona, você pode chamar (e `esperar`) outras funções `async` além de enviar requisições para a sua aplicação FastAPI em seus testes, exatamente como você as chamaria em qualquer outro lugar do seu código.
+
+!!! tip "Dica"
+ Se você se deparar com um `RuntimeError: Task attached to a different loop` ao integrar funções assíncronas em seus testes (e.g. ao utilizar o
MotorClient do MongoDB) Lembre-se de instanciar objetos que precisam de um loop de eventos (*event loop*) apenas em funções assíncronas, e.g. um *"callback"* `'@app.on_event("startup")`.
diff --git a/docs/pt/docs/advanced/benchmarks.md b/docs/pt/docs/advanced/benchmarks.md
new file mode 100644
index 000000000..72ef1e444
--- /dev/null
+++ b/docs/pt/docs/advanced/benchmarks.md
@@ -0,0 +1,34 @@
+# Benchmarks
+
+Benchmarks independentes da TechEmpower mostram que aplicações **FastAPI** rodando com o Uvicorn como
um dos frameworks Python mais rápidos disponíveis, ficando atrás apenas do Starlette e Uvicorn (utilizado internamente pelo FastAPI).
+
+Porém, ao verificar benchmarks e comparações você deve prestar atenção ao seguinte:
+
+## Benchmarks e velocidade
+
+Quando você verifica os benchmarks, é comum ver diversas ferramentas de diferentes tipos comparados como se fossem equivalentes.
+
+Especificamente, para ver o Uvicorn, Starlette e FastAPI comparados entre si (entre diversas outras ferramentas).
+
+Quanto mais simples o problema resolvido pela ferramenta, melhor será a performance. E a maioria das análises não testa funcionalidades adicionais que são oferecidas pela ferramenta.
+
+A hierarquia é:
+
+* **Uvicorn**: um servidor ASGI
+ * **Starlette**: (utiliza Uvicorn) um microframework web
+ * **FastAPI**: (utiliza Starlette) um microframework para APIs com diversas funcionalidades adicionais para a construção de APIs, com validação de dados, etc.
+
+* **Uvicorn**:
+ * Terá a melhor performance, pois não possui muito código além do próprio servidor.
+ * Você não escreveria uma aplicação utilizando o Uvicorn diretamente. Isso significaria que o seu código teria que incluir pelo menos todo o código fornecido pelo Starlette (ou o **FastAPI**). E caso você fizesse isso, a sua aplicação final teria a mesma sobrecarga que teria se utilizasse um framework, minimizando o código e os bugs.
+ * Se você está comparando o Uvicorn, compare com os servidores de aplicação Daphne, Hypercorn, uWSGI, etc.
+* **Starlette**:
+ * Terá o melhor desempenho, depois do Uvicorn. Na verdade, o Starlette utiliza o Uvicorn para rodar. Portanto, ele pode ficar mais "devagar" que o Uvicorn apenas por ter que executar mais código.
+ * Mas ele fornece as ferramentas para construir aplicações web simples, com roteamento baseado em caminhos, etc.
+ * Se você está comparando o Starlette, compare-o com o Sanic, Flask, Django, etc. Frameworks web (ou microframeworks).
+* **FastAPI**:
+ * Da mesma forma que o Starlette utiliza o Uvicorn e não consegue ser mais rápido que ele, o **FastAPI** utiliza o Starlette, portanto, ele não consegue ser mais rápido que ele.
+ * O FastAPI provê mais funcionalidades em cima do Starlette. Funcionalidades que você quase sempre precisará quando estiver construindo APIs, como validação de dados e serialização. E ao utilizá-lo, você obtém documentação automática sem custo nenhum (a documentação automática sequer adiciona sobrecarga nas aplicações rodando, pois ela é gerada na inicialização).
+ * Caso você não utilize o FastAPI e faz uso do Starlette diretamente (ou outra ferramenta, como o Sanic, Flask, Responder, etc) você mesmo teria que implementar toda a validação de dados e serialização. Então, a sua aplicação final ainda teria a mesma sobrecarga caso estivesse usando o FastAPI. E em muitos casos, validação de dados e serialização é a maior parte do código escrito em aplicações.
+ * Então, ao utilizar o FastAPI, você está economizando tempo de programação, evitando bugs, linhas de código, e provavelmente terá a mesma performance (ou até melhor) do que teria caso você não o utilizasse (já que você teria que implementar tudo no seu código).
+ * Se você está comparando o FastAPI, compare-o com frameworks de aplicações web (ou conjunto de ferramentas) que oferecem validação de dados, serialização e documentação, como por exemplo o Flask-apispec, NestJS, Molten, etc. Frameworks que possuem validação integrada de dados, serialização e documentação.
diff --git a/docs/pt/docs/advanced/openapi-webhooks.md b/docs/pt/docs/advanced/openapi-webhooks.md
new file mode 100644
index 000000000..932fe0d9a
--- /dev/null
+++ b/docs/pt/docs/advanced/openapi-webhooks.md
@@ -0,0 +1,51 @@
+# Webhooks OpenAPI
+
+Existem situações onde você deseja informar os **usuários** da sua API que a sua aplicação pode chamar a aplicação *deles* (enviando uma requisição) com alguns dados, normalmente para **notificar** algum tipo de **evento**.
+
+Isso significa que no lugar do processo normal de seus usuários enviarem requisições para a sua API, é a **sua API** (ou sua aplicação) que poderia **enviar requisições para o sistema deles** (para a API deles, a aplicação deles).
+
+Isso normalmente é chamado de **webhook**.
+
+## Etapas dos Webhooks
+
+Normalmente, o processo é que **você define** em seu código qual é a mensagem que você irá mandar, o **corpo da sua requisição**.
+
+Você também define de alguma maneira em quais **momentos** a sua aplicação mandará essas requisições ou eventos.
+
+E os **seus usuários** definem de alguma forma (em algum painel por exemplo) a **URL** que a sua aplicação deve enviar essas requisições.
+
+Toda a **lógica** sobre como cadastrar as URLs para os webhooks e o código para enviar de fato as requisições cabe a você definir. Você escreve da maneira que você desejar no **seu próprio código**.
+
+## Documentando webhooks com o FastAPI e OpenAPI
+
+Com o **FastAPI**, utilizando o OpenAPI, você pode definir os nomes destes webhooks, os tipos das operações HTTP que a sua aplicação pode enviar (e.g. `POST`, `PUT`, etc.) e os **corpos** da requisição que a sua aplicação enviaria.
+
+Isto pode facilitar bastante para os seus usuários **implementarem as APIs deles** para receber as requisições dos seus **webhooks**, eles podem inclusive ser capazes de gerar parte do código da API deles.
+
+!!! info "Informação"
+ Webhooks estão disponíveis a partir do OpenAPI 3.1.0, e possui suporte do FastAPI a partir da versão `0.99.0`.
+
+## Uma aplicação com webhooks
+
+Quando você cria uma aplicação com o **FastAPI**, existe um atributo chamado `webhooks`, que você utilizar para defini-los da mesma maneira que você definiria as suas **operações de rotas**, utilizando por exemplo `@app.webhooks.post()`.
+
+```Python hl_lines="9-13 36-53"
+{!../../../docs_src/openapi_webhooks/tutorial001.py!}
+```
+
+Os webhooks que você define aparecerão no esquema do **OpenAPI** e na **página de documentação** gerada automaticamente.
+
+!!! info "Informação"
+ O objeto `app.webhooks` é na verdade apenas um `APIRouter`, o mesmo tipo que você utilizaria ao estruturar a sua aplicação com diversos arquivos.
+
+Note que utilizando webhooks você não está de fato declarando uma **rota** (como `/items/`), o texto que informa é apenas um **identificador** do webhook (o nome do evento), por exemplo em `@app.webhooks.post("new-subscription")`, o nome do webhook é `new-subscription`.
+
+Isto porque espera-se que os **seus usuários** definam o verdadeiro **caminho da URL** onde eles desejam receber a requisição do webhook de algum outra maneira. (e.g. um painel).
+
+### Confira a documentação
+
+Agora você pode iniciar a sua aplicação e ir até
http://127.0.0.1:8000/docs.
+
+Você verá que a sua documentação possui as *operações de rota* normais e agora também possui alguns **webhooks**:
+
+
diff --git a/docs/pt/docs/advanced/settings.md b/docs/pt/docs/advanced/settings.md
new file mode 100644
index 000000000..f6962831f
--- /dev/null
+++ b/docs/pt/docs/advanced/settings.md
@@ -0,0 +1,485 @@
+# Configurações e Variáveis de Ambiente
+
+Em muitos casos a sua aplicação pode precisar de configurações externas, como chaves secretas, credenciais de banco de dados, credenciais para serviços de email, etc.
+
+A maioria dessas configurações é variável (podem mudar), como URLs de bancos de dados. E muitas delas podem conter dados sensíveis, como tokens secretos.
+
+Por isso é comum prover essas configurações como variáveis de ambiente que são utilizidas pela aplicação.
+
+## Variáveis de Ambiente
+
+!!! dica
+ Se você já sabe o que são variáveis de ambiente e como utilizá-las, sinta-se livre para avançar para o próximo tópico.
+
+Uma
variável de ambiente (abreviada em inglês para "env var") é uma variável definida fora do código Python, no sistema operacional, e pode ser lida pelo seu código Python (ou por outros programas).
+
+Você pode criar e utilizar variáveis de ambiente no terminal, sem precisar utilizar Python:
+
+=== "Linux, macOS, Windows Bash"
+
+
+
+ ```console
+ // Você pode criar uma env var MY_NAME usando
+ $ export MY_NAME="Wade Wilson"
+
+ // E utilizá-la em outros programas, como
+ $ echo "Hello $MY_NAME"
+
+ Hello Wade Wilson
+ ```
+
+
+
+=== "Windows PowerShell"
+
+
+
+ ```console
+ // Criando env var MY_NAME
+ $ $Env:MY_NAME = "Wade Wilson"
+
+ // Usando em outros programas, como
+ $ echo "Hello $Env:MY_NAME"
+
+ Hello Wade Wilson
+ ```
+
+
+
+### Lendo variáveis de ambiente com Python
+
+Você também pode criar variáveis de ambiente fora do Python, no terminal (ou com qualquer outro método), e realizar a leitura delas no Python.
+
+Por exemplo, você pode definir um arquivo `main.py` com o seguinte código:
+
+```Python hl_lines="3"
+import os
+
+name = os.getenv("MY_NAME", "World")
+print(f"Hello {name} from Python")
+```
+
+!!! dica
+ O segundo parâmetro em
`os.getenv()` é o valor padrão para o retorno.
+
+ Se nenhum valor for informado, `None` é utilizado por padrão, aqui definimos `"World"` como o valor padrão a ser utilizado.
+
+E depois você pode executar esse arquivo:
+
+
+
+```console
+// Aqui ainda não definimos a env var
+$ python main.py
+
+// Por isso obtemos o valor padrão
+
+Hello World from Python
+
+// Mas se definirmos uma variável de ambiente primeiro
+$ export MY_NAME="Wade Wilson"
+
+// E executarmos o programa novamente
+$ python main.py
+
+// Agora ele pode ler a variável de ambiente
+
+Hello Wade Wilson from Python
+```
+
+
+
+Como variáveis de ambiente podem ser definidas fora do código da aplicação, mas acessadas pela aplicação, e não precisam ser armazenadas (versionadas com `git`) junto dos outros arquivos, é comum utilizá-las para guardar configurações.
+
+Você também pode criar uma variável de ambiente específica para uma invocação de um programa, que é acessível somente para esse programa, e somente enquanto ele estiver executando.
+
+Para fazer isso, crie a variável imediatamente antes de iniciar o programa, na mesma linha:
+
+
+
+```console
+// Criando uma env var MY_NAME na mesma linha da execução do programa
+$ MY_NAME="Wade Wilson" python main.py
+
+// Agora a aplicação consegue ler a variável de ambiente
+
+Hello Wade Wilson from Python
+
+// E a variável deixa de existir após isso
+$ python main.py
+
+Hello World from Python
+```
+
+
+
+!!! dica
+ Você pode ler mais sobre isso em:
The Twelve-Factor App: Configurações.
+
+### Tipagem e Validação
+
+Essas variáveis de ambiente suportam apenas strings, por serem externas ao Python e por que precisam ser compatíveis com outros programas e o resto do sistema (e até mesmo com outros sistemas operacionais, como Linux, Windows e macOS).
+
+Isso significa que qualquer valor obtido de uma variável de ambiente em Python terá o tipo `str`, e qualquer conversão para um tipo diferente ou validação deve ser realizada no código.
+
+## Pydantic `Settings`
+
+Por sorte, o Pydantic possui uma funcionalidade para lidar com essas configurações vindas de variáveis de ambiente utilizando
Pydantic: Settings management.
+
+### Instalando `pydantic-settings`
+
+Primeiro, instale o pacote `pydantic-settings`:
+
+
+
+```console
+$ pip install pydantic-settings
+---> 100%
+```
+
+
+
+Ele também está incluído no fastapi quando você instala com a opção `all`:
+
+
+
+```console
+$ pip install "fastapi[all]"
+---> 100%
+```
+
+
+
+!!! info
+ Na v1 do Pydantic ele estava incluído no pacote principal. Agora ele está distribuido como um pacote independente para que você possa optar por instalar ou não caso você não precise dessa funcionalidade.
+
+### Criando o objeto `Settings`
+
+Importe a classe `BaseSettings` do Pydantic e crie uma nova subclasse, de forma parecida com um modelo do Pydantic.
+
+Os atributos da classe são declarados com anotações de tipo, e possíveis valores padrão, da mesma maneira que os modelos do Pydantic.
+
+Você pode utilizar todas as ferramentas e funcionalidades de validação que são utilizadas nos modelos do Pydantic, como tipos de dados diferentes e validações adicionei com `Field()`.
+
+=== "Pydantic v2"
+
+ ```Python hl_lines="2 5-8 11"
+ {!> ../../../docs_src/settings/tutorial001.py!}
+ ```
+
+=== "Pydantic v1"
+
+ !!! Info
+ Na versão 1 do Pydantic você importaria `BaseSettings` diretamente do módulo `pydantic` em vez do módulo `pydantic_settings`.
+
+ ```Python hl_lines="2 5-8 11"
+ {!> ../../../docs_src/settings/tutorial001_pv1.py!}
+ ```
+
+!!! dica
+ Se você quiser algo pronto para copiar e colar na sua aplicação, não use esse exemplo, mas sim o exemplo abaixo.
+
+Portanto, quando você cria uma instância da classe `Settings` (nesse caso, o objeto `settings`), o Pydantic lê as variáveis de ambiente sem diferenciar maiúsculas e minúsculas, por isso, uma variável maiúscula `APP_NAME` será usada para o atributo `app_name`.
+
+Depois ele irá converter e validar os dados. Assim, quando você utilizar aquele objeto `settings`, os dados terão o tipo que você declarou (e.g. `items_per_user` será do tipo `int`).
+
+### Usando o objeto `settings`
+
+Depois, Você pode utilizar o novo objeto `settings` na sua aplicação:
+
+```Python hl_lines="18-20"
+{!../../../docs_src/settings/tutorial001.py!}
+```
+
+### Executando o servidor
+
+No próximo passo, você pode inicializar o servidor passando as configurações em forma de variáveis de ambiente, por exemplo, você poderia definir `ADMIN_EMAIL` e `APP_NAME` da seguinte forma:
+
+
+
+```console
+$ ADMIN_EMAIL="deadpool@example.com" APP_NAME="ChimichangApp" fastapi run main.py
+
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+
+
+!!! dica
+ Para definir múltiplas variáveis de ambiente para um único comando basta separá-las utilizando espaços, e incluir todas elas antes do comando.
+
+Assim, o atributo `admin_email` seria definido como `"deadpool@example.com"`.
+
+`app_name` seria `"ChimichangApp"`.
+
+E `items_per_user` manteria o valor padrão de `50`.
+
+## Configurações em um módulo separado
+
+Você também pode incluir essas configurações em um arquivo de um módulo separado como visto em [Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=\_blank}.
+
+Por exemplo, você pode adicionar um arquivo `config.py` com:
+
+```Python
+{!../../../docs_src/settings/app01/config.py!}
+```
+
+E utilizar essa configuração em `main.py`:
+
+```Python hl_lines="3 11-13"
+{!../../../docs_src/settings/app01/main.py!}
+```
+
+!!! dica
+ Você também precisa incluir um arquivo `__init__.py` como visto em [Bigger Applications - Multiple Files](../tutorial/bigger-applications.md){.internal-link target=\_blank}.
+
+## Configurações em uma dependência
+
+Em certas ocasiões, pode ser útil fornecer essas configurações a partir de uma dependência, em vez de definir um objeto global `settings` que é utilizado em toda a aplicação.
+
+Isso é especialmente útil durante os testes, já que é bastante simples sobrescrever uma dependência com suas configurações personalizadas.
+
+### O arquivo de configuração
+
+Baseando-se no exemplo anterior, seu arquivo `config.py` seria parecido com isso:
+
+```Python hl_lines="10"
+{!../../../docs_src/settings/app02/config.py!}
+```
+
+Perceba que dessa vez não criamos uma instância padrão `settings = Settings()`.
+
+### O arquivo principal da aplicação
+
+Agora criamos a dependência que retorna um novo objeto `config.Settings()`.
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="6 12-13"
+ {!> ../../../docs_src/settings/app02_an_py39/main.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="6 12-13"
+ {!> ../../../docs_src/settings/app02_an/main.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! dica
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="5 11-12"
+ {!> ../../../docs_src/settings/app02/main.py!}
+ ```
+
+!!! dica
+ Vamos discutir sobre `@lru_cache` logo mais.
+
+ Por enquanto, você pode considerar `get_settings()` como uma função normal.
+
+E então podemos declarar essas configurações como uma dependência na função de operação da rota e utilizar onde for necessário.
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="17 19-21"
+ {!> ../../../docs_src/settings/app02_an_py39/main.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="17 19-21"
+ {!> ../../../docs_src/settings/app02_an/main.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! dica
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="16 18-20"
+ {!> ../../../docs_src/settings/app02/main.py!}
+ ```
+
+### Configurações e testes
+
+Então seria muito fácil fornecer uma configuração diferente durante a execução dos testes sobrescrevendo a dependência de `get_settings`:
+
+```Python hl_lines="9-10 13 21"
+{!../../../docs_src/settings/app02/test_main.py!}
+```
+
+Na sobrescrita da dependência, definimos um novo valor para `admin_email` quando instanciamos um novo objeto `Settings`, e então retornamos esse novo objeto.
+
+Após isso, podemos testar se o valor está sendo utilizado.
+
+## Lendo um arquivo `.env`
+
+Se você tiver muitas configurações que variem bastante, talvez em ambientes distintos, pode ser útil colocá-las em um arquivo e depois lê-las como se fossem variáveis de ambiente.
+
+Essa prática é tão comum que possui um nome, essas variáveis de ambiente normalmente são colocadas em um arquivo `.env`, e esse arquivo é chamado de "dotenv".
+
+!!! dica
+ Um arquivo iniciando com um ponto final (`.`) é um arquivo oculto em sistemas baseados em Unix, como Linux e MacOS.
+
+ Mas um arquivo dotenv não precisa ter esse nome exato.
+
+Pydantic suporta a leitura desses tipos de arquivos utilizando uma biblioteca externa. Você pode ler mais em
Pydantic Settings: Dotenv (.env) support.
+
+!!! dica
+ Para que isso funcione você precisa executar `pip install python-dotenv`.
+
+### O arquivo `.env`
+
+Você pode definir um arquivo `.env` com o seguinte conteúdo:
+
+```bash
+ADMIN_EMAIL="deadpool@example.com"
+APP_NAME="ChimichangApp"
+```
+
+### Obtendo configurações do `.env`
+
+E então adicionar o seguinte código em `config.py`:
+
+=== "Pydantic v2"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/settings/app03_an/config.py!}
+ ```
+
+ !!! dica
+ O atributo `model_config` é usado apenas para configuração do Pydantic. Você pode ler mais em
Pydantic Model Config.
+
+=== "Pydantic v1"
+
+ ```Python hl_lines="9-10"
+ {!> ../../../docs_src/settings/app03_an/config_pv1.py!}
+ ```
+
+ !!! dica
+ A classe `Config` é usada apenas para configuração do Pydantic. Você pode ler mais em
Pydantic Model Config.
+
+!!! info
+ Na versão 1 do Pydantic a configuração é realizada por uma classe interna `Config`, na versão 2 do Pydantic isso é feito com o atributo `model_config`. Esse atributo recebe um `dict`, para utilizar o autocomplete e checagem de erros do seu editor de texto você pode importar e utilizar `SettingsConfigDict` para definir esse `dict`.
+
+Aqui definimos a configuração `env_file` dentro da classe `Settings` do Pydantic, e definimos o valor como o nome do arquivo dotenv que queremos utilizar.
+
+### Declarando `Settings` apenas uma vez com `lru_cache`
+
+Ler o conteúdo de um arquivo em disco normalmente é uma operação custosa (lenta), então você provavelmente quer fazer isso apenas um vez e reutilizar o mesmo objeto settings depois, em vez de ler os valores a cada requisição.
+
+Mas cada vez que fazemos:
+
+```Python
+Settings()
+```
+
+um novo objeto `Settings` é instanciado, e durante a instanciação, o arquivo `.env` é lido novamente.
+
+Se a função da dependência fosse apenas:
+
+```Python
+def get_settings():
+ return Settings()
+```
+
+Iriamos criar um novo objeto a cada requisição, e estaríamos lendo o arquivo `.env` a cada requisição. ⚠️
+
+Mas como estamos utilizando o decorador `@lru_cache` acima, o objeto `Settings` é criado apenas uma vez, na primeira vez que a função é chamada. ✔️
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="1 11"
+ {!> ../../../docs_src/settings/app03_an_py39/main.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="1 11"
+ {!> ../../../docs_src/settings/app03_an/main.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! dica
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="1 10"
+ {!> ../../../docs_src/settings/app03/main.py!}
+ ```
+
+Dessa forma, todas as chamadas da função `get_settings()` nas dependências das próximas requisições, em vez de executar o código interno de `get_settings()` e instanciar um novo objeto `Settings`, irão retornar o mesmo objeto que foi retornado na primeira chamada, de novo e de novo.
+
+#### Detalhes Técnicos de `lru_cache`
+
+`@lru_cache` modifica a função decorada para retornar o mesmo valor que foi retornado na primeira vez, em vez de calculá-lo novamente, executando o código da função toda vez.
+
+Assim, a função abaixo do decorador é executada uma única vez para cada combinação dos argumentos passados. E os valores retornados para cada combinação de argumentos são sempre reutilizados para cada nova chamada da função com a mesma combinação de argumentos.
+
+Por exemplo, se você definir uma função:
+
+```Python
+@lru_cache
+def say_hi(name: str, salutation: str = "Ms."):
+ return f"Hello {salutation} {name}"
+```
+
+Seu programa poderia executar dessa forma:
+
+```mermaid
+sequenceDiagram
+
+participant code as Código
+participant function as say_hi()
+participant execute as Executar Função
+
+ rect rgba(0, 255, 0, .1)
+ code ->> function: say_hi(name="Camila")
+ function ->> execute: executar código da função
+ execute ->> code: retornar o resultado
+ end
+
+ rect rgba(0, 255, 255, .1)
+ code ->> function: say_hi(name="Camila")
+ function ->> code: retornar resultado armazenado
+ end
+
+ rect rgba(0, 255, 0, .1)
+ code ->> function: say_hi(name="Rick")
+ function ->> execute: executar código da função
+ execute ->> code: retornar o resultado
+ end
+
+ rect rgba(0, 255, 0, .1)
+ code ->> function: say_hi(name="Rick", salutation="Mr.")
+ function ->> execute: executar código da função
+ execute ->> code: retornar o resultado
+ end
+
+ rect rgba(0, 255, 255, .1)
+ code ->> function: say_hi(name="Rick")
+ function ->> code: retornar resultado armazenado
+ end
+
+ rect rgba(0, 255, 255, .1)
+ code ->> function: say_hi(name="Camila")
+ function ->> code: retornar resultado armazenado
+ end
+```
+
+No caso da nossa dependência `get_settings()`, a função não recebe nenhum argumento, então ela sempre retorna o mesmo valor.
+
+Dessa forma, ela se comporta praticamente como uma variável global, mas ao ser utilizada como uma função de uma dependência, pode facilmente ser sobrescrita durante os testes.
+
+`@lru_cache` é definido no módulo `functools` que faz parte da biblioteca padrão do Python, você pode ler mais sobre esse decorador no link
Python Docs sobre `@lru_cache`.
+
+## Recapitulando
+
+Você pode usar o módulo Pydantic Settings para gerenciar as configurações de sua aplicação, utilizando todo o poder dos modelos Pydantic.
+
+- Utilizar dependências simplifica os testes.
+- Você pode utilizar arquivos .env junto das configurações do Pydantic.
+- Utilizar o decorador `@lru_cache` evita que o arquivo .env seja lido de novo e de novo para cada requisição, enquanto permite que você sobrescreva durante os testes.
diff --git a/docs/pt/docs/deployment.md b/docs/pt/docs/deployment.md
index 2272467fd..d25ea79fd 100644
--- a/docs/pt/docs/deployment.md
+++ b/docs/pt/docs/deployment.md
@@ -345,7 +345,7 @@ Você apenas precisa instalar um servidor ASGI compatível como:
=== "Hypercorn"
- *
Hypercorn, um servidor ASGI também compatível com HTTP/2.
+ *
Hypercorn, um servidor ASGI também compatível com HTTP/2.
diff --git a/docs/pt/docs/fastapi-cli.md b/docs/pt/docs/fastapi-cli.md
new file mode 100644
index 000000000..a4dfda660
--- /dev/null
+++ b/docs/pt/docs/fastapi-cli.md
@@ -0,0 +1,84 @@
+# FastAPI CLI
+
+**FastAPI CLI** é uma interface por linha de comando do `fastapi` que você pode usar para rodar sua app FastAPI, gerenciar seu projeto FastAPI e mais.
+
+Quando você instala o FastAPI (ex.: com `pip install fastapi`), isso inclui um pacote chamado `fastapi-cli`. Esse pacote disponibiliza o comando `fastapi` no terminal.
+
+Para rodar seu app FastAPI em desenvolvimento, você pode usar o comando `fastapi dev`:
+
+
+
+```console
+$ fastapi dev main.py
+INFO Using path main.py
+INFO Resolved absolute path /home/user/code/awesomeapp/main.py
+INFO Searching for package file structure from directories with __init__.py files
+INFO Importing from /home/user/code/awesomeapp
+
+ ╭─ Python module file ─╮
+ │ │
+ │ 🐍 main.py │
+ │ │
+ ╰──────────────────────╯
+
+INFO Importing module main
+INFO Found importable FastAPI app
+
+ ╭─ Importable FastAPI app ─╮
+ │ │
+ │ from main import app │
+ │ │
+ ╰──────────────────────────╯
+
+INFO Using import string main:app
+
+ ╭────────── 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 [2265862] using WatchFiles
+INFO: Started server process [2265873]
+INFO: Waiting for application startup.
+INFO: Application startup complete.
+```
+
+
+
+Aquele commando por linha de programa chamado `fastapi` é o **FastAPI CLI**.
+
+O FastAPI CLI recebe o caminho do seu programa Python, detecta automaticamente a variável com o FastAPI (comumente nomeada `app`) e como importá-la, e então a serve.
+
+Para produção você usaria `fastapi run` no lugar. 🚀
+
+Internamente, **FastAPI CLI** usa
Uvicorn, um servidor ASGI de alta performance e pronto para produção. 😎
+
+## `fastapi dev`
+
+Quando você roda `fastapi dev`, isso vai executar em modo de desenvolvimento.
+
+Por padrão, teremos o **recarregamento automático** ativo, então o programa irá recarregar o servidor automaticamente toda vez que você fizer mudanças no seu código. Isso usa muitos recursos e pode ser menos estável. Você deve apenas usá-lo em modo de desenvolvimento.
+
+O servidor de desenvolvimento escutará no endereço de IP `127.0.0.1` por padrão, este é o IP que sua máquina usa para se comunicar com ela mesma (`localhost`).
+
+## `fastapi run`
+
+Quando você rodar `fastapi run`, isso executará em modo de produção por padrão.
+
+Este modo terá **recarregamento automático desativado** por padrão.
+
+Isso irá escutar no endereço de IP `0.0.0.0`, o que significa todos os endereços IP disponíveis, dessa forma o programa estará acessível publicamente para qualquer um que consiga se comunicar com a máquina. Isso é como você normalmente roda em produção em um contêiner, por exemplo.
+
+Em muitos casos você pode ter (e deveria ter) um "proxy de saída" tratando HTTPS no topo, isso dependerá de como você fará o deploy da sua aplicação, seu provedor pode fazer isso pra você ou talvez seja necessário fazer você mesmo.
+
+!!! tip
+ Você pode aprender mais sobre em [documentação de deployment](deployment/index.md){.internal-link target=_blank}.
diff --git a/docs/pt/docs/how-to/general.md b/docs/pt/docs/how-to/general.md
new file mode 100644
index 000000000..4f21463b2
--- /dev/null
+++ b/docs/pt/docs/how-to/general.md
@@ -0,0 +1,39 @@
+# Geral - Como Fazer - Receitas
+
+Aqui estão vários links para outros locais na documentação, para perguntas gerais ou frequentes
+
+## Filtro de dados- Segurança
+
+Para assegurar que você não vai retornar mais dados do que deveria, leia a seção [Tutorial - Response Model - Return Type](../tutorial/response-model.md){.internal-link target=_blank}.
+
+## Tags de Documentação - OpenAPI
+Para adicionar tags às suas *rotas* e agrupá-las na UI da documentação, leia a seção [Tutorial - Path Operation Configurations - Tags](../tutorial/path-operation-configuration.md#tags){.internal-link target=_blank}.
+
+## Resumo e Descrição da documentação - OpenAPI
+
+Para adicionar um resumo e uma descrição às suas *rotas* e exibi-los na UI da documentação, leia a seção [Tutorial - Path Operation Configurations - Summary and Description](../tutorial/path-operation-configuration.md#summary-and-description){.internal-link target=_blank}.
+
+## Documentação das Descrições de Resposta - OpenAPI
+
+Para definir a descrição de uma resposta exibida na interface da documentação, leia a seção [Tutorial - Path Operation Configurations - Response description](../tutorial/path-operation-configuration.md#response-description){.internal-link target=_blank}.
+
+## Documentação para Depreciar uma *Operação de Rota* - OpenAPI
+
+Para depreciar uma *operação de rota* e exibi-la na interface da documentação, leia a seção [Tutorial - Path Operation Configurations - Deprecation](../tutorial/path-operation-configuration.md#deprecate-a-path-operation){.internal-link target=_blank}.
+
+## Converter qualquer dado para JSON
+
+
+Para converter qualquer dado para um formato compatível com JSON, leia a seção [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank}.
+
+## OpenAPI Metadata - Docs
+
+Para adicionar metadados ao seu esquema OpenAPI, incluindo licensa, versão, contato, etc, leia a seção [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md){.internal-link target=_blank}.
+
+## OpenAPI com URL customizada
+
+Para customizar a URL do OpenAPI (ou removê-la), leia a seção [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#openapi-url){.internal-link target=_blank}.
+
+## URLs de documentação do OpenAPI
+
+Para alterar as URLs usadas para as interfaces de usuário da documentação gerada automaticamente, leia a seção [Tutorial - Metadata and Docs URLs](../tutorial/metadata.md#docs-urls){.internal-link target=_blank}.
diff --git a/docs/pt/docs/how-to/index.md b/docs/pt/docs/how-to/index.md
new file mode 100644
index 000000000..664e89144
--- /dev/null
+++ b/docs/pt/docs/how-to/index.md
@@ -0,0 +1,11 @@
+# Como Fazer - Exemplos Práticos
+
+Aqui você encontrará diferentes exemplos práticos ou tutoriais de "como fazer" para vários tópicos.
+
+A maioria dessas ideias será mais ou menos **independente**, e na maioria dos casos você só precisará estudá-las se elas se aplicarem diretamente ao **seu projeto**.
+
+Se algo parecer interessante e útil para o seu projeto, vá em frente e dê uma olhada. Caso contrário, você pode simplesmente ignorá-lo.
+
+!!! tip
+
+ Se você deseja **aprender FastAPI** de forma estruturada (recomendado), leia capítulo por capítulo [Tutorial - Guia de Usuário](../tutorial/index.md){.internal-link target=_blank} em vez disso.
diff --git a/docs/pt/docs/index.md b/docs/pt/docs/index.md
index 86b77f117..6e7aa21f7 100644
--- a/docs/pt/docs/index.md
+++ b/docs/pt/docs/index.md
@@ -33,7 +33,7 @@ hide:
---
-FastAPI é um moderno e rápido (alta performance) _framework web_ para construção de APIs com Python 3.8 ou superior, baseado nos _type hints_ padrões do Python.
+FastAPI é um moderno e rápido (alta performance) _framework web_ para construção de APIs com Python, baseado nos _type hints_ padrões do Python.
Os recursos chave são:
@@ -109,8 +109,6 @@ Se você estiver construindo uma aplicação
Starlette para as partes web.
@@ -128,7 +126,7 @@ $ pip install fastapi
-Você também precisará de um servidor ASGI para produção, tal como
Uvicorn ou
Hypercorn.
+Você também precisará de um servidor ASGI para produção, tal como
Uvicorn ou
Hypercorn.
@@ -325,7 +323,7 @@ Você faz com tipos padrão do Python moderno.
Você não terá que aprender uma nova sintaxe, métodos ou classes de uma biblioteca específica etc.
-Apenas **Python 3.8+** padrão.
+Apenas **Python** padrão.
Por exemplo, para um `int`:
diff --git a/docs/pt/docs/reference/apirouter.md b/docs/pt/docs/reference/apirouter.md
new file mode 100644
index 000000000..7568601c9
--- /dev/null
+++ b/docs/pt/docs/reference/apirouter.md
@@ -0,0 +1,24 @@
+# Classe `APIRouter`
+
+Aqui está a informação de referência para a classe `APIRouter`, com todos os seus parâmetros, atributos e métodos.
+
+Você pode importar a classe `APIRouter` diretamente do `fastapi`:
+
+```python
+from fastapi import APIRouter
+```
+
+::: fastapi.APIRouter
+ options:
+ members:
+ - websocket
+ - include_router
+ - get
+ - put
+ - post
+ - delete
+ - options
+ - head
+ - patch
+ - trace
+ - on_event
diff --git a/docs/pt/docs/reference/background.md b/docs/pt/docs/reference/background.md
new file mode 100644
index 000000000..bfc15aa76
--- /dev/null
+++ b/docs/pt/docs/reference/background.md
@@ -0,0 +1,11 @@
+# Tarefas em Segundo Plano - `BackgroundTasks`
+
+Você pode declarar um parâmetro em uma *função de operação de rota* ou em uma função de dependência com o tipo `BackgroundTasks`, e então utilizá-lo para agendar a execução de tarefas em segundo plano após o envio da resposta.
+
+Você pode importá-lo diretamente do `fastapi`:
+
+```python
+from fastapi import BackgroundTasks
+```
+
+::: fastapi.BackgroundTasks
diff --git a/docs/pt/docs/reference/exceptions.md b/docs/pt/docs/reference/exceptions.md
new file mode 100644
index 000000000..d6b5d2613
--- /dev/null
+++ b/docs/pt/docs/reference/exceptions.md
@@ -0,0 +1,20 @@
+# Exceções - `HTTPException` e `WebSocketException`
+
+Essas são as exceções que você pode lançar para mostrar erros ao cliente.
+
+Quando você lança uma exceção, como aconteceria com o Python normal, o restante da execução é abortado. Dessa forma, você pode lançar essas exceções de qualquer lugar do código para abortar uma solicitação e mostrar o erro ao cliente.
+
+Você pode usar:
+
+* `HTTPException`
+* `WebSocketException`
+
+Essas exceções podem ser importadas diretamente do `fastapi`:
+
+```python
+from fastapi import HTTPException, WebSocketException
+```
+
+::: fastapi.HTTPException
+
+::: fastapi.WebSocketException
diff --git a/docs/pt/docs/reference/index.md b/docs/pt/docs/reference/index.md
new file mode 100644
index 000000000..533a6a996
--- /dev/null
+++ b/docs/pt/docs/reference/index.md
@@ -0,0 +1,6 @@
+# Referência - API de Código
+
+Aqui está a referência ou API de código, as classes, funções, parâmetros, atributos e todas as partes do FastAPI que você pode usar em suas aplicações.
+
+Se você quer **aprender FastAPI**, é muito melhor ler o
+[FastAPI Tutorial](https://fastapi.tiangolo.com/tutorial/).
diff --git a/docs/pt/docs/tutorial/dependencies/classes-as-dependencies.md b/docs/pt/docs/tutorial/dependencies/classes-as-dependencies.md
new file mode 100644
index 000000000..028bf3d20
--- /dev/null
+++ b/docs/pt/docs/tutorial/dependencies/classes-as-dependencies.md
@@ -0,0 +1,497 @@
+# Classes como Dependências
+
+Antes de nos aprofundarmos no sistema de **Injeção de Dependência**, vamos melhorar o exemplo anterior.
+
+## `dict` do exemplo anterior
+
+No exemplo anterior, nós retornávamos um `dict` da nossa dependência ("injetável"):
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="11"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="12"
+ {!> ../../../docs_src/dependencies/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/dependencies/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="11"
+ {!> ../../../docs_src/dependencies/tutorial001.py!}
+ ```
+
+Mas assim obtemos um `dict` como valor do parâmetro `commons` na *função de operação de rota*.
+
+E sabemos que editores de texto não têm como oferecer muitas funcionalidades (como sugestões automáticas) para objetos do tipo `dict`, por que não há como eles saberem o tipo das chaves e dos valores.
+
+Podemos fazer melhor...
+
+## O que caracteriza uma dependência
+
+Até agora você apenas viu dependências declaradas como funções.
+
+Mas essa não é a única forma de declarar dependências (mesmo que provavelmente seja a mais comum).
+
+O fator principal para uma dependência é que ela deve ser "chamável"
+
+Um objeto "chamável" em Python é qualquer coisa que o Python possa "chamar" como uma função
+
+Então se você tiver um objeto `alguma_coisa` (que pode *não* ser uma função) que você possa "chamar" (executá-lo) dessa maneira:
+
+```Python
+something()
+```
+
+ou
+
+```Python
+something(some_argument, some_keyword_argument="foo")
+```
+
+Então esse objeto é um "chamável".
+
+## Classes como dependências
+
+Você deve ter percebido que para criar um instância de uma classe em Python, a mesma sintaxe é utilizada.
+
+Por exemplo:
+
+```Python
+class Cat:
+ def __init__(self, name: str):
+ self.name = name
+
+
+fluffy = Cat(name="Mr Fluffy")
+```
+
+Nesse caso, `fluffy` é uma instância da classe `Cat`.
+
+E para criar `fluffy`, você está "chamando" `Cat`.
+
+Então, uma classe Python também é "chamável".
+
+Então, no **FastAPI**, você pode utilizar uma classe Python como uma dependência.
+
+O que o FastAPI realmente verifica, é se a dependência é algo chamável (função, classe, ou outra coisa) e os parâmetros que foram definidos.
+
+Se você passar algo "chamável" como uma dependência do **FastAPI**, o framework irá analisar os parâmetros desse "chamável" e processá-los da mesma forma que os parâmetros de uma *função de operação de rota*. Incluindo as sub-dependências.
+
+Isso também se aplica a objetos chamáveis que não recebem nenhum parâmetro. Da mesma forma que uma *função de operação de rota* sem parâmetros.
+
+Então, podemos mudar o "injetável" na dependência `common_parameters` acima para a classe `CommonQueryParams`:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="11-15"
+ {!> ../../../docs_src/dependencies/tutorial002_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="11-15"
+ {!> ../../../docs_src/dependencies/tutorial002_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="12-16"
+ {!> ../../../docs_src/dependencies/tutorial002_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="9-13"
+ {!> ../../../docs_src/dependencies/tutorial002_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="11-15"
+ {!> ../../../docs_src/dependencies/tutorial002.py!}
+ ```
+
+Observe o método `__init__` usado para criar uma instância da classe:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="12"
+ {!> ../../../docs_src/dependencies/tutorial002_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="12"
+ {!> ../../../docs_src/dependencies/tutorial002_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="13"
+ {!> ../../../docs_src/dependencies/tutorial002_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="10"
+ {!> ../../../docs_src/dependencies/tutorial002_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="12"
+ {!> ../../../docs_src/dependencies/tutorial002.py!}
+ ```
+
+...ele possui os mesmos parâmetros que nosso `common_parameters` anterior:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="8"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="10"
+ {!> ../../../docs_src/dependencies/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="6"
+ {!> ../../../docs_src/dependencies/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/dependencies/tutorial001.py!}
+ ```
+
+Esses parâmetros são utilizados pelo **FastAPI** para "definir" a dependência.
+
+Em ambos os casos teremos:
+
+* Um parâmetro de consulta `q` opcional do tipo `str`.
+* Um parâmetro de consulta `skip` do tipo `int`, com valor padrão `0`.
+* Um parâmetro de consulta `limit` do tipo `int`, com valor padrão `100`.
+
+Os dados serão convertidos, validados, documentados no esquema da OpenAPI e etc nos dois casos.
+
+## Utilizando
+
+Agora você pode declarar sua dependência utilizando essa classe.
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial002_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial002_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="20"
+ {!> ../../../docs_src/dependencies/tutorial002_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="17"
+ {!> ../../../docs_src/dependencies/tutorial002_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial002.py!}
+ ```
+
+O **FastAPI** chama a classe `CommonQueryParams`. Isso cria uma "instância" dessa classe e é a instância que será passada para o parâmetro `commons` na sua função.
+
+## Anotações de Tipo vs `Depends`
+
+Perceba como escrevemos `CommonQueryParams` duas vezes no código abaixo:
+
+=== "Python 3.8+"
+
+ ```Python
+ commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python
+ commons: CommonQueryParams = Depends(CommonQueryParams)
+ ```
+
+O último `CommonQueryParams`, em:
+
+```Python
+... Depends(CommonQueryParams)
+```
+
+...é o que o **FastAPI** irá realmente usar para saber qual é a dependência.
+
+É a partir dele que o FastAPI irá extrair os parâmetros passados e será o que o FastAPI irá realmente chamar.
+
+---
+
+Nesse caso, o primeiro `CommonQueryParams`, em:
+
+=== "Python 3.8+"
+
+ ```Python
+ commons: Annotated[CommonQueryParams, ...
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python
+ commons: CommonQueryParams ...
+ ```
+
+...não tem nenhum signficado especial para o **FastAPI**. O FastAPI não irá utilizá-lo para conversão dos dados, validação, etc (já que ele utiliza `Depends(CommonQueryParams)` para isso).
+
+Na verdade você poderia escrever apenas:
+
+=== "Python 3.8+"
+
+ ```Python
+ commons: Annotated[Any, Depends(CommonQueryParams)]
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python
+ commons = Depends(CommonQueryParams)
+ ```
+
+...como em:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial003_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial003_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="20"
+ {!> ../../../docs_src/dependencies/tutorial003_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="17"
+ {!> ../../../docs_src/dependencies/tutorial003_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial003.py!}
+ ```
+
+Mas declarar o tipo é encorajado por que é a forma que o seu editor de texto sabe o que será passado como valor do parâmetro `commons`.
+
+
+
+## Pegando um Atalho
+
+Mas você pode ver que temos uma repetição do código neste exemplo, escrevendo `CommonQueryParams` duas vezes:
+
+=== "Python 3.8+"
+
+ ```Python
+ commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python
+ commons: CommonQueryParams = Depends(CommonQueryParams)
+ ```
+
+O **FastAPI** nos fornece um atalho para esses casos, onde a dependência é *especificamente* uma classe que o **FastAPI** irá "chamar" para criar uma instância da própria classe.
+
+Para esses casos específicos, você pode fazer o seguinte:
+
+Em vez de escrever:
+
+=== "Python 3.8+"
+
+ ```Python
+ commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python
+ commons: CommonQueryParams = Depends(CommonQueryParams)
+ ```
+
+...escreva:
+
+=== "Python 3.8+"
+
+ ```Python
+ commons: Annotated[CommonQueryParams, Depends()]
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python
+ commons: CommonQueryParams = Depends()
+ ```
+
+Você declara a dependência como o tipo do parâmetro, e utiliza `Depends()` sem nenhum parâmetro, em vez de ter que escrever a classe *novamente* dentro de `Depends(CommonQueryParams)`.
+
+O mesmo exemplo ficaria então dessa forma:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial004_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial004_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="20"
+ {!> ../../../docs_src/dependencies/tutorial004_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="17"
+ {!> ../../../docs_src/dependencies/tutorial004_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial004.py!}
+ ```
+
+...e o **FastAPI** saberá o que fazer.
+
+!!! tip "Dica"
+ Se isso parece mais confuso do que útil, não utilize, você não *precisa* disso.
+
+ É apenas um atalho. Por que o **FastAPI** se preocupa em ajudar a minimizar a repetição de código.
diff --git a/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md b/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
new file mode 100644
index 000000000..4a297268c
--- /dev/null
+++ b/docs/pt/docs/tutorial/dependencies/dependencies-in-path-operation-decorators.md
@@ -0,0 +1,138 @@
+# Dependências em decoradores de operações de rota
+
+Em alguns casos você não precisa necessariamente retornar o valor de uma dependência dentro de uma *função de operação de rota*.
+
+Ou a dependência não retorna nenhum valor.
+
+Mas você ainda precisa que ela seja executada/resolvida.
+
+Para esses casos, em vez de declarar um parâmetro em uma *função de operação de rota* com `Depends`, você pode adicionar um argumento `dependencies` do tipo `list` ao decorador da operação de rota.
+
+## Adicionando `dependencies` ao decorador da operação de rota
+
+O *decorador da operação de rota* recebe um argumento opcional `dependencies`.
+
+Ele deve ser uma lista de `Depends()`:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="18"
+ {!> ../../../docs_src/dependencies/tutorial006_an.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível
+
+ ```Python hl_lines="17"
+ {!> ../../../docs_src/dependencies/tutorial006.py!}
+ ```
+Essas dependências serão executadas/resolvidas da mesma forma que dependências comuns. Mas o valor delas (se existir algum) não será passado para a sua *função de operação de rota*.
+
+!!! tip "Dica"
+ Alguns editores de texto checam parâmetros de funções não utilizados, e os mostram como erros.
+
+ Utilizando `dependencies` no *decorador da operação de rota* você pode garantir que elas serão executadas enquanto evita errors de editores/ferramentas.
+
+ Isso também pode ser útil para evitar confundir novos desenvolvedores que ao ver um parâmetro não usado no seu código podem pensar que ele é desnecessário.
+
+!!! info "Informação"
+ Neste exemplo utilizamos cabeçalhos personalizados inventados `X-Keys` e `X-Token`.
+
+ Mas em situações reais, como implementações de segurança, você pode obter mais vantagens em usar as [Ferramentas de segurança integradas (o próximo capítulo)](../security/index.md){.internal-link target=_blank}.
+
+## Erros das dependências e valores de retorno
+
+Você pode utilizar as mesmas *funções* de dependências que você usaria normalmente.
+
+### Requisitos de Dependências
+
+Dependências podem declarar requisitos de requisições (como cabeçalhos) ou outras subdependências:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="8 13"
+ {!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="7 12"
+ {!> ../../../docs_src/dependencies/tutorial006_an.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível
+
+ ```Python hl_lines="6 11"
+ {!> ../../../docs_src/dependencies/tutorial006.py!}
+ ```
+
+### Levantando exceções
+
+Essas dependências podem levantar exceções, da mesma forma que dependências comuns:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="10 15"
+ {!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="9 14"
+ {!> ../../../docs_src/dependencies/tutorial006_an.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível
+
+ ```Python hl_lines="8 13"
+ {!> ../../../docs_src/dependencies/tutorial006.py!}
+ ```
+
+### Valores de retorno
+
+E elas também podem ou não retornar valores, eles não serão utilizados.
+
+Então, você pode reutilizar uma dependência comum (que retorna um valor) que já seja utilizada em outro lugar, e mesmo que o valor não seja utilizado, a dependência será executada:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="11 16"
+ {!> ../../../docs_src/dependencies/tutorial006_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="10 15"
+ {!> ../../../docs_src/dependencies/tutorial006_an.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível
+
+ ```Python hl_lines="9 14"
+ {!> ../../../docs_src/dependencies/tutorial006.py!}
+ ```
+
+## Dependências para um grupo de *operações de rota*
+
+Mais a frente, quando você ler sobre como estruturar aplicações maiores ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você aprenderá a declarar um único parâmetro `dependencies` para um grupo de *operações de rota*.
+
+## Dependências globais
+
+No próximo passo veremos como adicionar dependências para uma aplicação `FastAPI` inteira, para que ela seja aplicada em toda *operação de rota*.
diff --git a/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md b/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md
new file mode 100644
index 000000000..8b4175fc5
--- /dev/null
+++ b/docs/pt/docs/tutorial/dependencies/dependencies-with-yield.md
@@ -0,0 +1,349 @@
+# Dependências com yield
+
+O FastAPI possui suporte para dependências que realizam
alguns passos extras ao finalizar.
+
+Para fazer isso, utilize `yield` em vez de `return`, e escreva os passos extras (código) depois.
+
+!!! tip "Dica"
+ Garanta que `yield` é utilizado apenas uma vez.
+
+!!! note "Detalhes Técnicos"
+ Qualquer função que possa ser utilizada com:
+
+ *
`@contextlib.contextmanager` ou
+ *
`@contextlib.asynccontextmanager`
+
+ pode ser utilizada como uma dependência do **FastAPI**.
+
+ Na realidade, o FastAPI utiliza esses dois decoradores internamente.
+
+## Uma dependência de banco de dados com `yield`
+
+Por exemplo, você poderia utilizar isso para criar uma sessão do banco de dados, e fechá-la após terminar sua operação.
+
+Apenas o código anterior a declaração com `yield` e o código contendo essa declaração são executados antes de criar uma resposta.
+
+```Python hl_lines="2-4"
+{!../../../docs_src/dependencies/tutorial007.py!}
+```
+
+O valor gerado (yielded) é o que é injetado nas *operações de rota* e outras dependências.
+
+```Python hl_lines="4"
+{!../../../docs_src/dependencies/tutorial007.py!}
+```
+
+O código após o `yield` é executado após a resposta ser entregue:
+
+```Python hl_lines="5-6"
+{!../../../docs_src/dependencies/tutorial007.py!}
+```
+
+!!! tip "Dica"
+ Você pode usar funções assíncronas (`async`) ou funções comuns.
+
+ O **FastAPI** saberá o que fazer com cada uma, da mesma forma que as dependências comuns.
+
+## Uma dependência com `yield` e `try`
+
+Se você utilizar um bloco `try` em uma dependência com `yield`, você irá capturar qualquer exceção que for lançada enquanto a dependência é utilizada.
+
+Por exemplo, se algum código em um certo momento no meio da operação, em outra dependência ou em uma *operação de rota*, fizer um "rollback" de uma transação de banco de dados ou causar qualquer outro erro, você irá capturar a exceção em sua dependência.
+
+Então, você pode procurar por essa exceção específica dentro da dependência com `except AlgumaExcecao`.
+
+Da mesma forma, você pode utilizar `finally` para garantir que os passos de saída são executados, com ou sem exceções.
+
+```python hl_lines="3 5"
+{!../../../docs_src/dependencies/tutorial007.py!}
+```
+
+## Subdependências com `yield`
+
+Você pode ter subdependências e "árvores" de subdependências de qualquer tamanho e forma, e qualquer uma ou todas elas podem utilizar `yield`.
+
+O **FastAPI** garantirá que o "código de saída" em cada dependência com `yield` é executado na ordem correta.
+
+Por exemplo, `dependency_c` pode depender de `dependency_b`, e `dependency_b` depender de `dependency_a`:
+
+=== "python 3.9+"
+
+ ```python hl_lines="6 14 22"
+ {!> ../../../docs_src/dependencies/tutorial008_an_py39.py!}
+ ```
+
+=== "python 3.8+"
+
+ ```python hl_lines="5 13 21"
+ {!> ../../../docs_src/dependencies/tutorial008_an.py!}
+ ```
+
+=== "python 3.8+ non-annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```python hl_lines="4 12 20"
+ {!> ../../../docs_src/dependencies/tutorial008.py!}
+ ```
+
+E todas elas podem utilizar `yield`.
+
+Neste caso, `dependency_c` precisa que o valor de `dependency_b` (nomeada de `dep_b` aqui) continue disponível para executar seu código de saída.
+
+E, por outro lado, `dependency_b` precisa que o valor de `dependency_a` (nomeada de `dep_a`) continue disponível para executar seu código de saída.
+
+=== "python 3.9+"
+
+ ```python hl_lines="18-19 26-27"
+ {!> ../../../docs_src/dependencies/tutorial008_an_py39.py!}
+ ```
+
+=== "python 3.8+"
+
+ ```python hl_lines="17-18 25-26"
+ {!> ../../../docs_src/dependencies/tutorial008_an.py!}
+ ```
+
+=== "python 3.8+ non-annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```python hl_lines="16-17 24-25"
+ {!> ../../../docs_src/dependencies/tutorial008.py!}
+ ```
+
+Da mesma forma, você pode ter algumas dependências com `yield` e outras com `return` e ter uma relação de dependência entre algumas dos dois tipos.
+
+E você poderia ter uma única dependência que precisa de diversas outras dependências com `yield`, etc.
+
+Você pode ter qualquer combinação de dependências que você quiser.
+
+O **FastAPI** se encarrega de executá-las na ordem certa.
+
+!!! note "Detalhes Técnicos"
+ Tudo isso funciona graças aos
gerenciadores de contexto do Python.
+
+ O **FastAPI** utiliza eles internamente para alcançar isso.
+
+## Dependências com `yield` e `httpexception`
+
+Você viu que dependências podem ser utilizadas com `yield` e podem incluir blocos `try` para capturar exceções.
+
+Da mesma forma, você pode lançar uma `httpexception` ou algo parecido no código de saída, após o `yield`
+
+!!! tip "Dica"
+
+ Essa é uma técnica relativamente avançada, e na maioria dos casos você não precisa dela totalmente, já que você pode lançar exceções (incluindo `httpexception`) dentro do resto do código da sua aplicação, por exemplo, em uma *função de operação de rota*.
+
+ Mas ela existe para ser utilizada caso você precise. 🤓
+
+=== "python 3.9+"
+
+ ```python hl_lines="18-22 31"
+ {!> ../../../docs_src/dependencies/tutorial008b_an_py39.py!}
+ ```
+
+=== "python 3.8+"
+
+ ```python hl_lines="17-21 30"
+ {!> ../../../docs_src/dependencies/tutorial008b_an.py!}
+ ```
+
+=== "python 3.8+ non-annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```python hl_lines="16-20 29"
+ {!> ../../../docs_src/dependencies/tutorial008b.py!}
+ ```
+
+Uma alternativa que você pode utilizar para capturar exceções (e possivelmente lançar outra HTTPException) é criar um [Manipulador de Exceções Customizado](../handling-errors.md#instalando-manipuladores-de-excecoes-customizados){.internal-link target=_blank}.
+
+## Dependências com `yield` e `except`
+
+Se você capturar uma exceção com `except` em uma dependência que utilize `yield` e ela não for levantada novamente (ou uma nova exceção for levantada), o FastAPI não será capaz de identifcar que houve uma exceção, da mesma forma que aconteceria com Python puro:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="15-16"
+ {!> ../../../docs_src/dependencies/tutorial008c_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="14-15"
+ {!> ../../../docs_src/dependencies/tutorial008c_an.py!}
+ ```
+
+=== "Python 3.8+ non-annotated"
+
+ !!! tip "dica"
+ utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="13-14"
+ {!> ../../../docs_src/dependencies/tutorial008c.py!}
+ ```
+
+Neste caso, o cliente irá ver uma resposta *HTTP 500 Internal Server Error* como deveria acontecer, já que não estamos levantando nenhuma `HTTPException` ou coisa parecida, mas o servidor **não terá nenhum log** ou qualquer outra indicação de qual foi o erro. 😱
+
+### Sempre levante (`raise`) exceções em Dependências com `yield` e `except`
+
+Se você capturar uma exceção em uma dependência com `yield`, a menos que você esteja levantando outra `HTTPException` ou coisa parecida, você deveria relançar a exceção original.
+
+Você pode relançar a mesma exceção utilizando `raise`:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="17"
+ {!> ../../../docs_src/dependencies/tutorial008d_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="16"
+ {!> ../../../docs_src/dependencies/tutorial008d_an.py!}
+ ```
+
+=== "python 3.8+ non-annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="15"
+ {!> ../../../docs_src/dependencies/tutorial008d.py!}
+ ```
+
+Agora o cliente irá receber a mesma resposta *HTTP 500 Internal Server Error*, mas o servidor terá nosso `InternalError` personalizado nos logs. 😎
+
+## Execução de dependências com `yield`
+
+A sequência de execução é mais ou menos como esse diagrama. O tempo passa do topo para baixo. E cada coluna é uma das partes interagindo ou executando código.
+
+```mermaid
+sequenceDiagram
+
+participant client as Cliente
+participant handler as Manipulador de exceções
+participant dep as Dep com yield
+participant operation as Operação de Rota
+participant tasks as Tarefas de Background
+
+ Note over client,operation: pode lançar exceções, incluindo HTTPException
+ client ->> dep: Iniciar requisição
+ Note over dep: Executar código até o yield
+ opt lançar Exceção
+ dep -->> handler: lançar Exceção
+ handler -->> client: resposta de erro HTTP
+ end
+ dep ->> operation: Executar dependência, e.g. sessão de BD
+ opt raise
+ operation -->> dep: Lançar exceção (e.g. HTTPException)
+ opt handle
+ dep -->> dep: Pode capturar exceções, lançar uma nova HTTPException, lançar outras exceções
+ end
+ handler -->> client: resposta de erro HTTP
+ end
+
+ operation ->> client: Retornar resposta ao cliente
+ Note over client,operation: Resposta já foi enviada, e não pode ser modificada
+ opt Tarefas
+ operation -->> tasks: Enviar tarefas de background
+ end
+ opt Lançar outra exceção
+ tasks -->> tasks: Manipula exceções no código da tarefa de background
+ end
+```
+
+!!! info "Informação"
+ Apenas **uma resposta** será enviada para o cliente. Ela pode ser uma das respostas de erro, ou então a resposta da *operação de rota*.
+
+ Após uma dessas respostas ser enviada, nenhuma outra resposta pode ser enviada
+
+!!! tip "Dica"
+ Esse diagrama mostra `HttpException`, mas você pode levantar qualquer outra exceção que você capture em uma dependência com `yield` ou um [Manipulador de exceções personalizado](../handling-errors.md#instalando-manipuladores-de-excecoes-customizados){.internal-link target=_blank}.
+
+ Se você lançar qualquer exceção, ela será passada para as dependências com yield, inlcuindo a `HTTPException`. Na maioria dos casos você vai querer relançar essa mesma exceção ou uma nova a partir da dependência com `yield` para garantir que ela seja tratada adequadamente.
+
+## Dependências com `yield`, `HTTPException`, `except` e Tarefas de Background
+
+!!! warning "Aviso"
+ Você provavelmente não precisa desses detalhes técnicos, você pode pular essa seção e continuar na próxima seção abaixo.
+
+ Esses detalhes são úteis principalmente se você estiver usando uma versão do FastAPI anterior à 0.106.0 e utilizando recursos de dependências com `yield` em tarefas de background.
+
+### Dependências com `yield` e `except`, Detalhes Técnicos
+
+Antes do FastAPI 0.110.0, se você utilizasse uma dependência com `yield`, e então capturasse uma dependência com `except` nessa dependência, caso a exceção não fosse relançada, ela era automaticamente lançada para qualquer manipulador de exceções ou o manipulador de erros interno do servidor.
+
+Isso foi modificado na versão 0.110.0 para consertar o consumo de memória não controlado das exceções relançadas automaticamente sem um manipulador (erros internos do servidor), e para manter o comportamento consistente com o código Python tradicional.
+
+### Tarefas de Background e Dependências com `yield`, Detalhes Técnicos
+
+Antes do FastAPI 0.106.0, levantar exceções após um `yield` não era possível, o código de saída nas dependências com `yield` era executado *após* a resposta ser enviada, então os [Manipuladores de Exceções](../handling-errors.md#instalando-manipuladores-de-excecoes-customizados){.internal-link target=_blank} já teriam executado.
+
+Isso foi implementado dessa forma principalmente para permitir que os mesmos objetos fornecidos ("yielded") pelas dependências dentro de tarefas de background fossem reutilizados, por que o código de saída era executado antes das tarefas de background serem finalizadas.
+
+Ainda assim, como isso exigiria esperar que a resposta navegasse pela rede enquanto mantia ativo um recurso desnecessário na dependência com yield (por exemplo, uma conexão com banco de dados), isso mudou na versão 0.106.0 do FastAPI.
+
+!!! tip "Dica"
+
+ Adicionalmente, uma tarefa de background é, normalmente, um conjunto de lógicas independentes que devem ser manipuladas separadamente, com seus próprios recursos (e.g. sua própria conexão com banco de dados).
+
+ Então, dessa forma você provavelmente terá um código mais limpo.
+
+Se você costumava depender desse comportamento, agora você precisa criar os recursos para uma tarefa de background dentro dela mesma, e usar internamente apenas dados que não dependam de recursos de dependências com `yield`.
+
+Por exemplo, em vez de utilizar a mesma sessão do banco de dados, você criaria uma nova sessão dentro da tarefa de background, e você obteria os objetos do banco de dados utilizando essa nova sessão. E então, em vez de passar o objeto obtido do banco de dados como um parâmetro para a função da tarefa de background, você passaria o ID desse objeto e buscaria ele novamente dentro da função da tarefa de background.
+
+## Gerenciadores de contexto
+
+### O que são gerenciadores de contexto
+
+"Gerenciadores de Contexto" são qualquer um dos objetos Python que podem ser utilizados com a declaração `with`.
+
+Por exemplo,
você pode utilizar `with` para ler um arquivo:
+
+```Python
+with open("./somefile.txt") as f:
+ contents = f.read()
+ print(contents)
+```
+
+Por baixo dos panos, o código `open("./somefile.txt")` cria um objeto que é chamado de "Gerenciador de Contexto".
+
+Quando o bloco `with` finaliza, ele se certifica de fechar o arquivo, mesmo que tenha ocorrido alguma exceção.
+
+Quando você cria uma dependência com `yield`, o **FastAPI** irá criar um gerenciador de contexto internamente para ela, e combiná-lo com algumas outras ferramentas relacionadas.
+
+### Utilizando gerenciadores de contexto em dependências com `yield`
+
+!!! warning "Aviso"
+ Isso é uma ideia mais ou menos "avançada".
+
+ Se você está apenas iniciando com o **FastAPI** você pode querer pular isso por enquanto.
+
+Em python, você pode criar Gerenciadores de Contexto ao
criar uma classe com dois métodos: `__enter__()` e `__exit__()`.
+
+Você também pode usá-los dentro de dependências com `yield` do **FastAPI** ao utilizar `with` ou `async with` dentro da função da dependência:
+
+```Python hl_lines="1-9 13"
+{!../../../docs_src/dependencies/tutorial010.py!}
+```
+
+!!! tip "Dica"
+ Outra forma de criar um gerenciador de contexto é utilizando:
+
+ *
`@contextlib.contextmanager` ou
+
+ *
`@contextlib.asynccontextmanager`
+
+ Para decorar uma função com um único `yield`.
+
+ Isso é o que o **FastAPI** usa internamente para dependências com `yield`.
+
+ Mas você não precisa usar esses decoradores para as dependências do FastAPI (e você não deveria).
+
+ O FastAPI irá fazer isso para você internamente.
diff --git a/docs/pt/docs/tutorial/dependencies/global-dependencies.md b/docs/pt/docs/tutorial/dependencies/global-dependencies.md
new file mode 100644
index 000000000..3eb5faa34
--- /dev/null
+++ b/docs/pt/docs/tutorial/dependencies/global-dependencies.md
@@ -0,0 +1,34 @@
+# Dependências Globais
+
+Para alguns tipos de aplicação específicos você pode querer adicionar dependências para toda a aplicação.
+
+De forma semelhante a [adicionar dependências (`dependencies`) em *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank}, você pode adicioná-las à aplicação `FastAPI`.
+
+Nesse caso, elas serão aplicadas a todas as *operações de rota* da aplicação:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="16"
+ {!> ../../../docs_src/dependencies/tutorial012_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="16"
+ {!> ../../../docs_src/dependencies/tutorial012_an.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="15"
+ {!> ../../../docs_src/dependencies/tutorial012.py!}
+ ```
+
+E todos os conceitos apresentados na sessão sobre [adicionar dependências em *decoradores de operação de rota*](dependencies-in-path-operation-decorators.md){.internal-link target=_blank} ainda se aplicam, mas nesse caso, para todas as *operações de rota* da aplicação.
+
+## Dependências para conjuntos de *operações de rota*
+
+Mais para a frente, quando você ler sobre como estruturar aplicações maiores ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você irá aprender a declarar um único parâmetro `dependencies` para um conjunto de *operações de rota*.
diff --git a/docs/pt/docs/tutorial/dependencies/index.md b/docs/pt/docs/tutorial/dependencies/index.md
new file mode 100644
index 000000000..3c0155a6e
--- /dev/null
+++ b/docs/pt/docs/tutorial/dependencies/index.md
@@ -0,0 +1,353 @@
+# Dependências
+
+O **FastAPI** possui um poderoso, mas intuitivo sistema de **
Injeção de Dependência**.
+
+Esse sistema foi pensado para ser fácil de usar, e permitir que qualquer desenvolvedor possa integrar facilmente outros componentes ao **FastAPI**.
+
+## O que é "Injeção de Dependência"
+
+**"Injeção de Dependência"** no mundo da programação significa, que existe uma maneira de declarar no seu código (nesse caso, suas *funções de operação de rota*) para declarar as coisas que ele precisa para funcionar e que serão utilizadas: "dependências".
+
+Então, esse sistema (nesse caso o **FastAPI**) se encarrega de fazer o que for preciso para fornecer essas dependências para o código ("injetando" as dependências).
+
+Isso é bastante útil quando você precisa:
+
+* Definir uma lógica compartilhada (mesmo formato de código repetidamente).
+* Compartilhar conexões com banco de dados.
+* Aplicar regras de segurança, autenticação, papéis de usuários, etc.
+* E muitas outras coisas...
+
+Tudo isso, enquanto minimizamos a repetição de código.
+
+## Primeiros passos
+
+Vamos ver um exemplo simples. Tão simples que não será muito útil, por enquanto.
+
+Mas dessa forma podemos focar em como o sistema de **Injeção de Dependência** funciona.
+
+### Criando uma dependência, ou "injetável"
+
+Primeiro vamos focar na dependência.
+
+Ela é apenas uma função que pode receber os mesmos parâmetros de uma *função de operação de rota*:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="8-9"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="8-11"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="9-12"
+ {!> ../../../docs_src/dependencies/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="6-7"
+ {!> ../../../docs_src/dependencies/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="8-11"
+ {!> ../../../docs_src/dependencies/tutorial001.py!}
+ ```
+
+E pronto.
+
+**2 linhas**.
+
+E com a mesma forma e estrutura de todas as suas *funções de operação de rota*.
+
+Você pode pensar nela como uma *função de operação de rota* sem o "decorador" (sem a linha `@app.get("/some-path")`).
+
+E com qualquer retorno que você desejar.
+
+Neste caso, a dependência espera por:
+
+* Um parâmetro de consulta opcional `q` do tipo `str`.
+* Um parâmetro de consulta opcional `skip` do tipo `int`, e igual a `0` por padrão.
+* Um parâmetro de consulta opcional `limit` do tipo `int`, e igual a `100` por padrão.
+
+E então retorna um `dict` contendo esses valores.
+
+!!! info "Informação"
+ FastAPI passou a suportar a notação `Annotated` (e começou a recomendá-la) na versão 0.95.0.
+
+ Se você utiliza uma versão anterior, ocorrerão erros ao tentar utilizar `Annotated`.
+
+ Certifique-se de [Atualizar a versão do FastAPI](../../deployment/versions.md#atualizando-as-versoes-do-fastapi){.internal-link target=_blank} para pelo menos 0.95.1 antes de usar `Annotated`.
+
+### Importando `Depends`
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/dependencies/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="1"
+ {!> ../../../docs_src/dependencies/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/dependencies/tutorial001.py!}
+ ```
+
+### Declarando a dependência, no "dependente"
+
+Da mesma forma que você utiliza `Body`, `Query`, etc. Como parâmetros de sua *função de operação de rota*, utilize `Depends` com um novo parâmetro:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="13 18"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="15 20"
+ {!> ../../../docs_src/dependencies/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="16 21"
+ {!> ../../../docs_src/dependencies/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="11 16"
+ {!> ../../../docs_src/dependencies/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="15 20"
+ {!> ../../../docs_src/dependencies/tutorial001.py!}
+ ```
+
+Ainda que `Depends` seja utilizado nos parâmetros da função da mesma forma que `Body`, `Query`, etc, `Depends` funciona de uma forma um pouco diferente.
+
+Você fornece um único parâmetro para `Depends`.
+
+Esse parâmetro deve ser algo como uma função.
+
+Você **não chama a função** diretamente (não adicione os parênteses no final), apenas a passe como parâmetro de `Depends()`.
+
+E essa função vai receber os parâmetros da mesma forma que uma *função de operação de rota*.
+
+!!! tip "Dica"
+ Você verá quais outras "coisas", além de funções, podem ser usadas como dependências no próximo capítulo.
+
+Sempre que uma nova requisição for realizada, o **FastAPI** se encarrega de:
+
+* Chamar sua dependência ("injetável") com os parâmetros corretos.
+* Obter o resultado da função.
+* Atribuir esse resultado para o parâmetro em sua *função de operação de rota*.
+
+```mermaid
+graph TB
+
+common_parameters(["common_parameters"])
+read_items["/items/"]
+read_users["/users/"]
+
+common_parameters --> read_items
+common_parameters --> read_users
+```
+
+Assim, você escreve um código compartilhado apenas uma vez e o **FastAPI** se encarrega de chamá-lo em suas *operações de rota*.
+
+!!! check "Checando"
+ Perceba que você não precisa criar uma classe especial e enviar a dependência para algum outro lugar em que o **FastAPI** a "registre" ou realize qualquer operação similar.
+
+ Você apenas envia para `Depends` e o **FastAPI** sabe como fazer o resto.
+
+## Compartilhando dependências `Annotated`
+
+Nos exemplos acima, você pode ver que existe uma pequena **duplicação de código**.
+
+Quando você precisa utilizar a dependência `common_parameters()`, você precisa escrever o parâmetro inteiro com uma anotação de tipo e `Depends()`:
+
+```Python
+commons: Annotated[dict, Depends(common_parameters)]
+```
+
+Mas como estamos utilizando `Annotated`, podemos guardar esse valor `Annotated` em uma variável e utilizá-la em múltiplos locais:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="12 16 21"
+ {!> ../../../docs_src/dependencies/tutorial001_02_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="14 18 23"
+ {!> ../../../docs_src/dependencies/tutorial001_02_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="15 19 24"
+ {!> ../../../docs_src/dependencies/tutorial001_02_an.py!}
+ ```
+
+!!! tip "Dica"
+ Isso é apenas Python padrão, essa funcionalidade é chamada de "type alias", e na verdade não é específica ao **FastAPI**.
+
+ Mas como o **FastAPI** se baseia em convenções do Python, incluindo `Annotated`, você pode incluir esse truque no seu código. 😎
+
+As dependências continuarão funcionando como esperado, e a **melhor parte** é que a **informação sobre o tipo é preservada**, o que signfica que seu editor de texto ainda irá incluir **preenchimento automático**, **visualização de erros**, etc. O mesmo vale para ferramentas como `mypy`.
+
+Isso é especialmente útil para uma **base de código grande** onde **as mesmas dependências** são utilizadas repetidamente em **muitas *operações de rota***.
+
+## `Async` ou não, eis a questão
+
+Como as dependências também serão chamadas pelo **FastAPI** (da mesma forma que *funções de operação de rota*), as mesmas regras se aplicam ao definir suas funções.
+
+Você pode utilizar `async def` ou apenas `def`.
+
+E você pode declarar dependências utilizando `async def` dentro de *funções de operação de rota* definidas com `def`, ou declarar dependências com `def` e utilizar dentro de *funções de operação de rota* definidas com `async def`, etc.
+
+Não faz diferença. O **FastAPI** sabe o que fazer.
+
+!!! note "Nota"
+ Caso você não conheça, veja em [Async: *"Com Pressa?"*](../../async.md#com-pressa){.internal-link target=_blank} a sessão acerca de `async` e `await` na documentação.
+
+## Integrando com OpenAPI
+
+Todas as declarações de requisições, validações e requisitos para suas dependências (e sub-dependências) serão integradas em um mesmo esquema OpenAPI.
+
+Então, a documentação interativa também terá toda a informação sobre essas dependências:
+
+
+
+## Caso de Uso Simples
+
+Se você parar para ver, *funções de operação de rota* são declaradas para serem usadas sempre que uma *rota* e uma *operação* se encaixam, e então o **FastAPI** se encarrega de chamar a função correspondente com os argumentos corretos, extraindo os dados da requisição.
+
+Na verdade, todos (ou a maioria) dos frameworks web funcionam da mesma forma.
+
+Você nunca chama essas funções diretamente. Elas são chamadas pelo framework utilizado (nesse caso, **FastAPI**).
+
+Com o Sistema de Injeção de Dependência, você também pode informar ao **FastAPI** que sua *função de operação de rota* também "depende" em algo a mais que deve ser executado antes de sua *função de operação de rota*, e o **FastAPI** se encarrega de executar e "injetar" os resultados.
+
+Outros termos comuns para essa mesma ideia de "injeção de dependência" são:
+
+* recursos
+* provedores
+* serviços
+* injetáveis
+* componentes
+
+## Plug-ins em **FastAPI**
+
+Integrações e "plug-ins" podem ser construídos com o sistema de **Injeção de Dependência**. Mas na verdade, **não há necessidade de criar "plug-ins"**, já que utilizando dependências é possível declarar um número infinito de integrações e interações que se tornam disponíveis para as suas *funções de operação de rota*.
+
+E as dependências pode ser criadas de uma forma bastante simples e intuitiva que permite que você importe apenas os pacotes Python que forem necessários, e integrá-los com as funções de sua API em algumas linhas de código, *literalmente*.
+
+Você verá exemplos disso nos próximos capítulos, acerca de bancos de dados relacionais e NoSQL, segurança, etc.
+
+## Compatibilidade do **FastAPI**
+
+A simplicidade do sistema de injeção de dependência do **FastAPI** faz ele compatível com:
+
+* todos os bancos de dados relacionais
+* bancos de dados NoSQL
+* pacotes externos
+* APIs externas
+* sistemas de autenticação e autorização
+* istemas de monitoramento de uso para APIs
+* sistemas de injeção de dados de resposta
+* etc.
+
+## Simples e Poderoso
+
+Mesmo que o sistema hierárquico de injeção de dependência seja simples de definir e utilizar, ele ainda é bastante poderoso.
+
+Você pode definir dependências que por sua vez definem suas próprias dependências.
+
+No fim, uma árvore hierárquica de dependências é criadas, e o sistema de **Injeção de Dependência** toma conta de resolver todas essas dependências (e as sub-dependências delas) para você, e provê (injeta) os resultados em cada passo.
+
+Por exemplo, vamos supor que você possua 4 endpoints na sua API (*operações de rota*):
+
+* `/items/public/`
+* `/items/private/`
+* `/users/{user_id}/activate`
+* `/items/pro/`
+
+Você poderia adicionar diferentes requisitos de permissão para cada um deles utilizando apenas dependências e sub-dependências:
+
+```mermaid
+graph TB
+
+current_user(["current_user"])
+active_user(["active_user"])
+admin_user(["admin_user"])
+paying_user(["paying_user"])
+
+public["/items/public/"]
+private["/items/private/"]
+activate_user["/users/{user_id}/activate"]
+pro_items["/items/pro/"]
+
+current_user --> active_user
+active_user --> admin_user
+active_user --> paying_user
+
+current_user --> public
+active_user --> private
+admin_user --> activate_user
+paying_user --> pro_items
+```
+
+## Integração com **OpenAPI**
+
+Todas essas dependências, ao declarar os requisitos para suas *operações de rota*, também adicionam parâmetros, validações, etc.
+
+O **FastAPI** se encarrega de adicionar tudo isso ao esquema OpenAPI, para que seja mostrado nos sistemas de documentação interativa.
diff --git a/docs/pt/docs/tutorial/dependencies/sub-dependencies.md b/docs/pt/docs/tutorial/dependencies/sub-dependencies.md
new file mode 100644
index 000000000..189f196ab
--- /dev/null
+++ b/docs/pt/docs/tutorial/dependencies/sub-dependencies.md
@@ -0,0 +1,194 @@
+# Subdependências
+
+Você pode criar dependências que possuem **subdependências**.
+
+Elas podem ter o nível de **profundidade** que você achar necessário.
+
+O **FastAPI** se encarrega de resolver essas dependências.
+
+## Primeira dependência "injetável"
+
+Você pode criar uma primeira dependência (injetável) dessa forma:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="8-9"
+ {!> ../../../docs_src/dependencies/tutorial005_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="8-9"
+ {!> ../../../docs_src/dependencies/tutorial005_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="9-10"
+ {!> ../../../docs_src/dependencies/tutorial005_an.py!}
+ ```
+
+=== "Python 3.10 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="6-7"
+ {!> ../../../docs_src/dependencies/tutorial005_py310.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="8-9"
+ {!> ../../../docs_src/dependencies/tutorial005.py!}
+ ```
+
+Esse código declara um parâmetro de consulta opcional, `q`, com o tipo `str`, e então retorna esse parâmetro.
+
+Isso é bastante simples (e não muito útil), mas irá nos ajudar a focar em como as subdependências funcionam.
+
+## Segunda dependência, "injetável" e "dependente"
+
+Então, você pode criar uma outra função para uma dependência (um "injetável") que ao mesmo tempo declara sua própria dependência (o que faz dela um "dependente" também):
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="13"
+ {!> ../../../docs_src/dependencies/tutorial005_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="13"
+ {!> ../../../docs_src/dependencies/tutorial005_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="14"
+ {!> ../../../docs_src/dependencies/tutorial005_an.py!}
+ ```
+
+=== "Python 3.10 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="11"
+ {!> ../../../docs_src/dependencies/tutorial005_py310.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="13"
+ {!> ../../../docs_src/dependencies/tutorial005.py!}
+ ```
+
+Vamos focar nos parâmetros declarados:
+
+* Mesmo que essa função seja uma dependência ("injetável") por si mesma, ela também declara uma outra dependência (ela "depende" de outra coisa).
+ * Ela depende do `query_extractor`, e atribui o valor retornado pela função ao parâmetro `q`.
+* Ela também declara um cookie opcional `last_query`, do tipo `str`.
+ * Se o usuário não passou nenhuma consulta `q`, a última consulta é utilizada, que foi salva em um cookie anteriormente.
+
+## Utilizando a dependência
+
+Então podemos utilizar a dependência com:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="23"
+ {!> ../../../docs_src/dependencies/tutorial005_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="23"
+ {!> ../../../docs_src/dependencies/tutorial005_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="24"
+ {!> ../../../docs_src/dependencies/tutorial005_an.py!}
+ ```
+
+=== "Python 3.10 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="19"
+ {!> ../../../docs_src/dependencies/tutorial005_py310.py!}
+ ```
+
+=== "Python 3.8 non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="22"
+ {!> ../../../docs_src/dependencies/tutorial005.py!}
+ ```
+
+!!! info "Informação"
+ Perceba que nós estamos declarando apenas uma dependência na *função de operação de rota*, em `query_or_cookie_extractor`.
+
+ Mas o **FastAPI** saberá que precisa solucionar `query_extractor` primeiro, para passar o resultado para `query_or_cookie_extractor` enquanto chama a função.
+
+```mermaid
+graph TB
+
+query_extractor(["query_extractor"])
+query_or_cookie_extractor(["query_or_cookie_extractor"])
+
+read_query["/items/"]
+
+query_extractor --> query_or_cookie_extractor --> read_query
+```
+
+## Utilizando a mesma dependência múltiplas vezes
+
+Se uma de suas dependências é declarada várias vezes para a mesma *operação de rota*, por exemplo, múltiplas dependências com uma mesma subdependência, o **FastAPI** irá chamar essa subdependência uma única vez para cada requisição.
+
+E o valor retornado é salvo em um
"cache" e repassado para todos os "dependentes" que precisam dele em uma requisição específica, em vez de chamar a dependência múltiplas vezes para uma mesma requisição.
+
+Em um cenário avançado onde você precise que a dependência seja calculada em cada passo (possivelmente várias vezes) de uma requisição em vez de utilizar o valor em "cache", você pode definir o parâmetro `use_cache=False` em `Depends`:
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="1"
+ async def needy_dependency(fresh_value: Annotated[str, Depends(get_value, use_cache=False)]):
+ return {"fresh_value": fresh_value}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "Dica"
+ Utilize a versão com `Annotated` se possível.
+
+ ```Python hl_lines="1"
+ async def needy_dependency(fresh_value: str = Depends(get_value, use_cache=False)):
+ return {"fresh_value": fresh_value}
+ ```
+
+## Recapitulando
+
+Com exceção de todas as palavras complicadas usadas aqui, o sistema de **Injeção de Dependência** é bastante simples.
+
+Consiste apenas de funções que parecem idênticas a *funções de operação de rota*.
+
+Mas ainda assim, é bastante poderoso, e permite que você declare grafos (árvores) de dependências com uma profundidade arbitrária.
+
+!!! tip "Dica"
+ Tudo isso pode não parecer muito útil com esses exemplos.
+
+ Mas você verá o quão útil isso é nos capítulos sobre **segurança**.
+
+ E você também verá a quantidade de código que você não precisara escrever.
diff --git a/docs/ru/docs/about/index.md b/docs/ru/docs/about/index.md
new file mode 100644
index 000000000..1015b667a
--- /dev/null
+++ b/docs/ru/docs/about/index.md
@@ -0,0 +1,3 @@
+# О проекте
+
+FastAPI: внутреннее устройство, повлиявшие технологии и всё такое прочее. 🤓
diff --git a/docs/ru/docs/deployment/manually.md b/docs/ru/docs/deployment/manually.md
index a24580489..0b24c0695 100644
--- a/docs/ru/docs/deployment/manually.md
+++ b/docs/ru/docs/deployment/manually.md
@@ -5,7 +5,7 @@
Существует три наиболее распространённые альтернативы:
*
Uvicorn: высокопроизводительный ASGI сервер.
-*
Hypercorn: ASGI сервер, помимо прочего поддерживающий HTTP/2 и Trio.
+*
Hypercorn: ASGI сервер, помимо прочего поддерживающий HTTP/2 и Trio.
*
Daphne: ASGI сервер, созданный для Django Channels.
## Сервер как машина и сервер как программа
@@ -46,7 +46,7 @@
=== "Hypercorn"
- *
Hypercorn, ASGI сервер, поддерживающий протокол HTTP/2.
+ *
Hypercorn, ASGI сервер, поддерживающий протокол HTTP/2.
diff --git a/docs/ru/docs/index.md b/docs/ru/docs/index.md
index 81c3835d9..d59f45031 100644
--- a/docs/ru/docs/index.md
+++ b/docs/ru/docs/index.md
@@ -36,7 +36,7 @@ hide:
---
-FastAPI — это современный, быстрый (высокопроизводительный) веб-фреймворк для создания API используя Python 3.8+, в основе которого лежит стандартная аннотация типов Python.
+FastAPI — это современный, быстрый (высокопроизводительный) веб-фреймворк для создания API используя Python, в основе которого лежит стандартная аннотация типов Python.
Ключевые особенности:
@@ -118,8 +118,6 @@ FastAPI — это современный, быстрый (высокопрои
## Зависимости
-Python 3.8+
-
FastAPI стоит на плечах гигантов:
*
Starlette для части связанной с вебом.
@@ -137,7 +135,7 @@ $ pip install fastapi
-Вам также понадобится сервер ASGI для производства, такой как
Uvicorn или
Hypercorn.
+Вам также понадобится сервер ASGI для производства, такой как
Uvicorn или
Hypercorn.
@@ -334,7 +332,7 @@ def update_item(item_id: int, item: Item):
Вам не нужно изучать новый синтаксис, методы или классы конкретной библиотеки и т. д.
-Только стандартный **Python 3.8+**.
+Только стандартный **Python**.
Например, для `int`:
diff --git a/docs/tr/docs/advanced/index.md b/docs/tr/docs/advanced/index.md
new file mode 100644
index 000000000..c0a566d12
--- /dev/null
+++ b/docs/tr/docs/advanced/index.md
@@ -0,0 +1,33 @@
+# Gelişmiş Kullanıcı Rehberi
+
+## Ek Özellikler
+
+[Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfası **FastAPI**'ın tüm ana özelliklerini tanıtmaya yetecektir.
+
+İlerleyen bölümlerde diğer seçenekler, konfigürasyonlar ve ek özellikleri göreceğiz.
+
+!!! 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.
+
+## Önce Öğreticiyi Okuyun
+
+[Tutorial - User Guide](../tutorial/index.md){.internal-link target=_blank} sayfasındaki bilgilerle **FastAPI**'nın çoğu özelliğini 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:
+
+*
Talk Python Training
+*
Test-Driven Development
diff --git a/docs/tr/docs/advanced/security/index.md b/docs/tr/docs/advanced/security/index.md
new file mode 100644
index 000000000..89a431687
--- /dev/null
+++ b/docs/tr/docs/advanced/security/index.md
@@ -0,0 +1,16 @@
+# Gelişmiş Güvenlik
+
+## Ek Özellikler
+
+[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.
+
+!!! 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.
+
+## Önce Öğreticiyi Okuyun
+
+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.
+
+Bu bölümler aynı kavramlara dayanır, ancak bazı ek işlevsellikler sağlar.
diff --git a/docs/tr/docs/advanced/testing-websockets.md b/docs/tr/docs/advanced/testing-websockets.md
new file mode 100644
index 000000000..cdd5b7ae5
--- /dev/null
+++ b/docs/tr/docs/advanced/testing-websockets.md
@@ -0,0 +1,12 @@
+# WebSockets'i Test Etmek
+
+WebSockets testi yapmak için `TestClient`'ı kullanabilirsiniz.
+
+Bu işlem için, `TestClient`'ı bir `with` ifadesinde kullanarak WebSocket'e bağlanabilirsiniz:
+
+```Python hl_lines="27-31"
+{!../../../docs_src/app_testing/tutorial002.py!}
+```
+
+!!! note "Not"
+ Daha fazla detay için Starlette'in
Websockets'i Test Etmek dokümantasyonunu inceleyin.
diff --git a/docs/tr/docs/advanced/wsgi.md b/docs/tr/docs/advanced/wsgi.md
new file mode 100644
index 000000000..54a6f20e2
--- /dev/null
+++ b/docs/tr/docs/advanced/wsgi.md
@@ -0,0 +1,37 @@
+# WSGI - Flask, Django ve Daha Fazlasını FastAPI ile Kullanma
+
+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.
+
+Bunun için `WSGIMiddleware` ile Flask, Django vb. WSGI uygulamanızı sarmalayabilir ve FastAPI'ya bağlayabilirsiniz.
+
+## `WSGIMiddleware` Kullanımı
+
+`WSGIMiddleware`'ı projenize dahil edin.
+
+Ardından WSGI (örneğin Flask) uygulamanızı middleware ile sarmalayın.
+
+Son olarak da bir yol altında bağlama işlemini gerçekleştirin.
+
+```Python hl_lines="2-3 23"
+{!../../../docs_src/wsgi/tutorial001.py!}
+```
+
+## Kontrol Edelim
+
+Artık `/v1/` yolunun altındaki her istek Flask uygulaması tarafından işlenecektir.
+
+Geri kalanı ise **FastAPI** tarafından işlenecektir.
+
+Eğer uygulamanızı çalıştırıp
http://localhost:8000/v1/ adresine giderseniz, Flask'tan gelen yanıtı göreceksiniz:
+
+```txt
+Hello, World from Flask!
+```
+
+Eğer
http://localhost:8000/v2/ adresine giderseniz, FastAPI'dan gelen yanıtı göreceksiniz:
+
+```JSON
+{
+ "message": "Hello World"
+}
+```
diff --git a/docs/tr/docs/deployment/cloud.md b/docs/tr/docs/deployment/cloud.md
new file mode 100644
index 000000000..5639567d4
--- /dev/null
+++ b/docs/tr/docs/deployment/cloud.md
@@ -0,0 +1,17 @@
+# FastAPI Uygulamasını Bulut Sağlayıcılar Üzerinde Yayınlama
+
+FastAPI uygulamasını yayınlamak için hemen hemen **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.
+
+## Bulut Sağlayıcılar - Sponsorlar
+
+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.
+
+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.
+
+Bu hizmetleri denemek ve kılavuzlarını incelemek isteyebilirsiniz:
+
+*
Platform.sh
+*
Porter
+*
Coherence
diff --git a/docs/tr/docs/deployment/index.md b/docs/tr/docs/deployment/index.md
new file mode 100644
index 000000000..e03bb4ee0
--- /dev/null
+++ b/docs/tr/docs/deployment/index.md
@@ -0,0 +1,21 @@
+# Deployment (Yayınlama)
+
+**FastAPI** uygulamasını deploy etmek oldukça kolaydır.
+
+## Deployment Ne Anlama Gelir?
+
+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 **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.
+
+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.
+
+## Deployment Stratejileri
+
+Kullanım durumunuza ve kullandığınız araçlara bağlı olarak bir kaç farklı yol izleyebilirsiniz.
+
+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.
+
+**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. ✨
diff --git a/docs/tr/docs/how-to/general.md b/docs/tr/docs/how-to/general.md
new file mode 100644
index 000000000..cbfa7beb2
--- /dev/null
+++ b/docs/tr/docs/how-to/general.md
@@ -0,0 +1,39 @@
+# Genel - Nasıl Yapılır - Tarifler
+
+Bu sayfada genel ve sıkça sorulan sorular için dokümantasyonun diğer sayfalarına yönlendirmeler bulunmaktadır.
+
+## Veri Filtreleme - Güvenlik
+
+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.
+
+## Dokümantasyon Etiketleri - 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.
+
+## Dokümantasyon Özeti ve Açıklaması - 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.
+
+## Yanıt Açıklaması Dokümantasyonu - 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.
+
+## *Yol Operasyonunu* Kullanımdan Kaldırma - 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.
+
+## Herhangi Bir Veriyi JSON Uyumlu Hale Getirme
+
+Herhangi bir veriyi JSON uyumlu hale getirmek için, [Tutorial - JSON Compatible Encoder](../tutorial/encoder.md){.internal-link target=_blank} sayfasını okuyun.
+
+## OpenAPI Meta Verileri - Dokümantasyon
+
+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.
+
+## OpenAPI Bağlantı Özelleştirme
+
+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 Dokümantasyon Bağlantıları
+
+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.
diff --git a/docs/tr/docs/index.md b/docs/tr/docs/index.md
index 67a9b4462..f7a8cf2a5 100644
--- a/docs/tr/docs/index.md
+++ b/docs/tr/docs/index.md
@@ -36,7 +36,7 @@ hide:
---
-FastAPI, Python
3.8+'nin standart
tip belirteçlerine dayalı, modern ve hızlı (yüksek performanslı) API'lar oluşturmak için kullanılabilecek web framework'tür.
+FastAPI, Python 'nin standart
tip belirteçlerine dayalı, modern ve hızlı (yüksek performanslı) API'lar oluşturmak için kullanılabilecek web framework'tür.
Temel özellikleri şunlardır:
@@ -124,8 +124,6 @@ Eğer API yerine, terminalde kullanılmak üzere bir
Starlette.
@@ -143,7 +141,7 @@ $ pip install fastapi
-Uygulamamızı kullanılabilir hale getirmek için
Uvicorn ya da
Hypercorn gibi bir ASGI sunucusuna ihtiyacımız olacak.
+Uygulamamızı kullanılabilir hale getirmek için
Uvicorn ya da
Hypercorn gibi bir ASGI sunucusuna ihtiyacımız olacak.
@@ -340,7 +338,7 @@ Bu işlemi standart modern Python tipleriyle yapıyoruz.
Yeni bir sözdizimi yapısını, bir kütüphane özel metod veya sınıfları öğrenmeye gerek yoktur.
-Hepsi sadece **Python 3.8+** standartlarına dayalıdır.
+Hepsi sadece **Python** standartlarına dayalıdır.
Örnek olarak, `int` tanımlamak için:
diff --git a/docs/tr/docs/tutorial/cookie-params.md b/docs/tr/docs/tutorial/cookie-params.md
new file mode 100644
index 000000000..4a66f26eb
--- /dev/null
+++ b/docs/tr/docs/tutorial/cookie-params.md
@@ -0,0 +1,97 @@
+# Çerez (Cookie) Parametreleri
+
+`Query` (Sorgu) ve `Path` (Yol) parametrelerini tanımladığınız şekilde çerez parametreleri tanımlayabilirsiniz.
+
+## Import `Cookie`
+
+Öncelikle, `Cookie`'yi projenize dahil edin:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/cookie_params/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/cookie_params/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/cookie_params/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "İpucu"
+ Mümkün mertebe 'Annotated' sınıfını kullanmaya çalışın.
+
+ ```Python hl_lines="1"
+ {!> ../../../docs_src/cookie_params/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "İpucu"
+ Mümkün mertebe 'Annotated' sınıfını kullanmaya çalışın.
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/cookie_params/tutorial001.py!}
+ ```
+
+## `Cookie` Parametrelerini Tanımlayın
+
+Çerez parametrelerini `Path` veya `Query` tanımlaması yapar gibi tanımlayın.
+
+İlk değer varsayılan değerdir; tüm ekstra doğrulama veya belirteç parametrelerini kullanabilirsiniz:
+
+=== "Python 3.10+"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/cookie_params/tutorial001_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/cookie_params/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="10"
+ {!> ../../../docs_src/cookie_params/tutorial001_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip "İpucu"
+ Mümkün mertebe 'Annotated' sınıfını kullanmaya çalışın.
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/cookie_params/tutorial001_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip "İpucu"
+ Mümkün mertebe 'Annotated' sınıfını kullanmaya çalışın.
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/cookie_params/tutorial001.py!}
+ ```
+
+!!! 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.
+
+ Ancak `fastapi`'dan projenize dahil ettiğiniz `Query`, `Path`, `Cookie` ve diğerleri aslında özel sınıflar döndüren birer fonksiyondur.
+
+!!! info "Bilgi"
+ Çerez tanımlamak için `Cookie` sınıfını kullanmanız gerekmektedir, aksi taktirde parametreler sorgu parametreleri olarak yorumlanır.
+
+## Özet
+
+Çerez tanımlamalarını `Cookie` sınıfını kullanarak `Query` ve `Path` tanımlar gibi tanımlayın.
diff --git a/docs/tr/docs/tutorial/request-forms.md b/docs/tr/docs/tutorial/request-forms.md
new file mode 100644
index 000000000..2728b6164
--- /dev/null
+++ b/docs/tr/docs/tutorial/request-forms.md
@@ -0,0 +1,92 @@
+# Form Verisi
+
+İstek gövdesinde JSON verisi yerine form alanlarını karşılamanız gerketiğinde `Form` sınıfını kullanabilirsiniz.
+
+!!! info "Bilgi"
+ Formları kullanmak için öncelikle
`python-multipart` paketini indirmeniz gerekmektedir.
+
+ Örneğin `pip install python-multipart`.
+
+## `Form` Sınıfını Projenize Dahil Edin
+
+`Form` sınıfını `fastapi`'den projenize dahil edin:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="3"
+ {!> ../../../docs_src/request_forms/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="1"
+ {!> ../../../docs_src/request_forms/tutorial001_an.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="1"
+ {!> ../../../docs_src/request_forms/tutorial001.py!}
+ ```
+
+## `Form` Parametrelerini Tanımlayın
+
+Form parametrelerini `Body` veya `Query` için yaptığınız gibi oluşturun:
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="9"
+ {!> ../../../docs_src/request_forms/tutorial001_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="8"
+ {!> ../../../docs_src/request_forms/tutorial001_an.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="7"
+ {!> ../../../docs_src/request_forms/tutorial001.py!}
+ ```
+
+Örneğin, OAuth2 spesifikasyonunun kullanılabileceği ("şifre akışı" olarak adlandırılan) yollardan birinde, form alanları olarak
"username" ve
"password" gönderilmesi gerekir.
+
+Bu
spesifikasyon form alanlarını adlandırırken isimlerinin birebir `username` ve `password` olmasını ve JSON verisi yerine form verisi 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.
+
+!!! info "Bilgi"
+ `Form` doğrudan `Body` sınıfını 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 Alanları" Hakkında
+
+HTML formlarının (`
`) verileri sunucuya gönderirken JSON'dan farklı özel bir kodlama kullanır.
+
+**FastAPI** bu verilerin JSON yerine doğru şekilde okunmasını sağlayacaktır.
+
+!!! note "Teknik Detaylar"
+ Form verileri normalde `application/x-www-form-urlencoded` medya tipiyle kodlanır.
+
+ 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.
+
+ Form kodlama türleri ve form alanları hakkında daha fazla bilgi edinmek istiyorsanız
MDN web docs for POST sayfasını ziyaret edebilirsiniz.
+
+!!! 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.
+
+ Bu **FastAPI**'ın getirdiği bir kısıtlama değildir, HTTP protokolünün bir parçasıdır.
+
+## Özet
+
+Form verisi girdi parametreleri tanımlamak için `Form` sınıfını kullanın.
diff --git a/docs/tr/docs/tutorial/static-files.md b/docs/tr/docs/tutorial/static-files.md
new file mode 100644
index 000000000..00c833686
--- /dev/null
+++ b/docs/tr/docs/tutorial/static-files.md
@@ -0,0 +1,39 @@
+# Statik Dosyalar
+
+`StaticFiles`'ı kullanarak statik dosyaları bir yol altında sunabilirsiniz.
+
+## `StaticFiles` Kullanımı
+
+* `StaticFiles` sınıfını projenize dahil edin.
+* Bir `StaticFiles()` örneğini belirli bir yola bağlayın.
+
+```Python hl_lines="2 6"
+{!../../../docs_src/static_files/tutorial001.py!}
+```
+
+!!! note "Teknik Detaylar"
+ Projenize dahil etmek için `from starlette.staticfiles import StaticFiles` 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.
+
+### Bağlama (Mounting) Nedir?
+
+"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.
+
+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.
+
+[Advanced User Guide](../advanced/index.md){.internal-link target=_blank} bölümünde daha fazla bilgi edinebilirsiniz.
+
+## Detaylar
+
+`"/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.
+
+`directory="static"` ifadesi, statik dosyalarınızı içeren dizinin adını belirtir.
+
+`name="static"` ifadesi, alt uygulamanın **FastAPI** tarafından kullanılacak ismini belirtir.
+
+Bu parametrelerin hepsi "`static`"den farklı olabilir, bunları kendi uygulamanızın ihtiyaçlarına göre belirleyebilirsiniz.
+
+## Daha Fazla Bilgi
+
+Daha fazla detay ve seçenek için
Starlette'in Statik Dosyalar hakkındaki dokümantasyonunu incelleyin.
diff --git a/docs/uk/docs/index.md b/docs/uk/docs/index.md
index bb21b68c2..29e19025a 100644
--- a/docs/uk/docs/index.md
+++ b/docs/uk/docs/index.md
@@ -27,7 +27,7 @@
---
-FastAPI - це сучасний, швидкий (високопродуктивний), вебфреймворк для створення API за допомогою Python 3.8+,в основі якого лежить стандартна анотація типів Python.
+FastAPI - це сучасний, швидкий (високопродуктивний), вебфреймворк для створення API за допомогою Python,в основі якого лежить стандартна анотація типів Python.
Ключові особливості:
@@ -110,8 +110,6 @@ FastAPI - це сучасний, швидкий (високопродуктив
## Вимоги
-Python 3.8+
-
FastAPI стоїть на плечах гігантів:
*
Starlette для web частини.
@@ -129,7 +127,7 @@ $ pip install fastapi
-Вам також знадобиться сервер ASGI для продакшину, наприклад
Uvicorn або
Hypercorn.
+Вам також знадобиться сервер ASGI для продакшину, наприклад
Uvicorn або
Hypercorn.
@@ -326,7 +324,7 @@ def update_item(item_id: int, item: Item):
Вам не потрібно вивчати новий синтаксис, методи чи класи конкретної бібліотеки тощо.
-Використовуючи стандартний **Python 3.8+**.
+Використовуючи стандартний **Python**.
Наприклад, для `int`:
diff --git a/docs/uk/docs/tutorial/first-steps.md b/docs/uk/docs/tutorial/first-steps.md
new file mode 100644
index 000000000..725677e42
--- /dev/null
+++ b/docs/uk/docs/tutorial/first-steps.md
@@ -0,0 +1,328 @@
+# Перші кроки
+
+Найпростіший файл FastAPI може виглядати так:
+
+```Python
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Скопіюйте це до файлу `main.py`.
+
+Запустіть сервер:
+
+
+
+```console
+$ fastapi dev main.py
+INFO Using path main.py
+INFO Resolved absolute path /home/user/code/awesomeapp/main.py
+INFO Searching for package file structure from directories with __init__.py files
+INFO Importing from /home/user/code/awesomeapp
+
+ ╭─ Python module file ─╮
+ │ │
+ │ 🐍 main.py │
+ │ │
+ ╰──────────────────────╯
+
+INFO Importing module main
+INFO Found importable FastAPI app
+
+ ╭─ Importable FastAPI app ─╮
+ │ │
+ │ from main import app │
+ │ │
+ ╰──────────────────────────╯
+
+INFO Using import string main:app
+
+ ╭────────── 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 [2265862] using WatchFiles
+INFO: Started server process [2265873]
+INFO: Waiting for application startup.
+INFO: Application startup complete.
+```
+
+
+
+У консолі буде рядок приблизно такого змісту:
+
+```hl_lines="4"
+INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
+```
+
+Цей рядок показує URL, за яким додаток запускається на вашій локальній машині.
+
+### Перевірте
+
+Відкрийте браузер та введіть адресу
http://127.0.0.1:8000.
+
+Ви побачите у відповідь таке повідомлення у форматі JSON:
+
+```JSON
+{"message": "Hello World"}
+```
+
+### Інтерактивна API документація
+
+Перейдемо сюди
http://127.0.0.1:8000/docs.
+
+Ви побачите автоматичну інтерактивну API документацію (створену завдяки
Swagger UI):
+
+
+
+### Альтернативна API документація
+
+Тепер перейдемо сюди
http://127.0.0.1:8000/redoc.
+
+Ви побачите альтернативну автоматичну документацію (створену завдяки
ReDoc):
+
+
+
+### OpenAPI
+
+**FastAPI** генерує "схему" з усім вашим API, використовуючи стандарт **OpenAPI** для визначення API.
+
+#### "Схема"
+
+"Схема" - це визначення або опис чогось. Це не код, який його реалізує, а просто абстрактний опис.
+
+#### API "схема"
+
+У цьому випадку,
OpenAPI є специфікацією, яка визначає, як описати схему вашого API.
+
+Це визначення схеми включає шляхи (paths) вашого API, можливі параметри, які вони приймають тощо.
+
+#### "Схема" даних
+
+Термін "схема" також може відноситися до структури даних, наприклад, JSON.
+
+У цьому випадку це означає - атрибути JSON і типи даних, які вони мають тощо.
+
+#### OpenAPI і JSON Schema
+
+OpenAPI описує схему для вашого API. І ця схема включає визначення (або "схеми") даних, що надсилаються та отримуються вашим API за допомогою **JSON Schema**, стандарту для схем даних JSON.
+
+#### Розглянемо `openapi.json`
+
+Якщо вас цікавить, як виглядає вихідна схема OpenAPI, то FastAPI автоматично генерує JSON-схему з усіма описами API.
+
+Ознайомитися можна за посиланням:
http://127.0.0.1:8000/openapi.json.
+
+Ви побачите приблизно такий JSON:
+
+```JSON
+{
+ "openapi": "3.1.0",
+ "info": {
+ "title": "FastAPI",
+ "version": "0.1.0"
+ },
+ "paths": {
+ "/items/": {
+ "get": {
+ "responses": {
+ "200": {
+ "description": "Successful Response",
+ "content": {
+ "application/json": {
+
+
+
+...
+```
+
+#### Для чого потрібний OpenAPI
+
+Схема OpenAPI є основою для обох систем інтерактивної документації.
+
+Існують десятки альтернативних інструментів, заснованих на OpenAPI. Ви можете легко додати будь-який з них до **FastAPI** додатку.
+
+Ви також можете використовувати OpenAPI для автоматичної генерації коду для клієнтів, які взаємодіють з API. Наприклад, для фронтенд-, мобільних або IoT-додатків
+
+## А тепер крок за кроком
+
+### Крок 1: імпортуємо `FastAPI`
+
+```Python hl_lines="1"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+`FastAPI` це клас у Python, який надає всю функціональність для API.
+
+!!! note "Технічні деталі"
+ `FastAPI` це клас, який успадковується безпосередньо від `Starlette`.
+
+ Ви також можете використовувати всю функціональність
Starlette у `FastAPI`.
+
+### Крок 2: створюємо екземпляр `FastAPI`
+
+```Python hl_lines="3"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+Змінна `app` є екземпляром класу `FastAPI`.
+
+Це буде головна точка для створення і взаємодії з API.
+
+### Крок 3: визначте операцію шляху (path operation)
+
+#### Шлях (path)
+
+"Шлях" це частина URL, яка йде одразу після символу `/`.
+
+Отже, у такому URL, як:
+
+```
+https://example.com/items/foo
+```
+
+...шлях буде:
+
+```
+/items/foo
+```
+
+!!! info "Додаткова інформація"
+ "Шлях" (path) також зазвичай називають "ендпоінтом" (endpoint) або "маршрутом" (route).
+
+При створенні API, "шлях" є основним способом розділення "завдань" і "ресурсів".
+#### Operation
+
+"Операція" (operation) тут означає один з "методів" HTTP.
+
+Один з:
+
+* `POST`
+* `GET`
+* `PUT`
+* `DELETE`
+
+...та більш екзотичних:
+
+* `OPTIONS`
+* `HEAD`
+* `PATCH`
+* `TRACE`
+
+У HTTP-протоколі можна спілкуватися з кожним шляхом, використовуючи один (або кілька) з цих "методів".
+
+---
+
+При створенні API зазвичай використовуються конкретні методи HTTP для виконання певних дій.
+
+Як правило, використовують:
+
+* `POST`: для створення даних.
+* `GET`: для читання даних.
+* `PUT`: для оновлення даних.
+* `DELETE`: для видалення даних.
+
+В OpenAPI кожен HTTP метод називається "операція".
+
+Ми також будемо дотримуватися цього терміна.
+
+#### Визначте декоратор операції шляху (path operation decorator)
+
+```Python hl_lines="6"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+Декоратор `@app.get("/")` вказує **FastAPI**, що функція нижче, відповідає за обробку запитів, які надходять до неї:
+
+* шлях `/`
+* використовуючи
get операцію
+
+!!! info "`@decorator` Додаткова інформація"
+ Синтаксис `@something` у Python називається "декоратором".
+
+ Ви розташовуєте його над функцією. Як гарний декоративний капелюх (мабуть, звідти походить термін).
+
+ "Декоратор" приймає функцію нижче і виконує з нею якусь дію.
+
+ У нашому випадку, цей декоратор повідомляє **FastAPI**, що функція нижче відповідає **шляху** `/` і **операції** `get`.
+
+ Це і є "декоратор операції шляху (path operation decorator)".
+
+Можна також використовувати операції:
+
+* `@app.post()`
+* `@app.put()`
+* `@app.delete()`
+
+І більш екзотичні:
+
+* `@app.options()`
+* `@app.head()`
+* `@app.patch()`
+* `@app.trace()`
+
+!!! tip "Порада"
+ Ви можете використовувати кожну операцію (HTTP-метод) на свій розсуд.
+
+ **FastAPI** не нав'язує жодного певного значення для кожного методу.
+
+ Наведена тут інформація є рекомендацією, а не обов'язковою вимогою.
+
+ Наприклад, під час використання GraphQL зазвичай усі дії виконуються тільки за допомогою `POST` операцій.
+
+
+### Крок 4: визначте **функцію операції шляху (path operation function)**
+
+Ось "**функція операції шляху**":
+
+* **шлях**: це `/`.
+* **операція**: це `get`.
+* **функція**: це функція, яка знаходиться нижче "декоратора" (нижче `@app.get("/")`).
+
+```Python hl_lines="7"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Це звичайна функція Python.
+
+FastAPI викликатиме її щоразу, коли отримає запит до URL із шляхом "/", використовуючи операцію `GET`.
+
+У даному випадку це асинхронна функція.
+
+---
+
+Ви також можете визначити її як звичайну функцію замість `async def`:
+
+```Python hl_lines="7"
+{!../../../docs_src/first_steps/tutorial003.py!}
+```
+
+!!! note "Примітка"
+ Якщо не знаєте в чому різниця, подивіться [Конкурентність: *"Поспішаєш?"*](../async.md#in-a-hurry){.internal-link target=_blank}.
+
+### Крок 5: поверніть результат
+
+```Python hl_lines="8"
+{!../../../docs_src/first_steps/tutorial001.py!}
+```
+
+Ви можете повернути `dict`, `list`, а також окремі значення `str`, `int`, ітд.
+
+Також можна повернути моделі Pydantic (про це ви дізнаєтесь пізніше).
+
+Існує багато інших об'єктів і моделей, які будуть автоматично конвертовані в JSON (зокрема ORM тощо). Спробуйте використати свої улюблені, велика ймовірність, що вони вже підтримуються.
+
+## Підіб'ємо підсумки
+
+* Імпортуємо `FastAPI`.
+* Створюємо екземпляр `app`.
+* Пишемо **декоратор операції шляху** як `@app.get("/")`.
+* Пишемо **функцію операції шляху**; наприклад, `def root(): ...`.
+* Запускаємо сервер у режимі розробки `fastapi dev`.
diff --git a/docs/vi/docs/index.md b/docs/vi/docs/index.md
index 652218afa..b13f91fb7 100644
--- a/docs/vi/docs/index.md
+++ b/docs/vi/docs/index.md
@@ -36,7 +36,7 @@ hide:
---
-FastAPI là một web framework hiện đại, hiệu năng cao để xây dựng web APIs với Python 3.8+ dựa trên tiêu chuẩn Python type hints.
+FastAPI là một web framework hiện đại, hiệu năng cao để xây dựng web APIs với Python dựa trên tiêu chuẩn Python type hints.
Những tính năng như:
@@ -125,8 +125,6 @@ Nếu bạn đang xây dựng một
CLIStarlette cho phần web.
@@ -341,7 +339,7 @@ Bạn định nghĩa bằng cách sử dụng các kiểu dữ liệu chuẩn c
Bạn không phải học một cú pháp mới, các phương thức và class của một thư viện cụ thể nào.
-Chỉ cần sử dụng các chuẩn của **Python 3.8+**.
+Chỉ cần sử dụng các chuẩn của **Python**.
Ví dụ, với một tham số kiểu `int`:
diff --git a/docs/yo/docs/index.md b/docs/yo/docs/index.md
index 352bf4df8..9bd21c4b9 100644
--- a/docs/yo/docs/index.md
+++ b/docs/yo/docs/index.md
@@ -36,7 +36,7 @@ hide:
---
-FastAPI jẹ́ ìgbàlódé, tí ó yára (iṣẹ-giga), ìlànà wẹ́ẹ́bù fún kikọ àwọn API pẹ̀lú Python 3.8+ èyí tí ó da lori àwọn ìtọ́kasí àmì irúfẹ́ Python.
+FastAPI jẹ́ ìgbàlódé, tí ó yára (iṣẹ-giga), ìlànà wẹ́ẹ́bù fún kikọ àwọn API pẹ̀lú Python èyí tí ó da lori àwọn ìtọ́kasí àmì irúfẹ́ Python.
Àwọn ẹya pàtàkì ni:
@@ -124,8 +124,6 @@ Ti o ba n kọ ohun èlò CLI láti
## Èròjà
-Python 3.8+
-
FastAPI dúró lórí àwọn èjìká tí àwọn òmíràn:
* Starlette fún àwọn ẹ̀yà ayélujára.
@@ -340,7 +338,7 @@ O ṣe ìyẹn pẹ̀lú irúfẹ́ àmì ìtọ́kasí ìgbàlódé Python.
O ò nílò láti kọ́ síńtáàsì tuntun, ìlànà tàbí ọ̀wọ́ kíláàsì kan pàtó, abbl (i.e. àti bẹbẹ lọ).
-Ìtọ́kasí **Python 3.8+**
+Ìtọ́kasí **Python**
Fún àpẹẹrẹ, fún `int`:
diff --git a/docs/zh-hant/docs/benchmarks.md b/docs/zh-hant/docs/benchmarks.md
new file mode 100644
index 000000000..cbd5a6cde
--- /dev/null
+++ b/docs/zh-hant/docs/benchmarks.md
@@ -0,0 +1,34 @@
+# 基準測試
+
+由第三方機構 TechEmpower 的基準測試表明在 Uvicorn 下運行的 **FastAPI** 應用程式是 最快的 Python 可用框架之一，僅次於 Starlette 和 Uvicorn 本身（於 FastAPI 內部使用）。
+
+但是在查看基準得分和對比時，請注意以下幾點。
+
+## 基準測試和速度
+
+當你查看基準測試時，時常會見到幾個不同類型的工具被同時進行測試。
+
+具體來說，是將 Uvicorn、Starlette 和 FastAPI 同時進行比較（以及許多其他工具）。
+
+該工具解決的問題越簡單，其效能就越好。而且大多數基準測試不會測試該工具提供的附加功能。
+
+層次結構如下：
+
+* **Uvicorn**：ASGI 伺服器
+ * **Starlette**：（使用 Uvicorn）一個網頁微框架
+ * **FastAPI**：（使用 Starlette）一個 API 微框架，具有用於建立 API 的多個附加功能、資料驗證等。
+
+* **Uvicorn**：
+ * 具有最佳效能，因為除了伺服器本身之外，它沒有太多額外的程式碼。
+ * 你不會直接在 Uvicorn 中編寫應用程式。這意味著你的程式碼必須或多或少地包含 Starlette（或 **FastAPI**）提供的所有程式碼。如果你這樣做，你的最終應用程式將具有與使用框架相同的開銷並最大限度地減少應用程式程式碼和錯誤。
+ * 如果你要比較 Uvicorn，請將其與 Daphne、Hypercorn、uWSGI 等應用程式伺服器進行比較。
+* **Starlette**：
+ * 繼 Uvicorn 之後的次佳表現。事實上，Starlette 使用 Uvicorn 來運行。因此它將可能只透過執行更多程式碼而變得比 Uvicorn「慢」。
+ * 但它為你提供了建立簡單網頁應用程式的工具，以及基於路徑的路由等。
+ * 如果你要比較 Starlette，請將其與 Sanic、Flask、Django 等網頁框架（或微框架）進行比較。
+* **FastAPI**：
+ * 就像 Starlette 使用 Uvicorn 並不能比它更快一樣， **FastAPI** 使用 Starlette，所以它不能比它更快。
+ * FastAPI 在 Starlette 基礎之上提供了更多功能。包含建構 API 時所需要的功能，例如資料驗證和序列化。FastAPI 可以幫助你自動產生 API 文件，（應用程式啟動時將會自動生成文件，所以不會增加應用程式運行時的開銷）。
+ * 如果你沒有使用 FastAPI 而是直接使用 Starlette（或其他工具，如 Sanic、Flask、Responder 等），你將必須自行實現所有資料驗證和序列化。因此，你的最終應用程式仍然具有與使用 FastAPI 建置相同的開銷。在許多情況下，這種資料驗證和序列化是應用程式中編寫最大量的程式碼。
+ * 因此透過使用 FastAPI，你可以節省開發時間、錯誤與程式碼數量，並且相比不使用 FastAPI 你很大可能會獲得相同或更好的效能（因為那樣你必須在程式碼中實現所有相同的功能）。
+ * 如果你要與 FastAPI 比較，請將其與能夠提供資料驗證、序列化和文件的網頁應用程式框架（或工具集）進行比較，例如 Flask-apispec、NestJS、Molten 等框架。
diff --git a/docs/zh-hant/docs/fastapi-people.md b/docs/zh-hant/docs/fastapi-people.md
new file mode 100644
index 000000000..0bc00f9c6
--- /dev/null
+++ b/docs/zh-hant/docs/fastapi-people.md
@@ -0,0 +1,236 @@
+---
+hide:
+ - navigation
+---
+
+# FastAPI 社群
+
+FastAPI 有一個非常棒的社群，歡迎來自不同背景的朋友參與。
+
+## 作者
+
+嘿! 👋
+
+關於我:
+
+{% if people %}
+
+{% for user in people.maintainers %}
+
+
+{% endfor %}
+
+
+{% for user in people.last_month_experts[:10] %}
+
+
+{% endfor %}
+
+
+{% for user in people.three_months_experts[:10] %}
+
+
+{% endfor %}
+
+
+{% for user in people.six_months_experts[:10] %}
+
+
+{% endfor %}
+
+
+{% for user in people.one_year_experts[:20] %}
+
+
+{% endfor %}
+
+
+{% for user in people.experts[:50] %}
+
+
+{% endfor %}
+
+
+{% for user in people.top_contributors[:50] %}
+
+
+{% endfor %}
+
+
+{% for user in people.top_translations_reviewers[:50] %}
+
+
+{% endfor %}
+
+
+{% endfor %}
+{% endif %}
+
+{% if sponsors.silver %}
+
+### 銀牌贊助商
+
+{% for sponsor in sponsors.silver -%}
+
+{% endfor %}
+{% endif %}
+
+{% if sponsors.bronze %}
+
+### 銅牌贊助商
+
+{% for sponsor in sponsors.bronze -%}
+
+{% endfor %}
+{% endif %}
+
+{% endif %}
+
+### 個人贊助商
+
+{% if github_sponsors %}
+{% for group in github_sponsors.sponsors %}
+
+
+
+{% for user in group %}
+{% if user.login not in sponsors_badge.logins %}
+
+
+
+{% endif %}
+{% endfor %}
+
+
-如需使用静态文件，还要安装 `aiofiles`：
-
-
-
-```console
-$ pip install aiofiles
-
----> 100%
-```
-
-
-
## 使用 `Jinja2Templates`
* 导入 `Jinja2Templates`
* 创建可复用的 `templates` 对象
* 在返回模板的*路径操作*中声明 `Request` 参数
-* 使用 `templates` 渲染并返回 `TemplateResponse`， 以键值对方式在 Jinja2 的 **context** 中传递 `request`
+* 使用 `templates` 渲染并返回 `TemplateResponse`， 传递模板的名称、request对象以及一个包含多个键值对（用于Jinja2模板）的"context"字典，
```Python hl_lines="4 11 15-16"
{!../../../docs_src/templates/tutorial001.py!}
@@ -45,7 +33,8 @@ $ pip install aiofiles
!!! note "笔记"
- 注意，必须为 Jinja2 以键值对方式在上下文中传递 `request`。因此，还要在*路径操作*中声明。
+ 在FastAPI 0.108.0，Starlette 0.29.0之前，`name`是第一个参数。
+ 并且，在此之前，`request`对象是作为context的一部分以键值对的形式传递的。
!!! tip "提示"
@@ -65,30 +54,68 @@ $ pip install aiofiles
{!../../../docs_src/templates/templates/item.html!}
```
-它会显示从 **context** 字典中提取的 `id`：
+### 模板上下文
+
+在包含如下语句的html中:
+
+{% raw %}
+
+```jinja
+Item ID: {{ id }}
+```
+
+{% endraw %}
+
+...这将显示你从"context"字典传递的 `id`:
```Python
-{"request": request, "id": id}
+{"id": id}
+```
+
+例如。当ID为 `42`时, 会渲染成:
+
+```html
+Item ID: 42
+```
+
+### 模板 `url_for` 参数
+
+你还可以在模板内使用 `url_for()`，其参数与*路径操作函数*的参数相同.
+
+所以，该部分:
+
+{% raw %}
+
+```jinja
+
+```
+
+{% endraw %}
+
+...将生成一个与处理*路径操作函数* `read_item(id=id)`的URL相同的链接
+
+例如。当ID为 `42`时, 会渲染成:
+
+```html
+
```
## 模板与静态文件
-在模板内部使用 `url_for()`，例如，与挂载的 `StaticFiles` 一起使用。
+你还可以在模板内部将 `url_for()`用于静态文件，例如你挂载的 `name="static"`的 `StaticFiles`。
```jinja hl_lines="4"
{!../../../docs_src/templates/templates/item.html!}
```
-本例中，使用 `url_for()` 为模板添加 CSS 文件 `static/styles.css` 链接：
+本例中，它将链接到 `static/styles.css`中的CSS文件：
```CSS hl_lines="4"
{!../../../docs_src/templates/static/styles.css!}
```
-因为使用了 `StaticFiles`， **FastAPI** 应用自动提供位于 URL `/static/styles.css`
-
-的 CSS 文件。
+因为使用了 `StaticFiles`， **FastAPI** 应用会自动提供位于 URL `/static/styles.css`的 CSS 文件。
## 更多说明
-包括测试模板等更多详情，请参阅 Starlette 官档 - 模板。
+包括测试模板等更多详情，请参阅
Starlette 官方文档 - 模板。
diff --git a/docs/zh/docs/deployment/manually.md b/docs/zh/docs/deployment/manually.md
index 15588043f..ca7142613 100644
--- a/docs/zh/docs/deployment/manually.md
+++ b/docs/zh/docs/deployment/manually.md
@@ -5,7 +5,7 @@
有 3 个主要可选方案：
*
Uvicorn：高性能 ASGI 服务器。
-*
Hypercorn：与 HTTP/2 和 Trio 等兼容的 ASGI 服务器。
+*
Hypercorn：与 HTTP/2 和 Trio 等兼容的 ASGI 服务器。
*
Daphne：为 Django Channels 构建的 ASGI 服务器。
## 服务器主机和服务器程序
@@ -44,7 +44,7 @@
=== "Hypercorn"
- *
Hypercorn，一个也与 HTTP/2 兼容的 ASGI 服务器。
+ *
Hypercorn，一个也与 HTTP/2 兼容的 ASGI 服务器。
diff --git a/docs/zh/docs/fastapi-cli.md b/docs/zh/docs/fastapi-cli.md
new file mode 100644
index 000000000..dd3914921
--- /dev/null
+++ b/docs/zh/docs/fastapi-cli.md
@@ -0,0 +1,84 @@
+# FastAPI CLI
+
+**FastAPI CLI** 是一个命令行程序，你可以用它来部署和运行你的 FastAPI 应用程序，管理你的 FastAPI 项目，等等。
+
+当你安装 FastAPI 时（例如使用 `pip install FastAPI` 命令），会包含一个名为 `fastapi-cli` 的软件包，该软件包在终端中提供 `fastapi` 命令。
+
+要在开发环境中运行你的 FastAPI 应用，你可以使用 `fastapi dev` 命令：
+
+
+
+```console
+$ fastapi dev main.py
+INFO Using path main.py
+INFO Resolved absolute path /home/user/code/awesomeapp/main.py
+INFO Searching for package file structure from directories with __init__.py files
+INFO Importing from /home/user/code/awesomeapp
+
+ ╭─ Python module file ─╮
+ │ │
+ │ 🐍 main.py │
+ │ │
+ ╰──────────────────────╯
+
+INFO Importing module main
+INFO Found importable FastAPI app
+
+ ╭─ Importable FastAPI app ─╮
+ │ │
+ │ from main import app │
+ │ │
+ ╰──────────────────────────╯
+
+INFO Using import string main:app
+
+ ╭────────── 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 [2265862] using WatchFiles
+INFO: Started server process [2265873]
+INFO: Waiting for application startup.
+INFO: Application startup complete.
+```
+
+
+
+该命令行程序 `fastapi` 就是 **FastAPI CLI**。
+
+FastAPI CLI 接收你的 Python 程序路径，自动检测包含 FastAPI 的变量（通常命名为 `app`）及其导入方式，然后启动服务。
+
+在生产环境中，你应该使用 `fastapi run` 命令。🚀
+
+在内部，**FastAPI CLI** 使用了
Uvicorn，这是一个高性能、适用于生产环境的 ASGI 服务器。😎
+
+## `fastapi dev`
+
+当你运行 `fastapi dev` 时，它将以开发模式运行。
+
+默认情况下，它会启用**自动重载**，因此当你更改代码时，它会自动重新加载服务器。该功能是资源密集型的，且相较不启用时更不稳定，因此你应该仅在开发环境下使用它。
+
+默认情况下，它将监听 IP 地址 `127.0.0.1`，这是你的机器与自身通信的 IP 地址（`localhost`）。
+
+## `fastapi run`
+
+当你运行 `fastapi run` 时，它默认以生产环境模式运行。
+
+默认情况下，**自动重载是禁用的**。
+
+它将监听 IP 地址 `0.0.0.0`，即所有可用的 IP 地址，这样任何能够与该机器通信的人都可以公开访问它。这通常是你在生产环境中运行它的方式，例如在容器中运行。
+
+在大多数情况下，你会（且应该）有一个“终止代理”在上层为你处理 HTTPS，这取决于你如何部署应用程序，你的服务提供商可能会为你处理此事，或者你可能需要自己设置。
+
+!!! tip "提示"
+ 你可以在 [deployment documentation](deployment/index.md){.internal-link target=_blank} 获得更多信息。
diff --git a/docs/zh/docs/fastapi-people.md b/docs/zh/docs/fastapi-people.md
index 6cf35253c..d6a3e66c3 100644
--- a/docs/zh/docs/fastapi-people.md
+++ b/docs/zh/docs/fastapi-people.md
@@ -33,39 +33,98 @@ FastAPI 有一个非常棒的社区，它欢迎来自各个领域和背景的朋
这些人：
-* [帮助他人解决 GitHub 的 issues](help-fastapi.md#github_1){.internal-link target=_blank}。
+* [帮助他人解决 GitHub 上的问题](help-fastapi.md#github_1){.internal-link target=_blank}。
* [创建 Pull Requests](help-fastapi.md#pr){.internal-link target=_blank}。
* 审核 Pull Requests， 对于 [翻译](contributing.md#_8){.internal-link target=_blank} 尤为重要。
向他们致以掌声。 👏 🙇
-## 上个月最活跃的用户
+## FastAPI 专家
-上个月这些用户致力于 [帮助他人解决 GitHub 的 issues](help-fastapi.md#github_1){.internal-link target=_blank}。
+这些用户一直以来致力于 [帮助他人解决 GitHub 上的问题](help-fastapi.md#github_1){.internal-link target=_blank}。 🙇
+
+他们通过帮助许多人而被证明是 **FastAPI 专家**。 ✨
+
+!!! 小提示
+ 你也可以成为认可的 FastAPI 专家！
+
+ 只需要 [帮助他人解决 GitHub 上的问题](help-fastapi.md#github_1){.internal-link target=_blank}。 🤓
+
+你可以查看不同时期的 **FastAPI 专家**：
+
+* [上个月](#fastapi-experts-last-month) 🤓
+* [三个月](#fastapi-experts-3-months) 😎
+* [六个月](#fastapi-experts-6-months) 🧐
+* [一年](#fastapi-experts-1-year) 🧑🔬
+* [**全部时间**](#fastapi-experts-all-time) 🧙
+
+## FastAPI 专家 - 上个月
+
+这些是在过去一个月中 [在 GitHub 上帮助他人解答最多问题](help-fastapi.md#github_1){.internal-link target=_blank} 的用户。 🤓
{% if people %}
{% for user in people.last_month_experts[:10] %}
-
+
+{% endfor %}
+
+
+{% endif %}
+
+### FastAPI 专家 - 三个月
+
+这些是在过去三个月中 [在 GitHub 上帮助他人解答最多问题](help-fastapi.md#github_1){.internal-link target=_blank} 的用户。 😎
+
+{% if people %}
+
+{% for user in people.three_months_experts[:10] %}
+
+
+{% endfor %}
+
+
+{% endif %}
+
+### FastAPI 专家 - 六个月
+
+这些是在过去六个月中 [在 GitHub 上帮助他人解答最多问题](help-fastapi.md#github_1){.internal-link target=_blank} 的用户。 🧐
+
+{% if people %}
+
+{% for user in people.six_months_experts[:10] %}
+
+
{% endfor %}
{% endif %}
-## 专家组
+### FastAPI 专家 - 一年
+
+这些是在过去一年中 [在 GitHub 上帮助他人解答最多问题](help-fastapi.md#github_1){.internal-link target=_blank} 的用户。 🧑🔬
+
+{% if people %}
+
+{% for user in people.one_year_experts[:20] %}
+
+
+{% endfor %}
+
+
+{% endif %}
-以下是 **FastAPI 专家**。 🤓
+## FastAPI 专家 - 全部时间
-这些用户一直以来致力于 [帮助他人解决 GitHub 的 issues](help-fastapi.md#github_1){.internal-link target=_blank}。
+以下是全部时间的 **FastAPI 专家**。 🤓🤯
-他们通过帮助许多人而被证明是专家。✨
+这些用户一直以来致力于 [帮助他人解决 GitHub 的 上的问题](help-fastapi.md#github_1){.internal-link target=_blank}。 🧙
{% if people %}
{% for user in people.experts[:50] %}
-
+
{% endfor %}
@@ -89,25 +148,19 @@ FastAPI 有一个非常棒的社区，它欢迎来自各个领域和背景的朋
{% endif %}
-还有很多其他贡献者（超过100个），你可以在
FastAPI GitHub 贡献者页面 中看到他们。👷
-
-## 杰出审核者
-
-以下用户是「杰出的评审者」。 🕵️
+还有很多别的贡献者（超过100个），你可以在
FastAPI GitHub 贡献者页面 中看到他们。👷
-### 翻译审核
+## 杰出翻译审核者
-我只会说少数几种语言（而且还不是很流利 😅）。所以，具备[能力去批准文档翻译](contributing.md#_8){.internal-link target=_blank} 是这些评审者们。如果没有它们，就不会有多语言文档。
-
----
+以下用户是 **杰出的评审者**。 🕵️
-**杰出的评审者** 🕵️ 评审了最多来自他人的 Pull Requests，他们保证了代码、文档尤其是 **翻译** 的质量。
+我只会说少数几种语言（而且还不是很流利 😅）。所以这些评审者们具备[能力去批准文档翻译](contributing.md#_8){.internal-link target=_blank}。如果没有他们，就不会有多语言文档。
{% if people %}
{% for user in people.top_translations_reviewers[:50] %}
-
+
{% endfor %}
diff --git a/docs/zh/docs/how-to/configure-swagger-ui.md b/docs/zh/docs/how-to/configure-swagger-ui.md
new file mode 100644
index 000000000..c0d09f943
--- /dev/null
+++ b/docs/zh/docs/how-to/configure-swagger-ui.md
@@ -0,0 +1,78 @@
+# 配置 Swagger UI
+
+你可以配置一些额外的
Swagger UI 参数.
+
+如果需要配置它们，可以在创建 `FastAPI()` 应用对象时或调用 `get_swagger_ui_html()` 函数时传递 `swagger_ui_parameters` 参数。
+
+`swagger_ui_parameters` 接受一个直接传递给 Swagger UI的字典，包含配置参数键值对。
+
+FastAPI会将这些配置转换为 **JSON**，使其与 JavaScript 兼容，因为这是 Swagger UI 需要的。
+
+## 不使用语法高亮
+
+比如，你可以禁用 Swagger UI 中的语法高亮。
+
+当没有改变设置时，语法高亮默认启用：
+
+
+
+但是你可以通过设置 `syntaxHighlight` 为 `False` 来禁用 Swagger UI 中的语法高亮：
+
+```Python hl_lines="3"
+{!../../../docs_src/configure_swagger_ui/tutorial001.py!}
+```
+
+...在此之后，Swagger UI 将不会高亮代码:
+
+
+
+## 改变主题
+
+同样地，你也可以通过设置键 `"syntaxHighlight.theme"` 来设置语法高亮主题（注意中间有一个点）：
+
+```Python hl_lines="3"
+{!../../../docs_src/configure_swagger_ui/tutorial002.py!}
+```
+
+这个配置会改变语法高亮主题：
+
+
+
+## 改变默认 Swagger UI 参数
+
+FastAPI 包含了一些默认配置参数，适用于大多数用例。
+
+其包括这些默认配置参数：
+
+```Python
+{!../../../fastapi/openapi/docs.py[ln:7-23]!}
+```
+
+你可以通过在 `swagger_ui_parameters` 中设置不同的值来覆盖它们。
+
+比如，如果要禁用 `deepLinking`，你可以像这样传递设置到 `swagger_ui_parameters` 中：
+
+```Python hl_lines="3"
+{!../../../docs_src/configure_swagger_ui/tutorial003.py!}
+```
+
+## 其他 Swagger UI 参数
+
+查看其他 Swagger UI 参数，请阅读
docs for Swagger UI parameters。
+
+## JavaScript-only 配置
+
+Swagger UI 同样允许使用 **JavaScript-only** 配置对象（例如，JavaScript 函数）。
+
+FastAPI 包含这些 JavaScript-only 的 `presets` 设置：
+
+```JavaScript
+presets: [
+ SwaggerUIBundle.presets.apis,
+ SwaggerUIBundle.SwaggerUIStandalonePreset
+]
+```
+
+这些是 **JavaScript** 对象，而不是字符串，所以你不能直接从 Python 代码中传递它们。
+
+如果你需要像这样使用 JavaScript-only 配置，你可以使用上述方法之一。覆盖所有 Swagger UI *path operation* 并手动编写任何你需要的 JavaScript。
diff --git a/docs/zh/docs/index.md b/docs/zh/docs/index.md
index 2a67e8d08..f03a0dd13 100644
--- a/docs/zh/docs/index.md
+++ b/docs/zh/docs/index.md
@@ -36,7 +36,7 @@ hide:
---
-FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用 Python 3.8+ 并基于标准的 Python 类型提示。
+FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用 Python 并基于标准的 Python 类型提示。
关键特性:
@@ -119,7 +119,7 @@ FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框
## 依赖
-Python 3.8 及更高版本
+Python 及更高版本
FastAPI 站在以下巨人的肩膀之上：
@@ -138,7 +138,7 @@ $ pip install fastapi
-你还会需要一个 ASGI 服务器，生产环境可以使用
Uvicorn 或者
Hypercorn。
+你还会需要一个 ASGI 服务器，生产环境可以使用
Uvicorn 或者
Hypercorn。
@@ -335,7 +335,7 @@ def update_item(item_id: int, item: Item):
你不需要去学习新的语法、了解特定库的方法或类，等等。
-只需要使用标准的 **Python 3.8 及更高版本**。
+只需要使用标准的 **Python 及更高版本**。
举个例子，比如声明 `int` 类型：
diff --git a/docs/zh/docs/tutorial/security/oauth2-jwt.md b/docs/zh/docs/tutorial/security/oauth2-jwt.md
index 33a4d7fc7..117f74d3e 100644
--- a/docs/zh/docs/tutorial/security/oauth2-jwt.md
+++ b/docs/zh/docs/tutorial/security/oauth2-jwt.md
@@ -26,29 +26,25 @@ JWT 字符串没有加密，任何人都能用它恢复原始信息。
如需深入了解 JWT 令牌，了解它的工作方式，请参阅
https://jwt.io。
-## 安装 `python-jose`
+## 安装 `PyJWT`
-安装 `python-jose`，在 Python 中生成和校验 JWT 令牌：
+安装 `PyJWT`，在 Python 中生成和校验 JWT 令牌：
```console
-$ pip install python-jose[cryptography]
+$ pip install pyjwt
---> 100%
```
-
Python-jose 需要安装配套的加密后端。
+!!! info "说明"
-本教程推荐的后端是：
pyca/cryptography。
+ 如果您打算使用类似 RSA 或 ECDSA 的数字签名算法，您应该安装加密库依赖项 `pyjwt[crypto]`。
-!!! tip "提示"
-
- 本教程以前使用
PyJWT。
-
- 但后来换成了 Python-jose，因为 Python-jose 支持 PyJWT 的所有功能，还支持与其它工具集成时可能会用到的一些其它功能。
+ 您可以在
PyJWT Installation docs 获得更多信息。
## 密码哈希
@@ -62,7 +58,7 @@ $ pip install python-jose[cryptography]
原因很简单，假如数据库被盗，窃贼无法获取用户的明文密码，得到的只是哈希值。
-这样一来，窃贼就无法在其它应用中使用窃取的密码，要知道，很多用户在所有系统中都使用相同的密码，风险超大）。
+这样一来，窃贼就无法在其它应用中使用窃取的密码（要知道，很多用户在所有系统中都使用相同的密码，风险超大）。
## 安装 `passlib`
@@ -112,9 +108,41 @@ $ pip install passlib[bcrypt]
第三个函数用于身份验证，并返回用户。
-```Python hl_lines="7 48 55-56 59-60 69-75"
-{!../../../docs_src/security/tutorial004.py!}
-```
+=== "Python 3.10+"
+
+ ```Python hl_lines="8 49 56-57 60-61 70-76"
+ {!> ../../../docs_src/security/tutorial004_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="8 49 56-57 60-61 70-76"
+ {!> ../../../docs_src/security/tutorial004_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="8 50 57-58 61-62 71-77"
+ {!> ../../../docs_src/security/tutorial004_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="7 48 55-56 59-60 69-75"
+ {!> ../../../docs_src/security/tutorial004_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="8 49 56-57 60-61 70-76"
+ {!> ../../../docs_src/security/tutorial004.py!}
+ ```
!!! note "笔记"
@@ -160,9 +188,41 @@ $ openssl rand -hex 32
如果令牌无效，则直接返回 HTTP 错误。
-```Python hl_lines="89-106"
-{!../../../docs_src/security/tutorial004.py!}
-```
+=== "Python 3.10+"
+
+ ```Python hl_lines="4 7 13-15 29-31 79-87"
+ {!> ../../../docs_src/security/tutorial004_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="4 7 13-15 29-31 79-87"
+ {!> ../../../docs_src/security/tutorial004_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="4 7 14-16 30-32 80-88"
+ {!> ../../../docs_src/security/tutorial004_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="3 6 12-14 28-30 78-86"
+ {!> ../../../docs_src/security/tutorial004_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="4 7 13-15 29-31 79-87"
+ {!> ../../../docs_src/security/tutorial004.py!}
+ ```
## 更新 `/token` *路径操作*
@@ -170,9 +230,41 @@ $ openssl rand -hex 32
创建并返回真正的 JWT 访问令牌。
-```Python hl_lines="115-130"
-{!../../../docs_src/security/tutorial004.py!}
-```
+=== "Python 3.10+"
+
+ ```Python hl_lines="118-133"
+ {!> ../../../docs_src/security/tutorial004_an_py310.py!}
+ ```
+
+=== "Python 3.9+"
+
+ ```Python hl_lines="118-133"
+ {!> ../../../docs_src/security/tutorial004_an_py39.py!}
+ ```
+
+=== "Python 3.8+"
+
+ ```Python hl_lines="119-134"
+ {!> ../../../docs_src/security/tutorial004_an.py!}
+ ```
+
+=== "Python 3.10+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="115-130"
+ {!> ../../../docs_src/security/tutorial004_py310.py!}
+ ```
+
+=== "Python 3.8+ non-Annotated"
+
+ !!! tip
+ Prefer to use the `Annotated` version if possible.
+
+ ```Python hl_lines="116-131"
+ {!> ../../../docs_src/security/tutorial004.py!}
+ ```
### JWT `sub` 的技术细节
@@ -261,7 +353,7 @@ OAuth2 支持**`scopes`**（作用域）。
开发者可以灵活选择最适合项目的安全机制。
-还可以直接使用 `passlib` 和 `python-jose` 等维护良好、使用广泛的包，这是因为 **FastAPI** 不需要任何复杂机制，就能集成外部的包。
+还可以直接使用 `passlib` 和 `PyJWT` 等维护良好、使用广泛的包，这是因为 **FastAPI** 不需要任何复杂机制，就能集成外部的包。
而且，**FastAPI** 还提供了一些工具，在不影响灵活、稳定和安全的前提下，尽可能地简化安全机制。
diff --git a/docs/zh/docs/tutorial/sql-databases.md b/docs/zh/docs/tutorial/sql-databases.md
index be0c76593..8629b23fa 100644
--- a/docs/zh/docs/tutorial/sql-databases.md
+++ b/docs/zh/docs/tutorial/sql-databases.md
@@ -1,12 +1,19 @@
# SQL (关系型) 数据库
+!!! info
+ 这些文档即将被更新。🎉
+
+ 当前版本假设Pydantic v1和SQLAlchemy版本小于2。
+
+ 新的文档将包括Pydantic v2以及
SQLModel（也是基于SQLAlchemy），一旦SQLModel更新为为使用Pydantic v2。
+
**FastAPI**不需要你使用SQL(关系型)数据库。
但是您可以使用任何您想要的关系型数据库。
在这里，让我们看一个使用着[SQLAlchemy](https://www.sqlalchemy.org/)的示例。
-您可以很容易地将SQLAlchemy支持任何数据库，像：
+您可以很容易地将其调整为任何SQLAlchemy支持的数据库，如：
* PostgreSQL
* MySQL
@@ -74,13 +81,13 @@ ORM 具有在代码和数据库表（“*关系型”）中的**对象**之间
└── schemas.py
```
-该文件`__init__.py`只是一个空文件，但它告诉 Python 其中`sql_app`的所有模块（Python 文件）都是一个包。
+该文件`__init__.py`只是一个空文件，但它告诉 Python `sql_app` 是一个包。
现在让我们看看每个文件/模块的作用。
## 安装 SQLAlchemy
-先下载`SQLAlchemy`所需要的依赖：
+首先你需要安装`SQLAlchemy`:
@@ -152,17 +159,17 @@ connect_args={"check_same_thread": False}
这是为了防止意外地为不同的事物（不同的请求）共享相同的连接。
- 但是在 FastAPI 中，普遍使用def函数，多个线程可以为同一个请求与数据库交互，所以我们需要使用`connect_args={"check_same_thread": False}`来让SQLite允许这样。
+ 但是在 FastAPI 中，使用普通函数（def）时，多个线程可以为同一个请求与数据库交互，所以我们需要使用`connect_args={"check_same_thread": False}`来让SQLite允许这样。
此外，我们将确保每个请求都在依赖项中获得自己的数据库连接会话，因此不需要该默认机制。
### 创建一个`SessionLocal`类
-每个实例`SessionLocal`都会是一个数据库会话。当然该类本身还不是数据库会话。
+每个`SessionLocal`类的实例都会是一个数据库会话。当然该类本身还不是数据库会话。
但是一旦我们创建了一个`SessionLocal`类的实例，这个实例将是实际的数据库会话。
-我们命名它是`SessionLocal`为了将它与我们从 SQLAlchemy 导入的`Session`区别开来。
+我们将它命名为`SessionLocal`是为了将它与我们从 SQLAlchemy 导入的`Session`区别开来。
稍后我们将使用`Session`（从 SQLAlchemy 导入的那个）。
@@ -176,7 +183,7 @@ connect_args={"check_same_thread": False}
现在我们将使用`declarative_base()`返回一个类。
-稍后我们将用这个类继承，来创建每个数据库模型或类（ORM 模型）：
+稍后我们将继承这个类，来创建每个数据库模型或类（ORM 模型）：
```Python hl_lines="13"
{!../../../docs_src/sql_databases/sql_app/database.py!}
@@ -209,7 +216,7 @@ connect_args={"check_same_thread": False}
### 创建模型属性/列
-现在创建所有模型（类）属性。
+现在创建所有模型（类）的属性。
这些属性中的每一个都代表其相应数据库表中的一列。
@@ -252,13 +259,13 @@ connect_args={"check_same_thread": False}
### 创建初始 Pydantic*模型*/模式
-创建一个`ItemBase`和`UserBase`Pydantic*模型*（或者我们说“schema”）以及在创建或读取数据时具有共同的属性。
+创建一个`ItemBase`和`UserBase`Pydantic*模型*（或者我们说“schema”），他们拥有创建或读取数据时具有的共同属性。
-`ItemCreate`为 创建一个`UserCreate`继承自它们的所有属性（因此它们将具有相同的属性），以及创建所需的任何其他数据（属性）。
+然后创建一个继承自他们的`ItemCreate`和`UserCreate`，并添加创建时所需的其他数据（或属性）。
因此在创建时也应当有一个`password`属性。
-但是为了安全起见，`password`不会出现在其他同类 Pydantic*模型*中，例如用户请求时不应该从 API 返回响应中包含它。
+但是为了安全起见，`password`不会出现在其他同类 Pydantic*模型*中，例如通过API读取一个用户数据时，它不应当包含在内。
=== "Python 3.10+"
@@ -368,7 +375,7 @@ Pydantic`orm_mode`将告诉 Pydantic*模型*读取数据，即它不是一个`di
id = data["id"]
```
-尝试从属性中获取它，如：
+它还会尝试从属性中获取它，如：
```Python
id = data.id
@@ -404,7 +411,7 @@ current_user.items
在这个文件中，我们将编写可重用的函数用来与数据库中的数据进行交互。
-**CRUD**分别为：**增加**、**查询**、**更改**和**删除**，即增删改查。
+**CRUD**分别为：增加（**C**reate）、查询（**R**ead）、更改（**U**pdate）、删除（**D**elete），即增删改查。
...虽然在这个例子中我们只是新增和查询。
@@ -414,7 +421,7 @@ current_user.items
导入之前的`models`（SQLAlchemy 模型）和`schemas`（Pydantic*模型*/模式）。
-创建一些实用函数来完成：
+创建一些工具函数来完成：
* 通过 ID 和电子邮件查询单个用户。
* 查询多个用户。
@@ -429,14 +436,14 @@ current_user.items
### 创建数据
-现在创建实用程序函数来创建数据。
+现在创建工具函数来创建数据。
它的步骤是：
* 使用您的数据创建一个 SQLAlchemy 模型*实例。*
-* 使用`add`来将该实例对象添加到您的数据库。
-* 使用`commit`来对数据库的事务提交（以便保存它们）。
-* 使用`refresh`来刷新您的数据库实例（以便它包含来自数据库的任何新数据，例如生成的 ID）。
+* 使用`add`来将该实例对象添加到数据库会话。
+* 使用`commit`来将更改提交到数据库（以便保存它们）。
+* 使用`refresh`来刷新您的实例对象（以便它包含来自数据库的任何新数据，例如生成的 ID）。
```Python hl_lines="18-24 31-36"
{!../../../docs_src/sql_databases/sql_app/crud.py!}
@@ -499,17 +506,17 @@ current_user.items
“迁移”是每当您更改 SQLAlchemy 模型的结构、添加新属性等以在数据库中复制这些更改、添加新列、新表等时所需的一组步骤。
-您可以在[Project Generation - Template](https://fastapi.tiangolo.com/zh/project-generation/)的模板中找到一个 FastAPI 项目中的 Alembic 示例。具体在[`alembic`代码目录中](https://github.com/tiangolo/full-stack-fastapi-postgresql/tree/master/src/backend/app/alembic/)。
+您可以在[Full Stack FastAPI Template](https://fastapi.tiangolo.com/zh/project-generation/)的模板中找到一个 FastAPI 项目中的 Alembic 示例。具体在[`alembic`代码目录中](https://github.com/tiangolo/full-stack-fastapi-template/tree/master/backend/app/alembic)。
### 创建依赖项
现在使用我们在`sql_app/database.py`文件中创建的`SessionLocal`来创建依赖项。
-我们需要每个请求有一个独立的数据库会话/连接（`SessionLocal`），在所有请求中使用相同的会话，然后在请求完成后关闭它。
+我们需要每个请求有一个独立的数据库会话/连接（`SessionLocal`），在整个请求中使用相同的会话，然后在请求完成后关闭它。
然后将为下一个请求创建一个新会话。
-为此，我们将创建一个新的依赖项`yield`，正如前面关于[Dependencies with`yield`](https://fastapi.tiangolo.com/zh/tutorial/dependencies/dependencies-with-yield/)的部分中所解释的那样。
+为此，我们将创建一个包含`yield`的依赖项，正如前面关于[Dependencies with`yield`](https://fastapi.tiangolo.com/zh/tutorial/dependencies/dependencies-with-yield/)的部分中所解释的那样。
我们的依赖项将创建一个新的 SQLAlchemy `SessionLocal`，它将在单个请求中使用，然后在请求完成后关闭它。
@@ -729,13 +736,13 @@ $ uvicorn sql_app.main:app --reload
## 中间件替代数据库会话
-如果你不能使用依赖项`yield`——例如，如果你没有使用**Python 3.7**并且不能安装上面提到的**Python 3.6**的“backports” ——你可以在类似的“中间件”中设置会话方法。
+如果你不能使用带有`yield`的依赖项——例如，如果你没有使用**Python 3.7**并且不能安装上面提到的**Python 3.6**的“backports” ——你可以使用类似的方法在“中间件”中设置会话。
-“中间件”基本功能是一个为每个请求执行的函数在请求之前进行执行相应的代码，以及在请求执行之后执行相应的代码。
+“中间件”基本上是一个对每个请求都执行的函数，其中一些代码在端点函数之前执行，另一些代码在端点函数之后执行。
### 创建中间件
-我们将添加中间件（只是一个函数）将为每个请求创建一个新的 SQLAlchemy`SessionLocal`，将其添加到请求中，然后在请求完成后关闭它。
+我们要添加的中间件（只是一个函数）将为每个请求创建一个新的 SQLAlchemy`SessionLocal`，将其添加到请求中，然后在请求完成后关闭它。
=== "Python 3.9+"
@@ -760,7 +767,7 @@ $ uvicorn sql_app.main:app --reload
`request.state`是每个`Request`对象的属性。它用于存储附加到请求本身的任意对象，例如本例中的数据库会话。您可以在[Starlette 的关于`Request`state](https://www.starlette.io/requests/#other-state)的文档中了解更多信息。
-对于这种情况下，它帮助我们确保在所有请求中使用单个数据库会话，然后关闭（在中间件中）。
+对于这种情况下，它帮助我们确保在整个请求中使用单个数据库会话，然后关闭（在中间件中）。
### 使用`yield`依赖项与使用中间件的区别
@@ -776,9 +783,9 @@ $ uvicorn sql_app.main:app --reload
* 即使处理该请求的*路径操作*不需要数据库。
!!! tip
- `tyield`当依赖项 足以满足用例时，使用`tyield`依赖项方法会更好。
+ 最好使用带有yield的依赖项，如果这足够满足用例需求
!!! info
- `yield`的依赖项是最近刚加入**FastAPI**中的。
+ 带有`yield`的依赖项是最近刚加入**FastAPI**中的。
所以本教程的先前版本只有带有中间件的示例，并且可能有多个应用程序使用中间件进行数据库会话管理。
diff --git a/docs_src/custom_docs_ui/tutorial001.py b/docs_src/custom_docs_ui/tutorial001.py
index 4384433e3..f7ceb0c2f 100644
--- a/docs_src/custom_docs_ui/tutorial001.py
+++ b/docs_src/custom_docs_ui/tutorial001.py
@@ -14,8 +14,8 @@ async def custom_swagger_ui_html():
openapi_url=app.openapi_url,
title=app.title + " - Swagger UI",
oauth2_redirect_url=app.swagger_ui_oauth2_redirect_url,
- swagger_js_url="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui-bundle.js",
- swagger_css_url="https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui.css",
+ swagger_js_url="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js",
+ swagger_css_url="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css",
)
diff --git a/docs_src/security/tutorial004.py b/docs_src/security/tutorial004.py
index d0fbaa572..91d161b8a 100644
--- a/docs_src/security/tutorial004.py
+++ b/docs_src/security/tutorial004.py
@@ -1,9 +1,10 @@
from datetime import datetime, timedelta, timezone
from typing import Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel
@@ -98,7 +99,7 @@ async def get_current_user(token: str = Depends(oauth2_scheme)):
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
- except JWTError:
+ except InvalidTokenError:
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial004_an.py b/docs_src/security/tutorial004_an.py
index eebd36d64..df50754af 100644
--- a/docs_src/security/tutorial004_an.py
+++ b/docs_src/security/tutorial004_an.py
@@ -1,9 +1,10 @@
from datetime import datetime, timedelta, timezone
from typing import Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel
from typing_extensions import Annotated
@@ -99,7 +100,7 @@ async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
- except JWTError:
+ except InvalidTokenError:
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial004_an_py310.py b/docs_src/security/tutorial004_an_py310.py
index 4e50ada7c..eff54ef01 100644
--- a/docs_src/security/tutorial004_an_py310.py
+++ b/docs_src/security/tutorial004_an_py310.py
@@ -1,9 +1,10 @@
from datetime import datetime, timedelta, timezone
from typing import Annotated
+import jwt
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel
@@ -98,7 +99,7 @@ async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
- except JWTError:
+ except InvalidTokenError:
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial004_an_py39.py b/docs_src/security/tutorial004_an_py39.py
index eb49aaa67..0455b500c 100644
--- a/docs_src/security/tutorial004_an_py39.py
+++ b/docs_src/security/tutorial004_an_py39.py
@@ -1,9 +1,10 @@
from datetime import datetime, timedelta, timezone
from typing import Annotated, Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel
@@ -98,7 +99,7 @@ async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
- except JWTError:
+ except InvalidTokenError:
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial004_py310.py b/docs_src/security/tutorial004_py310.py
index 5a905783d..78bee22a3 100644
--- a/docs_src/security/tutorial004_py310.py
+++ b/docs_src/security/tutorial004_py310.py
@@ -1,8 +1,9 @@
from datetime import datetime, timedelta, timezone
+import jwt
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel
@@ -97,7 +98,7 @@ async def get_current_user(token: str = Depends(oauth2_scheme)):
if username is None:
raise credentials_exception
token_data = TokenData(username=username)
- except JWTError:
+ except InvalidTokenError:
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial005.py b/docs_src/security/tutorial005.py
index d4a6975da..ccad07969 100644
--- a/docs_src/security/tutorial005.py
+++ b/docs_src/security/tutorial005.py
@@ -1,13 +1,14 @@
from datetime import datetime, timedelta, timezone
from typing import List, Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
OAuth2PasswordBearer,
OAuth2PasswordRequestForm,
SecurityScopes,
)
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError
@@ -120,7 +121,7 @@ async def get_current_user(
raise credentials_exception
token_scopes = payload.get("scopes", [])
token_data = TokenData(scopes=token_scopes, username=username)
- except (JWTError, ValidationError):
+ except (InvalidTokenError, ValidationError):
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial005_an.py b/docs_src/security/tutorial005_an.py
index 982daed2f..5b67cb145 100644
--- a/docs_src/security/tutorial005_an.py
+++ b/docs_src/security/tutorial005_an.py
@@ -1,13 +1,14 @@
from datetime import datetime, timedelta, timezone
from typing import List, Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
OAuth2PasswordBearer,
OAuth2PasswordRequestForm,
SecurityScopes,
)
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError
from typing_extensions import Annotated
@@ -121,7 +122,7 @@ async def get_current_user(
raise credentials_exception
token_scopes = payload.get("scopes", [])
token_data = TokenData(scopes=token_scopes, username=username)
- except (JWTError, ValidationError):
+ except (InvalidTokenError, ValidationError):
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial005_an_py310.py b/docs_src/security/tutorial005_an_py310.py
index 79aafbff1..297193e35 100644
--- a/docs_src/security/tutorial005_an_py310.py
+++ b/docs_src/security/tutorial005_an_py310.py
@@ -1,13 +1,14 @@
from datetime import datetime, timedelta, timezone
from typing import Annotated
+import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
OAuth2PasswordBearer,
OAuth2PasswordRequestForm,
SecurityScopes,
)
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError
@@ -120,7 +121,7 @@ async def get_current_user(
raise credentials_exception
token_scopes = payload.get("scopes", [])
token_data = TokenData(scopes=token_scopes, username=username)
- except (JWTError, ValidationError):
+ except (InvalidTokenError, ValidationError):
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial005_an_py39.py b/docs_src/security/tutorial005_an_py39.py
index 3bdab5507..1acf47bdc 100644
--- a/docs_src/security/tutorial005_an_py39.py
+++ b/docs_src/security/tutorial005_an_py39.py
@@ -1,13 +1,14 @@
from datetime import datetime, timedelta, timezone
from typing import Annotated, List, Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
OAuth2PasswordBearer,
OAuth2PasswordRequestForm,
SecurityScopes,
)
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError
@@ -120,7 +121,7 @@ async def get_current_user(
raise credentials_exception
token_scopes = payload.get("scopes", [])
token_data = TokenData(scopes=token_scopes, username=username)
- except (JWTError, ValidationError):
+ except (InvalidTokenError, ValidationError):
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial005_py310.py b/docs_src/security/tutorial005_py310.py
index 9f75aa0be..b244ef08e 100644
--- a/docs_src/security/tutorial005_py310.py
+++ b/docs_src/security/tutorial005_py310.py
@@ -1,12 +1,13 @@
from datetime import datetime, timedelta, timezone
+import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
OAuth2PasswordBearer,
OAuth2PasswordRequestForm,
SecurityScopes,
)
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError
@@ -119,7 +120,7 @@ async def get_current_user(
raise credentials_exception
token_scopes = payload.get("scopes", [])
token_data = TokenData(scopes=token_scopes, username=username)
- except (JWTError, ValidationError):
+ except (InvalidTokenError, ValidationError):
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/docs_src/security/tutorial005_py39.py b/docs_src/security/tutorial005_py39.py
index bac248932..8f0e93376 100644
--- a/docs_src/security/tutorial005_py39.py
+++ b/docs_src/security/tutorial005_py39.py
@@ -1,13 +1,14 @@
from datetime import datetime, timedelta, timezone
from typing import Union
+import jwt
from fastapi import Depends, FastAPI, HTTPException, Security, status
from fastapi.security import (
OAuth2PasswordBearer,
OAuth2PasswordRequestForm,
SecurityScopes,
)
-from jose import JWTError, jwt
+from jwt.exceptions import InvalidTokenError
from passlib.context import CryptContext
from pydantic import BaseModel, ValidationError
@@ -120,7 +121,7 @@ async def get_current_user(
raise credentials_exception
token_scopes = payload.get("scopes", [])
token_data = TokenData(scopes=token_scopes, username=username)
- except (JWTError, ValidationError):
+ except (InvalidTokenError, ValidationError):
raise credentials_exception
user = get_user(fake_users_db, username=token_data.username)
if user is None:
diff --git a/fastapi/__init__.py b/fastapi/__init__.py
index f28657712..4d60bc7de 100644
--- a/fastapi/__init__.py
+++ b/fastapi/__init__.py
@@ -1,6 +1,6 @@
"""FastAPI framework, high performance, easy to learn, fast to code, ready for production"""
-__version__ = "0.110.2"
+__version__ = "0.111.1"
from starlette import status as status
diff --git a/fastapi/applications.py b/fastapi/applications.py
index 4446cacfb..4f5e6f1d9 100644
--- a/fastapi/applications.py
+++ b/fastapi/applications.py
@@ -902,7 +902,7 @@ class FastAPI(Starlette):
A state object for the application. This is the same object for the
entire application, it doesn't change from request to request.
- You normally woudln't use this in FastAPI, for most of the cases you
+ You normally wouldn't use this in FastAPI, for most of the cases you
would instead use FastAPI dependencies.
This is simply inherited from Starlette.
diff --git a/fastapi/openapi/docs.py b/fastapi/openapi/docs.py
index 67815e0fb..c2ec358d2 100644
--- a/fastapi/openapi/docs.py
+++ b/fastapi/openapi/docs.py
@@ -53,7 +53,7 @@ def get_swagger_ui_html(
It is normally set to a CDN URL.
"""
),
- ] = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.9.0/swagger-ui-bundle.js",
+ ] = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui-bundle.js",
swagger_css_url: Annotated[
str,
Doc(
@@ -63,7 +63,7 @@ def get_swagger_ui_html(
It is normally set to a CDN URL.
"""
),
- ] = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5.9.0/swagger-ui.css",
+ ] = "https://cdn.jsdelivr.net/npm/swagger-ui-dist@5/swagger-ui.css",
swagger_favicon_url: Annotated[
str,
Doc(
diff --git a/fastapi/security/api_key.py b/fastapi/security/api_key.py
index b74a017f1..d68bdb037 100644
--- a/fastapi/security/api_key.py
+++ b/fastapi/security/api_key.py
@@ -76,7 +76,7 @@ class APIKeyQuery(APIKeyBase):
Doc(
"""
By default, if the query parameter is not provided, `APIKeyQuery` will
- automatically cancel the request and sebd the client an error.
+ automatically cancel the request and send the client an error.
If `auto_error` is set to `False`, when the query parameter is not
available, instead of erroring out, the dependency result will be
diff --git a/pdm_build.py b/pdm_build.py
new file mode 100644
index 000000000..45922d471
--- /dev/null
+++ b/pdm_build.py
@@ -0,0 +1,39 @@
+import os
+from typing import Any, Dict, List
+
+from pdm.backend.hooks import Context
+
+TIANGOLO_BUILD_PACKAGE = os.getenv("TIANGOLO_BUILD_PACKAGE", "fastapi")
+
+
+def pdm_build_initialize(context: Context) -> None:
+ metadata = context.config.metadata
+ # Get custom config for the current package, from the env var
+ config: Dict[str, Any] = context.config.data["tool"]["tiangolo"][
+ "_internal-slim-build"
+ ]["packages"][TIANGOLO_BUILD_PACKAGE]
+ project_config: Dict[str, Any] = config["project"]
+ # Get main optional dependencies, extras
+ optional_dependencies: Dict[str, List[str]] = metadata.get(
+ "optional-dependencies", {}
+ )
+ # Get custom optional dependencies name to always include in this (non-slim) package
+ include_optional_dependencies: List[str] = config.get(
+ "include-optional-dependencies", []
+ )
+ # Override main [project] configs with custom configs for this package
+ for key, value in project_config.items():
+ metadata[key] = value
+ # Get custom build config for the current package
+ build_config: Dict[str, Any] = (
+ config.get("tool", {}).get("pdm", {}).get("build", {})
+ )
+ # Override PDM build config with custom build config for this package
+ for key, value in build_config.items():
+ context.config.build_config[key] = value
+ # Get main dependencies
+ dependencies: List[str] = metadata.get("dependencies", [])
+ # Add optional dependencies to the default dependencies for this (non-slim) package
+ for include_optional in include_optional_dependencies:
+ optional_dependencies_group = optional_dependencies.get(include_optional, [])
+ dependencies.extend(optional_dependencies_group)
diff --git a/pyproject.toml b/pyproject.toml
index 6c3bebf2b..dbaa42149 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,13 +1,13 @@
[build-system]
-requires = ["hatchling >= 1.13.0"]
-build-backend = "hatchling.build"
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
[project]
name = "fastapi"
+dynamic = ["version"]
description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production"
readme = "README.md"
requires-python = ">=3.8"
-license = "MIT"
authors = [
{ name = "Sebastián Ramírez", email = "tiangolo@gmail.com" },
]
@@ -45,7 +45,6 @@ dependencies = [
"pydantic>=1.7.4,!=1.8,!=1.8.1,!=2.0.0,!=2.0.1,!=2.1.0,<3.0.0",
"typing-extensions>=4.8.0",
]
-dynamic = ["version"]
[project.urls]
Homepage = "https://github.com/tiangolo/fastapi"
@@ -53,22 +52,97 @@ Documentation = "https://fastapi.tiangolo.com/"
Repository = "https://github.com/tiangolo/fastapi"
[project.optional-dependencies]
+
+standard = [
+ "fastapi-cli >=0.0.2",
+ # For the test client
+ "httpx >=0.23.0",
+ # For templates
+ "jinja2 >=2.11.2",
+ # For forms and file uploads
+ "python-multipart >=0.0.7",
+ # To validate email fields
+ "email_validator >=2.0.0",
+ # Uvicorn with uvloop
+ "uvicorn[standard] >=0.12.0",
+ # TODO: this should be part of some pydantic optional extra dependencies
+ # # Settings management
+ # "pydantic-settings >=2.0.0",
+ # # Extra Pydantic data types
+ # "pydantic-extra-types >=2.0.0",
+]
+
all = [
+ "fastapi-cli >=0.0.2",
+ # # For the test client
"httpx >=0.23.0",
+ # For templates
"jinja2 >=2.11.2",
+ # For forms and file uploads
"python-multipart >=0.0.7",
+ # For Starlette's SessionMiddleware, not commonly used with FastAPI
"itsdangerous >=1.1.0",
+ # For Starlette's schema generation, would not be used with FastAPI
"pyyaml >=5.3.1",
+ # For UJSONResponse
"ujson >=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0",
+ # For ORJSONResponse
"orjson >=3.2.1",
+ # To validate email fields
"email_validator >=2.0.0",
+ # Uvicorn with uvloop
"uvicorn[standard] >=0.12.0",
+ # Settings management
"pydantic-settings >=2.0.0",
+ # Extra Pydantic data types
"pydantic-extra-types >=2.0.0",
]
-[tool.hatch.version]
-path = "fastapi/__init__.py"
+[tool.pdm]
+version = { source = "file", path = "fastapi/__init__.py" }
+distribution = true
+
+[tool.pdm.build]
+source-includes = [
+ "tests/",
+ "docs_src/",
+ "requirements*.txt",
+ "scripts/",
+ # For a test
+ "docs/en/docs/img/favicon.png",
+ ]
+
+[tool.tiangolo._internal-slim-build.packages.fastapi-slim.project]
+name = "fastapi-slim"
+
+[tool.tiangolo._internal-slim-build.packages.fastapi]
+include-optional-dependencies = ["standard"]
+
+[tool.tiangolo._internal-slim-build.packages.fastapi.project.optional-dependencies]
+all = [
+ # # For the test client
+ "httpx >=0.23.0",
+ # For templates
+ "jinja2 >=2.11.2",
+ # For forms and file uploads
+ "python-multipart >=0.0.7",
+ # For Starlette's SessionMiddleware, not commonly used with FastAPI
+ "itsdangerous >=1.1.0",
+ # For Starlette's schema generation, would not be used with FastAPI
+ "pyyaml >=5.3.1",
+ # For UJSONResponse
+ "ujson >=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0",
+ # For ORJSONResponse
+ "orjson >=3.2.1",
+ # To validate email fields
+ "email_validator >=2.0.0",
+ # Uvicorn with uvloop
+ "uvicorn[standard] >=0.12.0",
+ # Settings management
+ "pydantic-settings >=2.0.0",
+ # Extra Pydantic data types
+ "pydantic-extra-types >=2.0.0",
+]
[tool.mypy]
strict = true
diff --git a/requirements-docs.txt b/requirements-docs.txt
index 599e01f16..c672f0ef7 100644
--- a/requirements-docs.txt
+++ b/requirements-docs.txt
@@ -11,7 +11,7 @@ jieba==0.42.1
pillow==10.3.0
# For image processing by Material for MkDocs
cairosvg==2.7.0
-mkdocstrings[python]==0.23.0
+mkdocstrings[python]==0.24.3
griffe-typingdoc==0.2.2
# For griffe, it formats with black
black==24.3.0
diff --git a/requirements-tests.txt b/requirements-tests.txt
index 30762bc64..bfe70f2f5 100644
--- a/requirements-tests.txt
+++ b/requirements-tests.txt
@@ -1,22 +1,17 @@
--e .
+-e .[all]
-r requirements-docs-tests.txt
-pydantic-settings >=2.0.0
pytest >=7.1.3,<8.0.0
coverage[toml] >= 6.5.0,< 8.0
mypy ==1.8.0
ruff ==0.2.0
-email_validator >=1.1.1,<3.0.0
dirty-equals ==0.6.0
# TODO: once removing databases from tutorial, upgrade SQLAlchemy
# probably when including SQLModel
sqlalchemy >=1.3.18,<1.4.43
databases[sqlite] >=0.3.2,<0.7.0
-orjson >=3.2.1,<4.0.0
-ujson >=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0,<6.0.0
-python-multipart >=0.0.7,<0.1.0
flask >=1.1.2,<3.0.0
anyio[trio] >=3.2.1,<4.0.0
-python-jose[cryptography] >=3.3.0,<4.0.0
+PyJWT==2.8.0
pyyaml >=5.3.1,<7.0.0
passlib[bcrypt] >=1.7.2,<2.0.0
diff --git a/requirements.txt b/requirements.txt
index ef25ec483..8e1fef341 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,7 +1,6 @@
-e .[all]
-r requirements-tests.txt
-r requirements-docs.txt
-uvicorn[standard] >=0.12.0,<0.23.0
pre-commit >=2.17.0,<4.0.0
# For generating screenshots
playwright
diff --git a/scripts/build-docs.sh b/scripts/build-docs.sh
deleted file mode 100755
index 7aa0a9a47..000000000
--- a/scripts/build-docs.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-set -x
-
-# Check README.md is up to date
-python ./scripts/docs.py verify-docs
-python ./scripts/docs.py build-all
diff --git a/scripts/clean.sh b/scripts/clean.sh
deleted file mode 100755
index d5a4b790a..000000000
--- a/scripts/clean.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh -e
-
-if [ -d 'dist' ] ; then
- rm -r dist
-fi
-if [ -d 'site' ] ; then
- rm -r site
-fi
diff --git a/scripts/docs-live.sh b/scripts/docs-live.sh
deleted file mode 100755
index 30637a528..000000000
--- a/scripts/docs-live.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-mkdocs serve --dev-addr 0.0.0.0:8008
diff --git a/scripts/format.sh b/scripts/format.sh
index 11f25f1ce..45742f79a 100755
--- a/scripts/format.sh
+++ b/scripts/format.sh
@@ -1,5 +1,5 @@
#!/bin/sh -e
set -x
-ruff fastapi tests docs_src scripts --fix
+ruff check fastapi tests docs_src scripts --fix
ruff format fastapi tests docs_src scripts
diff --git a/scripts/lint.sh b/scripts/lint.sh
index c0e24db9f..18cf52a84 100755
--- a/scripts/lint.sh
+++ b/scripts/lint.sh
@@ -4,5 +4,5 @@ set -e
set -x
mypy fastapi
-ruff fastapi tests docs_src scripts
+ruff check fastapi tests docs_src scripts
ruff format fastapi tests --check
diff --git a/scripts/mkdocs_hooks.py b/scripts/mkdocs_hooks.py
index 8335a13f6..24ffecf46 100644
--- a/scripts/mkdocs_hooks.py
+++ b/scripts/mkdocs_hooks.py
@@ -39,7 +39,7 @@ def on_config(config: MkDocsConfig, **kwargs: Any) -> MkDocsConfig:
lang = dir_path.parent.name
if lang in available_langs:
config.theme["language"] = lang
- if not (config.site_url or "").endswith(f"{lang}/") and not lang == "en":
+ if not (config.site_url or "").endswith(f"{lang}/") and lang != "en":
config.site_url = f"{config.site_url}{lang}/"
return config
diff --git a/scripts/netlify-docs.sh b/scripts/netlify-docs.sh
deleted file mode 100755
index 8f9065e23..000000000
--- a/scripts/netlify-docs.sh
+++ /dev/null
@@ -1,14 +0,0 @@
-#!/usr/bin/env bash
-set -x
-set -e
-# Install pip
-cd /tmp
-curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
-python3.6 get-pip.py --user
-cd -
-# Install Flit to be able to install all
-python3.6 -m pip install --user flit
-# Install with Flit
-python3.6 -m flit install --user --extras doc
-# Finally, run mkdocs
-python3.6 -m mkdocs build
diff --git a/scripts/publish.sh b/scripts/publish.sh
deleted file mode 100755
index 122728a60..000000000
--- a/scripts/publish.sh
+++ /dev/null
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-
-set -e
-
-flit publish
diff --git a/tests/test_tutorial/test_custom_docs_ui/test_tutorial001.py b/tests/test_tutorial/test_custom_docs_ui/test_tutorial001.py
index 34a18b12c..aff070d74 100644
--- a/tests/test_tutorial/test_custom_docs_ui/test_tutorial001.py
+++ b/tests/test_tutorial/test_custom_docs_ui/test_tutorial001.py
@@ -20,10 +20,8 @@ def client():
def test_swagger_ui_html(client: TestClient):
response = client.get("/docs")
assert response.status_code == 200, response.text
- assert (
- "https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui-bundle.js" in response.text
- )
- assert "https://unpkg.com/swagger-ui-dist@5.9.0/swagger-ui.css" in response.text
+ assert "https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js" in response.text
+ assert "https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" in response.text
def test_swagger_ui_oauth2_redirect_html(client: TestClient):
-
+
-
+
+
+
-
+
+
@@ -122,8 +125,6 @@ If you are building a CLI app to be
## Requirements
-Python 3.8+
-
FastAPI stands on the shoulders of giants:
* Starlette for the web parts.
@@ -141,18 +142,6 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
-
-
+
+ 
+
+ 
+
+ 
+
Puis vient votre tour, vous commandez alors 2 magnifiques burgers 🍔 pour votre crush 😍 et vous.
-Vous payez 💸.
+
Le serveur 💁 dit quelque chose à son collègue dans la cuisine 👨🍳 pour qu'il sache qu'il doit préparer vos burgers 🍔 (bien qu'il soit déjà en train de préparer ceux des clients précédents).
+
+
+Vous payez 💸.
+
Le serveur 💁 vous donne le numéro assigné à votre commande.
+
+
Pendant que vous attendez, vous allez choisir une table avec votre crush 😍, vous discutez avec votre crush 😍 pendant un long moment (les burgers étant "magnifiques" ils sont très longs à préparer ✨🍔✨).
Pendant que vous êtes assis à table, en attendant que les burgers 🍔 soient prêts, vous pouvez passer ce temps à admirer à quel point votre crush 😍 est géniale, mignonne et intelligente ✨😍✨.
+
+
Pendant que vous discutez avec votre crush 😍, de temps en temps vous jetez un coup d'oeil au nombre affiché au-dessus du comptoir pour savoir si c'est à votre tour d'être servis.
Jusqu'au moment où c'est (enfin) votre tour. Vous allez au comptoir, récupérez vos burgers 🍔 et revenez à votre table.
+
+
Vous et votre crush 😍 mangez les burgers 🍔 et passez un bon moment ✨.
+
+
+!!! info
+ Illustrations proposées par Ketrina Thompson. 🎨
+
---
Imaginez que vous êtes l'ordinateur / le programme 🤖 dans cette histoire.
@@ -149,26 +166,41 @@ Vous attendez pendant que plusieurs (disons 8) serveurs qui sont aussi des cuisi
Chaque personne devant vous attend 🕙 que son burger 🍔 soit prêt avant de quitter le comptoir car chacun des 8 serveurs va lui-même préparer le burger directement avant de prendre la commande suivante.
+
+
Puis c'est enfin votre tour, vous commandez 2 magnifiques burgers 🍔 pour vous et votre crush 😍.
Vous payez 💸.
+
+
Le serveur va dans la cuisine 👨🍳.
Vous attendez devant le comptoir afin que personne ne prenne vos burgers 🍔 avant vous, vu qu'il n'y a pas de numéro de commande.
+
+
Vous et votre crush 😍 étant occupés à vérifier que personne ne passe devant vous prendre vos burgers au moment où ils arriveront 🕙, vous ne pouvez pas vous préoccuper de votre crush 😞.
C'est du travail "synchrone", vous être "synchronisés" avec le serveur/cuisinier 👨🍳. Vous devez attendre 🕙 et être présent au moment exact où le serveur/cuisinier 👨🍳 finira les burgers 🍔 et vous les donnera, sinon quelqu'un risque de vous les prendre.
+
+
Puis le serveur/cuisinier 👨🍳 revient enfin avec vos burgers 🍔, après un long moment d'attente 🕙 devant le comptoir.
+
+
Vous prenez vos burgers 🍔 et allez à une table avec votre crush 😍
Vous les mangez, et vous avez terminé 🍔 ⏹.
+
+
Durant tout ce processus, il n'y a presque pas eu de discussions ou de flirts car la plupart de votre temps à été passé à attendre 🕙 devant le comptoir 😞.
+!!! info
+ Illustrations proposées par Ketrina Thompson. 🎨
+
---
Dans ce scénario de burgers parallèles, vous êtes un ordinateur / programme 🤖 avec deux processeurs (vous et votre crush 😍) attendant 🕙 à deux et dédiant votre attention 🕙 à "attendre devant le comptoir" pour une longue durée.
diff --git a/docs/fr/docs/deployment/manually.md b/docs/fr/docs/deployment/manually.md
index c53e2db67..eb1253cf8 100644
--- a/docs/fr/docs/deployment/manually.md
+++ b/docs/fr/docs/deployment/manually.md
@@ -5,7 +5,7 @@ La principale chose dont vous avez besoin pour exécuter une application **FastA
Il existe 3 principales alternatives :
* Uvicorn : un serveur ASGI haute performance.
-* Hypercorn : un serveur
+* Hypercorn : un serveur
ASGI compatible avec HTTP/2 et Trio entre autres fonctionnalités.
* Daphne : le serveur ASGI
conçu pour Django Channels.
@@ -46,7 +46,7 @@ Vous pouvez installer un serveur compatible ASGI avec :
=== "Hypercorn"
- * Hypercorn, un serveur ASGI également compatible avec HTTP/2.
+ * Hypercorn, un serveur ASGI également compatible avec HTTP/2.
