```

#### 3. Get Suggestions

```java
import org.codelibs.fess.suggest.request.suggest.SuggestResponse;

// Synchronous suggestion request
SuggestResponse response = suggester.suggest()
    .setQuery("sea")                    // user input
    .setSize(10)                        // max suggestions
    .execute()
    .getResponse();

// Process suggestions
response.getItems().forEach(item -> {

    * Swagger UI.
    * ReDoc.

---

Volviendo al ejemplo de código anterior, **FastAPI**:

* Validará que haya un `item_id` en el path para requests `GET` y `PUT`.
* Validará que el `item_id` sea del tipo `int` para requests `GET` y `PUT`.
    * Si no lo es, el cliente verá un error útil y claro.
* Revisa si hay un parámetro de query opcional llamado `q` (como en `http://127.0.0.1:8000/items/foo?q=somequery`) para requests `GET`.

Un "middleware" es una función que trabaja con cada **request** antes de que sea procesada por cualquier *path operation* específica. Y también con cada **response** antes de devolverla.

* Toma cada **request** que llega a tu aplicación.
* Puede entonces hacer algo a esa **request** o ejecutar cualquier código necesario.
* Luego pasa la **request** para que sea procesada por el resto de la aplicación (por alguna *path operation*).

/// note | Nota

Tener un valor por defecto de cualquier tipo, incluyendo `None`, hace que el parámetro sea opcional (no requerido).

///

## Parámetros requeridos { #required-parameters }

Cuando no necesitamos declarar más validaciones o metadatos, podemos hacer que el parámetro de query `q` sea requerido simplemente no declarando un valor por defecto, como:

```Python
q: str
```

en lugar de:

Pero debido a nuestros cambios en `GzipRequest.body`, el request body se descomprimirá automáticamente cuando sea cargado por **FastAPI** si es necesario.

## Accediendo al request body en un manejador de excepciones { #accessing-the-request-body-in-an-exception-handler }

/// tip | Consejo

Este tipo de ataque es relevante principalmente cuando:

* la aplicación corre localmente (p. ej. en `localhost`) o en una red interna
* y la aplicación no tiene ninguna autenticación, espera que cualquier request de la misma red sea confiable.

## Ejemplo de ataque { #example-attack }

Imagina que construyes una forma de ejecutar un agente de IA local.

Provee un API en

```
http://localhost:8000/v1/agents/multivac
```

* **Por defecto**, eso significaría que solo puedes tener **un certificado HTTPS por dirección IP**.
    * No importa cuán grande sea tu servidor o qué tan pequeña pueda ser cada aplicación que tengas en él.
    * Sin embargo, hay una **solución** para esto.

Podemos hacerlo mejor...

## Qué hace a una dependencia { #what-makes-a-dependency }

Hasta ahora has visto dependencias declaradas como funciones.

Pero esa no es la única forma de declarar dependencias (aunque probablemente sea la más común).

El factor clave es que una dependencia debe ser un "callable".

Un "**callable**" en Python es cualquier cosa que Python pueda "llamar" como una función.

Y luego, ese sistema (en este caso **FastAPI**) se encargará de hacer lo que sea necesario para proporcionar a tu código esas dependencias necesarias ("inyectar" las dependencias).

Esto es muy útil cuando necesitas:

* Tener lógica compartida (la misma lógica de código una y otra vez).

## Campos de lista { #list-fields }

Puedes definir un atributo como un subtipo. Por ejemplo, una `list` en Python:

{* ../../docs_src/body_nested_models/tutorial001_py310.py hl[12] *}

Esto hará que `tags` sea una lista, aunque no declare el tipo de los elementos de la lista.

## Campos de lista con parámetro de tipo { #list-fields-with-type-parameter }