Um `Request` também tem um `request.receive`, que é uma função para "receber" o corpo da requisição.

O dicionário `scope` e a função `receive` são ambos parte da especificação ASGI.

E essas duas coisas, `scope` e `receive`, são o que é necessário para criar uma nova instância de `Request`.

* para **saída**, ele será **obrigatório** (e possivelmente `None`, ou em termos de JSON, `null`)

### Modelo para Saída na Documentação { #model-for-output-in-docs }

Você pode verificar o modelo de saída na documentação também, **ambos** `name` e `description` são marcados como **obrigatórios** com um **asterisco vermelho**:

<div class="screenshot">
<img src="/img/tutorial/separate-openapi-schemas/image03.png">
</div>

...ele possui os mesmos parâmetros que nosso `common_parameters` anterior:

{* ../../docs_src/dependencies/tutorial001_an_py310.py hl[8] *}

Esses parâmetros são utilizados pelo **FastAPI** para "definir" a dependência.

Em ambos os casos teremos:

* Um parâmetro de consulta `q` opcional do tipo `str`.
* Um parâmetro de consulta `skip` do tipo `int`, com valor padrão `0`.
* Um parâmetro de consulta `limit` do tipo `int`, com valor padrão `100`.

```

////

//// tab | Python 3.9+

```Python hl_lines="1  4"
{!> ../../docs_src/python_types/tutorial008b_py39.py!}
```

////

Em ambos os casos, isso significa que `item` poderia ser um `int` ou um `str`.

#### Possivelmente `None` { #possibly-none }

Você pode declarar que um valor pode ter um tipo, como `str`, mas que ele também pode ser `None`.

Probablemente puedas saltarte esta parte.

///

Hay una forma alternativa de definir esta lógica para ser ejecutada durante el *startup* y durante el *shutdown*.

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

De esta manera, si alguna parte del código interno de Starlette, o una extensión o plug-in de Starlette, lanza un `HTTPException` de Starlette, tu manejador podrá capturarlo y manejarlo.

En este ejemplo, para poder tener ambos `HTTPException` en el mismo código, las excepciones de Starlette son renombradas a `StarletteHTTPException`:

```Python
from starlette.exceptions import HTTPException as StarletteHTTPException
```

Esta idea de código **asíncrono** descrita anteriormente a veces también se llama **"concurrencia"**. Es diferente del **"paralelismo"**.

**Concurrencia** y **paralelismo** ambos se relacionan con "diferentes cosas sucediendo más o menos al mismo tiempo".

Pero los detalles entre *concurrencia* y *paralelismo* son bastante diferentes.

```Python
from .routers.items import router
from .routers.users import router
```

el `router` de `users` sobrescribiría el de `items` y no podríamos usarlos al mismo tiempo.

Así que, para poder usar ambos en el mismo archivo, importamos los submódulos directamente:

{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}

```Python
from .routers.items import router
from .routers.users import router
```

o `router` de `users` sobrescreveria o de `items` e não poderíamos usá-los ao mesmo tempo.

Então, para poder usar ambos no mesmo arquivo, importamos os submódulos diretamente:

{* ../../docs_src/bigger_applications/app_an_py39/main.py hl[5] title["app/main.py"] *}