### Criar com `HeroCreate` e retornar um `HeroPublic`

Agora que temos **múltiplos modelos**, podemos atualizar as partes do app que os utilizam.

Recebemos na requisição um *modelo de dados* `HeroCreate`, e a partir dele, criamos um *modelo de tabela* `Hero`.

Esse novo *modelo de tabela* `Hero` terá os campos enviados pelo cliente, e também terá um `id` gerado pelo banco de dados.

### Crear con `HeroCreate` y devolver un `HeroPublic`

Ahora que tenemos **múltiples modelos**, podemos actualizar las partes de la aplicación que los usan.

Recibimos en la request un *modelo de datos* `HeroCreate`, y a partir de él, creamos un *modelo de tabla* `Hero`.

Este nuevo *modelo de tabla* `Hero` tendrá los campos enviados por el cliente, y también tendrá un `id` generado por la base de datos.

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.

						_, err := disk.ReadVersion(ctx, "", minioMetaBucket,
							o.objectPath(partN), "", ReadOptions{})
						if err != nil {
							time.Sleep(retryDelay250)
							retries++
							continue
						}
						break
					}
				}

				// Load partN metadata...
				fi, metaArr, onlineDisks, err = er.getObjectFileInfo(ctx, minioMetaBucket, o.objectPath(partN), ObjectOptions{}, true)
				if err != nil {

De esa manera, se comporta casi como si fuera solo una variable global. Pero como usa una función de dependencia, entonces podemos sobrescribirla fácilmente para las pruebas.

`@lru_cache` es parte de `functools`, que es parte del library estándar de Python, puedes leer más sobre él en las <a href="https://docs.python.org/3/library/functools.html#functools.lru_cache" class="external-link" target="_blank">docs de Python para `@lru_cache`</a>.

{* ../../docs_src/events/tutorial003.py hl[14:19] *}

A primeira parte da função, antes do `yield`, será  executada **antes** da aplicação inicializar.

E a parte posterior do `yield` irá executar **após** a aplicação ser encerrada.

### Gerenciador de Contexto Assíncrono

En este escenario, cada uno de los limpiadores (incluyéndote) sería un procesador, haciendo su parte del trabajo.

Y como la mayor parte del tiempo de ejecución se dedica al trabajo real (en lugar de esperar), y el trabajo en una computadora lo realiza una <abbr title="Central Processing Unit">CPU</abbr>, llaman a estos problemas "CPU bound".

---

# Utilizando o Request diretamente

Até agora você declarou as partes da requisição que você precisa utilizando os seus tipos.

Obtendo dados de:

* Os parâmetros das rotas.
* Cabeçalhos (*Headers*).
* Cookies.
* etc.

E ao fazer isso, o **FastAPI** está validando as informações, convertendo-as e gerando documentação para a sua API automaticamente.

Porém há situações em que você possa precisar acessar o objeto `Request` diretamente.

## 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

Nesta seção, você verá como fazer isso.

## O processo normal

O processo normal (padrão) é o seguinte:

Uma aplicação (instância) do `FastAPI` possui um método `.openapi()` que deve retornar o esquema OpenAPI.

Como parte da criação do objeto de aplicação, uma *operação de rota* para `/openapi.json` (ou para o que você definir como `openapi_url`) é registrada.

Ela apenas retorna uma resposta JSON com o resultado do método `.openapi()` da aplicação.