update tutorial/handling-errors.md

docs/pt/docs/tutorial/handling-errors.md

@@ -1,4 +1,4 @@
-# Manipulação de erros
+# Manipulação de erros { #handling-errors }
 
 Há diversas situações em que você precisa notificar um erro a um cliente que está utilizando a sua API.
 
@@ -20,15 +20,15 @@ Os status codes na faixa dos 400 significam que houve um erro por parte do clien
 
 Você se lembra de todos aqueles erros (e piadas) a respeito do "**404 Not Found**"?
 
-## Use o `HTTPException`
+## Use o `HTTPException` { #use-httpexception }
 
 Para retornar ao cliente *responses* HTTP com erros, use o `HTTPException`.
 
-### Import `HTTPException`
+### Import `HTTPException` { #import-httpexception }
 
 {* ../../docs_src/handling_errors/tutorial001.py hl[1] *}
 
-### Lance o `HTTPException` no seu código.
+### Lance o `HTTPException` no seu código. { #raise-an-httpexception-in-your-code }
 
 `HTTPException`, ao fundo, nada mais é do que a conjunção entre uma exceção comum do Python e informações adicionais relevantes para APIs.
 
@@ -42,13 +42,12 @@ Neste exemplo, quando o cliente pede, na requisição, por um item cujo ID não
 
 {* ../../docs_src/handling_errors/tutorial001.py hl[11] *}
 
-### A response resultante
+### A response resultante { #the-resulting-response }
-
 
 Se o cliente faz uma requisição para `http://example.com/items/foo` (um `item_id` `"foo"`), esse cliente receberá um HTTP status code 200, e uma resposta JSON:
 
 
-```
+```JSON
 {
   "item": "The Foo Wrestlers"
 }
@@ -71,7 +70,7 @@ Esses tipos de dados são manipulados automaticamente pelo **FastAPI** e convert
 
 ///
 
-## Adicione headers customizados
+## Adicione headers customizados { #add-custom-headers }
 
 Há certas situações em que é bastante útil poder adicionar headers customizados no HTTP error. Exemplo disso seria adicionar headers customizados para tipos de segurança.
 
@@ -81,7 +80,7 @@ Mas caso você precise, para um cenário mais complexo, você pode adicionar hea
 
 {* ../../docs_src/handling_errors/tutorial002.py hl[14] *}
 
-## Instalando manipuladores de exceções customizados
+## Instale manipuladores de exceções customizados { #install-custom-exception-handlers }
 
 Você pode adicionar manipuladores de exceção customizados com <a href="https://www.starlette.dev/exceptions/" class="external-link" target="_blank">a mesma seção de utilidade de exceções presentes no Starlette</a>
 
@@ -109,7 +108,7 @@ Você também pode usar `from starlette.requests import Request` and `from starl
 
 ///
 
-## Sobrescreva o manipulador padrão de exceções
+## Sobrescreva os manipuladores de exceções padrão { #override-the-default-exception-handlers }
 
 **FastAPI** tem alguns manipuladores padrão de exceções.
 
@@ -117,12 +116,16 @@ Esses manipuladores são os responsáveis por retornar o JSON padrão de respost
 
 Você pode sobrescrever esses manipuladores de exceção com os seus próprios manipuladores.
 
-## Sobrescreva exceções de validação da requisição
+### Sobrescreva exceções de validação da requisição { #override-request-validation-exceptions }
 
 Quando a requisição contém dados inválidos, **FastAPI** internamente lança para o `RequestValidationError`.
 
+E também inclui um manipulador de exceções padrão para ele.
+
 Para sobrescrevê-lo, importe o `RequestValidationError` e use-o com o `@app.exception_handler(RequestValidationError)` para decorar o manipulador de exceções.
 
+O manipulador de exceções receberá um `Request` e a exceção.
+
 {* ../../docs_src/handling_errors/tutorial004.py hl[2,14:16] *}
 
 Se você for ao `/items/foo`, em vez de receber o JSON padrão com o erro:
@@ -150,15 +153,15 @@ path -> item_id
   value is not a valid integer (type=type_error.integer)
 ```
 
-### `RequestValidationError` vs `ValidationError`
+#### `RequestValidationError` vs `ValidationError` { #requestvalidationerror-vs-validationerror }
 
-/// warning | Aviso
+/// warning | Atenção
 
 Você pode pular estes detalhes técnicos caso eles não sejam importantes para você neste momento.
 
 ///
 
-`RequestValidationError` é uma subclasse do <a href="https://docs.pydantic.dev/latest/#error-handling" class="external-link" target="_blank">`ValidationError`</a> existente no Pydantic.
+`RequestValidationError` é uma subclasse do <a href="https://docs.pydantic.dev/latest/concepts/models/#error-handling" class="external-link" target="_blank">`ValidationError`</a> existente no Pydantic.
 
 **FastAPI** faz uso dele para que você veja o erro no seu log, caso você utilize um modelo de Pydantic em `response_model`, e seus dados tenham erro.
 
@@ -168,6 +171,8 @@ E assim deve ser porque seria um bug no seu código ter o `ValidationError` do P
 
 E enquanto você conserta o bug, os clientes / usuários não deveriam ter acesso às informações internas do erro, porque, desse modo, haveria exposição de uma vulnerabilidade de segurança.
 
+### Sobrescreva o manipulador de erro `HTTPException` { #override-the-httpexception-error-handler }
+
 Do mesmo modo, você pode sobreescrever o `HTTPException`.
 
 Por exemplo, você pode querer retornar uma *response* em *plain text* ao invés de um JSON para os seguintes erros:
@@ -182,12 +187,14 @@ Você pode usar `from starlette.responses import PlainTextResponse`.
 
 ///
 
-### Use o body do `RequestValidationError`.
+### Use o body do `RequestValidationError`. { #use-the-requestvalidationerror-body }
 
 O `RequestValidationError` contém o `body` que ele recebeu de dados inválidos.
 
 Você pode utilizá-lo enquanto desenvolve seu app para conectar o *body* e debugá-lo, e assim retorná-lo ao usuário, etc.
 
+{* ../../docs_src/handling_errors/tutorial005.py hl[14] *}
+
 Tente enviar um item inválido como este:
 
 ```JSON
@@ -197,7 +204,7 @@ Tente enviar um item inválido como este:
 }
 ```
 
-Você receberá uma *response* informando-o de que a data é inválida, e contendo o *body* recebido:
+Você receberá uma *response* informando-o de que os dados são inválidos, e contendo o *body* recebido:
 
 ```JSON hl_lines="12-15"
 {
@@ -218,27 +225,27 @@ Você receberá uma *response* informando-o de que a data é inválida, e conten
 }
 ```
 
-#### O `HTTPException` do FastAPI vs o `HTTPException` do Starlette.
+#### O `HTTPException` do FastAPI vs o `HTTPException` do Starlette { #fastapis-httpexception-vs-starlettes-httpexception }
 
 O **FastAPI** tem o seu próprio `HTTPException`.
 
 E a classe de erro `HTTPException` do **FastAPI** herda da classe de erro do `HTTPException` do Starlette.
 
-A diferença entre os dois é a de que o `HTTPException` do **FastAPI** permite que você adicione *headers* que serão incluídos nas *responses*.
+A única diferença é que o `HTTPException` do **FastAPI** aceita qualquer dado que possa ser convertido em JSON para o campo `detail`, enquanto o `HTTPException` do Starlette aceita apenas strings para esse campo.
-
-Esses *headers* são necessários/utilizados internamente pelo OAuth 2.0 e também por outras utilidades de segurança.
 
 Portanto, você pode continuar lançando o `HTTPException` do **FastAPI** normalmente no seu código.
 
 Porém, quando você registrar um manipulador de exceção, você deve registrá-lo através do `HTTPException` do Starlette.
 
-Dessa forma, se qualquer parte do código interno, extensão ou plug-in do Starlette lançar o `HTTPException`, o seu manipulador de exceção poderá capturar esse lançamento e tratá-lo.
+Dessa forma, se qualquer parte do código interno, extensão ou plug-in do Starlette lançar um `HTTPException` do Starlette, o seu manipulador poderá capturar e tratá-lo.
+
+Neste exemplo, para poder ter ambos os `HTTPException` no mesmo código, a exceção do Starlette é renomeada para `StarletteHTTPException`:
 
 ```Python
 from starlette.exceptions import HTTPException as StarletteHTTPException
 ```
 
-### Re-use os manipulares de exceção do **FastAPI**
+### Reutilize os manipuladores de exceção do **FastAPI** { #reuse-fastapis-exception-handlers }
 
 Se você quer usar a exceção em conjunto com o mesmo manipulador de exceção *default* do **FastAPI**, você pode importar e re-usar esses manipuladores de exceção do `fastapi.exception_handlers`: