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

Vamos imaginar que você deseja obter o endereço de IP/host do cliente dentro da sua *função de operação de rota*.

Para isso você precisa acessar a requisição diretamente.

```Python hl_lines="1  7-8"
{!../../docs_src/using_request_directly/tutorial001.py!}
```

Ao declarar o parâmetro com o tipo sendo um `Request` em sua *função de operação de rota*, o **FastAPI** saberá como passar o `Request` neste parâmetro.

/// tip | "Dica"

```Python hl_lines="3  25"
{!../../docs_src/openapi_callbacks/tutorial001.py!}
```

### Crie a *operação de rota* do callback

Para criar a *operação de rota* do callback, use o mesmo `APIRouter` que você criou acima.

Ele deve parecer exatamente como uma *operação de rota* normal do FastAPI:

* Ele provavelmente deveria ter uma declaração do corpo que deveria receber, por exemplo. `body: InvoiceEvent`.

```Python hl_lines="21"
{!../../docs_src/body/tutorial002.py!}
```

## Corpo da requisição + parâmetros de rota

Você pode declarar parâmetros de rota e corpo da requisição ao mesmo tempo.

O **FastAPI** irá reconhecer que os parâmetros da função que combinam com parâmetros de rota devem ser **retirados da rota**, e parâmetros da função que são declarados como modelos Pydantic sejam **retirados do corpo da requisição**.

E podemos adicionar uma lista de `dependencies` que serão adicionadas a todas as *operações de rota* no roteador e serão executadas/resolvidas para cada solicitação feita a elas.

/// tip | "Dica"

* Ele pega cada **requisição** que chega ao seu aplicativo.
* Ele pode então fazer algo com essa **requisição** ou executar qualquer código necessário.
* Então ele passa a **requisição** para ser processada pelo resto do aplicativo (por alguma *operação de rota*).

Se você tem algum conhecimento técnico (corrotinas, threads, blocking etc) e está curioso sobre como o FastAPI controla o `async def` vs normal `def`, vá em frente.

///

### Funções de operação de rota

Quando você declara uma *função de operação de rota* com `def` normal ao invés de `async def`, ela é rodada em uma threadpool externa que então é aguardada, ao invés de ser chamada diretamente (ela poderia bloquear o servidor).

# Parâmetros da Rota e Validações Numéricas

Do mesmo modo que você pode declarar mais validações e metadados para parâmetros de consulta com `Query`, você pode declarar os mesmos tipos de validações e metadados para parâmetros de rota com `Path`.

## Importe `Path`

Primeiro, importe `Path` de `fastapi`:

//// tab | Python 3.10+

```Python hl_lines="1"
{!> ../../docs_src/path_params_numeric_validations/tutorial001_py310.py!}
```

////

Como todos esses métodos são métodos `assíncronos`, você precisa "aguardar" por eles.

Por exemplo, dentro de uma função de *operação de rota* `assíncrona`, você pode obter o conteúdo com:

```Python
contents = await myfile.read()
```

Se você estiver dentro de uma função de *operação de rota* normal `def`, você pode acessar o `UploadFile.file` diretamente, por exemplo:

```Python
contents = myfile.file.read()
```

Swagger UI lidará com isso nos bastidores para você, mas ele precisa desse auxiliar de "redirecionamento".

///

### Criar uma *operação de rota* para testar

Agora, para poder testar se tudo funciona, crie uma *operação de rota*:

```Python hl_lines="36-38"
{!../../docs_src/custom_docs_ui/tutorial001.py!}
```

### Teste