-E se você olhar o esquema OpenAPI resultante (na rota `/openapi.json` da sua API), você verá que a sua extensão também faz parte da *operação de rota* específica:
+E se você olhar o OpenAPI resultante (em `/openapi.json` na sua API), você verá que a sua extensão também faz parte da *operação de rota* específica:
```JSON hl_lines="22"
{
@@ -131,70 +131,38 @@ E se você olhar o esquema OpenAPI resultante (na rota `/openapi.json` da sua AP
### Esquema de *operação de rota* do OpenAPI personalizado { #custom-openapi-path-operation-schema }
-O dicionário em `openapi_extra` vai ter todos os seus níveis mesclados dentro do esquema OpenAPI gerado automaticamente para a *operação de rota*.
+O dicionário em `openapi_extra` será mesclado profundamente com o esquema OpenAPI gerado automaticamente para a *operação de rota*.
-Então, você pode adicionar dados extras para o esquema gerado automaticamente.
+Assim, você poderia adicionar dados adicionais ao esquema gerado automaticamente.
-Por exemplo, você poderia optar por ler e validar a requisição com seu próprio código, sem utilizar funcionalidades automatizadas do FastAPI com o Pydantic, mas você ainda pode quere definir a requisição no esquema OpenAPI.
+Por exemplo, você poderia decidir ler e validar a request com seu próprio código, sem usar as funcionalidades automáticas do FastAPI com o Pydantic, mas ainda assim poderia querer definir a request no esquema OpenAPI.
Você pode fazer isso com `openapi_extra`:
{* ../../docs_src/path_operation_advanced_configuration/tutorial006_py39.py hl[19:36, 39:40] *}
-Nesse exemplo, nós não declaramos nenhum modelo do Pydantic. Na verdade, o corpo da requisição não está nem mesmo analisado como JSON, ele é lido diretamente como `bytes` e a função `magic_data_reader()` seria a responsável por analisar ele de alguma forma.
+Neste exemplo, não declaramos nenhum modelo do Pydantic. Na verdade, o corpo da request nem sequer é parsed como JSON, ele é lido diretamente como `bytes`, e a função `magic_data_reader()` seria a responsável por fazer o parsing dele de alguma forma.
-De toda forma, nós podemos declarar o esquema esperado para o corpo da requisição.
+Mesmo assim, podemos declarar o esquema esperado para o corpo da request.
### Tipo de conteúdo do OpenAPI personalizado { #custom-openapi-content-type }
-Utilizando esse mesmo truque, você pode utilizar um modelo Pydantic para definir o JSON Schema que é então incluído na seção do esquema personalizado do OpenAPI na *operação de rota*.
+Utilizando esse mesmo truque, você poderia usar um modelo Pydantic para definir o JSON Schema que é então incluído na seção do esquema OpenAPI personalizado da *operação de rota*.
-E você pode fazer isso até mesmo quando os dados da requisição não seguem o formato JSON.
+E você poderia fazer isso mesmo que o tipo de dados na request não seja JSON.
-Por exemplo, nesta aplicação nós não usamos a funcionalidade integrada ao FastAPI de extrair o JSON Schema dos modelos Pydantic nem a validação automática do JSON. Na verdade, estamos declarando o tipo do conteúdo da requisição como YAML, em vez de JSON:
-
-//// tab | Pydantic v2
+Por exemplo, nesta aplicação não usamos a funcionalidade integrada do FastAPI para extrair o JSON Schema dos modelos Pydantic nem a validação automática para JSON. Na verdade, estamos declarando o tipo de conteúdo da request como YAML, e não JSON:
{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[15:20, 22] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[15:20, 22] *}
-
-////
-
-/// info | Informação
-
-Na versão 1 do Pydantic, o método para obter o JSON Schema de um modelo é `Item.schema()`, na versão 2 do Pydantic, o método é `Item.model_json_schema()`.
-
-///
-
-Entretanto, mesmo que não utilizemos a funcionalidade integrada por padrão, ainda estamos usando um modelo Pydantic para gerar um JSON Schema manualmente para os dados que queremos receber no formato YAML.
+Mesmo assim, embora não estejamos usando a funcionalidade integrada padrão, ainda estamos usando um modelo Pydantic para gerar manualmente o JSON Schema para os dados que queremos receber em YAML.
-Então utilizamos a requisição diretamente, e extraímos o corpo como `bytes`. Isso significa que o FastAPI não vai sequer tentar analisar o corpo da requisição como JSON.
+Então usamos a request diretamente e extraímos o corpo como `bytes`. Isso significa que o FastAPI nem sequer vai tentar fazer o parsing do payload da request como JSON.
-E então no nosso código, nós analisamos o conteúdo YAML diretamente, e estamos utilizando o mesmo modelo Pydantic para validar o conteúdo YAML:
-
-//// tab | Pydantic v2
+E então no nosso código, fazemos o parsing desse conteúdo YAML diretamente, e então estamos novamente usando o mesmo modelo Pydantic para validar o conteúdo YAML:
{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/path_operation_advanced_configuration/tutorial007_pv1_py39.py hl[24:31] *}
-
-////
-
-/// info | Informação
-
-Na versão 1 do Pydantic, o método para analisar e validar um objeto era `Item.parse_obj()`, na versão 2 do Pydantic, o método é chamado de `Item.model_validate()`.
-
-///
-
/// tip | Dica
Aqui reutilizamos o mesmo modelo do Pydantic.
diff --git a/docs/pt/docs/advanced/settings.md b/docs/pt/docs/advanced/settings.md
index 6f5b7feae..2fc0c1d60 100644
--- a/docs/pt/docs/advanced/settings.md
+++ b/docs/pt/docs/advanced/settings.md
@@ -1,6 +1,6 @@
# Configurações e Variáveis de Ambiente { #settings-and-environment-variables }
-Em muitos casos, sua aplicação pode precisar de configurações externas, por exemplo chaves secretas, credenciais de banco de dados, credenciais para serviços de e-mail, etc.
+Em muitos casos, sua aplicação pode precisar de algumas configurações externas, por exemplo chaves secretas, credenciais de banco de dados, credenciais para serviços de e-mail, etc.
A maioria dessas configurações é variável (pode mudar), como URLs de banco de dados. E muitas podem ser sensíveis, como segredos.
@@ -12,7 +12,7 @@ Para entender variáveis de ambiente, você pode ler [Variáveis de Ambiente](..
///
-## Tipagem e validação { #types-and-validation }
+## Tipos e validação { #types-and-validation }
Essas variáveis de ambiente só conseguem lidar com strings de texto, pois são externas ao Python e precisam ser compatíveis com outros programas e com o resto do sistema (e até com diferentes sistemas operacionais, como Linux, Windows, macOS).
@@ -46,12 +46,6 @@ $ pip install "fastapi[all]"
-/// info | Informação
-
-No Pydantic v1 ele vinha incluído no pacote principal. Agora é distribuído como um pacote independente para que você possa optar por instalá-lo ou não, caso não precise dessa funcionalidade.
-
-///
-
### Criar o objeto `Settings` { #create-the-settings-object }
Importe `BaseSettings` do Pydantic e crie uma subclasse, muito parecido com um modelo do Pydantic.
@@ -60,24 +54,8 @@ Da mesma forma que com modelos do Pydantic, você declara atributos de classe co
Você pode usar as mesmas funcionalidades e ferramentas de validação que usa em modelos do Pydantic, como diferentes tipos de dados e validações adicionais com `Field()`.
-//// tab | Pydantic v2
-
{* ../../docs_src/settings/tutorial001_py39.py hl[2,5:8,11] *}
-////
-
-//// tab | Pydantic v1
-
-/// info | Informação
-
-No Pydantic v1 você importaria `BaseSettings` diretamente de `pydantic` em vez de `pydantic_settings`.
-
-///
-
-{* ../../docs_src/settings/tutorial001_pv1_py39.py hl[2,5:8,11] *}
-
-////
-
/// tip | Dica
Se você quer algo rápido para copiar e colar, não use este exemplo, use o último abaixo.
@@ -140,7 +118,7 @@ Você também precisaria de um arquivo `__init__.py` como visto em [Aplicações
## Configurações em uma dependência { #settings-in-a-dependency }
-Em algumas ocasiões, pode ser útil fornecer as configurações a partir de uma dependência, em vez de ter um objeto global `settings` usado em todos os lugares.
+Em algumas ocasiões, pode ser útil fornecer as configurações a partir de uma dependência, em vez de ter um objeto global com `settings` que é usado em todos os lugares.
Isso pode ser especialmente útil durante os testes, pois é muito fácil sobrescrever uma dependência com suas próprias configurações personalizadas.
@@ -215,8 +193,6 @@ APP_NAME="ChimichangApp"
E então atualizar seu `config.py` com:
-//// tab | Pydantic v2
-
{* ../../docs_src/settings/app03_an_py39/config.py hl[9] *}
/// tip | Dica
@@ -225,31 +201,11 @@ O atributo `model_config` é usado apenas para configuração do Pydantic. Você
///
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/settings/app03_an_py39/config_pv1.py hl[9:10] *}
-
-/// tip | Dica
-
-A classe `Config` é usada apenas para configuração do Pydantic. Você pode ler mais em 
@@ -95,10 +95,8 @@ O suporte para `separate_input_output_schemas` foi adicionado no FastAPI `0.102.
### Mesmo Esquema para Modelos de Entrada e Saída na Documentação { #same-schema-for-input-and-output-models-in-docs }
-E agora haverá um único esquema para entrada e saída para o modelo, apenas `Item`, e `description` **não será obrigatório**:
+E agora haverá um único esquema para entrada e saída para o modelo, apenas `Item`, e ele terá `description` como **não obrigatório**:
Brian Okken - Python Bytes podcaster (ref)
+Brian Okken - Python Bytes apresentador do podcast (ref)
---
@@ -117,6 +117,12 @@ Os recursos chave são:
---
+## Mini documentário do FastAPI { #fastapi-mini-documentary }
+
+Há um mini documentário do FastAPI lançado no final de 2025, você pode assisti-lo online:
+
+
+
## **Typer**, o FastAPI das interfaces de linhas de comando { #typer-the-fastapi-of-clis }
@@ -255,10 +261,10 @@ Você verá a resposta JSON como:
Você acabou de criar uma API que:
-* Recebe requisições HTTP nas _rotas_ `/` e `/items/{item_id}`.
-* Ambas _rotas_ fazem operações `GET` (também conhecido como _métodos_ HTTP).
-* A _rota_ `/items/{item_id}` tem um _parâmetro de rota_ `item_id` que deve ser um `int`.
-* A _rota_ `/items/{item_id}` tem um _parâmetro query_ `q` `str` opcional.
+* Recebe requisições HTTP nos _paths_ `/` e `/items/{item_id}`.
+* Ambos _paths_ fazem operações `GET` (também conhecido como _métodos_ HTTP).
+* O _path_ `/items/{item_id}` tem um _parâmetro de path_ `item_id` que deve ser um `int`.
+* O _path_ `/items/{item_id}` tem um _parâmetro query_ `q` `str` opcional.
### Documentação Interativa da API { #interactive-api-docs }
@@ -370,7 +376,7 @@ item: Item
* Validação até para objetos JSON profundamente aninhados.
* Conversão de dados de entrada: vindo da rede para dados e tipos Python. Consegue ler:
* JSON.
- * Parâmetros de rota.
+ * Parâmetros de path.
* Parâmetros de _query_ .
* _Cookies_.
* Cabeçalhos.
@@ -390,7 +396,7 @@ item: Item
Voltando ao código do exemplo anterior, **FastAPI** irá:
-* Validar que existe um `item_id` na rota para requisições `GET` e `PUT`.
+* Validar que existe um `item_id` no path para requisições `GET` e `PUT`.
* Validar que `item_id` é do tipo `int` para requisições `GET` e `PUT`.
* Se não é validado, o cliente verá um útil, claro erro.
* Verificar se existe um parâmetro de _query_ opcional nomeado como `q` (como em `http://127.0.0.1:8000/items/foo?q=somequery`) para requisições `GET`.
@@ -399,7 +405,7 @@ Voltando ao código do exemplo anterior, **FastAPI** irá:
* Para requisições `PUT` para `/items/{item_id}`, lerá o corpo como JSON:
* Verifica que tem um atributo obrigatório `name` que deve ser `str`.
* Verifica que tem um atributo obrigatório `price` que deve ser `float`.
- * Verifica que tem an atributo opcional `is_offer`, que deve ser `bool`, se presente.
+ * Verifica que tem um atributo opcional `is_offer`, que deve ser `bool`, se presente.
* Tudo isso também funciona para objetos JSON profundamente aninhados.
* Converter de e para JSON automaticamente.
* Documentar tudo com OpenAPI, que poderá ser usado por:
@@ -452,9 +458,9 @@ Para um exemplo mais completo incluindo mais recursos, veja FastAPI Cloud, inscreva-se na lista de espera se ainda não o fez. 🚀
+Você pode opcionalmente implantar sua aplicação FastAPI na FastAPI Cloud, vá e participe da lista de espera caso ainda não o tenha feito. 🚀
-Se você já tem uma conta na **FastAPI Cloud** (nós convidamos você da lista de espera 😉), pode implantar sua aplicação com um único comando.
+Se você já tem uma conta na **FastAPI Cloud** (nós convidamos você da lista de espera 😉), você pode implantar sua aplicação com um único comando.
Antes de implantar, certifique-se de que está autenticado:
@@ -506,7 +512,7 @@ Siga os tutoriais do seu provedor de nuvem para implantar aplicações FastAPI c
Testes de performance da _Independent TechEmpower_ mostram aplicações **FastAPI** rodando sob Uvicorn como um dos _frameworks_ Python mais rápidos disponíveis, somente atrás de Starlette e Uvicorn (utilizados internamente pelo FastAPI). (*)
-Para entender mais sobre performance, veja a seção Comparações.
+Para entender mais sobre isso, veja a seção Comparações.
## Dependências { #dependencies }
diff --git a/docs/pt/docs/tutorial/bigger-applications.md b/docs/pt/docs/tutorial/bigger-applications.md
index 9dec7b196..1b5a28ba8 100644
--- a/docs/pt/docs/tutorial/bigger-applications.md
+++ b/docs/pt/docs/tutorial/bigger-applications.md
@@ -31,11 +31,11 @@ Digamos que você tenha uma estrutura de arquivos como esta:
/// tip | Dica
-Existem vários arquivos `__init__.py` presentes em cada diretório ou subdiretório.
+Existem vários arquivos `__init__.py`: um em cada diretório ou subdiretório.
-Isso permite a importação de código de um arquivo para outro.
+Isso é o que permite importar código de um arquivo para outro.
-Por exemplo, no arquivo `app/main.py`, você poderia ter uma linha como:
+Por exemplo, em `app/main.py`, você poderia ter uma linha como:
```
from app.routers import items
@@ -43,47 +43,47 @@ from app.routers import items
///
-* O diretório `app` contém todo o código da aplicação. Ele possui um arquivo `app/__init__.py` vazio, o que o torna um "pacote Python" (uma coleção de "módulos Python"): `app`.
-* Dentro dele, o arquivo `app/main.py` está localizado em um pacote Python (diretório com `__init__.py`). Portanto, ele é um "módulo" desse pacote: `app.main`.
-* Existem também um arquivo `app/dependencies.py`, assim como o `app/main.py`, ele é um "módulo": `app.dependencies`.
+* O diretório `app` contém tudo. E ele tem um arquivo vazio `app/__init__.py`, então ele é um "pacote Python" (uma coleção de "módulos Python"): `app`.
+* Ele contém um arquivo `app/main.py`. Como ele está dentro de um pacote Python (um diretório com um arquivo `__init__.py`), ele é um "módulo" desse pacote: `app.main`.
+* Também há um arquivo `app/dependencies.py`, assim como `app/main.py`, ele é um "módulo": `app.dependencies`.
* Há um subdiretório `app/routers/` com outro arquivo `__init__.py`, então ele é um "subpacote Python": `app.routers`.
-* O arquivo `app/routers/items.py` está dentro de um pacote, `app/routers/`, portanto, é um "submódulo": `app.routers.items`.
-* O mesmo com `app/routers/users.py`, ele é outro submódulo: `app.routers.users`.
-* Há também um subdiretório `app/internal/` com outro arquivo `__init__.py`, então ele é outro "subpacote Python":`app.internal`.
+* O arquivo `app/routers/items.py` está dentro de um pacote, `app/routers/`, então, ele é um submódulo: `app.routers.items`.
+* O mesmo com `app/routers/users.py`, ele é outro submódulo: `app.routers.users`.
+* Há também um subdiretório `app/internal/` com outro arquivo `__init__.py`, então ele é outro "subpacote Python": `app.internal`.
* E o arquivo `app/internal/admin.py` é outro submódulo: `app.internal.admin`.
A mesma estrutura de arquivos com comentários:
-```
+```bash
.
├── app # "app" é um pacote Python
│ ├── __init__.py # este arquivo torna "app" um "pacote Python"
│ ├── main.py # "main" módulo, e.g. import app.main
│ ├── dependencies.py # "dependencies" módulo, e.g. import app.dependencies
-│ └── routers # "routers" é um "subpacote Python"
+│ └── routers # "routers" é um "subpacote Python"
│ │ ├── __init__.py # torna "routers" um "subpacote Python"
│ │ ├── items.py # "items" submódulo, e.g. import app.routers.items
│ │ └── users.py # "users" submódulo, e.g. import app.routers.users
-│ └── internal # "internal" é um "subpacote Python"
-│ ├── __init__.py # torna "internal" um "subpacote Python"
+│ └── internal # "internal" é um "subpacote Python"
+│ ├── __init__.py # torna "internal" um "subpacote Python"
│ └── admin.py # "admin" submódulo, e.g. import app.internal.admin
```
## `APIRouter` { #apirouter }
-Vamos supor que o arquivo dedicado a lidar apenas com usuários seja o submódulo em `/app/routers/users.py`.
+Digamos que o arquivo dedicado a lidar apenas com usuários seja o submódulo em `/app/routers/users.py`.
Você quer manter as *operações de rota* relacionadas aos seus usuários separadas do restante do código, para mantê-lo organizado.
Mas ele ainda faz parte da mesma aplicação/web API **FastAPI** (faz parte do mesmo "pacote Python").
-Você pode criar as *operações de rotas* para esse módulo usando o `APIRouter`.
+Você pode criar as *operações de rota* para esse módulo usando o `APIRouter`.
### Importe `APIRouter` { #import-apirouter }
-você o importa e cria uma "instância" da mesma maneira que faria com a classe `FastAPI`:
+Você o importa e cria uma "instância" da mesma maneira que faria com a classe `FastAPI`:
{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[1,3] title["app/routers/users.py"] *}
@@ -91,7 +91,7 @@ você o importa e cria uma "instância" da mesma maneira que faria com a classe
E então você o utiliza para declarar suas *operações de rota*.
-Utilize-o da mesma maneira que utilizaria a classe `FastAPI`:
+Utilize-o da mesma maneira que utilizaria a classe `FastAPI`:
{* ../../docs_src/bigger_applications/app_an_py39/routers/users.py hl[6,11,16] title["app/routers/users.py"] *}
@@ -151,7 +151,7 @@ Então, em vez de adicionar tudo isso a cada *operação de rota*, podemos adici
{* ../../docs_src/bigger_applications/app_an_py39/routers/items.py hl[5:10,16,21] title["app/routers/items.py"] *}
-Como o caminho de cada *operação de rota* deve começar com `/`, como em:
+Como o path de cada *operação de rota* tem que começar com `/`, como em:
```Python hl_lines="1"
@router.get("/{item_id}")
@@ -173,7 +173,7 @@ Observe que, assim como [dependências em *decoradores de operação de rota*](d
///
-O resultado final é que os caminhos dos itens agora são:
+O resultado final é que os paths dos itens agora são:
* `/items/`
* `/items/{item_id}`
@@ -186,7 +186,7 @@ O resultado final é que os caminhos dos itens agora são:
* Todas essas *operações de rota* terão a lista de `dependencies` avaliada/executada antes delas.
* Se você também declarar dependências em uma *operação de rota* específica, **elas também serão executadas**.
* As dependências do roteador são executadas primeiro, depois as [`dependencies` no decorador](dependencies/dependencies-in-path-operation-decorators.md){.internal-link target=_blank} e, em seguida, as dependências de parâmetros normais.
- * Você também pode adicionar [dependências de `Segurança` com `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
+ * Você também pode adicionar [`Security` dependencies com `scopes`](../advanced/security/oauth2-scopes.md){.internal-link target=_blank}.
/// tip | Dica
@@ -232,7 +232,7 @@ significaria:
Mas esse arquivo não existe, nossas dependências estão em um arquivo em `app/dependencies.py`.
-Lembre-se de como nossa estrutura app/file se parece:
+Lembre-se de como nossa estrutura de app/arquivos se parece:
@@ -246,7 +246,7 @@ from ..dependencies import get_token_header
significa:
-* Começando no mesmo pacote em que este módulo (o arquivo `app/routers/items.py`) reside (o diretório `app/routers/`)...
+* Começando no mesmo pacote em que este módulo (o arquivo `app/routers/items.py`) vive (o diretório `app/routers/`)...
* vá para o pacote pai (o diretório `app/`)...
* e lá, encontre o módulo `dependencies` (o arquivo em `app/dependencies.py`)...
* e dele, importe a função `get_token_header`.
@@ -283,7 +283,7 @@ Mas ainda podemos adicionar _mais_ `tags` que serão aplicadas a uma *operação
/// tip | Dica
-Esta última operação de caminho terá a combinação de tags: `["items", "custom"]`.
+Esta última operação de rota terá a combinação de tags: `["items", "custom"]`.
E também terá ambas as respostas na documentação, uma para `404` e uma para `403`.
@@ -376,7 +376,7 @@ Então, para poder usar ambos no mesmo arquivo, importamos os submódulos direta
{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}
-### Inclua os `APIRouter`s para `usuários` e `itens` { #include-the-apirouters-for-users-and-items }
+### Inclua os `APIRouter`s para `users` e `items` { #include-the-apirouters-for-users-and-items }
Agora, vamos incluir os `router`s dos submódulos `users` e `items`:
@@ -390,7 +390,7 @@ E `items.router` contém o `APIRouter` dentro do arquivo `app/routers/items.py`.
///
-Com `app.include_router()` podemos adicionar cada `APIRouter` ao aplicativo principal `FastAPI`.
+Com `app.include_router()` podemos adicionar cada `APIRouter` à aplicação principal `FastAPI`.
Ele incluirá todas as rotas daquele roteador como parte dele.
@@ -453,7 +453,7 @@ e funcionará corretamente, junto com todas as outras *operações de rota* adic
/// note | Detalhes Técnicos Avançados
-**Observação**: este é um detalhe muito técnico que você provavelmente pode **simplesmente pular**.
+**Nota**: este é um detalhe muito técnico que você provavelmente pode **simplesmente pular**.
---
@@ -481,7 +481,7 @@ $ fastapi dev app/main.py
E abra os documentos em http://127.0.0.1:8000/docs.
-Você verá a documentação automática da API, incluindo os caminhos de todos os submódulos, usando os caminhos (e prefixos) corretos e as tags corretas:
+Você verá a documentação automática da API, incluindo os paths de todos os submódulos, usando os paths (e prefixos) corretos e as tags corretas:
@@ -495,10 +495,10 @@ Esse é um uso avançado que você pode não precisar, mas está lá caso precis
## Inclua um `APIRouter` em outro { #include-an-apirouter-in-another }
-Da mesma forma que você pode incluir um `APIRouter` em um aplicativo `FastAPI`, você pode incluir um `APIRouter` em outro `APIRouter` usando:
+Da mesma forma que você pode incluir um `APIRouter` em uma aplicação `FastAPI`, você pode incluir um `APIRouter` em outro `APIRouter` usando:
```Python
router.include_router(other_router)
```
-Certifique-se de fazer isso antes de incluir `router` no aplicativo `FastAPI`, para que as *operações de rota* de `other_router` também sejam incluídas.
+Certifique-se de fazer isso antes de incluir `router` na aplicação `FastAPI`, para que as *operações de rota* de `other_router` também sejam incluídas.
diff --git a/docs/pt/docs/tutorial/body-updates.md b/docs/pt/docs/tutorial/body-updates.md
index 67bf68492..074eecd5a 100644
--- a/docs/pt/docs/tutorial/body-updates.md
+++ b/docs/pt/docs/tutorial/body-updates.md
@@ -1,10 +1,10 @@
# Corpo - Atualizações { #body-updates }
-## Atualização de dados existentes com `PUT` { #update-replacing-with-put }
+## Atualização substituindo com `PUT` { #update-replacing-with-put }
Para atualizar um item, você pode usar a operação HTTP `PUT`.
-Você pode usar `jsonable_encoder` para converter os dados de entrada em dados que podem ser armazenados como JSON (por exemplo, com um banco de dados NoSQL). Por exemplo, convertendo `datetime` em `str`.
+Você pode usar o `jsonable_encoder` para converter os dados de entrada em dados que podem ser armazenados como JSON (por exemplo, com um banco de dados NoSQL). Por exemplo, convertendo `datetime` em `str`.
{* ../../docs_src/body_updates/tutorial001_py310.py hl[28:33] *}
@@ -22,13 +22,13 @@ Isso significa que, se você quiser atualizar o item `bar` usando `PUT` com um c
}
```
-Como ele não inclui o atributo já armazenado `"tax": 20.2`, o modelo de entrada assumiria o valor padrão de `"tax": 10.5`.
+como ele não inclui o atributo já armazenado `"tax": 20.2`, o modelo de entrada assumiria o valor padrão de `"tax": 10.5`.
E os dados seriam salvos com esse "novo" `tax` de `10.5`.
## Atualizações parciais com `PATCH` { #partial-updates-with-patch }
-Você também pode usar a operação HTTP `PATCH` para atualizar parcialmente os dados.
+Você também pode usar a operação HTTP `PATCH` para atualizar os dados *parcialmente*.
Isso significa que você pode enviar apenas os dados que deseja atualizar, deixando o restante intacto.
@@ -40,27 +40,19 @@ E muitas equipes usam apenas `PUT`, mesmo para atualizações parciais.
Você é **livre** para usá-los como preferir, **FastAPI** não impõe restrições.
-Mas este guia te dá uma ideia de como eles são destinados a serem usados.
+Mas este guia mostra, mais ou menos, como eles devem ser usados.
///
### Usando o parâmetro `exclude_unset` do Pydantic { #using-pydantics-exclude-unset-parameter }
-Se você quiser receber atualizações parciais, é muito útil usar o parâmetro `exclude_unset` no método `.model_dump()` do modelo do Pydantic.
+Se você quiser receber atualizações parciais, é muito útil usar o parâmetro `exclude_unset` no `.model_dump()` do modelo do Pydantic.
Como `item.model_dump(exclude_unset=True)`.
-/// info | Informação
+Isso geraria um `dict` com apenas os dados que foram definidos ao criar o modelo `item`, excluindo valores padrão.
-No Pydantic v1, o método que era chamado `.dict()` e foi descontinuado (mas ainda suportado) no Pydantic v2. Agora, deve-se usar o método `.model_dump()`.
-
-Os exemplos aqui usam `.dict()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_dump()` a partir do Pydantic v2.
-
-///
-
-Isso gera um `dict` com apenas os dados definidos ao criar o modelo `item`, excluindo os valores padrão.
-
-Então, você pode usar isso para gerar um `dict` com apenas os dados definidos (enviados na solicitação), omitindo valores padrão:
+Então, você pode usar isso para gerar um `dict` com apenas os dados definidos (enviados na request), omitindo valores padrão:
{* ../../docs_src/body_updates/tutorial002_py310.py hl[32] *}
@@ -68,31 +60,23 @@ Então, você pode usar isso para gerar um `dict` com apenas os dados definidos
Agora, você pode criar uma cópia do modelo existente usando `.model_copy()`, e passar o parâmetro `update` com um `dict` contendo os dados para atualizar.
-/// info | Informação
-
-No Pydantic v1, o método era chamado `.copy()`, ele foi descontinuado (mas ainda suportado) no Pydantic v2, e renomeado para `.model_copy()`.
-
-Os exemplos aqui usam `.copy()` para compatibilidade com o Pydantic v1, mas você deve usar `.model_copy()` com o Pydantic v2.
-
-///
-
Como `stored_item_model.model_copy(update=update_data)`:
{* ../../docs_src/body_updates/tutorial002_py310.py hl[33] *}
### Recapitulando as atualizações parciais { #partial-updates-recap }
-Resumindo, para aplicar atualizações parciais você pode:
+Resumindo, para aplicar atualizações parciais você faria:
* (Opcionalmente) usar `PATCH` em vez de `PUT`.
* Recuperar os dados armazenados.
* Colocar esses dados em um modelo do Pydantic.
* Gerar um `dict` sem valores padrão a partir do modelo de entrada (usando `exclude_unset`).
- * Dessa forma, você pode atualizar apenas os valores definidos pelo usuário, em vez de substituir os valores já armazenados com valores padrão em seu modelo.
+ * Dessa forma, você pode atualizar apenas os valores realmente definidos pelo usuário, em vez de sobrescrever os valores já armazenados com valores padrão no seu modelo.
* Criar uma cópia do modelo armazenado, atualizando seus atributos com as atualizações parciais recebidas (usando o parâmetro `update`).
-* Converter o modelo copiado em algo que possa ser armazenado no seu banco de dados (por exemplo, usando o `jsonable_encoder`).
- * Isso é comparável ao uso do método `.model_dump()`, mas garante (e converte) os valores para tipos de dados que possam ser convertidos em JSON, por exemplo, `datetime` para `str`.
-* Salvar os dados no seu banco de dados.
+* Converter o modelo copiado em algo que possa ser armazenado na sua BD (por exemplo, usando o `jsonable_encoder`).
+ * Isso é comparável a usar o método `.model_dump()` do modelo novamente, mas garante (e converte) os valores para tipos de dados que possam ser convertidos em JSON, por exemplo, `datetime` em `str`.
+* Salvar os dados na sua BD.
* Retornar o modelo atualizado.
{* ../../docs_src/body_updates/tutorial002_py310.py hl[28:35] *}
@@ -101,7 +85,7 @@ Resumindo, para aplicar atualizações parciais você pode:
Você pode realmente usar essa mesma técnica com uma operação HTTP `PUT`.
-Mas o exemplo aqui usa `PATCH` porque foi criado para esses casos de uso.
+Mas o exemplo aqui usa `PATCH` porque ele foi criado para esses casos de uso.
///
@@ -109,8 +93,8 @@ Mas o exemplo aqui usa `PATCH` porque foi criado para esses casos de uso.
Observe que o modelo de entrada ainda é validado.
-Portanto, se você quiser receber atualizações parciais que possam omitir todos os atributos, precisará ter um modelo com todos os atributos marcados como opcionais (com valores padrão ou `None`).
+Portanto, se você quiser receber atualizações parciais que possam omitir todos os atributos, você precisa ter um modelo com todos os atributos marcados como opcionais (com valores padrão ou `None`).
-Para distinguir os modelos com todos os valores opcionais para **atualizações** e modelos com valores obrigatórios para **criação**, você pode usar as ideias descritas em [Modelos Adicionais](extra-models.md){.internal-link target=_blank}.
+Para distinguir dos modelos com todos os valores opcionais para **atualizações** e modelos com valores obrigatórios para **criação**, você pode usar as ideias descritas em [Modelos Extras](extra-models.md){.internal-link target=_blank}.
///
diff --git a/docs/pt/docs/tutorial/body.md b/docs/pt/docs/tutorial/body.md
index 1330f4458..fc59c7d06 100644
--- a/docs/pt/docs/tutorial/body.md
+++ b/docs/pt/docs/tutorial/body.md
@@ -10,7 +10,7 @@ Para declarar um corpo da **requisição**, você utiliza os modelos do JSON Schema para o seu modelo; você também pode usá-las em qualquer outro lugar se fizer sentido para o seu projeto.
-* Esses schemas farão parte do esquema OpenAPI gerado, e serão usados pelas UIs de documentação automática.
+* Esses schemas farão parte do esquema OpenAPI gerado, e serão usados pelas UIs de documentação automática.
## Documentação automática { #automatic-docs }
@@ -113,7 +114,7 @@ Se você utiliza o 0.95.0) exigiam que você usasse `Query` como valor padrão do seu parâmetro, em vez de colocá-lo em `Annotated`. É muito provável que você veja código assim por aí, então vou te explicar.
+Versões anteriores do FastAPI (antes de 0.95.0) exigiam que você usasse `Query` como valor padrão do seu parâmetro, em vez de colocá-lo em `Annotated`, é muito provável que você veja código assim por aí, então vou te explicar.
/// tip | Dica
@@ -206,20 +206,6 @@ Se você se sentir perdido com essas ideias de **"expressão regular"**, não se
Agora você sabe que, sempre que precisar delas, pode usá-las no **FastAPI**.
-### Pydantic v1 `regex` em vez de `pattern` { #pydantic-v1-regex-instead-of-pattern }
-
-Antes da versão 2 do Pydantic e antes do FastAPI 0.100.0, o parâmetro se chamava `regex` em vez de `pattern`, mas agora está descontinuado.
-
-Você ainda pode ver algum código usando isso:
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/query_params_str_validations/tutorial004_regex_an_py310.py hl[11] *}
-
-////
-
-Mas saiba que isso está descontinuado e deve ser atualizado para usar o novo parâmetro `pattern`. 🤓
-
## Valores padrão { #default-values }
Você pode, claro, usar valores padrão diferentes de `None`.
@@ -280,7 +266,7 @@ Então, com uma URL como:
http://localhost:8000/items/?q=foo&q=bar
```
-você receberá os múltiplos valores do *parâmetro de consulta* `q` (`foo` e `bar`) em uma `list` Python dentro da sua *função de operação de rota*, no *parâmetro da função* `q`.
+(você deveria) receber os múltiplos valores dos *parâmetros de consulta* `q` (`foo` e `bar`) em uma `list` Python dentro da sua *função de operação de rota*, no *parâmetro da função* `q`.
Assim, a resposta para essa URL seria:
@@ -386,7 +372,7 @@ Então você pode declarar um `alias`, e esse alias será usado para encontrar o
Agora digamos que você não gosta mais desse parâmetro.
-Você tem que deixá-lo por um tempo, pois há clientes usando-o, mas quer que a documentação mostre claramente que ele está descontinuado.
+Você tem que deixá-lo por um tempo, pois há clientes usando-o, mas quer que a documentação mostre claramente que ele está deprecated.
Então passe o parâmetro `deprecated=True` para `Query`:
@@ -416,7 +402,7 @@ O Pydantic também tem ISBN ou com `imdb-` para um ID de URL de filme IMDB:
+Por exemplo, este validador personalizado verifica se o ID do item começa com `isbn-` para um número de livro ISBN ou com `imdb-` para um ID de URL de filme IMDB:
{* ../../docs_src/query_params_str_validations/tutorial015_an_py310.py hl[5,16:19,24] *}
@@ -440,7 +426,7 @@ O ponto importante é apenas usar **`AfterValidator` com uma função dentro de
---
-Mas se você está curioso sobre este exemplo específico e ainda entretido, aqui vão alguns detalhes extras.
+Mas se você está curioso sobre este exemplo específico de código e ainda entretido, aqui vão alguns detalhes extras.
#### String com `value.startswith()` { #string-with-value-startswith }
diff --git a/docs/pt/docs/tutorial/response-model.md b/docs/pt/docs/tutorial/response-model.md
index dc66bb46c..8a7a71248 100644
--- a/docs/pt/docs/tutorial/response-model.md
+++ b/docs/pt/docs/tutorial/response-model.md
@@ -252,20 +252,6 @@ Então, se você enviar uma solicitação para essa *operação de rota* para o
/// info | Informação
-No Pydantic v1, o método era chamado `.dict()`, ele foi descontinuado (mas ainda suportado) no Pydantic v2 e renomeado para `.model_dump()`.
-
-Os exemplos aqui usam `.dict()` para compatibilidade com Pydantic v1, mas você deve usar `.model_dump()` em vez disso se puder usar Pydantic v2.
-
-///
-
-/// info | Informação
-
-O FastAPI usa `.dict()` do modelo Pydantic com seu parâmetro `exclude_unset` para chegar a isso.
-
-///
-
-/// info | Informação
-
Você também pode usar:
* `response_model_exclude_defaults=True`
diff --git a/docs/pt/docs/tutorial/schema-extra-example.md b/docs/pt/docs/tutorial/schema-extra-example.md
index bddd320cd..d274d4c97 100644
--- a/docs/pt/docs/tutorial/schema-extra-example.md
+++ b/docs/pt/docs/tutorial/schema-extra-example.md
@@ -8,39 +8,17 @@ Aqui estão várias maneiras de fazer isso.
Você pode declarar `examples` para um modelo Pydantic que serão adicionados ao JSON Schema gerado.
-//// tab | Pydantic v2
-
{* ../../docs_src/schema_extra_example/tutorial001_py310.py hl[13:24] *}
-////
-
-//// tab | Pydantic v1
-
-{* ../../docs_src/schema_extra_example/tutorial001_pv1_py310.py hl[13:23] *}
-
-////
-
Essas informações extras serão adicionadas como estão ao **JSON Schema** de saída para esse modelo e serão usadas na documentação da API.
-//// tab | Pydantic v2
-
-Na versão 2 do Pydantic, você usaria o atributo `model_config`, que recebe um `dict`, conforme descrito na documentação do Pydantic: Configuration.
-
-Você pode definir `"json_schema_extra"` com um `dict` contendo quaisquer dados adicionais que você queira que apareçam no JSON Schema gerado, incluindo `examples`.
-
-////
-
-//// tab | Pydantic v1
-
-Na versão 1 do Pydantic, você usaria uma classe interna `Config` e `schema_extra`, conforme descrito na documentação do Pydantic: Schema customization.
-
-Você pode definir `schema_extra` com um `dict` contendo quaisquer dados adicionais que você queira que apareçam no JSON Schema gerado, incluindo `examples`.
+Você pode usar o atributo `model_config`, que recebe um `dict`, conforme descrito na documentação do Pydantic: Configuration.
-////
+Você pode definir `"json_schema_extra"` com um `dict` contendo quaisquer dados adicionais que você gostaria que aparecessem no JSON Schema gerado, incluindo `examples`.
/// tip | Dica
-Você pode usar a mesma técnica para estender o JSON Schema e adicionar suas próprias informações extras personalizadas.
+Você poderia usar a mesma técnica para estender o JSON Schema e adicionar suas próprias informações extras personalizadas.
Por exemplo, você poderia usá-la para adicionar metadados para uma interface de usuário de front-end, etc.
@@ -100,13 +78,13 @@ No entanto, no momento em que isto foi escrito,
### `examples` específicos do OpenAPI { #openapi-specific-examples }
-Antes do **JSON Schema** suportar `examples`, o OpenAPI já tinha suporte para um campo diferente também chamado `examples`.
+Desde antes de o **JSON Schema** suportar `examples`, o OpenAPI já tinha suporte para um campo diferente também chamado `examples`.
-Esse `examples` específico do OpenAPI vai em outra seção da especificação. Ele fica nos **detalhes de cada função de operação de rota**, não dentro de cada JSON Schema.
+Esse `examples` **específico do OpenAPI** vai em outra seção da especificação do OpenAPI. Ele fica nos **detalhes de cada *operação de rota***, não dentro de cada JSON Schema.
E o Swagger UI tem suportado esse campo `examples` particular há algum tempo. Então, você pode usá-lo para **mostrar** diferentes **exemplos na UI da documentação**.
-O formato desse campo `examples` específico do OpenAPI é um `dict` com **vários exemplos** (em vez de uma `list`), cada um com informações extras que também serão adicionadas ao **OpenAPI**.
+O formato desse campo específico do OpenAPI `examples` é um `dict` com **vários exemplos** (em vez de uma `list`), cada um com informações extras que também serão adicionadas ao **OpenAPI**.
Isso não vai dentro de cada JSON Schema contido no OpenAPI, vai fora, diretamente na *operação de rota*.
@@ -167,12 +145,12 @@ O JSON Schema não tinha `examples`, então o OpenAPI adicionou seu próprio cam
O OpenAPI também adicionou os campos `example` e `examples` a outras partes da especificação:
-* `Parameter Object` (na especificação), usado no FastAPI por:
+* `Parameter Object` (na especificação) que era usado no FastAPI por:
* `Path()`
* `Query()`
* `Header()`
* `Cookie()`
-* `Request Body Object`, no campo `content`, no `Media Type Object` (na especificação), usado no FastAPI por:
+* `Request Body Object`, no campo `content`, no `Media Type Object` (na especificação) que era usado no FastAPI por:
* `Body()`
* `File()`
* `Form()`
@@ -185,13 +163,13 @@ Esse parâmetro antigo `examples` específico do OpenAPI agora é `openapi_examp
### Campo `examples` do JSON Schema { #json-schemas-examples-field }
-Depois, o JSON Schema adicionou um campo `examples` em uma nova versão da especificação.
+Mas então o JSON Schema adicionou um campo `examples` em uma nova versão da especificação.
E então o novo OpenAPI 3.1.0 passou a se basear na versão mais recente (JSON Schema 2020-12), que incluiu esse novo campo `examples`.
-Agora, esse novo campo `examples` tem precedência sobre o antigo (e customizado) campo único `example`, que agora está descontinuado.
+E agora esse novo campo `examples` tem precedência sobre o antigo campo único `example` (e customizado), que agora está descontinuado.
-Esse novo campo `examples` no JSON Schema é **apenas uma `list`** de exemplos, não um `dict` com metadados extras como nos outros lugares do OpenAPI (descritos acima).
+Esse novo campo `examples` no JSON Schema é **apenas uma `list`** de exemplos, não um dict com metadados extras como nos outros lugares do OpenAPI (descritos acima).
/// info | Informação
@@ -213,7 +191,7 @@ Mas agora que o FastAPI 0.99.0 e superiores usam o OpenAPI 3.1.0, que usa o JSON
### Swagger UI e `examples` específicos do OpenAPI { #swagger-ui-and-openapi-specific-examples }
-Como o Swagger UI não suportava vários exemplos no JSON Schema (em 2023-08-26), os usuários não tinham uma forma de mostrar vários exemplos na documentação.
+Agora, como o Swagger UI não suportava vários exemplos no JSON Schema (em 2023-08-26), os usuários não tinham uma forma de mostrar vários exemplos na documentação.
Para resolver isso, o FastAPI `0.103.0` **adicionou suporte** para declarar o mesmo antigo campo **específico do OpenAPI** `examples` com o novo parâmetro `openapi_examples`. 🤓