Nesse cenário, se você fizer uma requisição para `/unicorns/yolo`, a *operação de caminho* vai lançar (`raise`) o `UnicornException`.

Essa exceção será manipulada, contudo, pelo `unicorn_exception_handler`.

Dessa forma você receberá um erro "limpo", com o HTTP status code `418` e um JSON com o conteúdo:

```JSON
{"message": "Oops! yolo did something. There goes a rainbow..."}
```

/// note | "Detalhes Técnicos"

Os arquivos serão enviados como "form data".

Se você declarar o tipo do seu parâmetro na sua *função de operação de rota* como `bytes`, o **FastAPI** irá ler o arquivo para você e você receberá o conteúdo como `bytes`.

Lembre-se que isso significa que o conteúdo inteiro será armazenado em memória. Isso funciona bem para arquivos pequenos.

Mas existem vários casos em que você pode se beneficiar ao usar `UploadFile`.

Ele terá a propriedade `scopes` com uma lista contendo todos os escopos requeridos por ele e todas as dependências que utilizam ele como uma subdependência. Isso significa, todos  os "dependentes"... pode soar meio confuso, e isso será explicado novamente mais adiante.

O objeto `security_scopes` (da classe `SecurityScopes`) também oferece um atributo `scope_str` com uma única string, contendo os escopos separados por espaços (nós vamos utilizar isso).

Mas se você tem certeza que o conteúdo que você está retornando é **serializável com JSON**, você pode passá-lo diretamente para a classe de resposta e evitar o trabalho extra que o FastAPI teria ao passar o conteúdo pelo `jsonable_encoder` antes de passar para a classe de resposta.

```Python hl_lines="2  7"

* dados do cliente para serem enviados através da rede
* dados enviados pelo seu programa para serem recebidos pelo clente através da rede
* conteúdo de um arquivo no disco pra ser lido pelo sistema e entregar ao seu programa
* conteúdo que seu programa deu ao sistema para ser escrito no disco
* uma operação remota API
* uma operação no banco de dados para finalizar

Se as senhas não corresponderem, retornaremos o mesmo erro.

#### Hashing de senha

"Hashing" significa: converter algum conteúdo (uma senha neste caso) em uma sequência de bytes (apenas uma string) que parece algo sem sentido.

Sempre que você passa exatamente o mesmo conteúdo (exatamente a mesma senha), você obtém exatamente a mesma sequência aleatória de caracteres.

```

</details>

## O que é um Contêiner

Contêineres (especificamente contêineres Linux) são um jeito muito **leve** de empacotar aplicações contendo todas as dependências e arquivos necessários enquanto os mantém isolados de outros contêineres (outras aplicações ou componentes) no mesmo sistema.

## 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!}
```

/// 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="******@****.***"
APP_NAME="ChimichangApp"
```

### Obtendo configurações do `.env`

E então adicionar o seguinte código em `config.py`:

//// tab | Pydantic v2

///

```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.