* Devuelve un objeto de tipo `HTTPBasicCredentials`:
  * Contiene el `username` y `password` enviados.

{* ../../docs_src/security/tutorial006_an_py310.py hl[4,8,12] *}

Cuando intentas abrir la URL por primera vez (o haces clic en el botón "Execute" en la documentación) el navegador te pedirá tu nombre de usuario y contraseña:

<img src="/img/tutorial/security/image12.png">

## Revisa el nombre de usuario { #check-the-username }

Você também pode usá-lo para transmitir arquivos binários grandes, enviando cada bloco de dados à medida que o lê, sem precisar carregar tudo na memória de uma vez.

Você também pode transmitir vídeo ou áudio desta forma; pode até ser gerado enquanto você processa e envia.

## Um `StreamingResponse` com `yield` { #a-streamingresponse-with-yield }

```

e depois chamarmos:

```Python
user_dict = user_in.model_dump()
```

agora temos um `dict` com os dados na variável `user_dict` (é um `dict` em vez de um objeto de modelo Pydantic).

E se chamarmos:

```Python
print(user_dict)
```

teríamos um `dict` Python com:

```Python
{
    'username': 'john',
    'password': 'secret',

Esto te permitiría **reutilizar el modelo** en **múltiples lugares** y también declarar validaciones y metadatos para todos los parámetros de una vez. 😎

/// note | Nota

Esto es compatible desde la versión `0.115.0` de FastAPI. 🤓

///

## Parámetros Query con un Modelo Pydantic { #query-parameters-with-a-pydantic-model }

     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
```

</div>

/// tip | Dica

Em produção, você usaria `fastapi run` em vez de `fastapi dev`. 🚀

///

Internamente, o **FastAPI CLI** usa o [Uvicorn](https://www.uvicorn.dev), um servidor ASGI de alta performance e pronto para produção. 😎

Então, defina os cookies nela e a retorne:

{* ../../docs_src/response_cookies/tutorial001_py310.py hl[10:12] *}

/// tip | Dica

Lembre-se de que se você retornar uma resposta diretamente em vez de usar o parâmetro `Response`, FastAPI a retornará diretamente.

Portanto, você terá que garantir que seus dados sejam do tipo correto. E.g. será compatível com JSON se você estiver retornando um `JSONResponse`.

É por isso que ao falar sobre a versão 2.0 é comum dizer "Swagger", e para a versão 3+ "OpenAPI".

/// check | Inspirou o **FastAPI** a

Adotar e usar um padrão aberto para especificações de API, em vez de um schema personalizado.

E integrar ferramentas de interface para usuários baseadas nos padrões:

* [Swagger UI](https://github.com/swagger-api/swagger-ui)
* [ReDoc](https://github.com/Rebilly/ReDoc)

Resumindo, para aplicar atualizações parciais você deveria:

* (Opcionalmente) usar `PATCH` em vez de `PUT`.
* Recuperar os dados armazenados.
* Colocar esses dados em um modelo do Pydantic.
* Gerar um `dict` sem valores padrão a partir do modelo de entrada (usando `exclude_unset`).
    * Dessa forma, você pode atualizar apenas os valores realmente definidos pelo usuário, em vez de substituir valores já armazenados por valores padrão do modelo.

Para esses casos específicos, você pode fazer o seguinte:

Em vez de escrever:

//// tab | Python 3.10+

```Python
commons: Annotated[CommonQueryParams, Depends(CommonQueryParams)]
```

////

//// tab | Python 3.10+ non-Annotated

/// tip | Dica

De la misma manera, puedes definir lógica (código) que debería ser ejecutada cuando la aplicación esté **cerrándose**. En este caso, este código será ejecutado **una vez**, **después** de haber manejado posiblemente **muchos requests**.